models/base.py

   1 from django.db import models
   2 from django.contrib.contenttypes.models import ContentType
   3 from django.contrib.contenttypes import generic
   4 from django.utils import simplejson as json
   5 from django.core.exceptions import ObjectDoesNotExist
   6 from philo.utils import ContentTypeRegistryLimiter
   7 from philo.signals import entity_class_prepared
   8 from UserDict import DictMixin
   9
  10
  11 class Tag(models.Model):
  12         name = models.CharField(max_length=250)
  13         slug = models.SlugField(unique=True)
  14
  15         def __unicode__(self):
  16                 return self.name
  17
  18         class Meta:
  19                 app_label = 'philo'
  20
  21
  22 class Titled(models.Model):
  23         title = models.CharField(max_length=255)
  24         slug = models.SlugField(max_length=255)
  25
  26         def __unicode__(self):
  27                 return self.title
  28
  29         class Meta:
  30                 abstract = True
  31
  32
  33 class Attribute(models.Model):
  34         entity_content_type = models.ForeignKey(ContentType, verbose_name='Entity type')
  35         entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
  36         entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
  37         key = models.CharField(max_length=255)
  38         json_value = models.TextField(verbose_name='Value (JSON)', help_text='This value must be valid JSON.')
  39
  40         def get_value(self):
  41                 return json.loads(self.json_value)
  42
  43         def set_value(self, value):
  44                 self.json_value = json.dumps(value)
  45
  46         def delete_value(self):
  47                 self.json_value = json.dumps(None)
  48
  49         value = property(get_value, set_value, delete_value)
  50
  51         def __unicode__(self):
  52                 return u'"%s": %s' % (self.key, self.value)
  53
  54         class Meta:
  55                 app_label = 'philo'
  56                 unique_together = ('key', 'entity_content_type', 'entity_object_id')
  57
  58
  59 value_content_type_limiter = ContentTypeRegistryLimiter()
  60
  61
  62 def register_value_model(model):
  63         value_content_type_limiter.register_class(model)
  64
  65
  66 def unregister_value_model(model):
  67         value_content_type_limiter.unregister_class(model)
  68
  69
  70
  71 class Relationship(models.Model):
  72         entity_content_type = models.ForeignKey(ContentType, related_name='relationship_entity_set', verbose_name='Entity type')
  73         entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
  74         entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
  75         key = models.CharField(max_length=255)
  76         value_content_type = models.ForeignKey(ContentType, related_name='relationship_value_set', limit_choices_to=value_content_type_limiter, verbose_name='Value type', null=True, blank=True)
  77         value_object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True)
  78         value = generic.GenericForeignKey('value_content_type', 'value_object_id')
  79
  80         def __unicode__(self):
  81                 return u'"%s": %s' % (self.key, self.value)
  82
  83         class Meta:
  84                 app_label = 'philo'
  85                 unique_together = ('key', 'entity_content_type', 'entity_object_id')
  86
  87
  88 class QuerySetMapper(object, DictMixin):
  89         def __init__(self, queryset, passthrough=None):
  90                 self.queryset = queryset
  91                 self.passthrough = passthrough
  92
  93         def __getitem__(self, key):
  94                 try:
  95                         return self.queryset.get(key__exact=key).value
  96                 except ObjectDoesNotExist:
  97                         if self.passthrough is not None:
  98                                 return self.passthrough.__getitem__(key)
  99                         raise KeyError
 100
 101         def keys(self):
 102                 keys = set(self.queryset.values_list('key', flat=True).distinct())
 103                 if self.passthrough is not None:
 104                         keys |= set(self.passthrough.keys())
 105                 return list(keys)
 106
 107
 108 class EntityOptions(object):
 109         def __init__(self, options):
 110                 if options is not None:
 111                         for key, value in options.__dict__.items():
 112                                 setattr(self, key, value)
 113                 if not hasattr(self, 'proxy_fields'):
 114                         self.proxy_fields = []
 115
 116         def add_proxy_field(self, proxy_field):
 117                 self.proxy_fields.append(proxy_field)
 118
 119
 120 class EntityBase(models.base.ModelBase):
 121         def __new__(cls, name, bases, attrs):
 122                 new = super(EntityBase, cls).__new__(cls, name, bases, attrs)
 123                 entity_options = attrs.pop('EntityMeta', None)
 124                 setattr(new, '_entity_meta', EntityOptions(entity_options))
 125                 entity_class_prepared.send(sender=new)
 126                 return new
 127
 128
 129 class Entity(models.Model):
 130         __metaclass__ = EntityBase
 131
 132         attribute_set = generic.GenericRelation(Attribute, content_type_field='entity_content_type', object_id_field='entity_object_id')
 133         relationship_set = generic.GenericRelation(Relationship, content_type_field='entity_content_type', object_id_field='entity_object_id')
 134
 135         @property
 136         def attributes(self):
 137                 return QuerySetMapper(self.attribute_set)
 138
 139         @property
 140         def relationships(self):
 141                 return QuerySetMapper(self.relationship_set)
 142
 143         @property
 144         def _added_attribute_registry(self):
 145                 if not hasattr(self, '_real_added_attribute_registry'):
 146                         self._real_added_attribute_registry = {}
 147                 return self._real_added_attribute_registry
 148
 149         @property
 150         def _removed_attribute_registry(self):
 151                 if not hasattr(self, '_real_removed_attribute_registry'):
 152                         self._real_removed_attribute_registry = []
 153                 return self._real_removed_attribute_registry
 154
 155         @property
 156         def _added_relationship_registry(self):
 157                 if not hasattr(self, '_real_added_relationship_registry'):
 158                         self._real_added_relationship_registry = {}
 159                 return self._real_added_relationship_registry
 160
 161         @property
 162         def _removed_relationship_registry(self):
 163                 if not hasattr(self, '_real_removed_relationship_registry'):
 164                         self._real_removed_relationship_registry = []
 165                 return self._real_removed_relationship_registry
 166
 167         def save(self, *args, **kwargs):
 168                 super(Entity, self).save(*args, **kwargs)
 169
 170                 for key in self._removed_attribute_registry:
 171                         self.attribute_set.filter(key__exact=key).delete()
 172                 del self._removed_attribute_registry[:]
 173
 174                 for key, value in self._added_attribute_registry.items():
 175                         try:
 176                                 attribute = self.attribute_set.get(key__exact=key)
 177                         except Attribute.DoesNotExist:
 178                                 attribute = Attribute()
 179                                 attribute.entity = self
 180                                 attribute.key = key
 181                         attribute.value = value
 182                         attribute.save()
 183                 self._added_attribute_registry.clear()
 184
 185                 for key in self._removed_relationship_registry:
 186                         self.relationship_set.filter(key__exact=key).delete()
 187                 del self._removed_relationship_registry[:]
 188
 189                 for key, value in self._added_relationship_registry.items():
 190                         try:
 191                                 relationship = self.relationship_set.get(key__exact=key)
 192                         except Relationship.DoesNotExist:
 193                                 relationship = Relationship()
 194                                 relationship.entity = self
 195                                 relationship.key = key
 196                         relationship.value = value
 197                         relationship.save()
 198                 self._added_relationship_registry.clear()
 199
 200         class Meta:
 201                 abstract = True
 202
 203
 204 class TreeManager(models.Manager):
 205         use_for_related_fields = True
 206
 207         def roots(self):
 208                 return self.filter(parent__isnull=True)
 209
 210         def get_with_path(self, path, root=None, absolute_result=True, pathsep='/'):
 211                 """
 212                 Returns the object with the path, or None if there is no object with that path,
 213                 unless absolute_result is set to False, in which case it returns a tuple containing
 214                 the deepest object found along the path, and the remainder of the path after that
 215                 object as a string (or None in the case that there is no remaining path).
 216                 """
 217                 slugs = path.split(pathsep)
 218                 obj = root
 219                 remaining_slugs = list(slugs)
 220                 remainder = None
 221                 for slug in slugs:
 222                         remaining_slugs.remove(slug)
 223                         if slug: # ignore blank slugs, handles for multiple consecutive pathseps
 224                                 try:
 225                                         obj = self.get(slug__exact=slug, parent__exact=obj)
 226                                 except self.model.DoesNotExist:
 227                                         if absolute_result:
 228                                                 obj = None
 229                                         remaining_slugs.insert(0, slug)
 230                                         remainder = pathsep.join(remaining_slugs)
 231                                         break
 232                 if obj:
 233                         if absolute_result:
 234                                 return obj
 235                         else:
 236                                 return (obj, remainder)
 237                 raise self.model.DoesNotExist('%s matching query does not exist.' % self.model._meta.object_name)
 238
 239
 240 class TreeModel(models.Model):
 241         objects = TreeManager()
 242         parent = models.ForeignKey('self', related_name='children', null=True, blank=True)
 243         slug = models.SlugField()
 244
 245         def has_ancestor(self, ancestor):
 246                 parent = self
 247                 while parent:
 248                         if parent == ancestor:
 249                                 return True
 250                         parent = parent.parent
 251                 return False
 252
 253         def get_path(self, root=None, pathsep='/', field='slug'):
 254                 if root is not None and self.has_ancestor(root):
 255                         path = ''
 256                         parent = self
 257                         while parent and parent != root:
 258                                 path = getattr(parent, field, '?') + pathsep + path
 259                                 parent = parent.parent
 260                         return path
 261                 else:
 262                         path = getattr(self, field, '?')
 263                         parent = self.parent
 264                         while parent and parent != root:
 265                                 path = getattr(parent, field, '?') + pathsep + path
 266                                 parent = parent.parent
 267                         return path
 268         path = property(get_path)
 269
 270         def __unicode__(self):
 271                 return self.path
 272
 273         class Meta:
 274                 unique_together = (('parent', 'slug'),)
 275                 abstract = True
 276
 277
 278 class TreeEntity(Entity, TreeModel):
 279         @property
 280         def attributes(self):
 281                 if self.parent:
 282                         return QuerySetMapper(self.attribute_set, passthrough=self.parent.attributes)
 283                 return super(TreeEntity, self).attributes
 284
 285         @property
 286         def relationships(self):
 287                 if self.parent:
 288                         return QuerySetMapper(self.relationship_set, passthrough=self.parent.relationships)
 289                 return super(TreeEntity, self).relationships
 290
 291         class Meta:
 292                 abstract = True