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