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     # ---- copy stuff from DiffModelMixin ----
  90
  91     # XXX Django fails miserably when trying to create initial migrations when
  92     #    DiffModelMixin is used. So, until we figure out what's wrong,
  93     #    just copied the guts of DiffModelMixIn here.
  94
  95     @property
  96     def _dict(self):
  97         return model_to_dict(self, fields=[field.name for field in
  98                              self._meta.fields])
  99
 100     @property
 101     def diff(self):
 102         d1 = self._initial
 103         d2 = self._dict
 104         diffs = [(k, (v, d2[k])) for k, v in d1.items() if v != d2[k]]
 105         return dict(diffs)
 106
 107     @property
 108     def has_changed(self):
 109         return bool(self.diff)
 110
 111     @property
 112     def changed_fields(self):
 113         return self.diff.keys()
 114
 115     def has_field_changed(self, field_name):
 116         return field_name in self.diff.keys()
 117
 118     def get_field_diff(self, field_name):
 119         return self.diff.get(field_name, None)
 120     # ---- end copy stuff from DiffModelMixin ----
 121
 122     # default values for created and updated are only there to keep evolution
 123     # from failing.
 124     created = models.DateTimeField(auto_now_add=True, default=timezone.now)
 125     updated = models.DateTimeField(auto_now=True, default=timezone.now)
 126     enacted = models.DateTimeField(null=True, default=None)
 127     backend_status = models.CharField(max_length=140,
 128                                       default="Provisioning in progress")
 129     deleted = models.BooleanField(default=False)
 130
 131     class Meta:
 132         # Changing abstract to False would require the managers of subclasses of
 133         # PlCoreBase to be customized individually.
 134         abstract = True
 135         app_label = "core"
 136
 137     def __init__(self, *args, **kwargs):
 138         super(PlCoreBase, self).__init__(*args, **kwargs)
 139         self._initial = self._dict # for DiffModelMixIn
 140         self.silent = False
 141
 142     def can_update(self, user):
 143         if user.is_readonly:
 144             return False
 145         if user.is_admin:
 146             return True
 147
 148         return False
 149
 150     def delete(self, *args, **kwds):
 151         # so we have something to give the observer
 152         purge = kwds.get('purge',False)
 153         if purge:
 154             del kwds['purge']
 155         silent = kwds.get('silent',False)
 156         if silent:
 157             del kwds['silent']
 158         try:
 159             purge = purge or observer_disabled
 160         except NameError:
 161             pass
 162
 163         if (purge):
 164             super(PlCoreBase, self).delete(*args, **kwds)
 165         else:
 166             self.deleted = True
 167             self.enacted=None
 168             self.save(update_fields=['enacted','deleted'], silent=silent)
 169
 170     def save(self, *args, **kwargs):
 171         # let the user specify silence as either a kwarg or an instance varible
 172         silent = self.silent
 173         if "silent" in kwargs:
 174             silent=silent or kwargs.pop("silent")
 175
 176         super(PlCoreBase, self).save(*args, **kwargs)
 177
 178         # This is a no-op if observer_disabled is set
 179         if not silent:
 180             notify_observer()
 181
 182         self._initial = self._dict
 183
 184     def save_by_user(self, user, *args, **kwds):
 185         if not self.can_update(user):
 186             if getattr(self, "_cant_update_fieldName", None) is not None:
 187                 raise PermissionDenied("You do not have permission to update field %s on object %s" % (self._cant_update_fieldName, self.__class__.__name__))
 188             else:
 189                 raise PermissionDenied("You do not have permission to update %s objects" % self.__class__.__name__)
 190
 191         self.save(*args, **kwds)
 192
 193     def delete_by_user(self, user, *args, **kwds):
 194         if not self.can_update(user):
 195             raise PermissionDenied("You do not have permission to delete %s objects" % self.__class__.__name__)
 196         self.delete(*args, **kwds)
 197
 198     @classmethod
 199     def select_by_user(cls, user):
 200         # This should be overridden by descendant classes that want to perform
 201         # filtering of visible objects by user.
 202         return cls.objects.all()
 203
 204     @classmethod
 205     def is_ephemeral(cls):
 206         return False
 207
 208
 209
 210