X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/afd4b528f146e68d31315df32dbab94a9c2d7f0f..7ec22cc295e564d14bc47deaca98937d494546a9:/models/base.py diff --git a/models/base.py b/models/base.py index bd55e95..ceeb81e 100644 --- a/models/base.py +++ b/models/base.py @@ -1,33 +1,35 @@ -# encoding: utf-8 -from django.utils.translation import ugettext_lazy as _ -from django.contrib.auth.models import User, Group -from django.contrib.contenttypes import generic -from django.contrib.contenttypes.models import ContentType from django.db import models -from django.contrib.sites.models import Site -from philo.utils import fattr -from django.template import add_to_builtins as register_templatetags -from django.template import Template as DjangoTemplate -from django.template import TemplateDoesNotExist -from django.template import Context, RequestContext -from django.core.exceptions import ObjectDoesNotExist +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.exceptions import AncestorDoesNotExist +from philo.utils import ContentTypeRegistryLimiter +from philo.signals import entity_class_prepared +from philo.validators import json_validator from UserDict import DictMixin -from philo.templatetags.containers import ContainerNode -from django.template.loader_tags import ExtendsNode, ConstantIncludeNode, IncludeNode -from django.template.loader import get_template -from django.http import Http404, HttpResponse, HttpResponseServerError, HttpResponseRedirect -from django.core.servers.basehttp import FileWrapper -from django.conf import settings -from philo.validators import RedirectValidator -def register_value_model(model): - pass +class Tag(models.Model): + name = models.CharField(max_length=255) + slug = models.SlugField(max_length=255, unique=True) + + def __unicode__(self): + return self.name + + class Meta: + app_label = 'philo' -def unregister_value_model(model): - pass +class Titled(models.Model): + title = models.CharField(max_length=255) + slug = models.SlugField(max_length=255) + + def __unicode__(self): + return self.title + + class Meta: + abstract = True class Attribute(models.Model): @@ -35,7 +37,7 @@ class Attribute(models.Model): 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.') + json_value = models.TextField(verbose_name='Value (JSON)', help_text='This value must be valid JSON.', validators=[json_validator]) def get_value(self): return json.loads(self.json_value) @@ -53,6 +55,19 @@ class Attribute(models.Model): class Meta: app_label = 'philo' + unique_together = ('key', 'entity_content_type', 'entity_object_id') + + +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 Relationship(models.Model): @@ -60,8 +75,8 @@ class Relationship(models.Model): 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', verbose_name='Value type') - value_object_id = models.PositiveIntegerField(verbose_name='Value ID') + 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_object_id = models.PositiveIntegerField(verbose_name='Value ID', null=True, blank=True) value = generic.GenericForeignKey('value_content_type', 'value_object_id') def __unicode__(self): @@ -69,27 +84,53 @@ class Relationship(models.Model): class Meta: app_label = 'philo' + unique_together = ('key', 'entity_content_type', 'entity_object_id') class QuerySetMapper(object, DictMixin): def __init__(self, queryset, passthrough=None): self.queryset = queryset self.passthrough = passthrough + def __getitem__(self, key): try: return self.queryset.get(key__exact=key).value except ObjectDoesNotExist: - if self.passthrough: + if self.passthrough is not None: return self.passthrough.__getitem__(key) raise KeyError + def keys(self): keys = set(self.queryset.values_list('key', flat=True).distinct()) - if self.passthrough: - keys += set(self.passthrough.keys()) + if self.passthrough is not None: + keys |= set(self.passthrough.keys()) 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') @@ -101,46 +142,65 @@ class Entity(models.Model): def relationships(self): return QuerySetMapper(self.relationship_set) - class Meta: - abstract = True - app_label = 'philo' - - -class Collection(models.Model): - name = models.CharField(max_length=255) - description = models.TextField(blank=True, null=True) + @property + def _added_attribute_registry(self): + if not hasattr(self, '_real_added_attribute_registry'): + self._real_added_attribute_registry = {} + return self._real_added_attribute_registry - @fattr(short_description='Members') - def get_count(self): - return self.members.count() + @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 __unicode__(self): - return self.name + @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 - class Meta: - app_label = 'philo' - - -class CollectionMemberManager(models.Manager): - use_for_related_fields = True - - def with_model(self, model): - return model._default_manager.filter(pk__in=self.filter(member_content_type=ContentType.objects.get_for_model(model)).values_list('member_object_id', flat=True)) - - -class CollectionMember(models.Model): - objects = CollectionMemberManager() - collection = models.ForeignKey(Collection, related_name='members') - index = models.PositiveIntegerField(verbose_name='Index', help_text='This will determine the ordering of the item within the collection. (Optional)', null=True, blank=True) - member_content_type = models.ForeignKey(ContentType, verbose_name='Member type') - member_object_id = models.PositiveIntegerField(verbose_name='Member ID') - member = generic.GenericForeignKey('member_content_type', 'member_object_id') + @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 __unicode__(self): - return u'%s - %s' % (self.collection, self.member) + 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.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: - app_label = 'philo' + abstract = True class TreeManager(models.Manager): @@ -182,26 +242,44 @@ 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): return self.path 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: @@ -215,240 +293,4 @@ class TreeEntity(TreeModel, Entity): return super(TreeEntity, self).relationships class Meta: - abstract = True - app_label = 'philo' - - -class InheritableTreeEntity(TreeEntity): - instance_type = models.ForeignKey(ContentType, editable=False) - - def save(self, force_insert=False, force_update=False): - if not hasattr(self, 'instance_type_ptr'): - self.instance_type = ContentType.objects.get_for_model(self.__class__) - super(InheritableTreeEntity, self).save(force_insert, force_update) - - @property - def instance(self): - try: - return self.instance_type.get_object_for_this_type(id=self.id) - except: - return None - - def get_path(self, pathsep='/', field='slug'): - path = getattr(self.instance, field, getattr(self.instance, 'slug', '?')) - parent = self.parent - while parent: - path = getattr(parent.instance, field, getattr(parent.instance, 'slug', '?')) + pathsep + path - parent = parent.parent - return path - path = property(get_path) - - @property - def attributes(self): - if self.parent: - return QuerySetMapper(self.instance.attribute_set, passthrough=self.parent.instance.attributes) - return QuerySetMapper(self.instance.attribute_set) - - @property - def relationships(self): - if self.parent: - return QuerySetMapper(self.instance.relationship_set, passthrough=self.parent.instance.relationships) - return QuerySetMapper(self.instance.relationship_set) - - class Meta: - abstract = True - app_label = 'philo' - - -class Node(InheritableTreeEntity): - accepts_subpath = False - - def render_to_response(self, request, path=None, subpath=None): - return HttpResponseServerError() - - class Meta: - unique_together = (('parent', 'slug'),) - app_label = 'philo' - - -class MultiNode(Node): - accepts_subpath = True - - urlpatterns = [] - - def render_to_response(self, request, path=None, subpath=None): - if not subpath: - subpath = "" - subpath = "/" + subpath - from django.core.urlresolvers import resolve - view, args, kwargs = resolve(subpath, urlconf=self) - return view(request, *args, **kwargs) - - class Meta: - abstract = True - app_label = 'philo' - - -class Redirect(Node): - STATUS_CODES = ( - (302, 'Temporary'), - (301, 'Permanent'), - ) - target = models.CharField(max_length=200,validators=[RedirectValidator()]) - status_code = models.IntegerField(choices=STATUS_CODES, default=302, verbose_name='redirect type') - - def render_to_response(self, request, path=None, subpath=None): - response = HttpResponseRedirect(self.target) - response.status_code = self.status_code - return response - - class Meta: - app_label = 'philo' - - -class File(Node): - """ For storing arbitrary files """ - mimetype = models.CharField(max_length=255) - file = models.FileField(upload_to='philo/files/%Y/%m/%d') - - def render_to_response(self, request, path=None, subpath=None): - wrapper = FileWrapper(self.file) - response = HttpResponse(wrapper, content_type=self.mimetype) - response['Content-Length'] = self.file.size - return response - - class Meta: - app_label = 'philo' - - -class Template(TreeModel): - name = models.CharField(max_length=255) - documentation = models.TextField(null=True, blank=True) - mimetype = models.CharField(max_length=255, null=True, blank=True, help_text='Default: %s' % settings.DEFAULT_CONTENT_TYPE) - code = models.TextField(verbose_name='django template code') - - @property - def origin(self): - return 'philo.models.Template: ' + self.path - - @property - def django_template(self): - return DjangoTemplate(self.code) - - @property - def containers(self): - """ - Returns a tuple where the first item is a list of names of contentlets referenced by containers, - and the second item is a list of tuples of names and contenttypes of contentreferences referenced by containers. - This will break if there is a recursive extends or includes in the template code. - Due to the use of an empty Context, any extends or include tags with dynamic arguments probably won't work. - """ - def container_nodes(template): - def nodelist_container_nodes(nodelist): - nodes = [] - for node in nodelist: - try: - for nodelist_name in ('nodelist', 'nodelist_loop', 'nodelist_empty', 'nodelist_true', 'nodelist_false', 'nodelist_main'): - if hasattr(node, nodelist_name): - nodes.extend(nodelist_container_nodes(getattr(node, nodelist_name))) - if isinstance(node, ContainerNode): - nodes.append(node) - elif isinstance(node, ExtendsNode): - extended_template = node.get_parent(Context()) - if extended_template: - nodes.extend(container_nodes(extended_template)) - elif isinstance(node, ConstantIncludeNode): - included_template = node.template - if included_template: - nodes.extend(container_nodes(included_template)) - elif isinstance(node, IncludeNode): - included_template = get_template(node.template_name.resolve(Context())) - if included_template: - nodes.extend(container_nodes(included_template)) - except: - pass # fail for this node - return nodes - return nodelist_container_nodes(template.nodelist) - all_nodes = container_nodes(self.django_template) - contentlet_node_names = set([node.name for node in all_nodes if not node.references]) - contentreference_node_names = [] - contentreference_node_specs = [] - for node in all_nodes: - if node.references and node.name not in contentreference_node_names: - contentreference_node_specs.append((node.name, node.references)) - contentreference_node_names.append(node.name) - return contentlet_node_names, contentreference_node_specs - - def __unicode__(self): - return self.get_path(u' › ', 'name') - - @staticmethod - @fattr(is_usable=True) - def loader(template_name, template_dirs=None): # load_template_source - try: - template = Template.objects.get_with_path(template_name) - except Template.DoesNotExist: - raise TemplateDoesNotExist(template_name) - return (template.code, template.origin) - - class Meta: - app_label = 'philo' - - -class Page(Node): - """ - Represents a page - something which is rendered according to a template. The page will have a number of related Contentlets depending on the template selected - but these will appear only after the page has been saved with that template. - """ - template = models.ForeignKey(Template, related_name='pages') - title = models.CharField(max_length=255) - - def render_to_response(self, request, path=None, subpath=None): - return HttpResponse(self.template.django_template.render(RequestContext(request, {'page': self})), mimetype=self.template.mimetype) - - def __unicode__(self): - return self.get_path(u' › ', 'title') - - class Meta: - app_label = 'philo' - - -# the following line enables the selection of a node as the root for a given django.contrib.sites Site object -models.ForeignKey(Node, related_name='sites', null=True, blank=True).contribute_to_class(Site, 'root_node') - - -class Contentlet(models.Model): - page = models.ForeignKey(Page, related_name='contentlets') - name = models.CharField(max_length=255) - content = models.TextField() - dynamic = models.BooleanField(default=False) - - def __unicode__(self): - return self.name - - class Meta: - app_label = 'philo' - - -class ContentReference(models.Model): - page = models.ForeignKey(Page, related_name='contentreferences') - name = models.CharField(max_length=255) - content_type = models.ForeignKey(ContentType, verbose_name='Content type') - content_id = models.PositiveIntegerField(verbose_name='Content ID', blank=True, null=True) - content = generic.GenericForeignKey('content_type', 'content_id') - - def __unicode__(self): - return self.name - - class Meta: - app_label = 'philo' - - -register_templatetags('philo.templatetags.containers') - - -register_value_model(User) -register_value_model(Group) -register_value_model(Site) -register_value_model(Collection) -register_value_model(Template) -register_value_model(Page) + abstract = True \ No newline at end of file