404 lines
13 KiB
Python
404 lines
13 KiB
Python
# -'- Encoding: utf-8 -*-
|
|
|
|
import os
|
|
|
|
from django.conf import settings
|
|
from django.core.urlresolvers import reverse
|
|
from django.db import models
|
|
from django.template.defaultfilters import slugify
|
|
from django.utils.timezone import now
|
|
from django.utils.translation import ugettext as _
|
|
from imagekit import ImageSpec
|
|
import imagekit
|
|
from imagekit.models import ImageSpecField
|
|
from pilkit import processors
|
|
import pyexiv2
|
|
|
|
from utils import COUNTRIES, OverwriteStorage
|
|
|
|
|
|
CHOICES_HORIZONTAL = (
|
|
(0.00000001, _('left')),
|
|
(0.5, _('center')),
|
|
(1, _('right'))
|
|
)
|
|
|
|
CHOICES_VERTICAL = (
|
|
(0.00000001, _('top')),
|
|
(0.5, _('middle')),
|
|
(1, _('bottom'))
|
|
)
|
|
|
|
|
|
def get_upload_path(instance, filename):
|
|
"""
|
|
Generates the desired file path and filename for an uploaded Image.
|
|
With this function Django can save the uploaded images to subfolders that
|
|
also have a meaning for humans.
|
|
|
|
@param instance: an Django Object for which the Image has been uploaded.
|
|
@type instance: a instace of an models.Model sub-class.
|
|
@param filename: The filename of the uploaded image.
|
|
@type filename: String
|
|
"""
|
|
extension = filename[filename.rfind('.') + 1:]
|
|
if isinstance(instance, Event):
|
|
if instance.id:
|
|
return "events/%s.%s" % (instance.id, extension)
|
|
else:
|
|
return "events/%s.%s" % (slugify(instance.name), extension)
|
|
elif isinstance(instance, Location):
|
|
if instance.id:
|
|
return "events/location/%s.%s" % (instance.id, extension)
|
|
else:
|
|
return "events/location/%s.%s" % (instance.id, extension)
|
|
elif isinstance(instance, Photo):
|
|
return "events/%s/%s" % (instance.event.id, filename)
|
|
|
|
|
|
def post_save_image(sender, instance=None, created=False, raw=False, **kwargs):
|
|
"""
|
|
Reganerate the images.
|
|
"""
|
|
os.remove(instance.display.path)
|
|
os.remove(instance.callout.path)
|
|
os.remove(instance.thumbnail.path)
|
|
|
|
"""
|
|
instance.callout.generate(force=True)
|
|
instance.display.generate(force=True)
|
|
instance.thumbnail.generate(force=True)
|
|
"""
|
|
|
|
|
|
class CalloutImage(ImageSpec):
|
|
format = 'PNG'
|
|
width = 940
|
|
height = 300
|
|
|
|
@property
|
|
def processors(self):
|
|
model, field_name = imagekit.utils.get_field_info(self.source) # @UnusedVariable @IgnorePep8
|
|
anchor = model.get_anchor()
|
|
if anchor:
|
|
return [processors.Transpose(), processors.ResizeToFill(
|
|
width=self.width,
|
|
height=self.height, anchor=anchor
|
|
)]
|
|
else:
|
|
return [processors.Transpose(), processors.SmartResize(
|
|
width=self.width,
|
|
height=self.height
|
|
)]
|
|
|
|
|
|
class DisplayImage(ImageSpec):
|
|
format = 'PNG'
|
|
processors = [processors.Transpose(),
|
|
processors.ResizeToFit(width=940, height=940, upscale=False)]
|
|
|
|
|
|
class ThumbnailImage(CalloutImage):
|
|
format = 'PNG'
|
|
width = 140
|
|
height = 140
|
|
|
|
|
|
imagekit.register.generator('kasu:image:callout', CalloutImage)
|
|
imagekit.register.generator('kasu:image:display', DisplayImage)
|
|
imagekit.register.generator('kasu:image:thumbnail', ThumbnailImage)
|
|
|
|
|
|
class ImageModel(models.Model):
|
|
callout = ImageSpecField(source='image', id='kasu:image:callout')
|
|
display = ImageSpecField(source='image', id='kasu:image:display')
|
|
thumbnail = ImageSpecField(source='image', id='kasu:image:thumbnail')
|
|
|
|
def get_anchor(self):
|
|
try:
|
|
anchor_horizontal = getattr(self, 'anchor_horizontal')
|
|
anchor_vertical = getattr(self, 'anchor_vertical')
|
|
except AttributeError:
|
|
return None
|
|
if anchor_horizontal and anchor_vertical:
|
|
return self.anchor_horizontal, self.anchor_vertical
|
|
else:
|
|
return None
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
class EventManager(models.Manager):
|
|
def current_event(self):
|
|
try:
|
|
current = self.filter(start__lte=now())
|
|
current = current.filter(end__gte=now())
|
|
return current.order_by('start', 'end')[0]
|
|
except:
|
|
return None
|
|
|
|
def next_event(self):
|
|
try:
|
|
return self.filter(start__gt=now()).order_by('start', 'end')[0]
|
|
except:
|
|
return None
|
|
|
|
def archive(self):
|
|
return self.filter(start__lt=now())
|
|
|
|
def upcoming(self, limit=3):
|
|
result = self.filter(start__gt=now()).order_by('start', 'end')
|
|
if limit:
|
|
return result[1:(limit + 1)]
|
|
else:
|
|
return result
|
|
|
|
|
|
class Event(ImageModel):
|
|
name = models.CharField(_('Name'), max_length=255)
|
|
description = models.TextField(_("Description"), blank=True)
|
|
location = models.ForeignKey('Location')
|
|
start = models.DateTimeField(_('Start'))
|
|
end = models.DateTimeField(_('End'), blank=True, null=True)
|
|
url = models.URLField(_('Homepage'), blank=True)
|
|
image = models.ImageField(_("Image"), upload_to=get_upload_path,
|
|
storage=OverwriteStorage(), blank=True, null=True)
|
|
is_tournament = models.BooleanField(_('Tournament'), default=False,
|
|
help_text=_(u'This event is a tournament, different rules apply for \
|
|
the kyu ranking.'))
|
|
photo_count = models.PositiveIntegerField(default=0, editable=False)
|
|
event_series = models.ForeignKey('Event', blank=True, null=True,
|
|
on_delete=models.SET_NULL, editable=False,
|
|
verbose_name=_('Event Series'),
|
|
help_text=_(u'Wenn dieser Event zu einer Veranstaltungsreihe gehört \
|
|
werden Ort, Beschreibung, Bild und Homepage von dem hier angegebenen \
|
|
Event übernommen.'))
|
|
objects = EventManager()
|
|
|
|
class Meta(object):
|
|
verbose_name = _('Event')
|
|
verbose_name_plural = _('Events')
|
|
ordering = ('-start', '-end',)
|
|
|
|
def __unicode__(self):
|
|
try:
|
|
return "%(name)s (%(date)s)" % {'name': self.name,
|
|
'date': self.start.date()}
|
|
except:
|
|
return "New Event Model"
|
|
|
|
def get_absolute_url(self):
|
|
kwargs = {
|
|
'pk': self.id,
|
|
'year': self.start.strftime('%Y'),
|
|
'month': self.start.strftime('%m')
|
|
}
|
|
return reverse('event-detail', kwargs=kwargs)
|
|
|
|
def get_edit_url(self):
|
|
kwargs = {
|
|
'pk': self.id,
|
|
'year': self.start.strftime('%Y'),
|
|
'month': self.start.strftime('%m')
|
|
}
|
|
return reverse('event-form', kwargs=kwargs)
|
|
|
|
def get_callout(self):
|
|
if self.image:
|
|
return self.callout
|
|
elif self.photo_set.count():
|
|
return self.photo_set.all().order_by('?')[0].callout
|
|
elif self.location.image:
|
|
return self.location.callout
|
|
else:
|
|
return None
|
|
|
|
def get_thumbnail(self):
|
|
if self.image:
|
|
return self.thumbnail
|
|
elif self.photo_set.count():
|
|
return self.photo_set.all().order_by('?')[0].thumbnail
|
|
elif self.location.image:
|
|
return self.location.thumbnail
|
|
else:
|
|
return None
|
|
|
|
def save(self, **kwargs):
|
|
if self.event_series:
|
|
master_event = self.event_series
|
|
self.description = master_event.description
|
|
self.location = master_event.location
|
|
self.url = master_event.url
|
|
self.image = master_event.image
|
|
self.photo_count = self.photo_set.count()
|
|
models.Model.save(self, **kwargs)
|
|
|
|
# Update the rest of the event series:
|
|
for sub_event in Event.objects.filter(event_series=self):
|
|
sub_event.save()
|
|
|
|
# Update the Hanchans if necesery:
|
|
for hanchan in self.hanchan_set.all():
|
|
hanchan.save()
|
|
|
|
|
|
class Location(ImageModel):
|
|
name = models.CharField(_("Name"), max_length=200)
|
|
description = models.TextField(_("Description"), blank=True)
|
|
image = models.ImageField(_("Image"), upload_to=get_upload_path,
|
|
storage=OverwriteStorage(), blank=True, null=True)
|
|
url = models.URLField(_('Homepage'), blank=True)
|
|
postal_code = models.CharField(_('Postal Code'), max_length=6)
|
|
street_address = models.CharField(_('Street Address'), max_length=127)
|
|
locality = models.CharField(_('Locality'), max_length=127)
|
|
country = models.CharField(_('Country'), max_length=2, choices=COUNTRIES)
|
|
|
|
class Meta(object):
|
|
verbose_name = _('Venue')
|
|
verbose_name_plural = _('Venues')
|
|
|
|
def __unicode__(self):
|
|
return self.name
|
|
|
|
@property
|
|
def address(self):
|
|
address = (self.street_address, self.locality, self.country,)
|
|
return ','.join(address)
|
|
|
|
|
|
class PhotoManager(models.Manager):
|
|
def get_random(self, startpage=True):
|
|
if startpage:
|
|
queryset = self.filter(on_startpage=True)
|
|
else:
|
|
queryset = self.all().order_by('?')[0]
|
|
try:
|
|
return queryset.order_by('?')[0]
|
|
except IndexError:
|
|
return Photo()
|
|
|
|
|
|
class Photo(ImageModel):
|
|
name = models.CharField(_("Name"), max_length=100, blank=True)
|
|
image = models.ImageField(_("Image"), upload_to=get_upload_path,
|
|
storage=OverwriteStorage())
|
|
anchor_horizontal = models.FloatField(
|
|
_('horizontal Anchorpoint'),
|
|
choices=CHOICES_HORIZONTAL,
|
|
blank=True, null=True,
|
|
help_text='Der Ankerpunkt ist der interessante Teil des Bildes,\
|
|
welcher nie abgeschnitten werden darf'
|
|
)
|
|
anchor_vertical = models.FloatField(
|
|
_('vertical Anchorpoint'),
|
|
choices=CHOICES_VERTICAL,
|
|
blank=True, null=True,
|
|
help_text='Wenn kein Ankerpunkt von Hand (horizontal und vertikal)\
|
|
festgelegt wird, versucht die Software diesen selbst zu erraten.'
|
|
)
|
|
|
|
event = models.ForeignKey(Event)
|
|
description = models.TextField(
|
|
_("Description"),
|
|
max_length=300,
|
|
blank=True
|
|
)
|
|
photographer = models.ForeignKey(settings.AUTH_USER_MODEL)
|
|
on_startpage = models.BooleanField(
|
|
_("Startpage"),
|
|
default=False,
|
|
help_text=_('Display this Photo on the Startpage Teaser')
|
|
)
|
|
created_date = models.DateTimeField(_("Published on"))
|
|
views = models.PositiveIntegerField(
|
|
_("Number of views"),
|
|
editable=False,
|
|
default=0
|
|
)
|
|
objects = PhotoManager()
|
|
metadata = None
|
|
orientation = 1
|
|
|
|
class Meta:
|
|
verbose_name = _('Event Image')
|
|
verbose_name_plural = _('Event Images')
|
|
ordering = ["created_date"]
|
|
get_latest_by = "created_date"
|
|
|
|
def __unicode__(self):
|
|
return os.path.basename(self.image.name)
|
|
|
|
def read_metadata(self):
|
|
image_path = os.path.join(settings.MEDIA_ROOT, self.image.name)
|
|
self.metadata = pyexiv2.ImageMetadata(image_path)
|
|
self.metadata.read()
|
|
try:
|
|
self.orientation = self.metadata['Exif.Image.Orientation'].value
|
|
except:
|
|
self.orientation = 1
|
|
|
|
def save_metadata(self):
|
|
if not self.metadata:
|
|
self.read_metadata()
|
|
self.metadata['Exif.Image.DateTime'] = self.created_date
|
|
self.metadata['Exif.Image.ImageDescription'] = self.description
|
|
self.metadata['Exif.Image.Artist'] = self.photographer.username
|
|
self.metadata['Exif.Image.Orientation'] = self.orientation or 1
|
|
self.metadata.write()
|
|
|
|
def rotate(self, rotate):
|
|
"""
|
|
Sets an the Exif tag in an image to set the right direction.
|
|
This provides lossless image rotation.
|
|
@param rotate: 'clockwise' or 'counter-clockwise' the direction in
|
|
which we should rotate the image in 90° steps.
|
|
"""
|
|
if not self.metadata:
|
|
self.read_metadata()
|
|
if rotate == 'clockwise':
|
|
if self.orientation == 1:
|
|
self.orientation = 6
|
|
elif self.orientation == 6:
|
|
self.orientation = 3
|
|
elif self.orientation == 3:
|
|
self.orientation = 8
|
|
else:
|
|
self.orientation = 1
|
|
elif rotate == 'counter-clockwise':
|
|
if self.orientation == 1:
|
|
self.orientation = 8
|
|
elif self.orientation == 8:
|
|
self.orientation = 3
|
|
elif self.orientation == 3:
|
|
self.orientation = 6
|
|
else:
|
|
self.orientation = 1
|
|
self.save()
|
|
|
|
def get_absolute_url(self):
|
|
return reverse(
|
|
'event-photo',
|
|
kwargs={'event': self.event.id, 'pk': self.id}
|
|
)
|
|
|
|
@property
|
|
def next_photo(self):
|
|
return self.get_next_by_created_date(event=self.event)
|
|
|
|
@property
|
|
def previous_photo(self):
|
|
return self.get_previous_by_created_date(event=self.event)
|
|
|
|
def save(self, **kwargs):
|
|
"""
|
|
Triggers to save related Event to save. This should force an update for
|
|
the denormalized Photo count.
|
|
"""
|
|
ImageModel.save(self, **kwargs)
|
|
self.save_metadata()
|
|
self.event.save()
|
|
|
|
|
|
models.signals.post_save.connect(post_save_image, sender=Photo)
|