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