planetstack/core/models/plcorebase.py

   1 import os
   2 import sys
   3 from django.db import models
   4 from django.forms.models import model_to_dict
   5 from django.core.urlresolvers import reverse
   6 from django.forms.models import model_to_dict
   7 from django.utils import timezone
   8 from django.core.exceptions import PermissionDenied
   9 import model_policy
  10
  11 try:
  12     # This is a no-op if observer_disabled is set to 1 in the config file
  13     from observer import *
  14 except:
  15     print >> sys.stderr, "import of observer failed! printing traceback and disabling observer:"
  16     import traceback
  17     traceback.print_exc()
  18
  19     # guard against something failing
  20     def notify_observer(*args, **kwargs):
  21         pass
  22
  23 # This manager will be inherited by all subclasses because
  24 # the core model is abstract.
  25 class PlCoreBaseDeletionManager(models.Manager):
  26     def get_queryset(self):
  27         parent=super(PlCoreBaseDeletionManager, self)
  28         if hasattr(parent, "get_queryset"):
  29             return parent.get_queryset().filter(deleted=True)
  30         else:
  31             return parent.get_query_set().filter(deleted=True)
  32
  33     # deprecated in django 1.7 in favor of get_queryset().
  34     def get_query_set(self):
  35         return self.get_queryset()
  36
  37 # This manager will be inherited by all subclasses because
  38 # the core model is abstract.
  39 class PlCoreBaseManager(models.Manager):
  40     def get_queryset(self):
  41         parent=super(PlCoreBaseManager, self)
  42         if hasattr(parent, "get_queryset"):
  43             return parent.get_queryset().filter(deleted=False)
  44         else:
  45             return parent.get_query_set().filter(deleted=False)
  46
  47     # deprecated in django 1.7 in favor of get_queryset().
  48     def get_query_set(self):
  49         return self.get_queryset()
  50
  51 class DiffModelMixIn:
  52     # Provides useful methods for computing which objects in a model have
  53     # changed. Make sure to do self._initial = self._dict in the __init__
  54     # method.
  55
  56     # This is broken out of PlCoreBase into a Mixin so the User model can
  57     # also make use of it.
  58
  59     @property
  60     def _dict(self):
  61         return model_to_dict(self, fields=[field.name for field in
  62                              self._meta.fields])
  63
  64     @property
  65     def diff(self):
  66         d1 = self._initial
  67         d2 = self._dict
  68         diffs = [(k, (v, d2[k])) for k, v in d1.items() if v != d2[k]]
  69         return dict(diffs)
  70
  71     @property
  72     def has_changed(self):
  73         return bool(self.diff)
  74
  75     @property
  76     def changed_fields(self):
  77         return self.diff.keys()
  78
  79     def has_field_changed(self, field_name):
  80         return field_name in self.diff.keys()
  81
  82     def get_field_diff(self, field_name):
  83         return self.diff.get(field_name, None)
  84
  85 class PlCoreBase(models.Model, DiffModelMixIn):
  86     objects = PlCoreBaseManager()
  87     deleted_objects = PlCoreBaseDeletionManager()
  88
  89     # default values for created and updated are only there to keep evolution
  90     # from failing.
  91     created = models.DateTimeField(auto_now_add=True, default=timezone.now)
  92     updated = models.DateTimeField(auto_now=True, default=timezone.now)
  93     enacted = models.DateTimeField(null=True, default=None)
  94     backend_status = models.CharField(max_length=140,
  95                                       default="Provisioning in progress")
  96     deleted = models.BooleanField(default=False)
  97
  98     class Meta:
  99         # Changing abstract to False would require the managers of subclasses of
 100         # PlCoreBase to be customized individually.
 101         abstract = True
 102         app_label = "core"
 103
 104     def __init__(self, *args, **kwargs):
 105         super(PlCoreBase, self).__init__(*args, **kwargs)
 106         self._initial = self._dict # for DiffModelMixIn
 107         self.silent = False
 108
 109     def can_update(self, user):
 110         if user.is_readonly:
 111             return False
 112         if user.is_admin:
 113             return True
 114
 115         return False
 116
 117     def delete(self, *args, **kwds):
 118         # so we have something to give the observer
 119         purge = kwds.get('purge',False)
 120         silent = kwds.get('silent',False)
 121         try:
 122             purge = purge or observer_disabled
 123         except NameError:
 124             pass
 125
 126         if (purge):
 127             del kwds['purge']
 128             super(PlCoreBase, self).delete(*args, **kwds)
 129         else:
 130             self.deleted = True
 131             self.enacted=None
 132             self.save(update_fields=['enacted','deleted'], silent=silent)
 133
 134     def save(self, *args, **kwargs):
 135         # let the user specify silence as either a kwarg or an instance varible
 136         silent = self.silent
 137         if "silent" in kwargs:
 138             silent=silent or kwargs.pop("silent")
 139
 140         super(PlCoreBase, self).save(*args, **kwargs)
 141
 142         # This is a no-op if observer_disabled is set
 143         if not silent:
 144             notify_observer()
 145
 146         self._initial = self._dict
 147
 148     def save_by_user(self, user, *args, **kwds):
 149         if not self.can_update(user):
 150             if getattr(self, "_cant_update_fieldName", None) is not None:
 151                 raise PermissionDenied("You do not have permission to update field %s on object %s" % (self._cant_update_fieldName, self.__class__.__name__))
 152             else:
 153                 raise PermissionDenied("You do not have permission to update %s objects" % self.__class__.__name__)
 154
 155         self.save(*args, **kwds)
 156
 157     def delete_by_user(self, user, *args, **kwds):
 158         if not self.can_update(user):
 159             raise PermissionDenied("You do not have permission to delete %s objects" % self.__class__.__name__)
 160         self.delete(*args, **kwds)
 161
 162     @classmethod
 163     def select_by_user(cls, user):
 164         # This should be overridden by descendant classes that want to perform
 165         # filtering of visible objects by user.
 166         return cls.objects.all()
 167
 168
 169
 170