1 from django import forms
2 from django.db import models
3 from django.contrib.contenttypes.models import ContentType
4 from django.contrib.contenttypes import generic
5 from django.core.exceptions import ObjectDoesNotExist
6 from django.core.validators import RegexValidator
7 from django.utils import simplejson as json
8 from django.utils.encoding import force_unicode
9 from philo.exceptions import AncestorDoesNotExist
10 from philo.models.fields import JSONField
11 from philo.utils import ContentTypeRegistryLimiter, ContentTypeSubclassLimiter
12 from philo.signals import entity_class_prepared
13 from philo.validators import json_validator
14 from UserDict import DictMixin
15 from mptt.models import MPTTModel, MPTTModelBase, MPTTOptions
18 class Tag(models.Model):
19 name = models.CharField(max_length=255)
20 slug = models.SlugField(max_length=255, unique=True)
22 def __unicode__(self):
30 class Titled(models.Model):
31 title = models.CharField(max_length=255)
32 slug = models.SlugField(max_length=255)
34 def __unicode__(self):
41 value_content_type_limiter = ContentTypeRegistryLimiter()
44 def register_value_model(model):
45 value_content_type_limiter.register_class(model)
48 register_value_model(Tag)
51 def unregister_value_model(model):
52 value_content_type_limiter.unregister_class(model)
55 class AttributeValue(models.Model):
56 attribute_set = generic.GenericRelation('Attribute', content_type_field='value_content_type', object_id_field='value_object_id')
58 def set_value(self, value):
59 raise NotImplementedError
61 def value_formfields(self, **kwargs):
62 """Define any formfields that would be used to construct an instance of this value."""
63 raise NotImplementedError
65 def construct_instance(self, **kwargs):
66 """Apply cleaned data from the formfields generated by valid_formfields to oneself."""
67 raise NotImplementedError
69 def __unicode__(self):
70 return unicode(self.value)
76 attribute_value_limiter = ContentTypeSubclassLimiter(AttributeValue)
79 class JSONValue(AttributeValue):
80 value = JSONField(verbose_name='Value (JSON)', help_text='This value must be valid JSON.', default='null', db_index=True)
82 def __unicode__(self):
83 return force_unicode(self.value)
85 def value_formfields(self):
86 kwargs = {'initial': self.value_json}
87 field = self._meta.get_field('value')
88 return {field.name: field.formfield(**kwargs)}
90 def construct_instance(self, **kwargs):
91 field_name = self._meta.get_field('value').name
92 self.set_value(kwargs.pop(field_name, None))
94 def set_value(self, value):
101 class ForeignKeyValue(AttributeValue):
102 content_type = models.ForeignKey(ContentType, limit_choices_to=value_content_type_limiter, verbose_name='Value type', null=True, blank=True)
103 object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True, db_index=True)
104 value = generic.GenericForeignKey()
106 def value_formfields(self):
107 field = self._meta.get_field('content_type')
108 fields = {field.name: field.formfield(initial=getattr(self.content_type, 'pk', None))}
110 if self.content_type:
112 'initial': self.object_id,
114 'queryset': self.content_type.model_class()._default_manager.all()
116 fields['value'] = forms.ModelChoiceField(**kwargs)
119 def construct_instance(self, **kwargs):
120 field_name = self._meta.get_field('content_type').name
121 ct = kwargs.pop(field_name, None)
122 if ct is None or ct != self.content_type:
123 self.object_id = None
124 self.content_type = ct
126 value = kwargs.pop('value', None)
127 self.set_value(value)
129 self.content_type = ct
131 def set_value(self, value):
138 class ManyToManyValue(AttributeValue):
139 content_type = models.ForeignKey(ContentType, limit_choices_to=value_content_type_limiter, verbose_name='Value type', null=True, blank=True)
140 values = models.ManyToManyField(ForeignKeyValue, blank=True, null=True)
142 def get_object_ids(self):
143 return self.values.values_list('object_id', flat=True)
144 object_ids = property(get_object_ids)
146 def set_value(self, value):
147 # Value must be a queryset. Watch out for ModelMultipleChoiceField;
148 # it returns its value as a list if empty.
150 self.content_type = ContentType.objects.get_for_model(value.model)
152 # Before we can fiddle with the many-to-many to foreignkeyvalues, we need
157 object_ids = value.values_list('id', flat=True)
159 # These lines shouldn't be necessary; however, if object_ids is an EmptyQuerySet,
160 # the code (specifically the object_id__in query) won't work without them. Unclear why...
161 # TODO: is this still the case?
163 self.values.all().delete()
165 self.values.exclude(object_id__in=object_ids, content_type=self.content_type).delete()
167 current_ids = self.object_ids
169 for object_id in object_ids:
170 if object_id in current_ids:
172 self.values.create(content_type=self.content_type, object_id=object_id)
175 if self.content_type is None:
178 # HACK to be safely explicit until http://code.djangoproject.com/ticket/15145 is resolved
179 object_ids = self.object_ids
180 manager = self.content_type.model_class()._default_manager
182 return manager.none()
183 return manager.filter(id__in=self.object_ids)
185 value = property(get_value, set_value)
187 def value_formfields(self):
188 field = self._meta.get_field('content_type')
189 fields = {field.name: field.formfield(initial=getattr(self.content_type, 'pk', None))}
191 if self.content_type:
193 'initial': self.object_ids,
195 'queryset': self.content_type.model_class()._default_manager.all()
197 fields['value'] = forms.ModelMultipleChoiceField(**kwargs)
200 def construct_instance(self, **kwargs):
201 field_name = self._meta.get_field('content_type').name
202 ct = kwargs.pop(field_name, None)
203 if ct is None or ct != self.content_type:
205 self.content_type = ct
207 value = kwargs.get('value', None)
209 value = self.content_type.model_class()._default_manager.none()
210 self.set_value(value)
211 construct_instance.alters_data = True
217 class Attribute(models.Model):
218 entity_content_type = models.ForeignKey(ContentType, related_name='attribute_entity_set', verbose_name='Entity type')
219 entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID', db_index=True)
220 entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
222 value_content_type = models.ForeignKey(ContentType, related_name='attribute_value_set', limit_choices_to=attribute_value_limiter, verbose_name='Value type', null=True, blank=True)
223 value_object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True, db_index=True)
224 value = generic.GenericForeignKey('value_content_type', 'value_object_id')
226 key = models.CharField(max_length=255, validators=[RegexValidator("\w+")], help_text="Must contain one or more alphanumeric characters or underscores.", db_index=True)
228 def __unicode__(self):
229 return u'"%s": %s' % (self.key, self.value)
233 unique_together = (('key', 'entity_content_type', 'entity_object_id'), ('value_content_type', 'value_object_id'))
236 class QuerySetMapper(object, DictMixin):
237 def __init__(self, queryset, passthrough=None):
238 self.queryset = queryset
239 self.passthrough = passthrough
241 def __getitem__(self, key):
243 value = self.queryset.get(key__exact=key).value
244 except ObjectDoesNotExist:
245 if self.passthrough is not None:
246 return self.passthrough.__getitem__(key)
249 if value is not None:
254 keys = set(self.queryset.values_list('key', flat=True).distinct())
255 if self.passthrough is not None:
256 keys |= set(self.passthrough.keys())
260 class EntityOptions(object):
261 def __init__(self, options):
262 if options is not None:
263 for key, value in options.__dict__.items():
264 setattr(self, key, value)
265 if not hasattr(self, 'proxy_fields'):
266 self.proxy_fields = []
268 def add_proxy_field(self, proxy_field):
269 self.proxy_fields.append(proxy_field)
272 class EntityBase(models.base.ModelBase):
273 def __new__(cls, name, bases, attrs):
274 new = super(EntityBase, cls).__new__(cls, name, bases, attrs)
275 entity_options = attrs.pop('EntityMeta', None)
276 setattr(new, '_entity_meta', EntityOptions(entity_options))
277 entity_class_prepared.send(sender=new)
281 class Entity(models.Model):
282 __metaclass__ = EntityBase
284 attribute_set = generic.GenericRelation(Attribute, content_type_field='entity_content_type', object_id_field='entity_object_id')
287 def attributes(self):
288 return QuerySetMapper(self.attribute_set.all())
294 class TreeManager(models.Manager):
295 use_for_related_fields = True
297 def get_with_path(self, path, root=None, absolute_result=True, pathsep='/', field='slug'):
299 Returns the object with the path, unless absolute_result is set to False, in which
300 case it returns a tuple containing the deepest object found along the path, and the
301 remainder of the path after that object as a string (or None if there is no remaining
302 path). Raises a DoesNotExist exception if no object is found with the given path.
304 If the path you're searching for is known to exist, it is always faster to use
305 absolute_result=True - unless the path depth is over ~40, in which case the high cost
306 of the absolute query makes a binary search (i.e. non-absolute) faster.
308 # Note: SQLite allows max of 64 tables in one join. That means the binary search will
309 # only work on paths with a max depth of 127 and the absolute fetch will only work
310 # to a max depth of (surprise!) 63. Although this could be handled, chances are your
311 # tree structure won't be that deep.
312 segments = path.split(pathsep)
314 # Clean out blank segments. Handles multiple consecutive pathseps.
321 # Special-case a lack of segments. No queries necessary.
328 raise self.model.DoesNotExist('%s matching query does not exist.' % self.model._meta.object_name)
330 def make_query_kwargs(segments, root):
333 revsegs = list(segments)
336 for segment in revsegs:
337 kwargs["%s%s__exact" % (prefix, field)] = segment
341 kwargs[prefix[:-2]] = root
345 def find_obj(segments, depth, deepest_found=None):
346 if deepest_found is None:
349 deepest_level = deepest_found.get_level() + 1
351 deepest_level = deepest_found.get_level() - root.get_level()
353 obj = self.get(**make_query_kwargs(segments[deepest_level:depth], deepest_found or root))
354 except self.model.DoesNotExist:
355 if not deepest_level and depth > 1:
356 # make sure there's a root node...
359 # Try finding one with half the path since the deepest find.
360 depth = (deepest_level + depth)/2
362 if deepest_level == depth:
363 # This should happen if nothing is found with any part of the given path.
364 if root is not None and deepest_found is None:
365 return root, pathsep.join(segments)
368 return find_obj(segments, depth, deepest_found)
372 deepest_level = obj.get_level() + 1
374 deepest_level = obj.get_level() - root.get_level()
376 # Could there be a deeper one?
377 if obj.is_leaf_node():
378 return obj, pathsep.join(segments[deepest_level:]) or None
380 depth += (len(segments) - depth)/2 or len(segments) - depth
382 if depth > deepest_level + obj.get_descendant_count():
383 depth = deepest_level + obj.get_descendant_count()
385 if deepest_level == depth:
386 return obj, pathsep.join(segments[deepest_level:]) or None
389 return find_obj(segments, depth, obj)
390 except self.model.DoesNotExist:
391 # Then this was the deepest.
392 return obj, pathsep.join(segments[deepest_level:])
395 return self.get(**make_query_kwargs(segments, root))
397 # Try a modified binary search algorithm. Feed the root in so that query complexity
398 # can be reduced. It might be possible to weight the search towards the beginning
399 # of the path, since short paths are more likely, but how far forward? It would
400 # need to shift depending on len(segments) - perhaps logarithmically?
401 return find_obj(segments, len(segments)/2 or len(segments))
404 class TreeModel(MPTTModel):
405 objects = TreeManager()
406 parent = models.ForeignKey('self', related_name='children', null=True, blank=True)
407 slug = models.SlugField(max_length=255)
409 def get_path(self, root=None, pathsep='/', field='slug'):
413 if root is not None and not self.is_descendant_of(root):
414 raise AncestorDoesNotExist(root)
416 qs = self.get_ancestors(include_self=True)
419 qs = qs.filter(**{'%s__gt' % self._mptt_meta.level_attr: root.get_level()})
421 return pathsep.join([getattr(parent, field, '?') for parent in qs])
422 path = property(get_path)
424 def __unicode__(self):
428 unique_together = (('parent', 'slug'),)
432 class TreeEntityBase(MPTTModelBase, EntityBase):
433 def __new__(meta, name, bases, attrs):
434 attrs['_mptt_meta'] = MPTTOptions(attrs.pop('MPTTMeta', None))
435 cls = EntityBase.__new__(meta, name, bases, attrs)
437 return meta.register(cls)
440 class TreeEntity(Entity, TreeModel):
441 __metaclass__ = TreeEntityBase
444 def attributes(self):
446 return QuerySetMapper(self.attribute_set.all(), passthrough=self.parent.attributes)
447 return super(TreeEntity, self).attributes