X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/b2f456977cd5884c625f704e024213ad86163929..1d3756407233b937d7491bde6dd4046fb8b4b6d6:/models/base.py?ds=sidebyside

diff --git a/models/base.py b/models/base.py
index f062e2c..5d9d761 100644
--- a/models/base.py
+++ b/models/base.py
@@ -1,35 +1,37 @@
+from django import forms
 from django.db import models
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes import generic
 from django.utils import simplejson as json
 from django.core.exceptions import ObjectDoesNotExist
-from philo.utils import ContentTypeRegistryLimiter
+from philo.exceptions import AncestorDoesNotExist
+from philo.models.fields import JSONField
+from philo.utils import ContentTypeRegistryLimiter, ContentTypeSubclassLimiter
+from philo.signals import entity_class_prepared
+from philo.validators import json_validator
 from UserDict import DictMixin
 
 
-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)
-	json_value = models.TextField(verbose_name='Value (JSON)', help_text='This value must be valid JSON.')
-	
-	def get_value(self):
-		return json.loads(self.json_value)
-	
-	def set_value(self, value):
-		self.json_value = json.dumps(value)
+class Tag(models.Model):
+	name = models.CharField(max_length=255)
+	slug = models.SlugField(max_length=255, unique=True)
 	
-	def delete_value(self):
-		self.json_value = json.dumps(None)
+	def __unicode__(self):
+		return self.name
 	
-	value = property(get_value, set_value, delete_value)
+	class Meta:
+		app_label = 'philo'
+
+
+class Titled(models.Model):
+	title = models.CharField(max_length=255)
+	slug = models.SlugField(max_length=255)
 	
 	def __unicode__(self):
-		return u'"%s": %s' % (self.key, self.value)
+		return self.title
 	
 	class Meta:
-		app_label = 'philo'
+		abstract = True
 
 
 value_content_type_limiter = ContentTypeRegistryLimiter()
@@ -43,21 +45,144 @@ def unregister_value_model(model):
 	value_content_type_limiter.unregister_class(model)
 
 
+class AttributeValue(models.Model):
+	attribute = generic.GenericRelation('Attribute', content_type_field='value_content_type', object_id_field='value_object_id')
+	def apply_data(self, data):
+		raise NotImplementedError
+	
+	def value_formfield(self, **kwargs):
+		raise NotImplementedError
+	
+	def __unicode__(self):
+		return unicode(self.value)
+	
+	class Meta:
+		abstract = True
+
+
+attribute_value_limiter = ContentTypeSubclassLimiter(AttributeValue)
+
+
+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'
+
+
+class ForeignKeyValue(AttributeValue):
+	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 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, 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_object_id_list(self):
+		if not self.object_ids:
+			return []
+		else:
+			return self.object_ids.split(',')
+	
+	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):
+		if value is None:
+			self.object_ids = ""
+			return
+		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` for value in value.values_list('id', flat=True)])
+	
+	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):
+		self.value = cleaned_data.get('value', None)
+	
+	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')
-	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')
-	value_object_id = models.PositiveIntegerField(verbose_name='Value ID')
+	
+	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) or (value is None and self.value_content_type.model_class() is ForeignKeyValue):
+			return ForeignKeyValue
+		else:
+			return JSONValue
+	
+	def set_value(self, value):
+		# is this useful? The best way of doing it?
+		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'), ('value_content_type', 'value_object_id'))
 
 
 class QuerySetMapper(object, DictMixin):
@@ -80,21 +205,68 @@ class QuerySetMapper(object, DictMixin):
 		return list(keys)
 
 
+class EntityOptions(object):
+	def __init__(self, options):
+		if options is not None:
+			for key, value in options.__dict__.items():
+				setattr(self, key, value)
+		if not hasattr(self, 'proxy_fields'):
+			self.proxy_fields = []
+	
+	def add_proxy_field(self, proxy_field):
+		self.proxy_fields.append(proxy_field)
+
+
+class EntityBase(models.base.ModelBase):
+	def __new__(cls, name, bases, attrs):
+		new = super(EntityBase, cls).__new__(cls, name, bases, attrs)
+		entity_options = attrs.pop('EntityMeta', None)
+		setattr(new, '_entity_meta', EntityOptions(entity_options))
+		entity_class_prepared.send(sender=new)
+		return new
+
+
 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)
+	def _added_attribute_registry(self):
+		if not hasattr(self, '_real_added_attribute_registry'):
+			self._real_added_attribute_registry = {}
+		return self._real_added_attribute_registry
+	
+	@property
+	def _removed_attribute_registry(self):
+		if not hasattr(self, '_real_removed_attribute_registry'):
+			self._real_removed_attribute_registry = []
+		return self._real_removed_attribute_registry
+	
+	def save(self, *args, **kwargs):
+		super(Entity, self).save(*args, **kwargs)
+		
+		for key in 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():
+			try:
+				attribute = self.attribute_set.get(key__exact=key)
+			except Attribute.DoesNotExist:
+				attribute = Attribute()
+				attribute.entity = self
+				attribute.key = key
+			attribute.set_value(value)
+			attribute.save()
+		self._added_attribute_registry.clear()
 	
 	class Meta:
 		abstract = True
-		app_label = 'philo'
 
 
 class TreeManager(models.Manager):
@@ -136,15 +308,33 @@ class TreeManager(models.Manager):
 class TreeModel(models.Model):
 	objects = TreeManager()
 	parent = models.ForeignKey('self', related_name='children', null=True, blank=True)
-	slug = models.SlugField()
+	slug = models.SlugField(max_length=255)
 	
-	def get_path(self, pathsep='/', field='slug'):
-		path = getattr(self, field, '?')
-		parent = self.parent
+	def has_ancestor(self, ancestor):
+		parent = self
 		while parent:
-			path = getattr(parent, field, '?') + pathsep + path
+			if parent == ancestor:
+				return True
 			parent = parent.parent
-		return path
+		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
 	path = property(get_path)
 	
 	def __unicode__(self):
@@ -153,10 +343,9 @@ class TreeModel(models.Model):
 	class Meta:
 		unique_together = (('parent', 'slug'),)
 		abstract = True
-		app_label = 'philo'
 
 
-class TreeEntity(TreeModel, Entity):
+class TreeEntity(Entity, TreeModel):
 	@property
 	def attributes(self):
 		if self.parent:
@@ -170,5 +359,4 @@ class TreeEntity(TreeModel, Entity):
 		return super(TreeEntity, self).relationships
 	
 	class Meta:
-		abstract = True
-		app_label = 'philo'
\ No newline at end of file
+		abstract = True
\ No newline at end of file