From: Stephen Burrows Date: Tue, 12 Oct 2010 13:51:05 +0000 (-0400) Subject: Initial flexible attributes commit. Removed Relationship model in favor of a flexible... X-Git-Tag: philo-0.9~29^2~8^2~6 X-Git-Url: http://git.ithinksw.org/philo.git/commitdiff_plain/74ceac458ad030558f2e564ba34191115d0aadc5 Initial flexible attributes commit. Removed Relationship model in favor of a flexible Attribute model with generic foreign keys to an entity and a value type. This should allow for easy addition of attribute types: for example, an attribute with a ManyToMany value. --- diff --git a/admin/base.py b/admin/base.py index 46c7c22..3b2deba 100644 --- a/admin/base.py +++ b/admin/base.py @@ -1,6 +1,6 @@ from django.contrib import admin from django.contrib.contenttypes import generic -from philo.models import Tag, Attribute, Relationship +from philo.models import Tag, Attribute COLLAPSE_CLASSES = ('collapse', 'collapse-closed', 'closed',) @@ -16,18 +16,18 @@ class AttributeInline(generic.GenericTabularInline): classes = COLLAPSE_CLASSES -class RelationshipInline(generic.GenericTabularInline): - ct_field = 'entity_content_type' - ct_fk_field = 'entity_object_id' - model = Relationship - extra = 1 - template = 'admin/philo/edit_inline/tabular_collapse.html' - allow_add = True - classes = COLLAPSE_CLASSES +#class RelationshipInline(generic.GenericTabularInline): +# ct_field = 'entity_content_type' +# ct_fk_field = 'entity_object_id' +# model = Relationship +# extra = 1 +# template = 'admin/philo/edit_inline/tabular_collapse.html' +# allow_add = True +# classes = COLLAPSE_CLASSES class EntityAdmin(admin.ModelAdmin): - inlines = [AttributeInline, RelationshipInline] + inlines = [AttributeInline] #, RelationshipInline] save_on_top = True diff --git a/admin/pages.py b/admin/pages.py index 4810e0f..234b9d8 100644 --- a/admin/pages.py +++ b/admin/pages.py @@ -1,6 +1,5 @@ from django.contrib import admin from django import forms -from philo.admin import widgets from philo.admin.base import COLLAPSE_CLASSES from philo.admin.nodes import ViewAdmin from philo.models.pages import Page, Template, Contentlet, ContentReference diff --git a/forms.py b/forms.py index ced29b2..0e034df 100644 --- a/forms.py +++ b/forms.py @@ -8,7 +8,6 @@ from django.template import loader, loader_tags, TemplateDoesNotExist, Context, from django.utils.datastructures import SortedDict from philo.admin.widgets import ModelLookupWidget from philo.models import Entity, Template, Contentlet, ContentReference -from philo.models.fields import RelationshipField from philo.utils import fattr diff --git a/models/base.py b/models/base.py index 718429b..145c1ee 100644 --- a/models/base.py +++ b/models/base.py @@ -33,48 +33,106 @@ class Titled(models.Model): 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_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 JSONValue(models.Model): value = JSONField() #verbose_name='Value (JSON)', help_text='This value must be valid JSON.') def __unicode__(self): - return u'"%s": %s' % (self.key, self.value) + return self.value_json class Meta: app_label = 'philo' - unique_together = ('key', 'entity_content_type', 'entity_object_id') -value_content_type_limiter = ContentTypeRegistryLimiter() - +class ForeignKeyValue(models.Model): + content_type = models.ForeignKey(ContentType, related_name='foreign_key_value_set', 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 __unicode__(self): + return unicode(self.value) + + class Meta: + app_label = 'philo' -def register_value_model(model): - value_content_type_limiter.register_class(model) +class ManyToManyValue(models.Model): + content_type = models.ForeignKey(ContentType, related_name='many_to_many_value_set', limit_choices_to=value_content_type_limiter, verbose_name='Value type', null=True, blank=True) + object_ids = models.CommaSeparatedIntegerField(max_length=300, verbose_name='Value IDs', null=True, blank=True) + + def get_value(self): + return self.content_type.model_class()._default_manager.filter(id__in=self.object_ids) + + def set_value(self, value): + if not isinstance(value, models.query.QuerySet): + raise TypeError("Value must be a QuerySet.") + self.content_type = ContentType.objects.get_for_model(value.model) + self.object_ids = ','.join(value.values_list('id', flat=True)) + + value = property(get_value, set_value) + + def __unicode__(self): + return unicode(self.value) + + class Meta: + app_label = 'philo' -def unregister_value_model(model): - value_content_type_limiter.unregister_class(model) +attribute_value_limiter = ContentTypeRegistryLimiter() +attribute_value_limiter.register_class(JSONValue) +attribute_value_limiter.register_class(ForeignKeyValue) +attribute_value_limiter.register_class(ManyToManyValue) -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') - 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') + key = models.CharField(max_length=255) + + def get_value_class(self, value): + if isinstance(value, models.query.QuerySet): + return ManyToManyValue + elif isinstance(value, models.Model): + return ForeignKeyValue + else: + return JSONValue + + def set_value(self, value): + value_class = self.get_value_class(value) + + if self.value is None or value_class != self.value_content_type.model_class(): + if self.value is not None: + self.value.delete() + new_value = value_class() + new_value.value = value + new_value.save() + self.value = new_value + else: + self.value.value = value + self.value.save() + 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): @@ -122,16 +180,11 @@ class Entity(models.Model): __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 relationships(self): - return QuerySetMapper(self.relationship_set) - @property def _added_attribute_registry(self): if not hasattr(self, '_real_added_attribute_registry'): @@ -144,18 +197,6 @@ class Entity(models.Model): 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) @@ -170,24 +211,9 @@ class Entity(models.Model): attribute = Attribute() attribute.entity = self attribute.key = key - attribute.value = value + attribute.set_value(value) 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 diff --git a/models/fields.py b/models/fields.py index 9483516..0c68858 100644 --- a/models/fields.py +++ b/models/fields.py @@ -7,7 +7,7 @@ from philo.signals import entity_class_prepared from philo.validators import TemplateValidator, json_validator -__all__ = ('AttributeField', 'RelationshipField') +__all__ = ('JSONAttribute', 'ForeignKeyAttribute', 'ManyToManyAttribute') class EntityProxyField(object): @@ -59,9 +59,7 @@ class AttributeFieldDescriptor(object): raise AttributeError('The \'%s\' attribute can only be accessed from %s instances.' % (self.field.name, owner.__name__)) def __set__(self, instance, value): - if self.field.key in instance._removed_attribute_registry: - instance._removed_attribute_registry.remove(self.field.key) - instance._added_attribute_registry[self.field.key] = value + raise NotImplementedError('AttributeFieldDescriptor subclasses must implement a __set__ method.') def __delete__(self, instance): if self.field.key in instance._added_attribute_registry: @@ -69,8 +67,42 @@ class AttributeFieldDescriptor(object): instance._removed_attribute_registry.append(self.field.key) +class JSONAttributeDescriptor(AttributeFieldDescriptor): + def __set__(self, instance, value): + if self.field.key in instance._removed_attribute_registry: + instance._removed_attribute_registry.remove(self.field.key) + instance._added_attribute_registry[self.field.key] = value + + +class ForeignKeyAttributeDescriptor(AttributeFieldDescriptor): + def __set__(self, instance, value): + if isinstance(value, (models.Model, type(None))): + if self.field.key in instance._removed_attribute_registry: + instance._removed_attribute_registry.remove(self.field.key) + instance._added_attribute_registry[self.field.key] = value + else: + raise AttributeError('The \'%s\' attribute can only be set using existing Model objects.' % self.field.name) + + +class ManyToManyAttributeDescriptor(AttributeFieldDescriptor): + def __set__(self, instance, value): + if isinstance(value, models.QuerySet): + if self.field.key in instance._removed_attribute_registry: + instance._removed_attribute_registry.remove(self.field.key) + instance._added_attribute_registry[self.field.key] = value + else: + raise AttributeError('The \'%s\' attribute can only be set to a QuerySet.' % self.field.name) + + class AttributeField(EntityProxyField): - descriptor_class = AttributeFieldDescriptor + def contribute_to_class(self, cls, name): + super(AttributeField, self).contribute_to_class(cls, name) + if self.key is None: + self.key = name + + +class JSONAttribute(AttributeField): + descriptor_class = JSONAttributeDescriptor def __init__(self, field_template=None, key=None, **kwargs): super(AttributeField, self).__init__(**kwargs) @@ -79,74 +111,41 @@ class AttributeField(EntityProxyField): field_template = models.CharField(max_length=255) self.field_template = field_template - def contribute_to_class(self, cls, name): - super(AttributeField, self).contribute_to_class(cls, name) - if self.key is None: - self.key = name - def formfield(self, **kwargs): defaults = {'required': False, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} defaults.update(kwargs) return self.field_template.formfield(**defaults) - - -class RelationshipFieldDescriptor(object): - def __init__(self, field): - self.field = field - def __get__(self, instance, owner): - if instance: - if self.field.key in instance._added_relationship_registry: - return instance._added_relationship_registry[self.field.key] - if self.field.key in instance._removed_relationship_registry: - return None - try: - return instance.relationships[self.field.key] - except KeyError: - return None - else: - raise AttributeError('The \'%s\' attribute can only be accessed from %s instances.' % (self.field.name, owner.__name__)) - - def __set__(self, instance, value): - if isinstance(value, (models.Model, type(None))): - if self.field.key in instance._removed_relationship_registry: - instance._removed_relationship_registry.remove(self.field.key) - instance._added_relationship_registry[self.field.key] = value - else: - raise AttributeError('The \'%s\' attribute can only be set using existing Model objects.' % self.field.name) - - def __delete__(self, instance): - if self.field.key in instance._added_relationship_registry: - del instance._added_relationship_registry[self.field.key] - instance._removed_relationship_registry.append(self.field.key) + def value_from_object(self, obj): + return getattr(obj, self.attname).value -class RelationshipField(EntityProxyField): - descriptor_class = RelationshipFieldDescriptor +class ForeignKeyAttribute(AttributeField): + descriptor_class = ForeignKeyAttributeDescriptor def __init__(self, model, limit_choices_to=None, key=None, **kwargs): - super(RelationshipField, self).__init__(**kwargs) + super(ForeignKeyAttribute, self).__init__(**kwargs) self.key = key self.model = model if limit_choices_to is None: limit_choices_to = {} self.limit_choices_to = limit_choices_to - def contribute_to_class(self, cls, name): - super(RelationshipField, self).contribute_to_class(cls, name) - if self.key is None: - self.key = name - def formfield(self, form_class=forms.ModelChoiceField, **kwargs): defaults = {'required': False, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} defaults.update(kwargs) return form_class(self.model._default_manager.complex_filter(self.limit_choices_to), **defaults) def value_from_object(self, obj): - relobj = super(RelationshipField, self).value_from_object(obj) + relobj = super(ForeignKeyAttribute, self).value_from_object(obj).value return getattr(relobj, 'pk', None) +class ManyToManyAttribute(AttributeField): + descriptor_class = ManyToManyAttributeDescriptor + #FIXME: Add __init__ and formfield methods + + class TemplateField(models.TextField): def __init__(self, allow=None, disallow=None, secure=True, *args, **kwargs): super(TemplateField, self).__init__(*args, **kwargs) diff --git a/models/nodes.py b/models/nodes.py index 14f5063..2bda588 100644 --- a/models/nodes.py +++ b/models/nodes.py @@ -57,9 +57,6 @@ class View(Entity): def attributes_with_node(self, node): return QuerySetMapper(self.attribute_set, passthrough=node.attributes) - def relationships_with_node(self, node): - return QuerySetMapper(self.relationship_set, passthrough=node.relationships) - def render_to_response(self, node, request, path=None, subpath=None, extra_context=None): extra_context = extra_context or {} view_about_to_render.send(sender=self, node=node, request=request, path=path, subpath=subpath, extra_context=extra_context) diff --git a/models/pages.py b/models/pages.py index 323aeb8..16098d1 100644 --- a/models/pages.py +++ b/models/pages.py @@ -82,9 +82,9 @@ class Page(View): def render_to_string(self, node=None, request=None, path=None, subpath=None, extra_context=None): context = {} context.update(extra_context or {}) - context.update({'page': self, 'attributes': self.attributes, 'relationships': self.relationships}) + context.update({'page': self, 'attributes': self.attributes}) if node and request: - context.update({'node': node, 'attributes': self.attributes_with_node(node), 'relationships': self.relationships_with_node(node)}) + context.update({'node': node, 'attributes': self.attributes_with_node(node)}) page_about_to_render_to_string.send(sender=self, node=node, request=request, extra_context=context) string = self.template.django_template.render(RequestContext(request, context)) else: