installer = forms.ModelChoiceField(queryset=Installer.objects.all(), required=False)
     scenario = forms.ModelChoiceField(queryset=Scenario.objects.all(), required=False)
 
-    def __init__(self, data=None, user=None, *args, **kwargs):
+    def __init__(self, data=None, user=None, lab_data=None, *args, **kwargs):
         if "default_user" in kwargs:
             default_user = kwargs.pop("default_user")
         else:
             **get_user_field_opts()
         )
 
-        attrs = FormUtils.getLabData()
-        self.fields['filter_field'] = MultipleSelectFilterField(widget=MultipleSelectFilterWidget(**attrs))
         self.fields['length'] = forms.IntegerField(
             widget=NumberInput(
                 attrs={
             )
         )
 
+        self.fields['filter_field'] = MultipleSelectFilterField(widget=MultipleSelectFilterWidget(**lab_data))
+
     def build_user_list(self):
         """
         Build list of UserProfiles.
 
 from booking.models import Booking
 from booking.stats import StatisticsManager
 from booking.forms import HostReImageForm
+from booking.forms import FormUtils
 from api.models import JobFactory
 from workflow.views import login
 from booking.forms import QuickBookingForm
 from booking.quick_deployer import create_from_form, drop_filter
-
+from workflow.forms import (MultipleSelectFilterField,
+        MultipleSelectFilterWidget)
 
 def quick_create_clear_fields(request):
     request.session['quick_create_forminfo'] = None
 
     if request.method == 'GET':
         context = {}
-
-        r_manager = ResourceManager.getInstance()
-        templates = {}
-        for lab in Lab.objects.all():
-            templates[str(lab)] = r_manager.getAvailableResourceTemplates(lab, request.user)
-
-        context['lab_profile_map'] = templates
-
-        context['form'] = QuickBookingForm(default_user=request.user.username, user=request.user)
-
+        attrs = FormUtils.getLabData(user=request.user)
+        context['form'] = QuickBookingForm(lab_data=attrs, default_user=request.user.username, user=request.user)
+        context['lab_profile_map'] = {}
         context.update(drop_filter(request.user))
-
         return render(request, 'booking/quick_deploy.html', context)
+
     if request.method == 'POST':
-        form = QuickBookingForm(request.POST, user=request.user)
+        attrs = FormUtils.getLabData(user=request.user)
+        form = QuickBookingForm(request.POST, lab_data=attrs, user=request.user)
+
         context = {}
         context['lab_profile_map'] = {}
         context['form'] = form
 
     OPNFVConfig,
     OPNFVRole,
     Image,
-    RemoteInfo
+    RemoteInfo,
+    PhysicalNetwork,
+    NetworkConnection
 )
 
 admin.site.register([
     OPNFVConfig,
     OPNFVRole,
     Image,
+    PhysicalNetwork,
+    NetworkConnection,
     RemoteInfo])
 
     temporary = models.BooleanField(default=False)
 
     def getConfigs(self):
+        configs = self.resourceConfigurations.all()
         return list(self.resourceConfigurations.all())
 
     def __str__(self):
     connections = models.ManyToManyField(NetworkConnection)
 
     def __str__(self):
-        return "type " + str(self.profile) + " on host " + str(self.host)
+        return "type " + str(self.profile.name) + " on host " + str(self.profile.host.name)
 
 
 """
 
     PhysicalNetwork,
 )
 
-
 class ResourceManager:
 
     instance = None
             ResourceManager.instance = ResourceManager()
         return ResourceManager.instance
 
-    def getAvailableResourceTemplates(self, lab, user):
-        templates = ResourceTemplate.objects.filter(lab=lab)
-        templates = templates.filter(Q(owner=user) | Q(public=True)).filter(temporary=False)
-        return templates
+    def getAvailableResourceTemplates(self, lab, user=None):
+        filter = Q(public=True)
+        if user:
+            filter = filter | Q(owner=user)
+        filter = filter & Q(temporary=False) & Q(lab=lab)
+        return ResourceTemplate.objects.filter(filter)
 
     def templateIsReservable(self, resource_template):
         """
 
     Installer,
     Scenario,
 )
+from resource_inventory.resource_manager import ResourceManager
 from booking.lib import get_user_items, get_user_field_opts
 
 
 
 class FormUtils:
     @staticmethod
-    def getLabData(multiple_hosts=False):
+    def getLabData(multiple_hosts=False, user=None):
         """
         Get all labs and thier host profiles, returns a serialized version the form can understand.
 
             neighbors[lab_node['id']] = []
             labs[lab_node['id']] = lab_node
 
-            for template in lab.resourcetemplates.all():
+            for template in ResourceManager.getInstance().getAvailableResourceTemplates(lab, user):
+
                 resource_node = {
                     'form': {"name": "host_name", "type": "text", "placeholder": "hostname"},
                     'id': "resource_" + str(template.id),