Switched Attribute ManyToManyValues to have a ManyToManyField to ForeignKeyValues...

[philo.git] / models / base.py

diff --git a/models/base.py b/models/base.py
index 718429b..0077250 100644 (file)
--- a/models/base.py
+++ b/models/base.py
@@ -1,3 +1,4 @@
+from django import forms

 from django.db import models
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes import generic
 from django.db import models
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes import generic


@@ -5,7 +6,7 @@ from django.utils import simplejson as json
 from django.core.exceptions import ObjectDoesNotExist
 from philo.exceptions import AncestorDoesNotExist
 from philo.models.fields import JSONField
 from django.core.exceptions import ObjectDoesNotExist
 from philo.exceptions import AncestorDoesNotExist
 from philo.models.fields import JSONField

-from philo.utils import ContentTypeRegistryLimiter
+from philo.utils import ContentTypeRegistryLimiter, ContentTypeSubclassLimiter

 from philo.signals import entity_class_prepared
 from philo.validators import json_validator
 from UserDict import DictMixin
 from philo.signals import entity_class_prepared
 from philo.validators import json_validator
 from UserDict import DictMixin


@@ -33,48 +34,152 @@ class Titled(models.Model):
                abstract = True
 
 
                abstract = True
 
 

-class Attribute(models.Model):
-       entity_content_type = models.ForeignKey(ContentType, verbose_name='Entity type')
-       entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
-       entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
-       key = models.CharField(max_length=255)
-       value = JSONField() #verbose_name='Value (JSON)', help_text='This value must be valid JSON.')
+value_content_type_limiter = ContentTypeRegistryLimiter()
+
+
+def register_value_model(model):
+       value_content_type_limiter.register_class(model)
+
+
+def unregister_value_model(model):
+       value_content_type_limiter.unregister_class(model)
+
+
+class AttributeValue(models.Model):
+       attribute_set = generic.GenericRelation('Attribute', content_type_field='value_content_type', object_id_field='value_object_id')
+       
+       @property
+       def attribute(self):
+               return self.attribute_set.all()[0]
+       
+       def apply_data(self, data):
+               raise NotImplementedError
+       
+       def value_formfield(self, **kwargs):
+               raise NotImplementedError

        
        def __unicode__(self):
        
        def __unicode__(self):

-               return u'"%s": %s' % (self.key, self.value)
+               return unicode(self.value)

        
        class Meta:
        
        class Meta:

-               app_label = 'philo'
-               unique_together = ('key', 'entity_content_type', 'entity_object_id')
+               abstract = True

 
 
 
 

-value_content_type_limiter = ContentTypeRegistryLimiter()
+attribute_value_limiter = ContentTypeSubclassLimiter(AttributeValue)

 
 
 
 

-def register_value_model(model):
-       value_content_type_limiter.register_class(model)
+class JSONValue(AttributeValue):
+       value = JSONField() #verbose_name='Value (JSON)', help_text='This value must be valid JSON.')
+       
+       def __unicode__(self):
+               return self.value_json
+       
+       def value_formfield(self, **kwargs):
+               kwargs['initial'] = self.value_json
+               return self._meta.get_field('value').formfield(**kwargs)
+       
+       def apply_data(self, cleaned_data):
+               self.value = cleaned_data.get('value', None)
+       
+       class Meta:
+               app_label = 'philo'

 
 
 
 

-def unregister_value_model(model):
-       value_content_type_limiter.unregister_class(model)
+class ForeignKeyValue(AttributeValue):
+       content_type = models.ForeignKey(ContentType, limit_choices_to=value_content_type_limiter, verbose_name='Value type', null=True, blank=True)
+       object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True)
+       value = generic.GenericForeignKey()
+       
+       def value_formfield(self, form_class=forms.ModelChoiceField, **kwargs):
+               if self.content_type is None:
+                       return None
+               kwargs.update({'initial': self.object_id, 'required': False})
+               return form_class(self.content_type.model_class()._default_manager.all(), **kwargs)
+       
+       def apply_data(self, cleaned_data):
+               if 'value' in cleaned_data and cleaned_data['value'] is not None:
+                       self.value = cleaned_data['value']
+               else:
+                       self.content_type = cleaned_data.get('content_type', None)
+                       # If there is no value set in the cleaned data, clear the stored value.
+                       self.object_id = None
+       
+       class Meta:
+               app_label = 'philo'
+

 
 

+class ManyToManyValue(AttributeValue):
+       content_type = models.ForeignKey(ContentType, limit_choices_to=value_content_type_limiter, verbose_name='Value type', null=True, blank=True)
+       values = models.ManyToManyField(ForeignKeyValue, blank=True, null=True)
+       
+       def get_object_id_list(self):
+               if not self.values.count():
+                       return []
+               else:
+                       return self.values.values_list('object_id', flat=True)
+       
+       def get_value(self):
+               if self.content_type is None:
+                       return None
+               
+               return self.content_type.model_class()._default_manager.filter(id__in=self.get_object_id_list())
+       
+       def set_value(self, value):
+               # Value is probably a queryset - but allow any iterable.
+               
+               # These lines shouldn't be necessary; however, if value is an EmptyQuerySet,
+               # the code won't work without them. Unclear why...
+               if not value:
+                       value = []
+               
+               if isinstance(value, models.query.QuerySet):
+                       value = value.values_list('id', flat=True)
+               
+               self.values.filter(~models.Q(object_id__in=value)).delete()
+               current = self.get_object_id_list()
+               
+               for v in value:
+                       if v in current:
+                               continue
+                       self.values.create(content_type=self.content_type, object_id=v)
+       
+       value = property(get_value, set_value)
+       
+       def value_formfield(self, form_class=forms.ModelMultipleChoiceField, **kwargs):
+               if self.content_type is None:
+                       return None
+               kwargs.update({'initial': self.get_object_id_list(), 'required': False})
+               return form_class(self.content_type.model_class()._default_manager.all(), **kwargs)
+       
+       def apply_data(self, cleaned_data):
+               if 'value' in cleaned_data and cleaned_data['value'] is not None:
+                       self.value = cleaned_data['value']
+               else:
+                       self.content_type = cleaned_data.get('content_type', None)
+                       # If there is no value set in the cleaned data, clear the stored value.
+                       self.value = []
+       
+       class Meta:
+               app_label = 'philo'

 
 
 
 

-class Relationship(models.Model):
-       entity_content_type = models.ForeignKey(ContentType, related_name='relationship_entity_set', verbose_name='Entity type')
+class Attribute(models.Model):
+       entity_content_type = models.ForeignKey(ContentType, related_name='attribute_entity_set', verbose_name='Entity type')

        entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
        entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
        entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
        entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')

-       key = models.CharField(max_length=255)
-       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)
+       
+       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)

        value_object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True)
        value = generic.GenericForeignKey('value_content_type', 'value_object_id')
        
        value_object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True)
        value = generic.GenericForeignKey('value_content_type', 'value_object_id')
        

+       key = models.CharField(max_length=255)
+       

        def __unicode__(self):
                return u'"%s": %s' % (self.key, self.value)
        
        class Meta:
                app_label = 'philo'
        def __unicode__(self):
                return u'"%s": %s' % (self.key, self.value)
        
        class Meta:
                app_label = 'philo'

-               unique_together = ('key', 'entity_content_type', 'entity_object_id')
+               unique_together = (('key', 'entity_content_type', 'entity_object_id'), ('value_content_type', 'value_object_id'))

 
 
 class QuerySetMapper(object, DictMixin):
 
 
 class QuerySetMapper(object, DictMixin):


@@ -84,11 +189,15 @@ class QuerySetMapper(object, DictMixin):
        
        def __getitem__(self, key):
                try:
        
        def __getitem__(self, key):
                try:

-                       return self.queryset.get(key__exact=key).value
+                       value = self.queryset.get(key__exact=key).value

                except ObjectDoesNotExist:
                        if self.passthrough is not None:
                                return self.passthrough.__getitem__(key)
                        raise KeyError
                except ObjectDoesNotExist:
                        if self.passthrough is not None:
                                return self.passthrough.__getitem__(key)
                        raise KeyError

+               else:
+                       if value is not None:
+                               return value.value
+                       return value

        
        def keys(self):
                keys = set(self.queryset.values_list('key', flat=True).distinct())
        
        def keys(self):
                keys = set(self.queryset.values_list('key', flat=True).distinct())


@@ -122,16 +231,11 @@ class Entity(models.Model):
        __metaclass__ = EntityBase
        
        attribute_set = generic.GenericRelation(Attribute, content_type_field='entity_content_type', object_id_field='entity_object_id')
        __metaclass__ = EntityBase
        
        attribute_set = generic.GenericRelation(Attribute, content_type_field='entity_content_type', object_id_field='entity_object_id')

-       relationship_set = generic.GenericRelation(Relationship, content_type_field='entity_content_type', object_id_field='entity_object_id')

        
        @property
        def attributes(self):
                return QuerySetMapper(self.attribute_set)
        
        
        @property
        def attributes(self):
                return QuerySetMapper(self.attribute_set)
        

-       @property
-       def relationships(self):
-               return QuerySetMapper(self.relationship_set)
-       

        @property
        def _added_attribute_registry(self):
                if not hasattr(self, '_real_added_attribute_registry'):
        @property
        def _added_attribute_registry(self):
                if not hasattr(self, '_real_added_attribute_registry'):


@@ -144,18 +248,6 @@ class Entity(models.Model):
                        self._real_removed_attribute_registry = []
                return self._real_removed_attribute_registry
        
                        self._real_removed_attribute_registry = []
                return self._real_removed_attribute_registry
        

-       @property
-       def _added_relationship_registry(self):
-               if not hasattr(self, '_real_added_relationship_registry'):
-                       self._real_added_relationship_registry = {}
-               return self._real_added_relationship_registry
-       
-       @property
-       def _removed_relationship_registry(self):
-               if not hasattr(self, '_real_removed_relationship_registry'):
-                       self._real_removed_relationship_registry = []
-               return self._real_removed_relationship_registry
-       

        def save(self, *args, **kwargs):
                super(Entity, self).save(*args, **kwargs)
                
        def save(self, *args, **kwargs):
                super(Entity, self).save(*args, **kwargs)
                


@@ -163,31 +255,17 @@ class Entity(models.Model):
                        self.attribute_set.filter(key__exact=key).delete()
                del self._removed_attribute_registry[:]
                
                        self.attribute_set.filter(key__exact=key).delete()
                del self._removed_attribute_registry[:]
                

-               for key, value in self._added_attribute_registry.items():
+               for field, value in self._added_attribute_registry.items():

                        try:
                        try:

-                               attribute = self.attribute_set.get(key__exact=key)
+                               attribute = self.attribute_set.get(key__exact=field.key)

                        except Attribute.DoesNotExist:
                                attribute = Attribute()
                                attribute.entity = self
                        except Attribute.DoesNotExist:
                                attribute = Attribute()
                                attribute.entity = self

-                               attribute.key = key
-                       attribute.value = value
+                               attribute.key = field.key
+                       
+                       field.set_attribute_value(attribute, value)

                        attribute.save()
                self._added_attribute_registry.clear()
                        attribute.save()
                self._added_attribute_registry.clear()

-               
-               for key in self._removed_relationship_registry:
-                       self.relationship_set.filter(key__exact=key).delete()
-               del self._removed_relationship_registry[:]
-               
-               for key, value in self._added_relationship_registry.items():
-                       try:
-                               relationship = self.relationship_set.get(key__exact=key)
-                       except Relationship.DoesNotExist:
-                               relationship = Relationship()
-                               relationship.entity = self
-                               relationship.key = key
-                       relationship.value = value
-                       relationship.save()
-               self._added_relationship_registry.clear()

        
        class Meta:
                abstract = True
        
        class Meta:
                abstract = True


@@ -243,22 +321,15 @@ class TreeModel(models.Model):
                return False
        
        def get_path(self, root=None, pathsep='/', field='slug'):
                return False
        
        def get_path(self, root=None, pathsep='/', field='slug'):

-               if root is not None:
-                       if not self.has_ancestor(root):
-                               raise AncestorDoesNotExist(root)
-                       path = ''
-                       parent = self
-                       while parent and parent != root:
-                               path = getattr(parent, field, '?') + pathsep + path
-                               parent = parent.parent
-                       return path
-               else:
-                       path = getattr(self, field, '?')
-                       parent = self.parent
-                       while parent and parent != root:
-                               path = getattr(parent, field, '?') + pathsep + path
-                               parent = parent.parent
-                       return path
+               if root is not None and not self.has_ancestor(root):
+                       raise AncestorDoesNotExist(root)
+               
+               path = getattr(self, field, '?')
+               parent = self.parent
+               while parent and parent != root:
+                       path = getattr(parent, field, '?') + pathsep + path
+                       parent = parent.parent
+               return path

        path = property(get_path)
        
        def __unicode__(self):
        path = property(get_path)
        
        def __unicode__(self):


@@ -276,11 +347,5 @@ class TreeEntity(Entity, TreeModel):
                        return QuerySetMapper(self.attribute_set, passthrough=self.parent.attributes)
                return super(TreeEntity, self).attributes
        
                        return QuerySetMapper(self.attribute_set, passthrough=self.parent.attributes)
                return super(TreeEntity, self).attributes
        

-       @property
-       def relationships(self):
-               if self.parent:
-                       return QuerySetMapper(self.relationship_set, passthrough=self.parent.relationships)
-               return super(TreeEntity, self).relationships
-       

        class Meta:
                abstract = True
\ No newline at end of file
        class Meta:
                abstract = True
\ No newline at end of file