X-Git-Url: https://git.mdrn.pl/wolnelektury.git/blobdiff_plain/0cae17bec6d31806615fae59a5b3945016285fbe..6f8ce976c498b1df0768c0965c0c9dc2e84bda1c:/apps/newtagging/models.py diff --git a/apps/newtagging/models.py b/apps/newtagging/models.py index 0c2b0e1f0..6d05e287e 100644 --- a/apps/newtagging/models.py +++ b/apps/newtagging/models.py @@ -1,8 +1,12 @@ +# -*- coding: utf-8 -*- """ Models and managers for generic tagging. """ + # Python 2.3 compatibility -if not hasattr(__builtins__, 'set'): +try: + set +except NameError: from sets import Set as set from django.contrib.contenttypes import generic @@ -10,6 +14,8 @@ from django.contrib.contenttypes.models import ContentType from django.db import connection, models from django.utils.translation import ugettext_lazy as _ from django.db.models.base import ModelBase +from django.core.exceptions import ObjectDoesNotExist +from django.dispatch import Signal qn = connection.ops.quote_name @@ -19,6 +25,8 @@ except ImportError: parse_lookup = None +tags_updated = Signal(providing_args=["affected_tags"]) + def get_queryset_and_model(queryset_or_model): """ Given a ``QuerySet`` or a ``Model``, returns a two-tuple of @@ -40,7 +48,17 @@ class TagManager(models.Manager): def __init__(self, intermediary_table_model): super(TagManager, self).__init__() self.intermediary_table_model = intermediary_table_model - + models.signals.pre_delete.connect(self.target_deleted) + + def target_deleted(self, instance, **kwargs): + """ clear tag relations before deleting an object """ + try: + int(instance.pk) + except ValueError: + return + + self.update_tags(instance, []) + def update_tags(self, obj, tags): """ Update tags associated with an object. @@ -49,7 +67,7 @@ class TagManager(models.Manager): current_tags = list(self.filter(items__content_type__pk=content_type.pk, items__object_id=obj.pk)) updated_tags = self.model.get_tag_list(tags) - + # Remove tags which no longer apply tags_for_removal = [tag for tag in current_tags \ if tag not in updated_tags] @@ -58,10 +76,22 @@ class TagManager(models.Manager): object_id=obj.pk, tag__in=tags_for_removal).delete() # Add new tags - for tag in updated_tags: + tags_to_add = [tag for tag in updated_tags + if tag not in current_tags] + for tag in tags_to_add: if tag not in current_tags: self.intermediary_table_model._default_manager.create(tag=tag, content_object=obj) - + + tags_updated.send(sender=obj, affected_tags=tags_to_add + tags_for_removal) + + def remove_tag(self, obj, tag): + """ + Remove tag from an object. + """ + content_type = ContentType.objects.get_for_model(obj) + self.intermediary_table_model._default_manager.filter(content_type__pk=content_type.pk, + object_id=obj.pk, tag=tag).delete() + def get_for_object(self, obj): """ Create a queryset matching all tags associated with the given @@ -70,7 +100,7 @@ class TagManager(models.Manager): ctype = ContentType.objects.get_for_model(obj) return self.filter(items__content_type__pk=ctype.pk, items__object_id=obj.pk) - + def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extra_criteria=None, params=None, extra=None): """ Perform the custom SQL query for ``usage_for_model`` and @@ -81,12 +111,12 @@ class TagManager(models.Manager): model_table = qn(model._meta.db_table) model_pk = '%s.%s' % (model_table, qn(model._meta.pk.column)) tag_columns = self._get_tag_columns() - + if extra is None: extra = {} extra_where = '' if 'where' in extra: extra_where = 'AND ' + ' AND '.join(extra['where']) - + query = """ SELECT DISTINCT %(tag_columns)s%(count_sql)s FROM @@ -99,7 +129,7 @@ class TagManager(models.Manager): WHERE %(tagged_item)s.content_type_id = %(content_type_id)s %%s %(extra_where)s - GROUP BY %(tag)s.id, %(tag)s.name + GROUP BY %(tag_columns)s, %(tag)s.id, %(tag)s.name %%s ORDER BY %(tag)s.%(ordering)s ASC""" % { 'tag': qn(self.model._meta.db_table), @@ -185,8 +215,18 @@ class TagManager(models.Manager): if parse_lookup: raise AttributeError("'TagManager.usage_for_queryset' is not compatible with pre-queryset-refactor versions of Django.") - extra_joins = ' '.join(queryset.query.get_from_clause()[0][1:]) - where, params = queryset.query.where.as_sql() + if getattr(queryset.query, 'get_compiler', None): + # Django 1.2+ + compiler = queryset.query.get_compiler(using='default') + extra_joins = ' '.join(compiler.get_from_clause()[0][1:]) + where, params = queryset.query.where.as_sql( + compiler.quote_name_unless_alias, compiler.connection + ) + else: + # Django pre-1.2 + extra_joins = ' '.join(queryset.query.get_from_clause()[0][1:]) + where, params = queryset.query.where.as_sql() + if where: extra_criteria = 'AND %s' % where else: @@ -211,29 +251,34 @@ class TagManager(models.Manager): tag_count = len(tags) tagged_item_table = qn(self.intermediary_table_model._meta.db_table) tag_columns = self._get_tag_columns() - + if extra is None: extra = {} extra_where = '' if 'where' in extra: extra_where = 'AND ' + ' AND '.join(extra['where']) - + + # Temporary table in this query is a hack to prevent MySQL from executing + # inner query as dependant query (which could result in severe performance loss) query = """ SELECT %(tag_columns)s%(count_sql)s FROM %(tagged_item)s INNER JOIN %(tag)s ON %(tagged_item)s.tag_id = %(tag)s.id WHERE %(tagged_item)s.content_type_id = %(content_type_id)s - AND %(tagged_item)s.object_id IN - ( - SELECT %(tagged_item)s.object_id - FROM %(tagged_item)s, %(tag)s - WHERE %(tagged_item)s.content_type_id = %(content_type_id)s - AND %(tag)s.id = %(tagged_item)s.tag_id - AND %(tag)s.id IN (%(tag_id_placeholders)s) - GROUP BY %(tagged_item)s.object_id - HAVING COUNT(%(tagged_item)s.object_id) = %(tag_count)s - ) - AND %(tag)s.id NOT IN (%(tag_id_placeholders)s) - %(extra_where)s - GROUP BY %(tag)s.id, %(tag)s.name + AND %(tagged_item)s.object_id IN + ( + SELECT * + FROM ( + SELECT %(tagged_item)s.object_id + FROM %(tagged_item)s, %(tag)s + WHERE %(tagged_item)s.content_type_id = %(content_type_id)s + AND %(tag)s.id = %(tagged_item)s.tag_id + AND %(tag)s.id IN (%(tag_id_placeholders)s) + GROUP BY %(tagged_item)s.object_id + HAVING COUNT(%(tagged_item)s.object_id) = %(tag_count)s + ) AS temporary + ) + AND %(tag)s.id NOT IN (%(tag_id_placeholders)s) + %(extra_where)s + GROUP BY %(tag_columns)s %(min_count_sql)s ORDER BY %(tag)s.%(ordering)s ASC""" % { 'tag': qn(self.model._meta.db_table), @@ -283,7 +328,7 @@ class TaggedItemManager(models.Manager): def __init__(self, tag_model): super(TaggedItemManager, self).__init__() self.tag_model = tag_model - + def get_by_model(self, queryset_or_model, tags): """ Create a ``QuerySet`` containing instances of the specified @@ -394,7 +439,7 @@ class TaggedItemManager(models.Manager): else: return model._default_manager.none() - def get_related(self, obj, queryset_or_model, num=None): + def get_related(self, obj, queryset_or_model, num=None, ignore_by_tag=None): """ Retrieve a list of instances of the specified model which share tags with the model instance ``obj``, ordered by the number of @@ -402,6 +447,8 @@ class TaggedItemManager(models.Manager): If ``num`` is given, a maximum of ``num`` instances will be returned. + + If ``ignore_by_tag`` is given, object tagged with it will be ignored. """ queryset, model = get_queryset_and_model(queryset_or_model) model_table = qn(model._meta.db_table) @@ -421,6 +468,15 @@ class TaggedItemManager(models.Manager): # instances for the same model. query += """ AND related_tagged_item.object_id != %(tagged_item)s.object_id""" + if ignore_by_tag is not None: + query += """ + AND NOT EXISTS ( + SELECT * FROM %(tagged_item)s + WHERE %(tagged_item)s.object_id = %(model_pk)s + AND %(tagged_item)s.content_type_id = %(content_type_id)s + AND %(ignore_id)s = %(tagged_item)s.tag_id + ) + """ query += """ GROUP BY %(model_pk)s ORDER BY %(count)s DESC @@ -434,6 +490,7 @@ class TaggedItemManager(models.Manager): 'content_type_id': content_type.pk, 'related_content_type_id': related_content_type.pk, 'limit_offset': num is not None and connection.ops.limit_offset_sql(num) or '', + 'ignore_id': ignore_by_tag.id if ignore_by_tag else None, } cursor = connection.cursor() @@ -455,15 +512,18 @@ class TaggedItemManager(models.Manager): def create_intermediary_table_model(model): """Create an intermediary table model for the specific tag model""" name = model.__name__ + 'Relation' - + class Meta: db_table = '%s_relation' % model._meta.db_table unique_together = (('tag', 'content_type', 'object_id'),) def obj_unicode(self): - return u'%s [%s]' % (self.content_type.get_object_for_this_type(pk=self.object_id), self.tag) - - # Set up a dictionary to simulate declarations within a class + try: + return u'%s [%s]' % (self.content_type.get_object_for_this_type(pk=self.object_id), self.tag) + except ObjectDoesNotExist: + return u' [%s]' % self.tag + + # Set up a dictionary to simulate declarations within a class attrs = { '__module__': model.__module__, 'Meta': Meta, @@ -492,15 +552,15 @@ class TagMeta(ModelBase): class TagBase(models.Model): """Abstract class to be inherited by model classes.""" __metaclass__ = TagMeta - + class Meta: abstract = True - + @staticmethod def get_tag_list(tag_list): """ Utility function for accepting tag input in a flexible manner. - + You should probably override this method in your subclass. """ if isinstance(tag_list, TagBase):