planetstack/core/admin.py

   1 from core.models import Site
   2 from core.models import *
   3 from openstack.manager import OpenStackManager
   4
   5 from django.contrib import admin
   6 from django.contrib.auth.models import Group
   7 from django import forms
   8 from django.utils.safestring import mark_safe
   9 from django.contrib.auth.admin import UserAdmin
  10 from django.contrib.admin.widgets import FilteredSelectMultiple, AdminTextareaWidget
  11 from django.contrib.auth.forms import ReadOnlyPasswordHashField, AdminPasswordChangeForm
  12 from django.contrib.auth.signals import user_logged_in
  13 from django.utils import timezone
  14 from django.contrib.contenttypes import generic
  15 from suit.widgets import LinkedSelect
  16 from django.core.exceptions import PermissionDenied
  17 from django.core.urlresolvers import reverse, NoReverseMatch
  18 from django.utils.encoding import force_text, python_2_unicode_compatible
  19 from django.utils.html import conditional_escape, format_html
  20 from django.forms.utils import flatatt, to_current_timezone
  21 from cgi import escape as html_escape
  22
  23 import django_evolution
  24 import threading
  25
  26 # thread locals necessary to work around a django-suit issue
  27 _thread_locals = threading.local()
  28
  29 def backend_icon(obj): # backend_status, enacted, updated):
  30     #return "%s %s %s" % (str(obj.updated), str(obj.enacted), str(obj.backend_status))
  31     if (obj.enacted is not None) and obj.enacted >= obj.updated:
  32         return '<span style="min-width:16px;"><img src="/static/admin/img/icon_success.gif"></span>'
  33     else:
  34         if obj.backend_status == "Provisioning in progress" or obj.backend_status=="":
  35             return '<span style="min-width:16px;" title="%s"><img src="/static/admin/img/icon_clock.gif"></span>' % obj.backend_status
  36         else:
  37             return '<span style="min-width:16px;" title="%s"><img src="/static/admin/img/icon_error.gif"></span>' % html_escape(obj.backend_status, quote=True)
  38
  39 def backend_text(obj):
  40     icon = backend_icon(obj)
  41     if (obj.enacted is not None) and obj.enacted >= obj.updated:
  42         return "%s %s" % (icon, "successfully enacted")
  43     else:
  44         return "%s %s" % (icon, html_escape(obj.backend_status, quote=True))
  45
  46 class UploadTextareaWidget(AdminTextareaWidget):
  47     def render(self, name, value, attrs=None):
  48         if value is None:
  49             value = ''\r
  50         final_attrs = self.build_attrs(attrs, name=name)\r
  51         return format_html('<input type="file" style="width: 0; height: 0" id="btn_upload_%s" onChange="uploadTextarea(event,\'%s\');">' \\r
  52                            '<button onClick="$(\'#btn_upload_%s\').click(); return false;">Upload</button>' \\r
  53                            '<br><textarea{0}>\r\n{1}</textarea>' % (attrs["id"], attrs["id"], attrs["id"]),\r
  54                            flatatt(final_attrs),\r
  55                            force_text(value))
  56
  57 class PlainTextWidget(forms.HiddenInput):
  58     input_type = 'hidden'
  59
  60     def render(self, name, value, attrs=None):
  61         if value is None:
  62             value = ''
  63         return mark_safe(str(value) + super(PlainTextWidget, self).render(name, value, attrs))
  64
  65 class PermissionCheckingAdminMixin(object):
  66     # call save_by_user and delete_by_user instead of save and delete
  67
  68     def has_add_permission(self, request, obj=None):
  69         return (not self.__user_is_readonly(request))
  70
  71     def has_delete_permission(self, request, obj=None):
  72         return (not self.__user_is_readonly(request))
  73
  74     def save_model(self, request, obj, form, change):
  75         if self.__user_is_readonly(request):
  76             # this 'if' might be redundant if save_by_user is implemented right
  77             raise PermissionDenied
  78
  79         obj.caller = request.user
  80         # update openstack connection to use this site/tenant
  81         obj.save_by_user(request.user)
  82
  83     def delete_model(self, request, obj):
  84         obj.delete_by_user(request.user)
  85
  86     def save_formset(self, request, form, formset, change):
  87         instances = formset.save(commit=False)
  88         for instance in instances:
  89             instance.save_by_user(request.user)
  90
  91         # BUG in django 1.7? Objects are not deleted by formset.save if
  92         # commit is False. So let's delete them ourselves.
  93         #
  94         # code from forms/models.py save_existing_objects()
  95         try:
  96             forms_to_delete = formset.deleted_forms\r
  97         except AttributeError:\r
  98             forms_to_delete = []
  99         if formset.initial_forms:
 100             for form in formset.initial_forms:
 101                 obj = form.instance
 102                 if form in forms_to_delete:
 103                     if obj.pk is None:
 104                         continue
 105                     formset.deleted_objects.append(obj)
 106                     obj.delete()
 107
 108         formset.save_m2m()
 109
 110     def get_actions(self,request):
 111         actions = super(PermissionCheckingAdminMixin,self).get_actions(request)
 112
 113         if self.__user_is_readonly(request):
 114             if 'delete_selected' in actions:
 115                 del actions['delete_selected']
 116
 117         return actions
 118
 119     def change_view(self,request,object_id, extra_context=None):
 120         if self.__user_is_readonly(request):
 121             if not hasattr(self, "readonly_save"):\r
 122                 # save the original readonly fields\r
 123                 self.readonly_save = self.readonly_fields\r
 124                 self.inlines_save = self.inlines\r
 125             if hasattr(self, "user_readonly_fields"):\r
 126                 self.readonly_fields=self.user_readonly_fields\r
 127             if hasattr(self, "user_readonly_inlines"):\r
 128                 self.inlines = self.user_readonly_inlines\r
 129         else:\r
 130             if hasattr(self, "readonly_save"):\r
 131                 # restore the original readonly fields\r
 132                 self.readonly_fields = self.readonly_save\r
 133             if hasattr(self, "inlines_save"):\r
 134                 self.inlines = self.inlines_save
 135
 136         try:
 137             return super(PermissionCheckingAdminMixin, self).change_view(request, object_id, extra_context=extra_context)
 138         except PermissionDenied:
 139             pass
 140         if request.method == 'POST':
 141             raise PermissionDenied
 142         request.readonly = True
 143         return super(PermissionCheckingAdminMixin, self).change_view(request, object_id, extra_context=extra_context)
 144
 145     def __user_is_readonly(self, request):
 146         return request.user.isReadOnlyUser()
 147
 148     def backend_status_text(self, obj):
 149         return mark_safe(backend_text(obj))
 150
 151     def backend_status_icon(self, obj):
 152         return mark_safe(backend_icon(obj))
 153     backend_status_icon.short_description = ""
 154
 155     def get_form(self, request, obj=None, **kwargs):
 156         # Save obj and request in thread-local storage, so suit_form_tabs can
 157         # use it to determine whether we're in edit or add mode, and can
 158         # determine whether the user is an admin.
 159         _thread_locals.request = request
 160         _thread_locals.obj = obj
 161         return super(PermissionCheckingAdminMixin, self).get_form(request, obj, **kwargs)
 162
 163     def get_inline_instances(self, request, obj=None):
 164         inlines = super(PermissionCheckingAdminMixin, self).get_inline_instances(request, obj)
 165
 166         # inlines that should only be shown to an admin user
 167         if request.user.is_admin:
 168             for inline_class in getattr(self, "admin_inlines", []):
 169                 inlines.append(inline_class(self.model, self.admin_site))
 170
 171         return inlines
 172
 173 class ReadOnlyAwareAdmin(PermissionCheckingAdminMixin, admin.ModelAdmin):
 174     # Note: Make sure PermissionCheckingAdminMixin is listed before
 175     # admin.ModelAdmin in the class declaration.
 176
 177     pass
 178
 179 class PlanetStackBaseAdmin(ReadOnlyAwareAdmin):
 180     save_on_top = False
 181
 182 class SingletonAdmin (ReadOnlyAwareAdmin):
 183     def has_add_permission(self, request):
 184         if not super(SingletonAdmin, self).has_add_permission(request):
 185             return False
 186
 187         num_objects = self.model.objects.count()
 188         if num_objects >= 1:
 189             return False
 190         else:
 191             return True
 192
 193 class PlStackTabularInline(admin.TabularInline):
 194     def __init__(self, *args, **kwargs):
 195         super(PlStackTabularInline, self).__init__(*args, **kwargs)
 196
 197         # InlineModelAdmin as no get_fields() method, so in order to add
 198         # the selflink field, we override __init__ to modify self.fields and
 199         # self.readonly_fields.
 200
 201         self.setup_selflink()
 202
 203     def get_change_url(self, model, id):
 204         """ Get the URL to a change form in the admin for this model """
 205         reverse_path = "admin:%s_change" % (model._meta.db_table)
 206         try:
 207             url = reverse(reverse_path, args=(id,))
 208         except NoReverseMatch:
 209             return None
 210
 211         return url
 212
 213     def setup_selflink(self):
 214         if hasattr(self, "selflink_fieldname"):
 215             """ self.selflink_model can be defined to punch through a relation
 216                 to its target object. For example, in SliceNetworkInline, set
 217                 selflink_model = "network", and the URL will lead to the Network
 218                 object instead of trying to bring up a change view of the
 219                 SliceNetwork object.
 220             """
 221             self.selflink_model = getattr(self.model,self.selflink_fieldname).field.rel.to
 222         else:
 223             self.selflink_model = self.model
 224
 225         url = self.get_change_url(self.selflink_model, 0)
 226
 227         # We don't have an admin for this object, so don't create the
 228         # selflink.
 229         if (url == None):
 230             return
 231
 232         # Since we need to add "selflink" to the field list, we need to create
 233         # self.fields if it is None.
 234         if (self.fields is None):
 235             self.fields = []
 236             for f in self.model._meta.fields:
 237                 if f.editable and f.name != "id":
 238                     self.fields.append(f.name)
 239
 240         self.fields = tuple(self.fields) + ("selflink", )
 241
 242         if self.readonly_fields is None:
 243             self.readonly_fields = ()
 244
 245         self.readonly_fields = tuple(self.readonly_fields) + ("selflink", )
 246
 247     def selflink(self, obj):
 248         if hasattr(self, "selflink_fieldname"):
 249             obj = getattr(obj, self.selflink_fieldname)
 250
 251         if obj.id:
 252             url = self.get_change_url(self.selflink_model, obj.id)
 253             return "<a href='%s'>Details</a>" % str(url)
 254         else:\r
 255             return "Not present"\r
 256
 257     selflink.allow_tags = True
 258     selflink.short_description = "Details"
 259
 260     def has_add_permission(self, request):
 261         return not request.user.isReadOnlyUser()
 262
 263     def get_readonly_fields(self, request, obj=None):
 264         readonly_fields = list(self.readonly_fields)[:]
 265         if request.user.isReadOnlyUser():
 266             for field in self.fields:
 267                 if not field in readonly_fields:
 268                     readonly_fields.append(field)
 269         return readonly_fields
 270
 271     def backend_status_icon(self, obj):
 272         return mark_safe(backend_icon(obj))
 273     backend_status_icon.short_description = ""
 274
 275 class PlStackGenericTabularInline(generic.GenericTabularInline):
 276     def has_add_permission(self, request):
 277         return not request.user.isReadOnlyUser()
 278
 279     def get_readonly_fields(self, request, obj=None):
 280         readonly_fields = list(self.readonly_fields)[:]
 281         if request.user.isReadOnlyUser():
 282             for field in self.fields:
 283                 if not field in readonly_fields:
 284                     readonly_fields.append(field)
 285         return readonly_fields
 286
 287     def backend_status_icon(self, obj):
 288         return mark_safe(backend_icon(obj))
 289     backend_status_icon.short_description = ""
 290
 291 class ReservationInline(PlStackTabularInline):
 292     model = Reservation
 293     extra = 0
 294     suit_classes = 'suit-tab suit-tab-reservations'
 295
 296     def queryset(self, request):
 297         return Reservation.select_by_user(request.user)
 298
 299 class TagInline(PlStackGenericTabularInline):
 300     model = Tag
 301     extra = 0
 302     suit_classes = 'suit-tab suit-tab-tags'
 303     fields = ['service', 'name', 'value']
 304
 305     def queryset(self, request):
 306         return Tag.select_by_user(request.user)
 307
 308 class NetworkLookerUpper:
 309     """ This is a callable that looks up a network name in a sliver and returns
 310         the ip address for that network.
 311     """
 312
 313     byNetworkName = {}    # class variable
 314
 315     def __init__(self, name):
 316         self.short_description = name
 317         self.__name__ = name
 318         self.network_name = name
 319
 320     def __call__(self, obj):
 321         if obj is not None:
 322             for nbs in obj.networksliver_set.all():
 323                 if (nbs.network.name == self.network_name):
 324                     return nbs.ip
 325         return ""
 326
 327     def __str__(self):
 328         return self.network_name
 329
 330     @staticmethod
 331     def get(network_name):
 332         """ We want to make sure we alwars return the same NetworkLookerUpper
 333             because sometimes django will cause them to be instantiated multiple
 334             times (and we don't want different ones in form.fields vs
 335             SliverInline.readonly_fields).
 336         """
 337         if network_name not in NetworkLookerUpper.byNetworkName:
 338             NetworkLookerUpper.byNetworkName[network_name] = NetworkLookerUpper(network_name)
 339         return NetworkLookerUpper.byNetworkName[network_name]
 340
 341 class SliverInline(PlStackTabularInline):
 342     model = Sliver
 343     fields = ['backend_status_icon', 'all_ips_string', 'instance_name', 'slice', 'deployment', 'flavor', 'image', 'node']
 344     extra = 0
 345     readonly_fields = ['backend_status_icon', 'all_ips_string', 'instance_name']
 346     suit_classes = 'suit-tab suit-tab-slivers'
 347
 348     def queryset(self, request):
 349         return Sliver.select_by_user(request.user)
 350
 351     def formfield_for_foreignkey(self, db_field, request=None, **kwargs):
 352         if db_field.name == 'deployment':
 353            kwargs['queryset'] = Deployment.select_by_acl(request.user)
 354            kwargs['widget'] = forms.Select(attrs={'onChange': "sliver_deployment_changed(this);"})
 355         if db_field.name == 'flavor':
 356            kwargs['widget'] = forms.Select(attrs={'onChange': "sliver_flavor_changed(this);"})
 357
 358         field = super(SliverInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
 359
 360         return field
 361
 362 class SiteInline(PlStackTabularInline):
 363     model = Site
 364     extra = 0
 365     suit_classes = 'suit-tab suit-tab-sites'
 366
 367     def queryset(self, request):
 368         return Site.select_by_user(request.user)
 369
 370 class UserInline(PlStackTabularInline):
 371     model = User
 372     fields = ['backend_status_icon', 'email', 'firstname', 'lastname']
 373     readonly_fields = ('backend_status_icon', )
 374     extra = 0
 375     suit_classes = 'suit-tab suit-tab-users'
 376
 377     def queryset(self, request):
 378         return User.select_by_user(request.user)
 379
 380 class SliceInline(PlStackTabularInline):
 381     model = Slice
 382     fields = ['backend_status_icon', 'name', 'site', 'serviceClass', 'service']
 383     readonly_fields = ('backend_status_icon', )
 384     extra = 0
 385     suit_classes = 'suit-tab suit-tab-slices'
 386
 387     def queryset(self, request):
 388         return Slice.select_by_user(request.user)
 389
 390 class NodeInline(PlStackTabularInline):
 391     model = Node
 392     extra = 0
 393     suit_classes = 'suit-tab suit-tab-nodes'
 394     fields = ['backend_status_icon', 'name', 'site_deployment']
 395     readonly_fields = ('backend_status_icon', )
 396
 397 class DeploymentPrivilegeInline(PlStackTabularInline):
 398     model = DeploymentPrivilege
 399     extra = 0
 400     suit_classes = 'suit-tab suit-tab-admin-only'
 401     fields = ['backend_status_icon', 'user','role','deployment']
 402     readonly_fields = ('backend_status_icon', )
 403
 404     def queryset(self, request):
 405         return DeploymentPrivilege.select_by_user(request.user)
 406
 407 class ControllerSiteInline(PlStackTabularInline):
 408     model = ControllerSite
 409     extra = 0
 410     suit_classes = 'suit-tab suit-tab-admin-only'
 411     fields = ['controller', 'site', 'tenant_id']
 412
 413
 414 class SitePrivilegeInline(PlStackTabularInline):
 415     model = SitePrivilege
 416     extra = 0
 417     suit_classes = 'suit-tab suit-tab-siteprivileges'
 418     fields = ['backend_status_icon', 'user','site', 'role']
 419     readonly_fields = ('backend_status_icon', )
 420
 421     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 422         if db_field.name == 'site':
 423             kwargs['queryset'] = Site.select_by_user(request.user)
 424
 425         if db_field.name == 'user':
 426             kwargs['queryset'] = User.select_by_user(request.user)
 427         return super(SitePrivilegeInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
 428
 429     def queryset(self, request):
 430         return SitePrivilege.select_by_user(request.user)
 431
 432 class SiteDeploymentInline(PlStackTabularInline):
 433     model = SiteDeployment
 434     extra = 0
 435     suit_classes = 'suit-tab suit-tab-deployments'
 436     fields = ['backend_status_icon', 'deployment','site', 'controller']
 437     readonly_fields = ('backend_status_icon', )
 438
 439     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 440         if db_field.name == 'site':
 441             kwargs['queryset'] = Site.select_by_user(request.user)
 442
 443         if db_field.name == 'deployment':
 444             kwargs['queryset'] = Deployment.select_by_user(request.user)
 445
 446         if db_field.name == 'controller':
 447             kwargs['queryset'] = Controller.select_by_user(request.user)
 448
 449         return super(SiteDeploymentInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
 450
 451     def queryset(self, request):
 452         return SiteDeployment.select_by_user(request.user)
 453
 454
 455 class SlicePrivilegeInline(PlStackTabularInline):
 456     model = SlicePrivilege
 457     suit_classes = 'suit-tab suit-tab-sliceprivileges'
 458     extra = 0
 459     fields = ('backend_status_icon', 'user', 'slice', 'role')
 460     readonly_fields = ('backend_status_icon', )
 461
 462     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 463         if db_field.name == 'slice':
 464            kwargs['queryset'] = Slice.select_by_user(request.user)
 465         if db_field.name == 'user':
 466            kwargs['queryset'] = User.select_by_user(request.user)
 467
 468         return super(SlicePrivilegeInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
 469
 470     def queryset(self, request):
 471         return SlicePrivilege.select_by_user(request.user)
 472
 473 class SliceNetworkInline(PlStackTabularInline):
 474     model = Network.slices.through
 475     selflink_fieldname = "network"
 476     extra = 0
 477     verbose_name = "Network Connection"
 478     verbose_name_plural = "Network Connections"
 479     suit_classes = 'suit-tab suit-tab-slicenetworks'
 480     fields = ['backend_status_icon', 'network']
 481     readonly_fields = ('backend_status_icon', )
 482
 483 class ImageDeploymentsInline(PlStackTabularInline):
 484     model = ImageDeployments
 485     extra = 0
 486     verbose_name = "Image Deployments"
 487     verbose_name_plural = "Image Deployments"
 488     suit_classes = 'suit-tab suit-tab-imagedeployments'
 489     fields = ['backend_status_icon', 'image', 'deployment']
 490     readonly_fields = ['backend_status_icon']
 491
 492 class ControllerImagesInline(PlStackTabularInline):
 493     model = ControllerImages
 494     extra = 0
 495     verbose_name = "Controller Images"
 496     verbose_name_plural = "Controller Images"
 497     suit_classes = 'suit-tab suit-tab-admin-only'
 498     fields = ['backend_status_icon', 'image', 'controller', 'glance_image_id']
 499     readonly_fields = ['backend_status_icon', 'glance_image_id']
 500
 501 class SliceRoleAdmin(PlanetStackBaseAdmin):
 502     model = SliceRole
 503     pass
 504
 505 class SiteRoleAdmin(PlanetStackBaseAdmin):
 506     model = SiteRole
 507     pass
 508
 509 class DeploymentAdminForm(forms.ModelForm):
 510     sites = forms.ModelMultipleChoiceField(
 511         queryset=Site.objects.all(),
 512         required=False,
 513         help_text="Select which sites are allowed to host nodes in this deployment",
 514         widget=FilteredSelectMultiple(
 515             verbose_name=('Sites'), is_stacked=False
 516         )
 517     )
 518     images = forms.ModelMultipleChoiceField(
 519         queryset=Image.objects.all(),
 520         required=False,
 521         help_text="Select which images should be deployed on this deployment",
 522         widget=FilteredSelectMultiple(
 523             verbose_name=('Images'), is_stacked=False
 524         )
 525     )
 526     flavors = forms.ModelMultipleChoiceField(
 527         queryset=Flavor.objects.all(),
 528         required=False,
 529         help_text="Select which flavors should be usable on this deployment",
 530         widget=FilteredSelectMultiple(
 531             verbose_name=('Flavors'), is_stacked=False
 532         )
 533     )
 534     class Meta:
 535         model = Deployment
 536         many_to_many = ["flavors",]
 537
 538     def __init__(self, *args, **kwargs):
 539       request = kwargs.pop('request', None)
 540       super(DeploymentAdminForm, self).__init__(*args, **kwargs)
 541
 542       self.fields['accessControl'].initial = "allow site " + request.user.site.name
 543
 544       if self.instance and self.instance.pk:
 545         self.fields['sites'].initial = [x for x in self.instance.sitesdeployments.all()]
 546         self.fields['images'].initial = [x.image for x in self.instance.imagedeployments.all()]
 547         self.fields['flavors'].initial = self.instance.flavors.all()
 548
 549     def manipulate_m2m_objs(self, this_obj, selected_objs, all_relations, relation_class, local_attrname, foreign_attrname):
 550         """ helper function for handling m2m relations from the MultipleChoiceField
 551
 552             this_obj: the source object we want to link from
 553
 554             selected_objs: a list of destination objects we want to link to
 555
 556             all_relations: the full set of relations involving this_obj, including ones we don't want
 557
 558             relation_class: the class that implements the relation from source to dest
 559
 560             local_attrname: field name representing this_obj in relation_class
 561
 562             foreign_attrname: field name representing selected_objs in relation_class
 563
 564             This function will remove all newobjclass relations from this_obj
 565             that are not contained in selected_objs, and add any relations that
 566             are in selected_objs but don't exist in the data model yet.
 567         """
 568
 569         existing_dest_objs = []
 570         for relation in list(all_relations):
 571             if getattr(relation, foreign_attrname) not in selected_objs:
 572                 #print "deleting site", sdp.site
 573                 relation.delete()
 574             else:
 575                 existing_dest_objs.append(getattr(relation, foreign_attrname))
 576
 577         for dest_obj in selected_objs:
 578             if dest_obj not in existing_dest_objs:
 579                 #print "adding site", site
 580                 kwargs = {foreign_attrname: dest_obj, local_attrname: this_obj}
 581                 relation = relation_class(**kwargs)
 582                 relation.save()
 583
 584     def save(self, commit=True):
 585       deployment = super(DeploymentAdminForm, self).save(commit=False)
 586
 587       if commit:
 588         deployment.save()
 589         # this has to be done after save() if/when a deployment is first created
 590         deployment.flavors = self.cleaned_data['flavors']
 591
 592       if deployment.pk:
 593         # save_m2m() doesn't seem to work with 'through' relations. So we
 594         #    create/destroy the through models ourselves. There has to be
 595         #    a better way...
 596
 597         self.manipulate_m2m_objs(deployment, self.cleaned_data['sites'], deployment.sitedeployment.all(), SiteDeployment, "deployment", "site")
 598         self.manipulate_m2m_objs(deployment, self.cleaned_data['images'], deployment.imagedeployments.all(), ImageDeployments, "deployment", "image")
 599         # manipulate_m2m_objs doesn't work for Flavor/Deployment relationship
 600         # so well handle that manually here
 601         for flavor in deployment.flavors.all():
 602             if getattr(flavor, 'name') not in self.cleaned_data['flavors']:
 603                 deployment.flavors.remove(flavor)
 604         for flavor in self.cleaned_data['flavors']:
 605             if flavor not in deployment.flavors.all():
 606                 flavor.deployments.add(deployment)
 607
 608       self.save_m2m()
 609
 610       return deployment
 611
 612 class DeploymentAdminROForm(DeploymentAdminForm):
 613     def save(self, commit=True):
 614         raise PermissionDenied
 615
 616 class SiteAssocInline(PlStackTabularInline):
 617     model = Site.deployments.through
 618     extra = 0
 619     suit_classes = 'suit-tab suit-tab-sites'
 620
 621 class DeploymentAdmin(PlanetStackBaseAdmin):
 622     model = Deployment
 623     fieldList = ['backend_status_text', 'name', 'sites', 'images', 'flavors', 'accessControl']
 624     fieldsets = [(None, {'fields': fieldList, 'classes':['suit-tab suit-tab-sites']})]
 625     # node no longer directly connected to deployment
 626     #inlines = [DeploymentPrivilegeInline,NodeInline,TagInline,ImageDeploymentsInline]
 627     inlines = [DeploymentPrivilegeInline,TagInline,ImageDeploymentsInline]
 628     list_display = ['backend_status_icon', 'name']
 629     list_display_links = ('backend_status_icon', 'name', )
 630     readonly_fields = ('backend_status_text', )
 631
 632     user_readonly_fields = ['name']
 633
 634     # nodes no longer direclty connected to deployments
 635     #suit_form_tabs =(('sites','Deployment Details'),('nodes','Nodes'),('deploymentprivileges','Privileges'),('tags','Tags'),('imagedeployments','Images'))
 636     suit_form_tabs =(('sites','Deployment Details'),('deploymentprivileges','Privileges'))
 637
 638     def get_form(self, request, obj=None, **kwargs):
 639         if request.user.isReadOnlyUser():
 640             kwargs["form"] = DeploymentAdminROForm
 641         else:
 642             kwargs["form"] = DeploymentAdminForm
 643         adminForm = super(DeploymentAdmin,self).get_form(request, obj, **kwargs)
 644
 645         # from stackexchange: pass the request object into the form
 646
 647         class AdminFormMetaClass(adminForm):
 648            def __new__(cls, *args, **kwargs):
 649                kwargs['request'] = request
 650                return adminForm(*args, **kwargs)
 651
 652         return AdminFormMetaClass
 653
 654 class ControllerAdminForm(forms.ModelForm):
 655     sites = forms.ModelMultipleChoiceField(
 656         queryset=Site.objects.all(),
 657         required=False,
 658         help_text="Select which sites are managed by this controller",
 659         widget=FilteredSelectMultiple(
 660             verbose_name=('Sites'), is_stacked=False
 661         )
 662     )
 663
 664     class Meta:
 665         model = Controller
 666
 667     def __init__(self, *args, **kwargs):
 668         request = kwargs.pop('request', None)
 669         super(ControllerAdminForm, self).__init__(*args, **kwargs)
 670
 671         if self.instance and self.instance.pk:
 672             self.fields['sites'].initial = [x.site for x in self.instance.controllersite.all()]
 673
 674     def manipulate_m2m_objs(self, this_obj, selected_objs, all_relations, relation_class, local_attrname, foreign_attrname):
 675         """ helper function for handling m2m relations from the MultipleChoiceField
 676             this_obj: the source object we want to link from
 677             selected_objs: a list of destination objects we want to link to
 678             all_relations: the full set of relations involving this_obj, including ones we don't want
 679             relation_class: the class that implements the relation from source to dest
 680             local_attrname: field name representing this_obj in relation_class
 681             foreign_attrname: field name representing selected_objs in relation_class
 682             This function will remove all newobjclass relations from this_obj
 683             that are not contained in selected_objs, and add any relations that
 684             are in selected_objs but don't exist in the data model yet.
 685         """
 686         existing_dest_objs = []
 687         for relation in list(all_relations):
 688             if getattr(relation, foreign_attrname) not in selected_objs:
 689                 #print "deleting site", sdp.site
 690                 relation.delete()
 691             else:
 692                 existing_dest_objs.append(getattr(relation, foreign_attrname))
 693
 694         for dest_obj in selected_objs:
 695             if dest_obj not in existing_dest_objs:
 696                 #print "adding site", site
 697                 kwargs = {foreign_attrname: dest_obj, local_attrname: this_obj}
 698                 relation = relation_class(**kwargs)
 699                 relation.save()
 700
 701     def save(self, commit=True):
 702         controller = super(ControllerAdminForm, self).save(commit=False)
 703         if commit:
 704             controller.save()
 705
 706         if controller.pk:
 707             # save_m2m() doesn't seem to work with 'through' relations. So we
 708             #    create/destroy the through models ourselves. There has to be
 709             #    a better way...
 710             self.manipulate_m2m_objs(controller, self.cleaned_data['sites'], controller.controllersite.all(), ControllerSite, "controller", "site")
 711             pass
 712
 713         self.save_m2m()
 714
 715         return controller
 716
 717 class ControllerAdmin(PlanetStackBaseAdmin):
 718     model = Controller
 719     fieldList = ['name', 'version', 'backend_type', 'auth_url', 'admin_user', 'admin_tenant','admin_password']
 720     #fieldsets = [(None, {'fields': fieldList, 'classes':['suit-tab suit-tab-general']})]
 721     inlines = [ControllerSiteInline] # ,ControllerImagesInline]
 722     list_display = ['backend_status_icon', 'name', 'version', 'backend_type']
 723     list_display_links = ('backend_status_icon', 'name', )
 724     readonly_fields = ('backend_status_text',)
 725
 726     user_readonly_fields = []
 727
 728     def get_form(self, request, obj=None, **kwargs):
 729         print self.fieldsets
 730         if request.user.isReadOnlyUser():
 731             kwargs["form"] = ControllerAdminROForm
 732         else:
 733             kwargs["form"] = ControllerAdminForm
 734         adminForm = super(ControllerAdmin,self).get_form(request, obj, **kwargs)
 735
 736         # from stackexchange: pass the request object into the form
 737
 738         class AdminFormMetaClass(adminForm):
 739            def __new__(cls, *args, **kwargs):
 740                kwargs['request'] = request
 741                return adminForm(*args, **kwargs)
 742
 743         return AdminFormMetaClass
 744
 745     def save_model(self, request, obj, form, change):
 746         # update openstack connection to use this site/tenant
 747         obj.save_by_user(request.user)
 748
 749     def delete_model(self, request, obj):
 750         obj.delete_by_user(request.user)
 751
 752 class ServiceAttrAsTabInline(PlStackTabularInline):
 753     model = ServiceAttribute
 754     fields = ['name','value']
 755     extra = 0
 756     suit_classes = 'suit-tab suit-tab-serviceattrs'
 757
 758 class ServiceAdmin(PlanetStackBaseAdmin):
 759     list_display = ("backend_status_icon","name","description","versionNumber","enabled","published")
 760     list_display_links = ('backend_status_icon', 'name', )
 761     fieldList = ["backend_status_text","name","description","versionNumber","enabled","published"]
 762     fieldsets = [(None, {'fields': fieldList, 'classes':['suit-tab suit-tab-general']})]
 763     inlines = [ServiceAttrAsTabInline,SliceInline]
 764     readonly_fields = ('backend_status_text', )
 765
 766     user_readonly_fields = fieldList
 767
 768     suit_form_tabs =(('general', 'Service Details'),
 769         ('slices','Slices'),
 770         ('serviceattrs','Additional Attributes'),
 771     )
 772
 773 class SiteNodeInline(PlStackTabularInline):
 774     model = Node
 775     fields = ['name', 'site_deployment']
 776     extra = 0
 777     suit_classes = 'suit-tab suit-tab-nodes'
 778
 779 class SiteAdmin(PlanetStackBaseAdmin):
 780     fieldList = ['backend_status_text', 'name', 'site_url', 'enabled', 'is_public', 'login_base', 'accountLink','location']
 781     fieldsets = [
 782         (None, {'fields': fieldList, 'classes':['suit-tab suit-tab-general']}),
 783         #('Deployment Networks', {'fields': ['deployments'], 'classes':['suit-tab suit-tab-deployments']}),
 784     ]
 785     readonly_fields = ['backend_status_text', 'accountLink']
 786
 787     user_readonly_fields = ['name', 'deployments','site_url', 'enabled', 'is_public', 'login_base', 'accountLink']
 788
 789     list_display = ('backend_status_icon', 'name', 'login_base','site_url', 'enabled')
 790     list_display_links = ('backend_status_icon', 'name', )
 791     filter_horizontal = ('deployments',)
 792     inlines = [SliceInline,UserInline,TagInline, SitePrivilegeInline, SiteDeploymentInline, SiteNodeInline]
 793     admin_inlines = [ControllerSiteInline]
 794     search_fields = ['name']
 795
 796     @property
 797     def suit_form_tabs(self):
 798         tabs = [('general', 'Site Details'),
 799             ('users','Users'),
 800             ('siteprivileges','Privileges'),
 801             ('deployments','Deployments'),
 802             ('slices','Slices'),
 803             ('nodes','Nodes'),
 804         ]
 805
 806         request=getattr(_thread_locals, "request", None)
 807         if request and request.user.is_admin:
 808             tabs.append( ('admin-only', 'Admin-Only') )
 809
 810         return tabs
 811
 812     def queryset(self, request):
 813         return Site.select_by_user(request.user)
 814
 815     def get_formsets(self, request, obj=None):
 816         for inline in self.get_inline_instances(request, obj):
 817             # hide MyInline in the add view
 818             if obj is None:
 819                 continue
 820             if isinstance(inline, SliverInline):
 821                 inline.model.caller = request.user
 822             yield inline.get_formset(request, obj)
 823
 824     def accountLink(self, obj):
 825         link_obj = obj.accounts.all()
 826         if link_obj:
 827             reverse_path = "admin:core_account_change"
 828             url = reverse(reverse_path, args =(link_obj[0].id,))
 829             return "<a href='%s'>%s</a>" % (url, "view billing details")
 830         else:
 831             return "no billing data for this site"
 832     accountLink.allow_tags = True
 833     accountLink.short_description = "Billing"
 834
 835     def save_model(self, request, obj, form, change):
 836         # update openstack connection to use this site/tenant
 837         obj.save_by_user(request.user)
 838
 839     def delete_model(self, request, obj):
 840         obj.delete_by_user(request.user)
 841
 842
 843 class SitePrivilegeAdmin(PlanetStackBaseAdmin):
 844     fieldList = ['backend_status_text', 'user', 'site', 'role']
 845     fieldsets = [
 846         (None, {'fields': fieldList, 'classes':['collapse']})
 847     ]
 848     readonly_fields = ('backend_status_text', )
 849     list_display = ('backend_status_icon', 'user', 'site', 'role')
 850     list_display_links = list_display
 851     user_readonly_fields = fieldList
 852     user_readonly_inlines = []
 853
 854     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 855         if db_field.name == 'site':
 856             if not request.user.is_admin:
 857                 # only show sites where user is an admin or pi
 858                 sites = set()
 859                 for site_privilege in SitePrivilege.objects.filer(user=request.user):
 860                     if site_privilege.role.role_type in ['admin', 'pi']:
 861                         sites.add(site_privilege.site)
 862                 kwargs['queryset'] = Site.objects.filter(site__in=list(sites))
 863
 864         if db_field.name == 'user':
 865             if not request.user.is_admin:
 866                 # only show users from sites where caller has admin or pi role
 867                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 868                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 869                 sites = [site_privilege.site for site_privilege in site_privileges]
 870                 site_privileges = SitePrivilege.objects.filter(site__in=sites)
 871                 emails = [site_privilege.user.email for site_privilege in site_privileges]
 872                 users = User.objects.filter(email__in=emails)
 873                 kwargs['queryset'] = users
 874
 875         return super(SitePrivilegeAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 876
 877     def queryset(self, request):
 878         # admins can see all privileges. Users can only see privileges at sites
 879         # where they have the admin role or pi role.
 880         qs = super(SitePrivilegeAdmin, self).queryset(request)
 881         #if not request.user.is_admin:
 882         #    roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 883         #    site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 884         #    login_bases = [site_privilege.site.login_base for site_privilege in site_privileges]
 885         #    sites = Site.objects.filter(login_base__in=login_bases)
 886         #    qs = qs.filter(site__in=sites)
 887         return qs
 888
 889 class SliceForm(forms.ModelForm):
 890     class Meta:
 891         model = Slice
 892         widgets = {
 893             'service': LinkedSelect
 894         }
 895
 896     def clean(self):
 897         cleaned_data = super(SliceForm, self).clean()
 898         name = cleaned_data.get('name')
 899         site = cleaned_data.get('site')
 900         slice_id = self.instance.id
 901         if not site and slice_id:
 902             site = Slice.objects.get(id=slice_id).site
 903         if (not isinstance(site,Site)):
 904             # previous code indicates 'site' could be a site_id and not a site?
 905             site = Slice.objects.get(id=site.id)
 906         if not name.startswith(site.login_base):
 907             raise forms.ValidationError('slice name must begin with %s' % site.login_base)
 908         return cleaned_data
 909
 910 class ControllerSliceInline(PlStackTabularInline):
 911     model = ControllerSlice
 912     extra = 0
 913     verbose_name = "Controller Slices"
 914     verbose_name_plural = "Controller Slices"
 915     suit_classes = 'suit-tab suit-tab-admin-only'
 916     fields = ['backend_status_icon', 'controller', 'tenant_id']
 917     readonly_fields = ('backend_status_icon', 'controller' )
 918
 919 class SliceAdmin(PlanetStackBaseAdmin):
 920     form = SliceForm
 921     fieldList = ['backend_status_text', 'site', 'name', 'serviceClass', 'enabled','description', 'service', 'slice_url', 'max_slivers']
 922     fieldsets = [('Slice Details', {'fields': fieldList, 'classes':['suit-tab suit-tab-general']}),]
 923     readonly_fields = ('backend_status_text', )
 924     list_display = ('backend_status_icon', 'name', 'site','serviceClass', 'slice_url', 'max_slivers')
 925     list_display_links = ('backend_status_icon', 'name', )
 926     inlines = [SlicePrivilegeInline,SliverInline, TagInline, ReservationInline,SliceNetworkInline]
 927     admin_inlines = [ControllerSliceInline]
 928
 929     user_readonly_fields = fieldList
 930
 931     @property
 932     def suit_form_tabs(self):
 933         tabs =[('general', 'Slice Details'),
 934           ('slicenetworks','Networks'),
 935           ('sliceprivileges','Privileges'),
 936           ('slivers','Slivers'),
 937           ('reservations','Reservations'),
 938           ('tags','Tags'),
 939           ]
 940
 941         request=getattr(_thread_locals, "request", None)
 942         if request and request.user.is_admin:
 943             tabs.append( ('admin-only', 'Admin-Only') )
 944
 945         return tabs
 946
 947     def add_view(self, request, form_url='', extra_context=None):
 948         # revert to default read-only fields
 949         self.readonly_fields = ('backend_status_text',)
 950         return super(SliceAdmin, self).add_view(request, form_url, extra_context=extra_context)
 951
 952     def change_view(self, request, object_id, form_url='', extra_context=None):
 953         # cannot change the site of an existing slice so make the site field read only
 954         if object_id:
 955             self.readonly_fields = ('backend_status_text','site')
 956         return super(SliceAdmin, self).change_view(request, object_id, form_url)
 957
 958     def render_change_form(self, request, context, add=False, change=False, form_url='', obj=None):
 959         deployment_nodes = []
 960         for node in Node.objects.all():
 961             deployment_nodes.append( (node.site_deployment.id, node.id, node.name) )
 962
 963         deployment_flavors = []
 964         for flavor in Flavor.objects.all():
 965             for deployment in flavor.deployments.all():
 966                 deployment_flavors.append( (deployment.id, flavor.id, flavor.name) )
 967
 968         deployment_images = []
 969         for image in Image.objects.all():
 970             for deployment_image in image.imagedeployments.all():
 971                 deployment_images.append( (deployment_image.deployment.id, image.id, image.name) )
 972
 973         site_login_bases = []
 974         for site in Site.objects.all():
 975             site_login_bases.append((site.id, site.login_base))
 976
 977         context["deployment_nodes"] = deployment_nodes
 978         context["deployment_flavors"] = deployment_flavors
 979         context["deployment_images"] = deployment_images
 980         context["site_login_bases"] = site_login_bases
 981         return super(SliceAdmin, self).render_change_form(request, context, add, change, form_url, obj)
 982
 983     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 984         if db_field.name == 'site':
 985             kwargs['queryset'] = Site.select_by_user(request.user)
 986             kwargs['widget'] = forms.Select(attrs={'onChange': "update_slice_prefix(this, $($(this).closest('fieldset')[0]).find('.field-name input')[0].id)"})
 987
 988         return super(SliceAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 989
 990     def queryset(self, request):
 991         # admins can see all keys. Users can only see slices they belong to.
 992         return Slice.select_by_user(request.user)
 993
 994     def get_formsets(self, request, obj=None):
 995         for inline in self.get_inline_instances(request, obj):
 996             # hide MyInline in the add view
 997             if obj is None:
 998                 continue
 999             if isinstance(inline, SliverInline):
1000                 inline.model.caller = request.user
1001             yield inline.get_formset(request, obj)
1002
1003 class SlicePrivilegeAdmin(PlanetStackBaseAdmin):
1004     fieldsets = [
1005         (None, {'fields': ['backend_status_text', 'user', 'slice', 'role']})
1006     ]
1007     readonly_fields = ('backend_status_text', )
1008     list_display = ('backend_status_icon', 'user', 'slice', 'role')
1009     list_display_links = list_display
1010
1011     user_readonly_fields = ['user', 'slice', 'role']
1012     user_readonly_inlines = []
1013
1014     def formfield_for_foreignkey(self, db_field, request, **kwargs):
1015         if db_field.name == 'slice':
1016             kwargs['queryset'] = Slice.select_by_user(request.user)
1017
1018         if db_field.name == 'user':
1019             kwargs['queryset'] = User.select_by_user(request.user)
1020
1021         return super(SlicePrivilegeAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
1022
1023     def queryset(self, request):
1024         # admins can see all memberships. Users can only see memberships of
1025         # slices where they have the admin role.
1026         return SlicePrivilege.select_by_user(request.user)
1027
1028     def save_model(self, request, obj, form, change):
1029         # update openstack connection to use this site/tenant
1030         auth = request.session.get('auth', {})
1031         auth['tenant'] = obj.slice.slicename
1032         obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
1033         obj.save()
1034
1035     def delete_model(self, request, obj):
1036         # update openstack connection to use this site/tenant
1037         auth = request.session.get('auth', {})
1038         auth['tenant'] = obj.slice.slicename
1039         obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
1040         obj.delete()
1041
1042
1043 class ImageAdmin(PlanetStackBaseAdmin):
1044
1045     fieldsets = [('Image Details',
1046                    {'fields': ['backend_status_text', 'name', 'disk_format', 'container_format'],
1047                     'classes': ['suit-tab suit-tab-general']})
1048                ]
1049     readonly_fields = ('backend_status_text', )
1050
1051     suit_form_tabs =(('general','Image Details'),('slivers','Slivers'),('imagedeployments','Deployments'), ('controllerimages', 'Controllers'))
1052
1053     inlines = [SliverInline, ControllerImagesInline]
1054
1055     user_readonly_fields = ['name', 'disk_format', 'container_format']
1056
1057     list_display = ['backend_status_icon', 'name']
1058     list_display_links = ('backend_status_icon', 'name', )
1059
1060 class NodeForm(forms.ModelForm):
1061     class Meta:
1062         widgets = {
1063             'site': LinkedSelect,
1064             'deployment': LinkedSelect
1065         }
1066
1067 class NodeAdmin(PlanetStackBaseAdmin):
1068     form = NodeForm
1069     list_display = ('backend_status_icon', 'name', 'site_deployment')
1070     list_display_links = ('backend_status_icon', 'name', )
1071     list_filter = ('site_deployment',)
1072
1073     inlines = [TagInline,SliverInline]
1074     fieldsets = [('Node Details', {'fields': ['backend_status_text', 'name','site_deployment'], 'classes':['suit-tab suit-tab-details']})]
1075     readonly_fields = ('backend_status_text', )
1076
1077     user_readonly_fields = ['name','site_deployment']
1078     user_readonly_inlines = [TagInline,SliverInline]
1079
1080     suit_form_tabs =(('details','Node Details'),('slivers','Slivers'))
1081
1082
1083 class SliverForm(forms.ModelForm):
1084     class Meta:
1085         model = Sliver
1086         ip = forms.CharField(widget=PlainTextWidget)
1087         instance_name = forms.CharField(widget=PlainTextWidget)
1088         widgets = {
1089             'ip': PlainTextWidget(),
1090             'instance_name': PlainTextWidget(),
1091             'slice': LinkedSelect,
1092             'deployment': LinkedSelect,
1093             'node': LinkedSelect,
1094             'image': LinkedSelect
1095         }
1096
1097 class TagAdmin(PlanetStackBaseAdmin):
1098     list_display = ['backend_status_icon', 'service', 'name', 'value', 'content_type', 'content_object',]
1099     list_display_links = list_display
1100     user_readonly_fields = ['service', 'name', 'value', 'content_type', 'content_object',]
1101     user_readonly_inlines = []
1102
1103 class SliverAdmin(PlanetStackBaseAdmin):
1104     form = SliverForm
1105     fieldsets = [
1106         ('Sliver Details', {'fields': ['backend_status_text', 'slice', 'deployment', 'node', 'ip', 'instance_name', 'flavor', 'image', ], 'classes': ['suit-tab suit-tab-general'], })
1107     ]
1108     readonly_fields = ('backend_status_text', )
1109     list_display = ['backend_status_icon', 'ip', 'instance_name', 'slice', 'flavor', 'image', 'node', 'deployment']
1110     list_display_links = ('backend_status_icon', 'ip',)
1111
1112     suit_form_tabs =(('general', 'Sliver Details'))
1113
1114     inlines = [TagInline]
1115
1116     user_readonly_fields = ['slice', 'deployment', 'node', 'ip', 'instance_name', 'flavor', 'image']
1117
1118     def formfield_for_foreignkey(self, db_field, request, **kwargs):
1119         if db_field.name == 'slice':
1120             kwargs['queryset'] = Slice.select_by_user(request.user)
1121
1122         return super(SliverAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
1123
1124     def queryset(self, request):
1125         # admins can see all slivers. Users can only see slivers of
1126         # the slices they belong to.
1127         return Sliver.select_by_user(request.user)
1128
1129
1130     def get_formsets(self, request, obj=None):
1131         # make some fields read only if we are updating an existing record
1132         if obj == None:
1133             #self.readonly_fields = ('ip', 'instance_name')
1134             self.readonly_fields = ('backend_status_text',)
1135         else:
1136             self.readonly_fields = ('backend_status_text',)
1137             #self.readonly_fields = ('ip', 'instance_name', 'slice', 'image', 'key')
1138
1139         for inline in self.get_inline_instances(request, obj):
1140             # hide MyInline in the add view
1141             if obj is None:
1142                 continue
1143             if isinstance(inline, SliverInline):
1144                 inline.model.caller = request.user
1145             yield inline.get_formset(request, obj)
1146
1147     #def save_model(self, request, obj, form, change):
1148     #    # update openstack connection to use this site/tenant
1149     #    auth = request.session.get('auth', {})
1150     #    auth['tenant'] = obj.slice.name
1151     #    obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
1152     #    obj.creator = request.user
1153     #    obj.save()
1154
1155     #def delete_model(self, request, obj):
1156     #    # update openstack connection to use this site/tenant
1157     #    auth = request.session.get('auth', {})
1158     #    auth['tenant'] = obj.slice.name
1159     #    obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
1160     #    obj.delete()
1161
1162 class UserCreationForm(forms.ModelForm):
1163     """A form for creating new users. Includes all the required
1164     fields, plus a repeated password."""
1165     password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
1166     password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)
1167
1168     class Meta:
1169         model = User
1170         fields = ('email', 'firstname', 'lastname', 'phone', 'public_key')
1171
1172     def clean_password2(self):
1173         # Check that the two password entries match
1174         password1 = self.cleaned_data.get("password1")
1175         password2 = self.cleaned_data.get("password2")
1176         if password1 and password2 and password1 != password2:
1177             raise forms.ValidationError("Passwords don't match")
1178         return password2
1179
1180     def save(self, commit=True):
1181         # Save the provided password in hashed format
1182         user = super(UserCreationForm, self).save(commit=False)
1183         user.password = self.cleaned_data["password1"]
1184         #user.set_password(self.cleaned_data["password1"])
1185         if commit:
1186             user.save()
1187         return user
1188
1189
1190 class UserChangeForm(forms.ModelForm):
1191     """A form for updating users. Includes all the fields on
1192     the user, but replaces the password field with admin's
1193     password hash display field.
1194     """
1195     password = ReadOnlyPasswordHashField(label='Password',
1196                    help_text= '<a href=\"password/\">Change Password</a>.')
1197
1198     class Meta:
1199         model = User
1200         widgets = { 'public_key': UploadTextareaWidget, }
1201
1202     def clean_password(self):
1203         # Regardless of what the user provides, return the initial value.
1204         # This is done here, rather than on the field, because the
1205         # field does not have access to the initial value
1206         return self.initial["password"]
1207
1208 class UserDashboardViewInline(PlStackTabularInline):
1209     model = UserDashboardView
1210     extra = 0
1211     suit_classes = 'suit-tab suit-tab-dashboards'
1212     fields = ['user', 'dashboardView', 'order']
1213
1214 class ControllerUserInline(PlStackTabularInline):
1215     model = ControllerUser
1216     extra = 0
1217     suit_classes = 'suit-tab suit-tab-admin-only'
1218     fields = ['controller', 'user', 'kuser_id']
1219     readonly_fields=['controller']
1220
1221
1222 class UserAdmin(PermissionCheckingAdminMixin, UserAdmin):
1223     # Note: Make sure PermissionCheckingAdminMixin is listed before
1224     # admin.ModelAdmin in the class declaration.
1225
1226     class Meta:
1227         app_label = "core"
1228
1229     # The forms to add and change user instances
1230     form = UserChangeForm
1231     add_form = UserCreationForm
1232
1233     # The fields to be used in displaying the User model.
1234     # These override the definitions on the base UserAdmin
1235     # that reference specific fields on auth.User.
1236     list_display = ('email', 'firstname', 'lastname', 'site', 'last_login')
1237     list_filter = ('site',)
1238     inlines = [SlicePrivilegeInline,SitePrivilegeInline,UserDashboardViewInline]
1239     admin_inlines = [ControllerUserInline]
1240     fieldListLoginDetails = ['backend_status_text', 'email','site','password','is_active','is_readonly','is_admin','public_key']
1241     fieldListContactInfo = ['firstname','lastname','phone','timezone']
1242
1243     fieldsets = (
1244         ('Login Details', {'fields': ['backend_status_text', 'email', 'site','password', 'is_active', 'is_readonly', 'is_admin', 'public_key'], 'classes':['suit-tab suit-tab-general']}),
1245         ('Contact Information', {'fields': ('firstname','lastname','phone', 'timezone'), 'classes':['suit-tab suit-tab-contact']}),
1246         #('Dashboard Views', {'fields': ('dashboards',), 'classes':['suit-tab suit-tab-dashboards']}),
1247         #('Important dates', {'fields': ('last_login',)}),
1248     )
1249     add_fieldsets = (
1250         (None, {
1251             'classes': ('wide',),
1252             'fields': ('email', 'firstname', 'lastname', 'is_readonly', 'phone', 'public_key','password1', 'password2')},
1253         ),
1254     )
1255     readonly_fields = ('backend_status_text', )
1256     search_fields = ('email',)
1257     ordering = ('email',)
1258     filter_horizontal = ()
1259
1260     user_readonly_fields = fieldListLoginDetails + fieldListContactInfo
1261
1262     @property
1263     def suit_form_tabs(self):
1264         if getattr(_thread_locals, "obj", None) is None:
1265             return []
1266         else:
1267             tabs = [('general','Login Details'),
1268                          ('contact','Contact Information'),
1269                          ('sliceprivileges','Slice Privileges'),
1270                          ('siteprivileges','Site Privileges'),
1271                          ('dashboards','Dashboard Views')]
1272
1273             request=getattr(_thread_locals, "request", None)
1274             if request and request.user.is_admin:
1275                 tabs.append( ('admin-only', 'Admin-Only') )
1276
1277             return tabs
1278
1279     def formfield_for_foreignkey(self, db_field, request, **kwargs):
1280         if db_field.name == 'site':
1281             kwargs['queryset'] = Site.select_by_user(request.user)
1282
1283         return super(UserAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
1284
1285     def queryset(self, request):
1286         return User.select_by_user(request.user)
1287
1288 class ControllerDashboardViewInline(PlStackTabularInline):
1289     model = ControllerDashboardView
1290     extra = 0
1291     fields = ["controller", "url"]
1292     suit_classes = 'suit-tab suit-tab-controllers'
1293
1294 class DashboardViewAdmin(PlanetStackBaseAdmin):
1295     fieldsets = [('Dashboard View Details',
1296                    {'fields': ['backend_status_text', 'name', 'url', 'enabled'],
1297                     'classes': ['suit-tab suit-tab-general']})
1298                ]
1299     list_display = ["name", "enabled", "url"]
1300     readonly_fields = ('backend_status_text', )
1301     inlines = [ControllerDashboardViewInline]
1302
1303     suit_form_tabs =(('general','Dashboard View Details'),
1304                      ('controllers', 'Per-controller Dashboard Details'))
1305
1306 class ServiceResourceInline(PlStackTabularInline):
1307     model = ServiceResource
1308     extra = 0
1309
1310 class ServiceClassAdmin(PlanetStackBaseAdmin):
1311     list_display = ('backend_status_icon', 'name', 'commitment', 'membershipFee')
1312     list_display_links = ('backend_status_icon', 'name', )
1313     inlines = [ServiceResourceInline]
1314
1315     user_readonly_fields = ['name', 'commitment', 'membershipFee']
1316     user_readonly_inlines = []
1317
1318 class ReservedResourceInline(PlStackTabularInline):
1319     model = ReservedResource
1320     extra = 0
1321     suit_classes = 'suit-tab suit-tab-reservedresources'
1322
1323     def formfield_for_foreignkey(self, db_field, request=None, **kwargs):
1324         field = super(ReservedResourceInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
1325
1326         if db_field.name == 'resource':
1327             # restrict resources to those that the slice's service class allows
1328             if request._slice is not None:
1329                 field.queryset = field.queryset.filter(serviceClass = request._slice.serviceClass, calendarReservable=True)
1330                 if len(field.queryset) > 0:
1331                     field.initial = field.queryset.all()[0]
1332             else:\r
1333                 field.queryset = field.queryset.none()\r
1334         elif db_field.name == 'sliver':\r
1335             # restrict slivers to those that belong to the slice\r
1336             if request._slice is not None:\r
1337                 field.queryset = field.queryset.filter(slice = request._slice)
1338             else:
1339                 field.queryset = field.queryset.none()\r
1340 \r
1341         return field
1342
1343     def queryset(self, request):
1344         return ReservedResource.select_by_user(request.user)
1345
1346 class ReservationChangeForm(forms.ModelForm):
1347     class Meta:
1348         model = Reservation
1349         widgets = {
1350             'slice' : LinkedSelect
1351         }
1352
1353 class ReservationAddForm(forms.ModelForm):
1354     slice = forms.ModelChoiceField(queryset=Slice.objects.all(), widget=forms.Select(attrs={"onChange":"document.getElementById('id_refresh').value=1; submit()"}))
1355     refresh = forms.CharField(widget=forms.HiddenInput())
1356
1357     class Media:
1358        css = {'all': ('planetstack.css',)}   # .field-refresh { display: none; }
1359
1360     def clean_slice(self):
1361         slice = self.cleaned_data.get("slice")
1362         x = ServiceResource.objects.filter(serviceClass = slice.serviceClass, calendarReservable=True)
1363         if len(x) == 0:
1364             raise forms.ValidationError("The slice you selected does not have a service class that allows reservations")
1365         return slice
1366
1367     class Meta:
1368         model = Reservation
1369         widgets = {
1370             'slice' : LinkedSelect
1371         }
1372
1373
1374 class ReservationAddRefreshForm(ReservationAddForm):
1375     """ This form is displayed when the Reservation Form receives an update
1376         from the Slice dropdown onChange handler. It doesn't validate the
1377         data and doesn't save the data. This will cause the form to be
1378         redrawn.
1379     """
1380
1381     """ don't validate anything other than slice """
1382     dont_validate_fields = ("startTime", "duration")
1383
1384     def full_clean(self):
1385         result = super(ReservationAddForm, self).full_clean()
1386
1387         for fieldname in self.dont_validate_fields:
1388             if fieldname in self._errors:
1389                 del self._errors[fieldname]
1390
1391         return result
1392
1393     """ don't save anything """
1394     def is_valid(self):
1395         return False
1396
1397 class ReservationAdmin(PlanetStackBaseAdmin):
1398     fieldList = ['backend_status_text', 'slice', 'startTime', 'duration']
1399     fieldsets = [('Reservation Details', {'fields': fieldList, 'classes': ['suit-tab suit-tab-general']})]
1400     readonly_fields = ('backend_status_text', )
1401     list_display = ('startTime', 'duration')
1402     form = ReservationAddForm
1403
1404     suit_form_tabs = (('general','Reservation Details'), ('reservedresources','Reserved Resources'))
1405
1406     inlines = [ReservedResourceInline]
1407     user_readonly_fields = fieldList
1408
1409     def add_view(self, request, form_url='', extra_context=None):
1410         timezone.activate(request.user.timezone)
1411         request._refresh = False
1412         request._slice = None
1413         if request.method == 'POST':
1414             # "refresh" will be set to "1" if the form was submitted due to
1415             # a change in the Slice dropdown.
1416             if request.POST.get("refresh","1") == "1":
1417                 request._refresh = True
1418                 request.POST["refresh"] = "0"
1419
1420             # Keep track of the slice that was selected, so the
1421             # reservedResource inline can filter items for the slice.
1422             request._slice = request.POST.get("slice",None)
1423             if (request._slice is not None):
1424                 request._slice = Slice.objects.get(id=request._slice)
1425
1426         result =  super(ReservationAdmin, self).add_view(request, form_url, extra_context)
1427         return result
1428
1429     def changelist_view(self, request, extra_context = None):
1430         timezone.activate(request.user.timezone)
1431         return super(ReservationAdmin, self).changelist_view(request, extra_context)
1432
1433     def get_form(self, request, obj=None, **kwargs):
1434         request._obj_ = obj
1435         if obj is not None:
1436             # For changes, set request._slice to the slice already set in the
1437             # object.
1438             request._slice = obj.slice
1439             self.form = ReservationChangeForm
1440         else:
1441             if getattr(request, "_refresh", False):
1442                 self.form = ReservationAddRefreshForm
1443             else:
1444                 self.form = ReservationAddForm
1445         return super(ReservationAdmin, self).get_form(request, obj, **kwargs)
1446
1447     def get_readonly_fields(self, request, obj=None):
1448         if (obj is not None):
1449             # Prevent slice from being changed after the reservation has been
1450             # created.
1451             return ['slice']
1452         else:
1453             return []
1454
1455     def queryset(self, request):
1456         return Reservation.select_by_user(request.user)
1457
1458 class NetworkParameterTypeAdmin(PlanetStackBaseAdmin):
1459     list_display = ("backend_status_icon", "name", )
1460     list_display_links = ('backend_status_icon', 'name', )
1461     user_readonly_fields = ['name']
1462     user_readonly_inlines = []
1463
1464 class RouterAdmin(PlanetStackBaseAdmin):
1465     list_display = ("backend_status_icon", "name", )
1466     list_display_links = ('backend_status_icon', 'name', )
1467     user_readonly_fields = ['name']
1468     user_readonly_inlines = []
1469
1470 class RouterInline(PlStackTabularInline):
1471     model = Router.networks.through
1472     extra = 0
1473     verbose_name_plural = "Routers"
1474     verbose_name = "Router"
1475     suit_classes = 'suit-tab suit-tab-routers'
1476
1477 class NetworkParameterInline(PlStackGenericTabularInline):
1478     model = NetworkParameter
1479     extra = 0
1480     verbose_name_plural = "Parameters"
1481     verbose_name = "Parameter"
1482     suit_classes = 'suit-tab suit-tab-netparams'
1483     fields = ['backend_status_icon', 'parameter', 'value']
1484     readonly_fields = ('backend_status_icon', )
1485
1486 class NetworkSliversInline(PlStackTabularInline):
1487     fields = ['backend_status_icon', 'network','sliver','ip']
1488     readonly_fields = ("backend_status_icon", "ip", )
1489     model = NetworkSliver
1490     selflink_fieldname = "sliver"
1491     extra = 0
1492     verbose_name_plural = "Slivers"
1493     verbose_name = "Sliver"
1494     suit_classes = 'suit-tab suit-tab-networkslivers'
1495
1496 class NetworkSlicesInline(PlStackTabularInline):
1497     model = NetworkSlice
1498     selflink_fieldname = "slice"
1499     extra = 0
1500     verbose_name_plural = "Slices"
1501     verbose_name = "Slice"
1502     suit_classes = 'suit-tab suit-tab-networkslices'
1503     fields = ['backend_status_icon', 'network','slice']
1504     readonly_fields = ('backend_status_icon', )
1505
1506 class ControllerNetworkInline(PlStackTabularInline):
1507     model = ControllerNetwork
1508     extra = 0
1509     verbose_name_plural = "Controller Networks"
1510     verbose_name = "Controller Network"
1511     suit_classes = 'suit-tab suit-tab-admin-only'
1512     fields = ['backend_status_icon', 'controller','net_id','subnet_id']
1513     readonly_fields = ('backend_status_icon', )
1514
1515 class NetworkForm(forms.ModelForm):
1516     class Meta:
1517         model = Network
1518         widgets = {
1519             'topologyParameters': UploadTextareaWidget,
1520             'controllerParameters': UploadTextareaWidget,
1521         }
1522
1523 class NetworkAdmin(PlanetStackBaseAdmin):
1524     list_display = ("backend_status_icon", "name", "subnet", "ports", "labels")
1525     list_display_links = ('backend_status_icon', 'name', )
1526     readonly_fields = ("subnet", )
1527
1528     inlines = [NetworkParameterInline, NetworkSliversInline, NetworkSlicesInline, RouterInline]
1529     admin_inlines = [ControllerNetworkInline]
1530
1531     form=NetworkForm
1532
1533     fieldsets = [
1534         (None, {'fields': ['backend_status_text', 'name','template','ports','labels','owner','guaranteed_bandwidth', 'permit_all_slices','permitted_slices','network_id','router_id','subnet_id','subnet'],
1535                 'classes':['suit-tab suit-tab-general']}),
1536         (None, {'fields': ['topology_parameters', 'controller_url', 'controller_parameters'],
1537                 'classes':['suit-tab suit-tab-sdn']}),
1538                 ]
1539
1540     readonly_fields = ('backend_status_text', )
1541     user_readonly_fields = ['name','template','ports','labels','owner','guaranteed_bandwidth', 'permit_all_slices','permitted_slices','network_id','router_id','subnet_id','subnet']
1542
1543     @property
1544     def suit_form_tabs(self):
1545         tabs=[('general','Network Details'),
1546             ('sdn', 'SDN Configuration'),
1547             ('netparams', 'Parameters'),
1548             ('networkslivers','Slivers'),
1549             ('networkslices','Slices'),
1550             ('routers','Routers'),
1551         ]
1552
1553         request=getattr(_thread_locals, "request", None)
1554         if request and request.user.is_admin:
1555             tabs.append( ('admin-only', 'Admin-Only') )
1556
1557         return tabs
1558
1559
1560 class NetworkTemplateAdmin(PlanetStackBaseAdmin):
1561     list_display = ("backend_status_icon", "name", "guaranteed_bandwidth", "visibility")
1562     list_display_links = ('backend_status_icon', 'name', )
1563     user_readonly_fields = ["name", "guaranteed_bandwidth", "visibility"]
1564     user_readonly_inlines = []
1565     fieldsets = [
1566         (None, {'fields': ['name', 'description', 'guaranteed_bandwidth', 'visibility', 'translation', 'shared_network_name', 'shared_network_id', 'topology_kind', 'controller_kind'],
1567                 'classes':['suit-tab suit-tab-general']}),]
1568     suit_form_tabs = (('general','Network Template Details'), )
1569
1570 class FlavorAdmin(PlanetStackBaseAdmin):
1571     list_display = ("backend_status_icon", "name", "flavor", "order", "default")
1572     list_display_links = ("backend_status_icon", "name")
1573     user_readonly_fields = ("name", "flavor")
1574     fields = ("name", "description", "flavor", "order", "default")
1575
1576 # register a signal that caches the user's credentials when they log in
1577 def cache_credentials(sender, user, request, **kwds):
1578     auth = {'username': request.POST['username'],
1579             'password': request.POST['password']}
1580     request.session['auth'] = auth
1581 user_logged_in.connect(cache_credentials)
1582
1583 def dollar_field(fieldName, short_description):
1584     def newFunc(self, obj):
1585         try:
1586             x= "$ %0.2f" % float(getattr(obj, fieldName, 0.0))
1587         except:
1588             x=getattr(obj, fieldName, 0.0)
1589         return x
1590     newFunc.short_description = short_description
1591     return newFunc
1592
1593 def right_dollar_field(fieldName, short_description):
1594     def newFunc(self, obj):
1595         try:
1596             #x= '<div align=right style="width:6em">$ %0.2f</div>' % float(getattr(obj, fieldName, 0.0))
1597             x= '<div align=right>$ %0.2f</div>' % float(getattr(obj, fieldName, 0.0))
1598         except:
1599             x=getattr(obj, fieldName, 0.0)
1600         return x
1601     newFunc.short_description = short_description
1602     newFunc.allow_tags = True
1603     return newFunc
1604
1605 class InvoiceChargeInline(PlStackTabularInline):
1606     model = Charge
1607     extra = 0
1608     verbose_name_plural = "Charges"
1609     verbose_name = "Charge"
1610     exclude = ['account']
1611     fields = ["date", "kind", "state", "object", "coreHours", "dollar_amount", "slice"]
1612     readonly_fields = ["date", "kind", "state", "object", "coreHours", "dollar_amount", "slice"]
1613     can_delete = False
1614     max_num = 0
1615
1616     dollar_amount = right_dollar_field("amount", "Amount")
1617
1618 class InvoiceAdmin(admin.ModelAdmin):
1619     list_display = ("date", "account")
1620
1621     inlines = [InvoiceChargeInline]
1622
1623     fields = ["date", "account", "dollar_amount"]
1624     readonly_fields = ["date", "account", "dollar_amount"]
1625
1626     dollar_amount = dollar_field("amount", "Amount")
1627
1628 class InvoiceInline(PlStackTabularInline):
1629     model = Invoice
1630     extra = 0
1631     verbose_name_plural = "Invoices"
1632     verbose_name = "Invoice"
1633     fields = ["date", "dollar_amount"]
1634     readonly_fields = ["date", "dollar_amount"]
1635     suit_classes = 'suit-tab suit-tab-accountinvoice'
1636     can_delete=False
1637     max_num=0
1638
1639     dollar_amount = right_dollar_field("amount", "Amount")
1640
1641 class PendingChargeInline(PlStackTabularInline):
1642     model = Charge
1643     extra = 0
1644     verbose_name_plural = "Charges"
1645     verbose_name = "Charge"
1646     exclude = ["invoice"]
1647     fields = ["date", "kind", "state", "object", "coreHours", "dollar_amount", "slice"]
1648     readonly_fields = ["date", "kind", "state", "object", "coreHours", "dollar_amount", "slice"]
1649     suit_classes = 'suit-tab suit-tab-accountpendingcharges'
1650     can_delete=False
1651     max_num=0
1652
1653     def queryset(self, request):
1654         qs = super(PendingChargeInline, self).queryset(request)
1655         qs = qs.filter(state="pending")
1656         return qs
1657
1658     dollar_amount = right_dollar_field("amount", "Amount")
1659
1660 class PaymentInline(PlStackTabularInline):
1661     model=Payment
1662     extra = 1
1663     verbose_name_plural = "Payments"
1664     verbose_name = "Payment"
1665     fields = ["date", "dollar_amount"]
1666     readonly_fields = ["date", "dollar_amount"]
1667     suit_classes = 'suit-tab suit-tab-accountpayments'
1668     can_delete=False
1669     max_num=0
1670
1671     dollar_amount = right_dollar_field("amount", "Amount")
1672
1673 class AccountAdmin(admin.ModelAdmin):
1674     list_display = ("site", "balance_due")
1675
1676     inlines = [InvoiceInline, PaymentInline, PendingChargeInline]
1677
1678     fieldsets = [
1679         (None, {'fields': ['site', 'dollar_balance_due', 'dollar_total_invoices', 'dollar_total_payments'],'classes':['suit-tab suit-tab-general']}),]
1680
1681     readonly_fields = ['site', 'dollar_balance_due', 'dollar_total_invoices', 'dollar_total_payments']
1682
1683     suit_form_tabs =(
1684         ('general','Account Details'),
1685         ('accountinvoice', 'Invoices'),
1686         ('accountpayments', 'Payments'),
1687         ('accountpendingcharges','Pending Charges'),
1688     )
1689
1690     dollar_balance_due = dollar_field("balance_due", "Balance Due")
1691     dollar_total_invoices = dollar_field("total_invoices", "Total Invoices")
1692     dollar_total_payments = dollar_field("total_payments", "Total Payments")
1693
1694 # Now register the new UserAdmin...
1695 admin.site.register(User, UserAdmin)
1696 # ... and, since we're not using Django's builtin permissions,
1697 # unregister the Group model from admin.
1698 #admin.site.unregister(Group)
1699
1700 #Do not show django evolution in the admin interface
1701 from django_evolution.models import Version, Evolution
1702 #admin.site.unregister(Version)
1703 #admin.site.unregister(Evolution)
1704
1705
1706 # When debugging it is often easier to see all the classes, but for regular use
1707 # only the top-levels should be displayed
1708 showAll = False
1709
1710 admin.site.register(Deployment, DeploymentAdmin)
1711 admin.site.register(Controller, ControllerAdmin)
1712 admin.site.register(Site, SiteAdmin)
1713 admin.site.register(Slice, SliceAdmin)
1714 admin.site.register(Service, ServiceAdmin)
1715 admin.site.register(Reservation, ReservationAdmin)
1716 admin.site.register(Network, NetworkAdmin)
1717 admin.site.register(Router, RouterAdmin)
1718 admin.site.register(NetworkTemplate, NetworkTemplateAdmin)
1719 admin.site.register(Account, AccountAdmin)
1720 admin.site.register(Invoice, InvoiceAdmin)
1721
1722 if True:
1723     admin.site.register(NetworkParameterType, NetworkParameterTypeAdmin)
1724     admin.site.register(ServiceClass, ServiceClassAdmin)
1725     #admin.site.register(PlanetStack)
1726     admin.site.register(Tag, TagAdmin)
1727     admin.site.register(ControllerRole)
1728     admin.site.register(SiteRole)
1729     admin.site.register(SliceRole)
1730     admin.site.register(PlanetStackRole)
1731     admin.site.register(Node, NodeAdmin)
1732     #admin.site.register(SlicePrivilege, SlicePrivilegeAdmin)
1733     #admin.site.register(SitePrivilege, SitePrivilegeAdmin)
1734     admin.site.register(Sliver, SliverAdmin)
1735     admin.site.register(Image, ImageAdmin)
1736     admin.site.register(DashboardView, DashboardViewAdmin)
1737     admin.site.register(Flavor, FlavorAdmin)
1738