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
  11 from django.contrib.auth.forms import ReadOnlyPasswordHashField
  12 from django.contrib.auth.signals import user_logged_in
  13 from django.utils import timezone
  14 import django_evolution
  15
  16
  17 class ReadonlyTabularInline(admin.TabularInline):
  18     can_delete = False
  19     extra = 0
  20     editable_fields = []
  21
  22     def get_readonly_fields(self, request, obj=None):
  23         fields = []
  24         for field in self.model._meta.get_all_field_names():
  25             if (not field == 'id'):
  26                 if (field not in self.editable_fields):
  27                     fields.append(field)
  28         return fields
  29
  30     def has_add_permission(self, request):
  31         return False
  32
  33 class SliverInline(admin.TabularInline):
  34     model = Sliver
  35     fields = ['ip', 'instance_name', 'slice', 'numberCores', 'image', 'node', 'deploymentNetwork']
  36     extra = 0
  37     #readonly_fields = ['ip', 'instance_name', 'image']
  38     readonly_fields = ['ip', 'instance_name']
  39
  40
  41 class SiteInline(admin.TabularInline):
  42     model = Site
  43     extra = 0
  44
  45 class UserInline(admin.TabularInline):
  46     model = User
  47     fields = ['email', 'firstname', 'lastname']
  48     extra = 0
  49
  50 class SliceInline(admin.TabularInline):
  51     model = Slice
  52     extra = 0
  53
  54 class RoleInline(admin.TabularInline):
  55     model = Role
  56     extra = 0
  57
  58 class NodeInline(admin.TabularInline):
  59     model = Node
  60     extra = 0
  61
  62 class SitePrivilegeInline(admin.TabularInline):
  63     model = SitePrivilege
  64     extra = 0
  65
  66     def formfield_for_foreignkey(self, db_field, request, **kwargs):
  67         if db_field.name == 'site':
  68             if not request.user.is_admin:
  69                 # only show sites where user is an admin or pi
  70                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
  71                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
  72                 login_bases = [site_privilege.site.login_base for site_privilege in site_privileges]
  73                 sites = Site.objects.filter(login_base__in=login_bases)
  74                 kwargs['queryset'] = sites
  75
  76         if db_field.name == 'user':
  77             if not request.user.is_admin:
  78                 # only show users from sites where caller has admin or pi role
  79                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
  80                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
  81                 sites = [site_privilege.site for site_privilege in site_privileges]
  82                 site_privileges = SitePrivilege.objects.filter(site__in=sites)
  83                 emails = [site_privilege.user.email for site_privilege in site_privileges]
  84                 users = User.objects.filter(email__in=emails)
  85                 kwargs['queryset'] = users
  86         return super(SitePrivilegeInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
  87
  88 class SliceMembershipInline(admin.TabularInline):
  89     model = SliceMembership
  90     extra = 0
  91     fields = ('user', 'role')
  92
  93     def formfield_for_foreignkey(self, db_field, request, **kwargs):
  94         if db_field.name == 'slice':
  95             if not request.user.is_admin:
  96                 # only show slices at sites where caller has admin or pi role
  97                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
  98                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
  99                 sites = [site_privilege.site for site_privilege in site_privileges]
 100                 slices = Slice.objects.filter(site__in=sites)
 101                 kwargs['queryset'] = slices
 102         if db_field.name == 'user':
 103             if not request.user.is_admin:
 104                 # only show users from sites where caller has admin or pi role
 105                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 106                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 107                 sites = [site_privilege.site for site_privilege in site_privileges]
 108                 site_privileges = SitePrivilege.objects.filter(site__in=sites)
 109                 emails = [site_privilege.user.email for site_privilege in site_privileges]
 110                 users = User.objects.filter(email__in=emails)
 111                 kwargs['queryset'] = list(users)
 112
 113         return super(SliceMembershipInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
 114
 115 class SliceTagInline(admin.TabularInline):
 116     model = SliceTag
 117     extra = 0
 118
 119 class PlainTextWidget(forms.HiddenInput):
 120     input_type = 'hidden'
 121
 122     def render(self, name, value, attrs=None):
 123         if value is None:
 124             value = ''
 125         return mark_safe(str(value) + super(PlainTextWidget, self).render(name, value, attrs))
 126
 127 class PlanetStackBaseAdmin(admin.ModelAdmin):
 128     save_on_top = False
 129
 130 class RoleAdmin(PlanetStackBaseAdmin):
 131     fieldsets = [
 132         ('Role', {'fields': ['role_type']})
 133     ]
 134     list_display = ('role_type',)
 135
 136
 137 class DeploymentAdminForm(forms.ModelForm):
 138     sites = forms.ModelMultipleChoiceField(
 139         queryset=Site.objects.all(),
 140         required=False,
 141         widget=FilteredSelectMultiple(
 142             verbose_name=('Sites'), is_stacked=False
 143         )
 144     )
 145     class Meta:
 146         model = Deployment
 147
 148     def __init__(self, *args, **kwargs):
 149         super(DeploymentAdminForm, self).__init__(*args, **kwargs)
 150
 151         if self.instance and self.instance.pk:
 152             self.fields['sites'].initial = self.instance.sites.all()
 153
 154     def save(self, commit=True):
 155         deploymentNetwork = super(DeploymentAdminForm, self).save(commit=False)
 156         if commit:
 157             deploymentNetwork.save()
 158
 159         if deploymentNetwork.pk:
 160             deploymentNetwork.sites = self.cleaned_data['sites']
 161             self.save_m2m()
 162
 163         return deploymentNetwork
 164
 165 class DeploymentAdmin(PlanetStackBaseAdmin):
 166     form = DeploymentAdminForm
 167     inlines = [NodeInline,SliverInline]
 168
 169     def get_formsets(self, request, obj=None):
 170         for inline in self.get_inline_instances(request, obj):
 171             # hide MyInline in the add view
 172             if obj is None:
 173                 continue
 174             # give inline object access to driver and caller
 175             auth = request.session.get('auth', {})
 176             if request.user.site:
 177                 auth['tenant'] = request.user.site.login_base
 178             inline.model.os_manager = OpenStackManager(auth=auth, caller=request.user)
 179             yield inline.get_formset(request, obj)
 180
 181 class SiteAdmin(PlanetStackBaseAdmin):
 182     fieldsets = [
 183         (None, {'fields': ['name', 'site_url', 'enabled', 'is_public', 'login_base']}),
 184         ('Location', {'fields': ['latitude', 'longitude']}),
 185         ('Deployment Networks', {'fields': ['deployments']})
 186     ]
 187     list_display = ('name', 'login_base','site_url', 'enabled')
 188     filter_horizontal = ('deployments',)
 189     inlines = [NodeInline, UserInline, SitePrivilegeInline]
 190     search_fields = ['name']
 191
 192     def queryset(self, request):
 193         # admins can see all keys. Users can only see sites they belong to.
 194         qs = super(SiteAdmin, self).queryset(request)
 195         if not request.user.is_admin:
 196             valid_sites = [request.user.site.login_base]
 197             roles = request.user.get_roles()
 198             for tenant_list in roles.values():
 199                 valid_sites.extend(tenant_list)
 200             qs = qs.filter(login_base__in=valid_sites)
 201         return qs
 202
 203     def get_formsets(self, request, obj=None):
 204         for inline in self.get_inline_instances(request, obj):
 205             # hide MyInline in the add view
 206             if obj is None:
 207                 continue
 208             if isinstance(inline, SliceInline):
 209                 inline.model.caller = request.user
 210             yield inline.get_formset(request, obj)
 211
 212     def get_formsets(self, request, obj=None):
 213         for inline in self.get_inline_instances(request, obj):
 214             # hide MyInline in the add view
 215             if obj is None:
 216                 continue
 217             if isinstance(inline, SliverInline):
 218                 inline.model.caller = request.user
 219             yield inline.get_formset(request, obj)
 220
 221 class SitePrivilegeAdmin(PlanetStackBaseAdmin):
 222     fieldsets = [
 223         (None, {'fields': ['user', 'site', 'role']})
 224     ]
 225     list_display = ('user', 'site', 'role')
 226
 227     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 228         if db_field.name == 'site':
 229             if not request.user.is_admin:
 230                 # only show sites where user is an admin or pi
 231                 sites = set()
 232                 for site_privilege in SitePrivilege.objects.filer(user=request.user):
 233                     if site_privilege.role.role_type in ['admin', 'pi']:
 234                         sites.add(site_privilege.site)
 235                 kwargs['queryset'] = Site.objects.filter(site__in=list(sites))
 236
 237         if db_field.name == 'user':
 238             if not request.user.is_admin:
 239                 # only show users from sites where caller has admin or pi role
 240                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 241                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 242                 sites = [site_privilege.site for site_privilege in site_privileges]
 243                 site_privileges = SitePrivilege.objects.filter(site__in=sites)
 244                 emails = [site_privilege.user.email for site_privilege in site_privileges]
 245                 users = User.objects.filter(email__in=emails)
 246                 kwargs['queryset'] = users
 247
 248         return super(SitePrivilegeAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 249
 250     def queryset(self, request):
 251         # admins can see all privileges. Users can only see privileges at sites
 252         # where they have the admin role or pi role.
 253         qs = super(SitePrivilegeAdmin, self).queryset(request)
 254         if not request.user.is_admin:
 255             roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 256             site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 257             login_bases = [site_privilege.site.login_base for site_privilege in site_privileges]
 258             sites = Site.objects.filter(login_base__in=login_bases)
 259             qs = qs.filter(site__in=sites)
 260         return qs
 261
 262 class SliceAdmin(PlanetStackBaseAdmin):
 263     fields = ['name', 'site', 'serviceClass', 'description', 'slice_url']
 264     list_display = ('name', 'site','serviceClass', 'slice_url')
 265     inlines = [SliverInline, SliceMembershipInline, SliceTagInline]
 266
 267     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 268         if db_field.name == 'site':
 269             if not request.user.is_admin:
 270                 # only show sites where user is a pi or admin
 271                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 272                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 273                 login_bases = [site_privilege.site.login_base for site_privilege in site_privileges]
 274                 sites = Site.objects.filter(login_base__in=login_bases)
 275                 kwargs['queryset'] = sites
 276
 277         return super(SliceAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 278
 279     def queryset(self, request):
 280         # admins can see all keys. Users can only see slices they belong to.
 281         qs = super(SliceAdmin, self).queryset(request)
 282         if not request.user.is_admin:
 283             valid_slices = []
 284             roles = request.user.get_roles()
 285             for tenant_list in roles.values():
 286                 valid_slices.extend(tenant_list)
 287             qs = qs.filter(name__in=valid_slices)
 288         return qs
 289
 290     def get_formsets(self, request, obj=None):
 291         for inline in self.get_inline_instances(request, obj):
 292             # hide MyInline in the add view
 293             if obj is None:
 294                 continue
 295             if isinstance(inline, SliverInline):
 296                 inline.model.caller = request.user
 297             yield inline.get_formset(request, obj)
 298
 299     def get_queryset(self, request):
 300         qs = super(SliceAdmin, self).get_queryset(request)
 301         if request.user.is_superuser:
 302             return qs
 303         # users can only see slices at their site
 304         return qs.filter(site=request.user.site)
 305
 306     def save_model(self, request, obj, form, change):
 307         # update openstack connection to use this site/tenant
 308         obj.caller = request.user
 309         obj.save()
 310
 311 class SliceMembershipAdmin(PlanetStackBaseAdmin):
 312     fieldsets = [
 313         (None, {'fields': ['user', 'slice', 'role']})
 314     ]
 315     list_display = ('user', 'slice', 'role')
 316
 317     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 318         if db_field.name == 'slice':
 319             if not request.user.is_admin:
 320                 # only show slices at sites where caller has admin or pi role
 321                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 322                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 323                 sites = [site_privilege.site for site_privilege in site_privileges]
 324                 slices = Slice.objects.filter(site__in=sites)
 325                 kwargs['queryset'] = slices
 326
 327         if db_field.name == 'user':
 328             if not request.user.is_admin:
 329                 # only show users from sites where caller has admin or pi role
 330                 roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 331                 site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 332                 sites = [site_privilege.site for site_privilege in site_privileges]
 333                 site_privileges = SitePrivilege.objects.filter(site__in=sites)
 334                 emails = [site_privilege.user.email for site_privilege in site_privileges]
 335                 users = User.objects.filter(email__in=emails)
 336                 kwargs['queryset'] = users
 337
 338         return super(SliceMembershipAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 339
 340     def queryset(self, request):
 341         # admins can see all memberships. Users can only see memberships of
 342         # slices where they have the admin role.
 343         qs = super(SliceMembershipAdmin, self).queryset(request)
 344         if not request.user.is_admin:
 345             roles = Role.objects.filter(role_type__in=['admin', 'pi'])
 346             site_privileges = SitePrivilege.objects.filter(user=request.user).filter(role__in=roles)
 347             login_bases = [site_privilege.site.login_base for site_privilege in site_privileges]
 348             sites = Site.objects.filter(login_base__in=login_bases)
 349             slices = Slice.objects.filter(site__in=sites)
 350             qs = qs.filter(slice__in=slices)
 351         return qs
 352
 353     def save_model(self, request, obj, form, change):
 354         # update openstack connection to use this site/tenant
 355         auth = request.session.get('auth', {})
 356         auth['tenant'] = obj.slice.name
 357         obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
 358         obj.save()
 359
 360     def delete_model(self, request, obj):
 361         # update openstack connection to use this site/tenant
 362         auth = request.session.get('auth', {})
 363         auth['tenant'] = obj.slice.name
 364         obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
 365         obj.delete()
 366
 367
 368 class ImageAdmin(admin.ModelAdmin):
 369     fields = ['image_id', 'name', 'disk_format', 'container_format']
 370
 371 class NodeAdmin(admin.ModelAdmin):
 372     list_display = ('name', 'site', 'deployment')
 373     list_filter = ('deployment',)
 374
 375
 376 class SliverForm(forms.ModelForm):
 377     class Meta:
 378         model = Sliver
 379         ip = forms.CharField(widget=PlainTextWidget)
 380         instance_name = forms.CharField(widget=PlainTextWidget)
 381         widgets = {
 382             'ip': PlainTextWidget(),
 383             'instance_name': PlainTextWidget(),
 384         }
 385
 386 class SliverAdmin(PlanetStackBaseAdmin):
 387     form = SliverForm
 388     fieldsets = [
 389         ('Sliver', {'fields': ['ip', 'instance_name', 'slice', 'numberCores', 'image', 'key', 'node', 'deploymentNetwork']})
 390     ]
 391     list_display = ['ip', 'instance_name', 'slice', 'numberCores', 'image', 'key', 'node', 'deploymentNetwork']
 392
 393     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 394         if db_field.name == 'slice':
 395             if not request.user.is_admin:
 396                 slices = set([sm.slice.name for sm in SliceMembership.objects.filter(user=request.user)])
 397                 kwargs['queryset'] = Slice.objects.filter(name__in=list(slices))
 398
 399         return super(SliverAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 400
 401     def queryset(self, request):
 402         # admins can see all slivers. Users can only see slivers of
 403         # the slices they belong to.
 404         qs = super(SliverAdmin, self).queryset(request)
 405         if not request.user.is_admin:
 406             tenants = []
 407             roles = request.user.get_roles()
 408             for tenant_list in roles.values():
 409                 tenants.extend(tenant_list)
 410             valid_slices = Slice.objects.filter(name__in=tenants)
 411             qs = qs.filter(slice__in=valid_slices)
 412         return qs
 413
 414     def get_formsets(self, request, obj=None):
 415         # make some fields read only if we are updating an existing record
 416         if obj == None:
 417             #self.readonly_fields = ('ip', 'instance_name')
 418             self.readonly_fields = ()
 419         else:
 420             self.readonly_fields = ()
 421             #self.readonly_fields = ('ip', 'instance_name', 'slice', 'image', 'key')
 422
 423         for inline in self.get_inline_instances(request, obj):
 424             # hide MyInline in the add view
 425             if obj is None:
 426                 continue
 427             # give inline object access to driver and caller
 428             auth = request.session.get('auth', {})
 429             auth['tenant'] = obj.name       # meed to connect using slice's tenant
 430             inline.model.os_manager = OpenStackManager(auth=auth, caller=request.user)
 431             yield inline.get_formset(request, obj)
 432
 433     def save_model(self, request, obj, form, change):
 434         # update openstack connection to use this site/tenant
 435         auth = request.session.get('auth', {})
 436         auth['tenant'] = obj.slice.name
 437         obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
 438         obj.creator = request.user
 439         obj.save()
 440
 441     def delete_model(self, request, obj):
 442         # update openstack connection to use this site/tenant
 443         auth = request.session.get('auth', {})
 444         auth['tenant'] = obj.slice.name
 445         obj.os_manager = OpenStackManager(auth=auth, caller=request.user)
 446         obj.delete()
 447
 448 class UserCreationForm(forms.ModelForm):
 449     """A form for creating new users. Includes all the required
 450     fields, plus a repeated password."""
 451     password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
 452     password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)
 453
 454     class Meta:
 455         model = User
 456         fields = ('email', 'firstname', 'lastname', 'phone', 'public_key', 'site')
 457
 458     def clean_password2(self):
 459         # Check that the two password entries match
 460         password1 = self.cleaned_data.get("password1")
 461         password2 = self.cleaned_data.get("password2")
 462         if password1 and password2 and password1 != password2:
 463             raise forms.ValidationError("Passwords don't match")
 464         return password2
 465
 466     def save(self, commit=True):
 467         # Save the provided password in hashed format
 468         user = super(UserCreationForm, self).save(commit=False)
 469         user.password = self.cleaned_data["password1"]
 470         #user.set_password(self.cleaned_data["password1"])
 471         if commit:
 472             user.save()
 473         return user
 474
 475
 476 class UserChangeForm(forms.ModelForm):
 477     """A form for updating users. Includes all the fields on
 478     the user, but replaces the password field with admin's
 479     password hash display field.
 480     """
 481     password = ReadOnlyPasswordHashField()
 482
 483     class Meta:
 484         model = User
 485
 486     def clean_password(self):
 487         # Regardless of what the user provides, return the initial value.
 488         # This is done here, rather than on the field, because the
 489         # field does not have access to the initial value
 490         return self.initial["password"]
 491
 492
 493 class UserAdmin(UserAdmin):
 494     class Meta:
 495         app_label = "core"
 496
 497     # The forms to add and change user instances
 498     form = UserChangeForm
 499     add_form = UserCreationForm
 500
 501     # The fields to be used in displaying the User model.
 502     # These override the definitions on the base UserAdmin
 503     # that reference specific fields on auth.User.
 504     list_display = ('email', 'site', 'firstname', 'lastname', 'is_admin', 'last_login')
 505     list_filter = ('site',)
 506     inlines = [SitePrivilegeInline, SliceMembershipInline]
 507     fieldsets = (
 508         (None, {'fields': ('email', 'password', 'site', 'is_admin', 'timezone')}),
 509         ('Personal info', {'fields': ('firstname','lastname','phone', 'public_key')}),
 510         #('Important dates', {'fields': ('last_login',)}),
 511     )
 512     add_fieldsets = (
 513         (None, {
 514             'classes': ('wide',),
 515             'fields': ('email', 'firstname', 'lastname', 'phone', 'site', 'public_key','password1', 'password2', 'is_admin')}
 516         ),
 517     )
 518     search_fields = ('email',)
 519     ordering = ('email',)
 520     filter_horizontal = ()
 521
 522     def formfield_for_foreignkey(self, db_field, request, **kwargs):
 523         if db_field.name == 'site':
 524             if not request.user.is_admin:
 525                 # show sites where caller is an admin or pi
 526                 sites = []
 527                 for site_privilege in SitePrivilege.objects.filer(user=request.user):
 528                     if site_privilege.role.role_type in ['admin', 'pi']:
 529                         sites.append(site_privilege.site.login_base)
 530                 kwargs['queryset'] = Site.objects.filter(login_base__in(list(sites)))
 531
 532         return super(UserAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
 533
 534 class ServiceResourceInline(admin.TabularInline):
 535     model = ServiceResource
 536     extra = 0
 537
 538 class ServiceClassAdmin(admin.ModelAdmin):
 539     list_display = ('name', 'commitment', 'membershipFee')
 540     inlines = [ServiceResourceInline]
 541
 542 class ReservedResourceInline(admin.TabularInline):
 543     model = ReservedResource
 544     extra = 0
 545
 546     def formfield_for_foreignkey(self, db_field, request=None, **kwargs):
 547         field = super(ReservedResourceInline, self).formfield_for_foreignkey(db_field, request, **kwargs)
 548
 549         if db_field.name == 'resource':
 550             # restrict resources to those that the slice's service class allows
 551             if request._slice is not None:
 552                 field.queryset = field.queryset.filter(serviceClass = request._slice.serviceClass, calendarReservable=True)
 553                 if len(field.queryset) > 0:
 554                     field.initial = field.queryset.all()[0]
 555             else:\r
 556                 field.queryset = field.queryset.none()\r
 557         elif db_field.name == 'sliver':\r
 558             # restrict slivers to those that belong to the slice\r
 559             if request._slice is not None:\r
 560                 field.queryset = field.queryset.filter(slice = request._slice)
 561             else:
 562                 field.queryset = field.queryset.none()\r
 563 \r
 564         return field
 565
 566 class ReservationChangeForm(forms.ModelForm):
 567     class Meta:
 568         model = Reservation
 569
 570 class ReservationAddForm(forms.ModelForm):
 571     slice = forms.ModelChoiceField(queryset=Slice.objects.all(), widget=forms.Select(attrs={"onChange":"document.getElementById('id_refresh').value=1; submit()"}))
 572     refresh = forms.CharField(widget=forms.HiddenInput())
 573
 574     class Media:
 575        css = {'all': ('planetstack.css',)}   # .field-refresh { display: none; }
 576
 577     def clean_slice(self):
 578         slice = self.cleaned_data.get("slice")
 579         x = ServiceResource.objects.filter(serviceClass = slice.serviceClass, calendarReservable=True)
 580         if len(x) == 0:
 581             raise forms.ValidationError("The slice you selected does not have a service class that allows reservations")
 582         return slice
 583
 584     class Meta:
 585         model = Reservation
 586
 587 class ReservationAddRefreshForm(ReservationAddForm):
 588     """ This form is displayed when the Reservation Form receives an update
 589         from the Slice dropdown onChange handler. It doesn't validate the
 590         data and doesn't save the data. This will cause the form to be
 591         redrawn.
 592     """
 593
 594     """ don't validate anything other than slice """
 595     dont_validate_fields = ("startTime", "duration")
 596
 597     def full_clean(self):
 598         result = super(ReservationAddForm, self).full_clean()
 599
 600         for fieldname in self.dont_validate_fields:
 601             if fieldname in self._errors:
 602                 del self._errors[fieldname]
 603
 604         return result
 605
 606     """ don't save anything """
 607     def is_valid(self):
 608         return False
 609
 610 class ReservationAdmin(admin.ModelAdmin):
 611     list_display = ('startTime', 'duration')
 612     inlines = [ReservedResourceInline]
 613     form = ReservationAddForm
 614
 615     def add_view(self, request, form_url='', extra_context=None):
 616         timezone.activate(request.user.timezone)
 617         request._refresh = False
 618         request._slice = None
 619         if request.method == 'POST':
 620             # "refresh" will be set to "1" if the form was submitted due to
 621             # a change in the Slice dropdown.
 622             if request.POST.get("refresh","1") == "1":
 623                 request._refresh = True
 624                 request.POST["refresh"] = "0"
 625
 626             # Keep track of the slice that was selected, so the
 627             # reservedResource inline can filter items for the slice.
 628             request._slice = request.POST.get("slice",None)
 629             if (request._slice is not None):
 630                 request._slice = Slice.objects.get(id=request._slice)
 631
 632         result =  super(ReservationAdmin, self).add_view(request, form_url, extra_context)
 633         return result
 634
 635     def changelist_view(self, request, extra_context = None):
 636         timezone.activate(request.user.timezone)
 637         return super(ReservationAdmin, self).changelist_view(request, extra_context)
 638
 639     def get_form(self, request, obj=None, **kwargs):
 640         request._obj_ = obj\r
 641         if obj is not None:\r
 642             # For changes, set request._slice to the slice already set in the\r
 643             # object.\r
 644             request._slice = obj.slice\r
 645             self.form = ReservationChangeForm\r
 646         else:\r
 647             if getattr(request, "_refresh", False):\r
 648                 self.form = ReservationAddRefreshForm\r
 649             else:\r
 650                 self.form = ReservationAddForm\r
 651         return super(ReservationAdmin, self).get_form(request, obj, **kwargs)\r
 652 \r
 653     def get_readonly_fields(self, request, obj=None):
 654         if (obj is not None):\r
 655             # Prevent slice from being changed after the reservation has been\r
 656             # created.\r
 657             return ['slice']\r
 658         else:\r
 659             return []
 660
 661 # register a signal that caches the user's credentials when they log in
 662 def cache_credentials(sender, user, request, **kwds):
 663     auth = {'username': request.POST['username'],
 664             'password': request.POST['password']}
 665     request.session['auth'] = auth
 666 user_logged_in.connect(cache_credentials)
 667
 668 # Now register the new UserAdmin...
 669 admin.site.register(User, UserAdmin)
 670 # ... and, since we're not using Django's builtin permissions,
 671 # unregister the Group model from admin.
 672 admin.site.unregister(Group)
 673
 674 #Do not show django evolution in the admin interface
 675 from django_evolution.models import Version, Evolution
 676 admin.site.unregister(Version)
 677 admin.site.unregister(Evolution)
 678
 679
 680 # When debugging it is often easier to see all the classes, but for regular use
 681 # only the top-levels should be displayed
 682 showAll = False
 683
 684 admin.site.register(Deployment, DeploymentAdmin)
 685 admin.site.register(Site, SiteAdmin)
 686 admin.site.register(Slice, SliceAdmin)
 687 #admin.site.register(Subnet)
 688
 689
 690 if showAll:
 691     admin.site.register(Node, NodeAdmin)
 692     admin.site.register(SliceMembership, SliceMembershipAdmin)
 693     admin.site.register(SitePrivilege, SitePrivilegeAdmin)
 694     admin.site.register(Role, RoleAdmin)
 695     admin.site.register(Sliver, SliverAdmin)
 696     admin.site.register(ServiceClass, ServiceClassAdmin)
 697     admin.site.register(Reservation, ReservationAdmin)
 698     admin.site.register(Image, ImageAdmin)
 699