Merge branch 'obrazy' into rwd

[wolnelektury.git] / apps / picture / models.py

diff --git a/apps/picture/models.py b/apps/picture/models.py
index cd91a3f..705025a 100644 (file)
--- a/apps/picture/models.py
+++ b/apps/picture/models.py
@@ -6,27 +6,84 @@ from django.conf import settings
 from django.core.files.storage import FileSystemStorage
 from django.utils.datastructures import SortedDict
 from django.template.loader import render_to_string
 from django.core.files.storage import FileSystemStorage
 from django.utils.datastructures import SortedDict
 from django.template.loader import render_to_string

+from django.utils.safestring import mark_safe

 from django.core.cache import get_cache
 from django.core.cache import get_cache

-from catalogue.utils import split_tags
+from catalogue.utils import split_tags, related_tag_name

 from django.utils.safestring import mark_safe
 from fnpdjango.utils.text.slughifi import slughifi
 from picture import tasks
 from StringIO import StringIO
 import jsonfield
 import itertools
 from django.utils.safestring import mark_safe
 from fnpdjango.utils.text.slughifi import slughifi
 from picture import tasks
 from StringIO import StringIO
 import jsonfield
 import itertools

+import logging
+from sorl.thumbnail import get_thumbnail, default
+from .engine import CustomCroppingEngine

 
 from PIL import Image
 
 
 from PIL import Image
 

-from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import get_language, ugettext_lazy as _

 from newtagging import managers
 from os import path
 
 
 from newtagging import managers
 from os import path
 
 

+permanent_cache = get_cache('permanent')
+

 picture_storage = FileSystemStorage(location=path.join(
         settings.MEDIA_ROOT, 'pictures'),
         base_url=settings.MEDIA_URL + "pictures/")
 
 
 picture_storage = FileSystemStorage(location=path.join(
         settings.MEDIA_ROOT, 'pictures'),
         base_url=settings.MEDIA_URL + "pictures/")
 
 

+class PictureArea(models.Model):
+    picture = models.ForeignKey('picture.Picture', related_name='areas')
+    area = jsonfield.JSONField(_('area'), default={}, editable=False)
+    kind = models.CharField(_('kind'), max_length=10, blank=False, 
+                           null=False, db_index=True, 
+                           choices=(('thing', _('thing')), 
+                                    ('theme', _('theme'))))
+
+    objects     = models.Manager()
+    tagged      = managers.ModelTaggedItemManager(catalogue.models.Tag)
+    tags        = managers.TagDescriptor(catalogue.models.Tag)
+
+    @classmethod
+    def rectangle(cls, picture, kind, coords):
+        pa = PictureArea()
+        pa.picture = picture
+        pa.kind = kind
+        pa.area = coords
+        return pa
+
+    def reset_short_html(self):
+        if self.id is None:
+            return
+
+        cache_key = "PictureArea.short_html/%d/%s"
+        for lang, langname in settings.LANGUAGES:
+            permanent_cache.delete(cache_key % (self.id, lang))
+
+
+    def short_html(self):
+        if self.id:
+            cache_key = "PictureArea.short_html/%d/%s" % (self.id, get_language())
+            short_html = permanent_cache.get(cache_key)
+        else:
+            short_html = None
+    
+        if short_html is not None:
+            return mark_safe(short_html)
+        else:
+            theme = self.tags.filter(category='theme')
+            theme = theme and theme[0] or None
+            thing = self.tags.filter(category='thing')
+            thing = thing and thing[0] or None
+            area = self
+            short_html = unicode(render_to_string(
+                    'picture/picturearea_short.html', locals()))
+            if self.id:
+                permanent_cache.set(cache_key, short_html)
+            return mark_safe(short_html)
+
+

 class Picture(models.Model):
     """
     Picture resource.
 class Picture(models.Model):
     """
     Picture resource.


@@ -35,12 +92,21 @@ class Picture(models.Model):
     title       = models.CharField(_('title'), max_length=120)
     slug        = models.SlugField(_('slug'), max_length=120, db_index=True, unique=True)
     sort_key    = models.CharField(_('sort key'), max_length=120, db_index=True, editable=False)
     title       = models.CharField(_('title'), max_length=120)
     slug        = models.SlugField(_('slug'), max_length=120, db_index=True, unique=True)
     sort_key    = models.CharField(_('sort key'), max_length=120, db_index=True, editable=False)

+    sort_key_author = models.CharField(_('sort key by author'), max_length=120, db_index=True, editable=False, default=u'')

     created_at  = models.DateTimeField(_('creation date'), auto_now_add=True, db_index=True)
     changed_at  = models.DateTimeField(_('creation date'), auto_now=True, db_index=True)
     xml_file    = models.FileField('xml_file', upload_to="xml", storage=picture_storage)
     image_file  = ImageField(_('image_file'), upload_to="images", storage=picture_storage)
     html_file   = models.FileField('html_file', upload_to="html", storage=picture_storage)
     created_at  = models.DateTimeField(_('creation date'), auto_now_add=True, db_index=True)
     changed_at  = models.DateTimeField(_('creation date'), auto_now=True, db_index=True)
     xml_file    = models.FileField('xml_file', upload_to="xml", storage=picture_storage)
     image_file  = ImageField(_('image_file'), upload_to="images", storage=picture_storage)
     html_file   = models.FileField('html_file', upload_to="html", storage=picture_storage)

-    areas       = jsonfield.JSONField(_('picture areas'), default='{}', editable=False)
+    areas_json       = jsonfield.JSONField(_('picture areas JSON'), default={}, editable=False)
+    extra_info    = jsonfield.JSONField(_('extra information'), default={})
+    culturepl_link   = models.CharField(blank=True, max_length=240)
+    wiki_link     = models.CharField(blank=True, max_length=240)
+
+    _related_info = jsonfield.JSONField(blank=True, null=True, editable=False)
+
+    width       = models.IntegerField(null=True)
+    height      = models.IntegerField(null=True)

 
     objects     = models.Manager()
     tagged      = managers.ModelTaggedItemManager(catalogue.models.Tag)
 
     objects     = models.Manager()
     tagged      = managers.ModelTaggedItemManager(catalogue.models.Tag)


@@ -107,10 +173,14 @@ class Picture(models.Model):
             if not created and not overwrite:
                 raise Picture.AlreadyExists('Picture %s already exists' % picture_xml.slug)
 
             if not created and not overwrite:
                 raise Picture.AlreadyExists('Picture %s already exists' % picture_xml.slug)
 

-            picture.title = picture_xml.picture_info.title
+            picture.areas.all().delete()
+            picture.title = unicode(picture_xml.picture_info.title)
+            picture.extra_info = picture_xml.picture_info.to_dict()

 
 

+            picture_tags = set(catalogue.models.Tag.tags_from_info(picture_xml.picture_info))

             motif_tags = set()
             thing_tags = set()
             motif_tags = set()
             thing_tags = set()

+

             area_data = {'themes':{}, 'things':{}}
 
             for part in picture_xml.partiter():
             area_data = {'themes':{}, 'things':{}}
 
             for part in picture_xml.partiter():


@@ -124,27 +194,38 @@ class Picture(models.Model):
                         tag.name = objname
                         tag.sort_key = sortify(tag.name)
                         tag.save()
                         tag.name = objname
                         tag.sort_key = sortify(tag.name)
                         tag.save()

-                    thing_tags.add(tag)
+                    #thing_tags.add(tag)

                     area_data['things'][tag.slug] = {
                         'object': part['object'],
                         'coords': part['coords'],
                         }
                     area_data['things'][tag.slug] = {
                         'object': part['object'],
                         'coords': part['coords'],
                         }

+                    area = PictureArea.rectangle(picture, 'thing', part['coords'])
+                    area.save()
+                    _tags = set()
+                    _tags.add(tag)
+                    area.tags = _tags

                 else:
                 else:

+                    _tags = set()

                     for motif in part['themes']:
                         tag, created = catalogue.models.Tag.objects.get_or_create(slug=slughifi(motif), category='theme')
                         if created:
                             tag.name = motif
                             tag.sort_key = sortify(tag.name)
                             tag.save()
                     for motif in part['themes']:
                         tag, created = catalogue.models.Tag.objects.get_or_create(slug=slughifi(motif), category='theme')
                         if created:
                             tag.name = motif
                             tag.sort_key = sortify(tag.name)
                             tag.save()

-                        motif_tags.add(tag)
+                        #motif_tags.add(tag)
+                        _tags.add(tag)

                         area_data['themes'][tag.slug] = {
                             'theme': motif,
                             'coords': part['coords']
                             }
 
                         area_data['themes'][tag.slug] = {
                             'theme': motif,
                             'coords': part['coords']
                             }
 

-            picture.tags = catalogue.models.Tag.tags_from_info(picture_xml.picture_info) + \
-                list(motif_tags) + list(thing_tags)
-            picture.areas = area_data
+                    logging.debug("coords for theme: %s" % part['coords'])
+                    area = PictureArea.rectangle(picture, 'theme', part['coords'])
+                    area.save()
+                    area.tags = _tags.union(picture_tags)
+
+            picture.tags = picture_tags.union(motif_tags).union(thing_tags)
+            picture.areas_json = area_data

 
             if image_file is not None:
                 img = image_file
 
             if image_file is not None:
                 img = image_file


@@ -152,15 +233,19 @@ class Picture(models.Model):
                 img = picture_xml.image_file()
 
             modified = cls.crop_to_frame(picture_xml, img)
                 img = picture_xml.image_file()
 
             modified = cls.crop_to_frame(picture_xml, img)

+            picture.width, picture.height = modified.size
+
+            modified_file = StringIO()
+            modified.save(modified_file, format='png', quality=95)

             # FIXME: hardcoded extension - detect from DC format or orginal filename
             # FIXME: hardcoded extension - detect from DC format or orginal filename

-            picture.image_file.save(path.basename(picture_xml.image_path), File(modified))
+            picture.image_file.save(path.basename(picture_xml.image_path), File(modified_file))

 
             picture.xml_file.save("%s.xml" % picture.slug, File(xml_file))
             picture.save()
             tasks.generate_picture_html(picture.id)
 
         except Exception, ex:
 
             picture.xml_file.save("%s.xml" % picture.slug, File(xml_file))
             picture.save()
             tasks.generate_picture_html(picture.id)
 
         except Exception, ex:

-            print "Rolling back a transaction"
+            logging.exception("Exception during import, rolling back")

             transaction.rollback()
             raise ex
 
             transaction.rollback()
             raise ex
 


@@ -176,13 +261,11 @@ class Picture(models.Model):
 
     @classmethod
     def crop_to_frame(cls, wlpic, image_file):
 
     @classmethod
     def crop_to_frame(cls, wlpic, image_file):

-        if wlpic.frame is None:
-            return image_file

         img = Image.open(image_file)
         img = Image.open(image_file)

+        if wlpic.frame is None:
+            return img

         img = img.crop(itertools.chain(*wlpic.frame))
         img = img.crop(itertools.chain(*wlpic.frame))

-        contents = StringIO()
-        img.save(contents, format='png', quality=95)
-        return contents
+        return img

 
     @classmethod
     def picture_list(cls, filter=None):
 
     @classmethod
     def picture_list(cls, filter=None):


@@ -223,13 +306,24 @@ class Picture(models.Model):
     def reset_short_html(self):
         if self.id is None:
             return
     def reset_short_html(self):
         if self.id is None:
             return

+        
+        type(self).objects.filter(pk=self.pk).update(_related_info=None)
+        for area in self.areas.all().iterator():
+            area.reset_short_html()
+
+        try: 
+            author = self.tags.filter(category='author')[0].sort_key
+        except IndexError:
+            author = u''
+        type(self).objects.filter(pk=self.pk).update(sort_key_author=author)

 
 

-        cache_key = "Picture.short_html/%d" % (self.id)
-        get_cache('permanent').delete(cache_key)
+        cache_key = "Picture.short_html/%d/%s"
+        for lang, langname in settings.LANGUAGES:
+            permanent_cache.delete(cache_key % (self.id, lang))

 
     def short_html(self):
         if self.id:
 
     def short_html(self):
         if self.id:

-            cache_key = "Picture.short_html/%d" % (self.id)
+            cache_key = "Picture.short_html/%d/%s" % (self.id, get_language())

             short_html = get_cache('permanent').get(cache_key)
         else:
             short_html = None
             short_html = get_cache('permanent').get(cache_key)
         else:
             short_html = None


@@ -247,3 +341,104 @@ class Picture(models.Model):
             if self.id:
                 get_cache('permanent').set(cache_key, short_html)
             return mark_safe(short_html)
             if self.id:
                 get_cache('permanent').set(cache_key, short_html)
             return mark_safe(short_html)

+
+    def pretty_title(self, html_links=False):
+        picture = self
+        # TODO Add translations (related_tag_info)
+        names = [(tag.name,
+                  catalogue.models.Tag.create_url('author', tag.slug))
+                 for tag in self.tags.filter(category='author')]
+        names.append((self.title, self.get_absolute_url()))
+
+        if html_links:
+            names = ['<a href="%s">%s</a>' % (tag[1], tag[0]) for tag in names]
+        else:
+            names = [tag[0] for tag in names]
+        return ', '.join(names)
+
+    def related_info(self):
+        """Keeps info about related objects (tags) in cache field."""
+        if self._related_info is not None:
+            return self._related_info
+        else:
+            rel = {'tags': {}}
+
+            tags = self.tags.filter(category__in=(
+                    'author', 'kind', 'genre', 'epoch'))
+            tags = split_tags(tags)
+            for category in tags:
+                cat = []
+                for tag in tags[category]:
+                    tag_info = {'slug': tag.slug, 'name': tag.name}
+                    for lc, ln in settings.LANGUAGES:
+                        tag_name = getattr(tag, "name_%s" % lc)
+                        if tag_name:
+                            tag_info["name_%s" % lc] = tag_name
+                    cat.append(tag_info)
+                rel['tags'][category] = cat
+            
+
+            if self.pk:
+                type(self).objects.filter(pk=self.pk).update(_related_info=rel)
+            return rel
+
+    # copied from book.py, figure out 
+    def related_themes(self):
+        # self.theme_counter hides a computation, so a line below actually makes sense
+        theme_counter = self.theme_counter
+        picture_themes = list(catalogue.models.Tag.objects.filter(pk__in=theme_counter.keys()))
+        for tag in picture_themes:
+            tag.count = theme_counter[tag.pk]
+        return picture_themes
+
+    def reset_tag_counter(self):
+        if self.id is None:
+            return
+
+        cache_key = "Picture.tag_counter/%d" % self.id
+        permanent_cache.delete(cache_key)
+        if self.parent:
+            self.parent.reset_tag_counter()
+
+    @property
+    def tag_counter(self):
+        if self.id:
+            cache_key = "Picture.tag_counter/%d" % self.id
+            tags = permanent_cache.get(cache_key)
+        else:
+            tags = None
+
+        if tags is None:
+            tags = {}
+            # do we need to do this? there are no children here.
+            for tag in self.tags.exclude(category__in=('book', 'theme', 'thing', 'set')).order_by().iterator():
+                tags[tag.pk] = 1
+
+            if self.id:
+                permanent_cache.set(cache_key, tags)
+        return tags
+
+    def reset_theme_counter(self):
+        if self.id is None:
+            return
+
+        cache_key = "Picture.theme_counter/%d" % self.id
+        permanent_cache.delete(cache_key)
+
+    @property
+    def theme_counter(self):
+        if self.id:
+            cache_key = "Picture.theme_counter/%d" % self.id
+            tags = permanent_cache.get(cache_key)
+        else:
+            tags = None
+
+        if tags is None:
+            tags = {}
+            for area in PictureArea.objects.filter(picture=self).order_by().iterator():
+                for tag in area.tags.filter(category__in=('theme','thing')).order_by().iterator():
+                    tags[tag.pk] = tags.get(tag.pk, 0) + 1
+
+            if self.id:
+                permanent_cache.set(cache_key, tags)
+        return tags