X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=planetstack%2Fcore%2Fmodels%2Fplcorebase.py;h=4b63062d3c98a4c269745e3687f89c9cbc206a5d;hb=451c4fc73c5fbb698af6e67e9488c1e7d167d209;hp=62bcb75d81bff9a56f36dbf8dca2c721e2dad570;hpb=2d95e48d394480aa22596105c9ca469fb5c4c923;p=plstackapi.git diff --git a/planetstack/core/models/plcorebase.py b/planetstack/core/models/plcorebase.py index 62bcb75..4b63062 100644 --- a/planetstack/core/models/plcorebase.py +++ b/planetstack/core/models/plcorebase.py @@ -1,57 +1,247 @@ import os +import sys from django.db import models from django.forms.models import model_to_dict -from observer.event_manager import EventSender - - -class PlCoreBase(models.Model): - - created = models.DateTimeField(auto_now_add=True) - updated = models.DateTimeField(auto_now=True) - - class Meta: - abstract = True - app_label = "core" - - def __init__(self, *args, **kwargs): - super(PlCoreBase, self).__init__(*args, **kwargs) - self.__initial = self._dict - - @property - def diff(self): - d1 = self.__initial - d2 = self._dict - diffs = [(k, (v, d2[k])) for k, v in d1.items() if v != d2[k]] - return dict(diffs) - - @property - def has_changed(self): - return bool(self.diff) - - @property - def changed_fields(self): - return self.diff.keys() - - def get_field_diff(self, field_name): - return self.diff.get(field_name, None) - - def delete(self, *args, **kwds): - super(PlCoreBase, self).delete(*args, **kwds) - - EventSender().fire({'delete_flag':True,'model':self.__name__}) +from django.core.urlresolvers import reverse +from django.forms.models import model_to_dict +from django.utils import timezone +from django.core.exceptions import PermissionDenied +import model_policy +from model_autodeletion import ephemeral_models + +try: + # This is a no-op if observer_disabled is set to 1 in the config file + from observer import * +except: + print >> sys.stderr, "import of observer failed! printing traceback and disabling observer:" + import traceback + traceback.print_exc() + + # guard against something failing + def notify_observer(*args, **kwargs): + pass + +# This manager will be inherited by all subclasses because +# the core model is abstract. +class PlCoreBaseDeletionManager(models.Manager): + def get_queryset(self): + parent=super(PlCoreBaseDeletionManager, self) + if hasattr(parent, "get_queryset"): + return parent.get_queryset().filter(deleted=True) + else: + return parent.get_query_set().filter(deleted=True) + + # deprecated in django 1.7 in favor of get_queryset(). + def get_query_set(self): + return self.get_queryset() + +# This manager will be inherited by all subclasses because +# the core model is abstract. +class PlCoreBaseManager(models.Manager): + def get_queryset(self): + parent=super(PlCoreBaseManager, self) + if hasattr(parent, "get_queryset"): + return parent.get_queryset().filter(deleted=False) + else: + return parent.get_query_set().filter(deleted=False) + + # deprecated in django 1.7 in favor of get_queryset(). + def get_query_set(self): + return self.get_queryset() + +class DiffModelMixIn: + # Provides useful methods for computing which objects in a model have + # changed. Make sure to do self._initial = self._dict in the __init__ + # method. + + # This is broken out of PlCoreBase into a Mixin so the User model can + # also make use of it. + + @property + def _dict(self): + return model_to_dict(self, fields=[field.name for field in + self._meta.fields]) + + @property + def diff(self): + d1 = self._initial + d2 = self._dict + diffs = [(k, (v, d2[k])) for k, v in d1.items() if v != d2[k]] + return dict(diffs) + + @property + def has_changed(self): + return bool(self.diff) + + @property + def changed_fields(self): + return self.diff.keys() + + def has_field_changed(self, field_name): + return field_name in self.diff.keys() + + def get_field_diff(self, field_name): + return self.diff.get(field_name, None) + + #classmethod + def getValidators(cls): + """ primarily for REST API, return a dictionary of field names mapped + to lists of the type of validations that need to be applied to + those fields. + """ + validators = {} + for field in cls._meta.fields: + l = [] + if field.blank==False: + l.append("notBlank") + if field.__class__.__name__=="URLField": + l.append("url") + validators[field.name] = l + return validators + +class PlCoreBase(models.Model): # , DiffModelMixIn): + objects = PlCoreBaseManager() + deleted_objects = PlCoreBaseDeletionManager() + + # ---- copy stuff from DiffModelMixin ---- + + # XXX Django fails miserably when trying to create initial migrations when + # DiffModelMixin is used. So, until we figure out what's wrong, + # just copied the guts of DiffModelMixIn here. + + @property + def _dict(self): + return model_to_dict(self, fields=[field.name for field in + self._meta.fields]) + + @property + def diff(self): + d1 = self._initial + d2 = self._dict + diffs = [(k, (v, d2[k])) for k, v in d1.items() if v != d2[k]] + return dict(diffs) + + @property + def has_changed(self): + return bool(self.diff) + + @property + def changed_fields(self): + return self.diff.keys() + + def has_field_changed(self, field_name): + return field_name in self.diff.keys() + + def get_field_diff(self, field_name): + return self.diff.get(field_name, None) + + #classmethod + def getValidators(cls): + """ primarily for REST API, return a dictionary of field names mapped + to lists of the type of validations that need to be applied to + those fields. + """ + validators = {} + for field in cls._meta.fields: + l = [] + if field.blank==False: + l.append("notBlank") + if field.__class__.__name__=="URLField": + l.append("url") + validators[field.name] = l + return validators + + # ---- end copy stuff from DiffModelMixin ---- + + # default values for created and updated are only there to keep evolution + # from failing. + created = models.DateTimeField(auto_now_add=True, default=timezone.now) + updated = models.DateTimeField(auto_now=True, default=timezone.now) + enacted = models.DateTimeField(null=True, blank=True, default=None) + policed = models.DateTimeField(null=True, blank=True, default=None) + backend_status = models.CharField(max_length=140, + default="0 - Provisioning in progress") + deleted = models.BooleanField(default=False) + + class Meta: + # Changing abstract to False would require the managers of subclasses of + # PlCoreBase to be customized individually. + abstract = True + app_label = "core" + + def __init__(self, *args, **kwargs): + super(PlCoreBase, self).__init__(*args, **kwargs) + self._initial = self._dict # for DiffModelMixIn + self.silent = False + + def can_update(self, user): + if user.is_readonly: + return False + if user.is_admin: + return True + + return False + + def delete(self, *args, **kwds): + # so we have something to give the observer + purge = kwds.get('purge',False) + if purge: + del kwds['purge'] + silent = kwds.get('silent',False) + if silent: + del kwds['silent'] + try: + purge = purge or observer_disabled + except NameError: + pass + + if (purge): + super(PlCoreBase, self).delete(*args, **kwds) + else: + self.deleted = True + self.enacted=None + self.save(update_fields=['enacted','deleted'], silent=silent) + + def save(self, *args, **kwargs): + # let the user specify silence as either a kwarg or an instance varible + silent = self.silent + if "silent" in kwargs: + silent=silent or kwargs.pop("silent") + + super(PlCoreBase, self).save(*args, **kwargs) + + # This is a no-op if observer_disabled is set + if not silent: + notify_observer() + + self._initial = self._dict + + def save_by_user(self, user, *args, **kwds): + if not self.can_update(user): + if getattr(self, "_cant_update_fieldName", None) is not None: + raise PermissionDenied("You do not have permission to update field %s on object %s" % (self._cant_update_fieldName, self.__class__.__name__)) + else: + raise PermissionDenied("You do not have permission to update %s objects" % self.__class__.__name__) + + self.save(*args, **kwds) + + def delete_by_user(self, user, *args, **kwds): + if not self.can_update(user): + raise PermissionDenied("You do not have permission to delete %s objects" % self.__class__.__name__) + self.delete(*args, **kwds) + + @classmethod + def select_by_user(cls, user): + # This should be overridden by descendant classes that want to perform + # filtering of visible objects by user. + return cls.objects.all() + + @classmethod + def is_ephemeral(cls): + return cls in ephemeral_models - def save(self, *args, **kwargs): - super(PlCoreBase, self).save(*args, **kwargs) - - # Tell the observer that the source database has been updated - EventSender().fire() - self.__initial = self._dict - @property - def _dict(self): - return model_to_dict(self, fields=[field.name for field in - self._meta.fields])