dashboard/src/workflow/forms.py

   1 ##############################################################################
   2 # Copyright (c) 2018 Sawyer Bergeron, Parker Berberian, and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10
  11 import django.forms as forms
  12 from django.forms import widgets, ValidationError
  13 from django.utils.safestring import mark_safe
  14 from django.template.loader import render_to_string
  15 from django.forms.widgets import NumberInput
  16
  17 import json
  18
  19 from account.models import Lab
  20 from account.models import UserProfile
  21 from resource_inventory.models import (
  22     OPNFVRole,
  23     Installer,
  24     Scenario,
  25 )
  26 from booking.lib import get_user_items, get_user_field_opts
  27
  28
  29 class SearchableSelectMultipleWidget(widgets.SelectMultiple):
  30     template_name = 'dashboard/searchable_select_multiple.html'
  31
  32     def __init__(self, attrs=None):
  33         self.items = attrs['items']
  34         self.show_from_noentry = attrs['show_from_noentry']
  35         self.show_x_results = attrs['show_x_results']
  36         self.results_scrollable = attrs['results_scrollable']
  37         self.selectable_limit = attrs['selectable_limit']
  38         self.placeholder = attrs['placeholder']
  39         self.name = attrs['name']
  40         self.initial = attrs.get("initial", [])
  41
  42         super(SearchableSelectMultipleWidget, self).__init__()
  43
  44     def render(self, name, value, attrs=None, renderer=None):
  45
  46         context = self.get_context(attrs)
  47         return mark_safe(render_to_string(self.template_name, context))
  48
  49     def get_context(self, attrs):
  50         return {
  51             'items': self.items,
  52             'name': self.name,
  53             'show_from_noentry': self.show_from_noentry,
  54             'show_x_results': self.show_x_results,
  55             'results_scrollable': self.results_scrollable,
  56             'selectable_limit': self.selectable_limit,
  57             'placeholder': self.placeholder,
  58             'initial': self.initial,
  59         }
  60
  61
  62 class SearchableSelectMultipleField(forms.Field):
  63     def __init__(self, *args, required=True, widget=None, label=None, disabled=False,
  64                  items=None, queryset=None, show_from_noentry=True, show_x_results=-1,
  65                  results_scrollable=False, selectable_limit=-1, placeholder="search here",
  66                  name="searchable_select", initial=[], **kwargs):
  67         """from the documentation:
  68         # required -- Boolean that specifies whether the field is required.
  69         #             True by default.
  70         # widget -- A Widget class, or instance of a Widget class, that should
  71         #           be used for this Field when displaying it. Each Field has a
  72         #           default Widget that it'll use if you don't specify this. In
  73         #           most cases, the default widget is TextInput.
  74         # label -- A verbose name for this field, for use in displaying this
  75         #          field in a form. By default, Django will use a "pretty"
  76         #          version of the form field name, if the Field is part of a
  77         #          Form.
  78         # initial -- A value to use in this Field's initial display. This value
  79         #            is *not* used as a fallback if data isn't given.
  80         # help_text -- An optional string to use as "help text" for this Field.
  81         # error_messages -- An optional dictionary to override the default
  82         #                   messages that the field will raise.
  83         # show_hidden_initial -- Boolean that specifies if it is needed to render a
  84         #                        hidden widget with initial value after widget.
  85         # validators -- List of additional validators to use
  86         # localize -- Boolean that specifies if the field should be localized.
  87         # disabled -- Boolean that specifies whether the field is disabled, that
  88         #             is its widget is shown in the form but not editable.
  89         # label_suffix -- Suffix to be added to the label. Overrides
  90         #                 form's label_suffix.
  91         """
  92
  93         self.widget = widget
  94         if self.widget is None:
  95             self.widget = SearchableSelectMultipleWidget(
  96                 attrs={
  97                     'items': items,
  98                     'initial': [obj.id for obj in initial],
  99                     'show_from_noentry': show_from_noentry,
 100                     'show_x_results': show_x_results,
 101                     'results_scrollable': results_scrollable,
 102                     'selectable_limit': selectable_limit,
 103                     'placeholder': placeholder,
 104                     'name': name,
 105                     'disabled': disabled
 106                 }
 107             )
 108         self.disabled = disabled
 109         self.queryset = queryset
 110         self.selectable_limit = selectable_limit
 111
 112         super().__init__(disabled=disabled, **kwargs)
 113
 114         self.required = required
 115
 116     def clean(self, data):
 117         data = data[0]
 118         if not data:
 119             if self.required:
 120                 raise ValidationError("Nothing was selected")
 121             else:
 122                 return []
 123         data_as_list = json.loads(data)
 124         if self.selectable_limit != -1:
 125             if len(data_as_list) > self.selectable_limit:
 126                 raise ValidationError("Too many items were selected")
 127
 128         items = []
 129         for elem in data_as_list:
 130             items.append(self.queryset.get(id=elem))
 131
 132         return items
 133
 134
 135 class SearchableSelectAbstractForm(forms.Form):
 136     def __init__(self, *args, queryset=None, initial=[], **kwargs):
 137         self.queryset = queryset
 138         items = self.generate_items(self.queryset)
 139         options = self.generate_options()
 140
 141         super(SearchableSelectAbstractForm, self).__init__(*args, **kwargs)
 142         self.fields['searchable_select'] = SearchableSelectMultipleField(
 143             initial=initial,
 144             items=items,
 145             queryset=self.queryset,
 146             **options
 147         )
 148
 149     def get_validated_bundle(self):
 150         bundles = self.cleaned_data['searchable_select']
 151         if len(bundles) < 1:  # don't need to check for >1, as field does that for us
 152             raise ValidationError("No bundle was selected")
 153         return bundles[0]
 154
 155     def generate_items(self, queryset):
 156         raise Exception("SearchableSelectAbstractForm does not implement concrete generate_items()")
 157
 158     def generate_options(self, disabled=False):
 159         return {
 160             'show_from_noentry': True,
 161             'show_x_results': -1,
 162             'results_scrollable': True,
 163             'selectable_limit': 1,
 164             'placeholder': 'Search for a Bundle',
 165             'name': 'searchable_select',
 166             'disabled': False
 167         }
 168
 169
 170 class SWConfigSelectorForm(SearchableSelectAbstractForm):
 171     def generate_items(self, queryset):
 172         items = {}
 173
 174         for bundle in queryset:
 175             items[bundle.id] = {
 176                 'expanded_name': bundle.name,
 177                 'small_name': bundle.owner.username,
 178                 'string': bundle.description,
 179                 'id': bundle.id
 180             }
 181
 182         return items
 183
 184
 185 class OPNFVSelectForm(SearchableSelectAbstractForm):
 186     def generate_items(self, queryset):
 187         items = {}
 188
 189         for config in queryset:
 190             items[config.id] = {
 191                 'expanded_name': config.name,
 192                 'small_name': config.bundle.owner.username,
 193                 'string': config.description,
 194                 'id': config.id
 195             }
 196
 197         return items
 198
 199
 200 class ResourceSelectorForm(SearchableSelectAbstractForm):
 201     def generate_items(self, queryset):
 202         items = {}
 203
 204         for bundle in queryset:
 205             items[bundle.id] = {
 206                 'expanded_name': bundle.name,
 207                 'small_name': bundle.owner.username,
 208                 'string': bundle.description,
 209                 'id': bundle.id
 210             }
 211
 212         return items
 213
 214
 215 class BookingMetaForm(forms.Form):
 216
 217     length = forms.IntegerField(
 218         widget=NumberInput(
 219             attrs={
 220                 "type": "range",
 221                 'min': "1",
 222                 "max": "21",
 223                 "value": "1"
 224             }
 225         )
 226     )
 227     purpose = forms.CharField(max_length=1000)
 228     project = forms.CharField(max_length=400)
 229     info_file = forms.CharField(max_length=1000, required=False)
 230     deploy_opnfv = forms.BooleanField(required=False)
 231
 232     def __init__(self, *args, user_initial=[], owner=None, **kwargs):
 233         super(BookingMetaForm, self).__init__(**kwargs)
 234
 235         self.fields['users'] = SearchableSelectMultipleField(
 236             queryset=UserProfile.objects.select_related('user').exclude(user=owner),
 237             initial=user_initial,
 238             items=get_user_items(exclude=owner),
 239             required=False,
 240             **get_user_field_opts()
 241         )
 242
 243
 244 class MultipleSelectFilterWidget(forms.Widget):
 245     def __init__(self, *args, display_objects=None, filter_items=None, neighbors=None, **kwargs):
 246         super(MultipleSelectFilterWidget, self).__init__(*args, **kwargs)
 247         self.display_objects = display_objects
 248         self.filter_items = filter_items
 249         self.neighbors = neighbors
 250         self.template_name = "dashboard/multiple_select_filter_widget.html"
 251
 252     def render(self, name, value, attrs=None, renderer=None):
 253         context = self.get_context(name, value, attrs)
 254         html = render_to_string(self.template_name, context=context)
 255         return mark_safe(html)
 256
 257     def get_context(self, name, value, attrs):
 258         return {
 259             'display_objects': self.display_objects,
 260             'neighbors': self.neighbors,
 261             'filter_items': self.filter_items,
 262             'initial_value': value
 263         }
 264
 265
 266 class MultipleSelectFilterField(forms.Field):
 267
 268     def __init__(self, **kwargs):
 269         self.initial = kwargs.get("initial")
 270         super().__init__(**kwargs)
 271
 272     def to_python(self, value):
 273         return json.loads(value)
 274
 275
 276 class FormUtils:
 277     @staticmethod
 278     def getLabData(multiple_hosts=False):
 279         """
 280         Gets all labs and thier host profiles and returns a serialized version the form can understand.
 281         Should be rewritten with a related query to make it faster
 282         """
 283         # javascript truthy variables
 284         true = 1
 285         false = 0
 286         if multiple_hosts:
 287             multiple_hosts = true
 288         else:
 289             multiple_hosts = false
 290         labs = {}
 291         hosts = {}
 292         items = {}
 293         neighbors = {}
 294         for lab in Lab.objects.all():
 295             lab_node = {
 296                 'id': "lab_" + str(lab.lab_user.id),
 297                 'model_id': lab.lab_user.id,
 298                 'name': lab.name,
 299                 'description': lab.description,
 300                 'selected': false,
 301                 'selectable': true,
 302                 'follow': false,
 303                 'multiple': false,
 304                 'class': 'lab'
 305             }
 306             if multiple_hosts:
 307                 # "follow" this lab node to discover more hosts if allowed
 308                 lab_node['follow'] = true
 309             items[lab_node['id']] = lab_node
 310             neighbors[lab_node['id']] = []
 311             labs[lab_node['id']] = lab_node
 312
 313             for host in lab.hostprofiles.all():
 314                 host_node = {
 315                     'form': {"name": "host_name", "type": "text", "placeholder": "hostname"},
 316                     'id': "host_" + str(host.id),
 317                     'model_id': host.id,
 318                     'name': host.name,
 319                     'description': host.description,
 320                     'selected': false,
 321                     'selectable': true,
 322                     'follow': false,
 323                     'multiple': multiple_hosts,
 324                     'class': 'host'
 325                 }
 326                 if multiple_hosts:
 327                     host_node['values'] = []  # place to store multiple values
 328                 items[host_node['id']] = host_node
 329                 neighbors[lab_node['id']].append(host_node['id'])
 330                 if host_node['id'] not in neighbors:
 331                     neighbors[host_node['id']] = []
 332                 neighbors[host_node['id']].append(lab_node['id'])
 333                 hosts[host_node['id']] = host_node
 334
 335         display_objects = [("lab", labs.values()), ("host", hosts.values())]
 336
 337         context = {
 338             'display_objects': display_objects,
 339             'neighbors': neighbors,
 340             'filter_items': items
 341         }
 342         return context
 343
 344
 345 class HardwareDefinitionForm(forms.Form):
 346
 347     def __init__(self, *args, **kwargs):
 348         super(HardwareDefinitionForm, self).__init__(*args, **kwargs)
 349         attrs = FormUtils.getLabData(multiple_hosts=True)
 350         self.fields['filter_field'] = MultipleSelectFilterField(
 351             widget=MultipleSelectFilterWidget(**attrs)
 352         )
 353
 354
 355 class PodDefinitionForm(forms.Form):
 356
 357     fields = ["xml"]
 358     xml = forms.CharField()
 359
 360
 361 class ResourceMetaForm(forms.Form):
 362
 363     bundle_name = forms.CharField(label="POD Name")
 364     bundle_description = forms.CharField(label="POD Description", widget=forms.Textarea)
 365
 366
 367 class GenericHostMetaForm(forms.Form):
 368
 369     host_profile = forms.CharField(label="Host Type", disabled=True, required=False)
 370     host_name = forms.CharField(label="Host Name")
 371
 372
 373 class NetworkDefinitionForm(forms.Form):
 374     def __init__(self, *args, **kwargs):
 375         super(NetworkDefinitionForm, self).__init__(**kwargs)
 376
 377
 378 class NetworkConfigurationForm(forms.Form):
 379     def __init__(self, *args, **kwargs):
 380         super(NetworkConfigurationForm).__init__(**kwargs)
 381
 382
 383 class HostSoftwareDefinitionForm(forms.Form):
 384
 385     host_name = forms.CharField(max_length=200, disabled=True, required=False)
 386     headnode = forms.BooleanField(required=False, widget=forms.HiddenInput)
 387
 388     def __init__(self, *args, **kwargs):
 389         imageQS = kwargs.pop("imageQS")
 390         super(HostSoftwareDefinitionForm, self).__init__(*args, **kwargs)
 391         self.fields['image'] = forms.ModelChoiceField(queryset=imageQS)
 392
 393
 394 class WorkflowSelectionForm(forms.Form):
 395     fields = ['workflow']
 396
 397     empty_permitted = False
 398
 399     workflow = forms.ChoiceField(
 400         choices=(
 401             (0, 'Booking'),
 402             (1, 'Resource Bundle'),
 403             (2, 'Software Configuration')
 404         ),
 405         label="Choose Workflow",
 406         initial='booking',
 407         required=True
 408     )
 409
 410
 411 class SnapshotHostSelectForm(forms.Form):
 412     host = forms.CharField()
 413
 414
 415 class BasicMetaForm(forms.Form):
 416     name = forms.CharField()
 417     description = forms.CharField(widget=forms.Textarea)
 418
 419
 420 class ConfirmationForm(forms.Form):
 421     fields = ['confirm']
 422
 423     confirm = forms.ChoiceField(
 424         choices=(
 425             (True, "Confirm"),
 426             (False, "Cancel")
 427         )
 428     )
 429
 430
 431 class OPNFVSelectionForm(forms.Form):
 432     installer = forms.ModelChoiceField(queryset=Installer.objects.all(), required=True)
 433     scenario = forms.ModelChoiceField(queryset=Scenario.objects.all(), required=True)
 434
 435
 436 class OPNFVNetworkRoleForm(forms.Form):
 437     role = forms.CharField(max_length=200, disabled=True, required=False)
 438
 439     def __init__(self, *args, config_bundle, **kwargs):
 440         super(OPNFVNetworkRoleForm, self).__init__(*args, **kwargs)
 441         self.fields['network'] = forms.ModelChoiceField(
 442             queryset=config_bundle.bundle.networks.all()
 443         )
 444
 445
 446 class OPNFVHostRoleForm(forms.Form):
 447     host_name = forms.CharField(max_length=200, disabled=True, required=False)
 448     role = forms.ModelChoiceField(queryset=OPNFVRole.objects.all().order_by("name").distinct("name"))