apps/picture/models.py

   1 from django.db import models
   2 import catalogue.models
   3 from django.db.models import permalink
   4 from sorl.thumbnail import ImageField
   5 from django.conf import settings
   6 from django.core.files.storage import FileSystemStorage
   7 from django.utils.datastructures import SortedDict
   8 from django.template.loader import render_to_string
   9 from django.core.cache import cache
  10 from catalogue.utils import split_tags
  11 from django.utils.safestring import mark_safe
  12 from librarian import dcparser, picture
  13 from slughifi import slughifi
  14
  15 from django.utils.translation import ugettext_lazy as _
  16 from newtagging import managers
  17 from os import path
  18
  19
  20 picture_storage = FileSystemStorage(location=path.join(settings.MEDIA_ROOT, 'pictures'), base_url=settings.MEDIA_URL + "pictures/")
  21
  22
  23 class Picture(models.Model):
  24     """
  25     Picture resource.
  26
  27     """
  28     title       = models.CharField(_('title'), max_length=120)
  29     slug        = models.SlugField(_('slug'), max_length=120, db_index=True, unique=True)
  30     sort_key    = models.CharField(_('sort key'), max_length=120, db_index=True, editable=False)
  31     created_at  = models.DateTimeField(_('creation date'), auto_now_add=True, db_index=True)
  32     changed_at  = models.DateTimeField(_('creation date'), auto_now=True, db_index=True)
  33     xml_file    = models.FileField('xml_file', upload_to="xml", storage=picture_storage)
  34     image_file  = ImageField(_('image_file'), upload_to="images", storage=picture_storage)
  35     objects     = models.Manager()
  36     tagged      = managers.ModelTaggedItemManager(catalogue.models.Tag)
  37     tags        = managers.TagDescriptor(catalogue.models.Tag)
  38
  39     class AlreadyExists(Exception):
  40         pass
  41
  42     class Meta:
  43         ordering = ('sort_key',)
  44
  45         verbose_name = _('picture')
  46         verbose_name_plural = _('pictures')
  47
  48     URLID_RE = r'[a-z0-9-]+'
  49     FILEID_RE = r'[a-z0-9-]+'
  50
  51     def save(self, force_insert=False, force_update=False, reset_short_html=True, **kwargs):
  52         from sortify import sortify
  53
  54         self.sort_key = sortify(self.title)
  55
  56         ret = super(Picture, self).save(force_insert, force_update)
  57
  58         if reset_short_html:
  59             self.reset_short_html()
  60
  61         return ret
  62
  63     def __unicode__(self):
  64         return self.title
  65
  66     @permalink
  67     def get_absolute_url(self):
  68         return ('picture.views.picture_detail', [self.urlid()])
  69
  70     def urlid(self):
  71         return self.slug
  72
  73     @classmethod
  74     def from_xml_file(cls, xml_file, image_file=None, overwrite=False):
  75         """
  76         Import xml and it's accompanying image file.
  77         """
  78         from sortify import sortify
  79         from django.core.files import File
  80         from librarian.picture import WLPicture
  81         close_xml_file = False
  82
  83         if not isinstance(xml_file, File):
  84             xml_file = File(open(xml_file))
  85             close_xml_file = True
  86         try:
  87             # use librarian to parse meta-data
  88             picture_xml = WLPicture.from_file(xml_file)
  89
  90             pict, created = Picture.objects.get_or_create(slug=picture_xml.slug)
  91             if not created and not overwrite:
  92                 raise Picture.AlreadyExists('Picture %s already exists' % picture_xml.slug)
  93
  94             pict.title = picture_xml.picture_info.title
  95
  96             #            from nose.tools import set_trace; set_trace()
  97             motif_tags = set()
  98             for part in picture_xml.partiter():
  99                 for motif in part['themes']:
 100                     tag, created = catalogue.models.Tag.objects.get_or_create(slug=slughifi(motif), category='theme')
 101                     if created:
 102                         tag.name = motif
 103                         tag.sort_key = sortify(tag.name)
 104                         tag.save()
 105                     motif_tags.add(tag)
 106
 107             pict.tags = catalogue.models.Tag.tags_from_info(picture_xml.picture_info) + \
 108                 list(motif_tags)
 109
 110             if image_file is not None:
 111                 img = image_file
 112             else:
 113                 img = picture_xml.image_file()
 114
 115             pict.image_file.save(path.basename(picture_xml.image_path), File(img))
 116
 117             pict.xml_file.save("%s.xml" % pict.slug, File(xml_file))
 118             pict.save()
 119         finally:
 120             if close_xml_file:
 121                 xml_file.close()
 122         return pict
 123
 124     @classmethod
 125     def picture_list(cls, filter=None):
 126         """Generates a hierarchical listing of all pictures
 127         Pictures are optionally filtered with a test function.
 128         """
 129
 130         pics = cls.objects.all().order_by('sort_key')\
 131             .only('title', 'slug', 'image_file')
 132
 133         if filter:
 134             pics = pics.filter(filter).distinct()
 135
 136         pics_by_author = SortedDict()
 137         orphans = []
 138         for tag in catalogue.models.Tag.objects.filter(category='author'):
 139             pics_by_author[tag] = []
 140
 141         for pic in pics:
 142             authors = list(pic.tags.filter(category='author'))
 143             if authors:
 144                 for author in authors:
 145                     pics_by_author[author].append(pic)
 146             else:
 147                 orphans.append(pic)
 148
 149         return pics_by_author, orphans
 150
 151     @property
 152     def info(self):
 153         if not hasattr(self, '_info'):
 154             info = dcparser.parse(self.xml_file.path, picture.PictureInfo)
 155             self._info = info
 156         return self._info
 157
 158     def reset_short_html(self):
 159         if self.id is None:
 160             return
 161
 162         cache_key = "Picture.short_html/%d" % (self.id)
 163         cache.delete(cache_key)
 164
 165     def short_html(self):
 166         if self.id:
 167             cache_key = "Picture.short_html/%d" % (self.id)
 168             short_html = cache.get(cache_key)
 169         else:
 170             short_html = None
 171
 172         if short_html is not None:
 173             return mark_safe(short_html)
 174         else:
 175             tags = self.tags.filter(category__in=('author', 'kind', 'epoch'))
 176             tags = split_tags(tags)
 177
 178             short_html = unicode(render_to_string('picture/picture_short.html',
 179                 {'picture': self, 'tags': tags}))
 180
 181             if self.id:
 182                 cache.set(cache_key, short_html, catalogue.models.CACHE_FOREVER)
 183             return mark_safe(short_html)