django_events.py

# -*- coding: UTF-8 -*-

from __future__ import absolute_import
from __future__ import unicode_literals

from django.db import models
from django.db.models.query import QuerySet
from django.core.urlresolvers import reverse
from django.utils.timezone import now
from django.utils.encoding import python_2_unicode_compatible

from djcommon.models import TimeStampedModel


class EventDateFilterMixin(object):

  def pending(self, **kwargs):
    return self.filter(date__gte=now().date(), **kwargs)

  def finished(self, **kwargs):
    return self.filter(date__lt=now().date(), **kwargs)

  def published(self, **kwargs):
    return self.filter(event__published=True, **kwargs)

  def unpublished(self, **kwargs):
    return self.filter(event__published=False, **kwargs)

  def upcoming(self, **kwargs):
    return self.filter(date__gte=now().date(), event__published=True, **kwargs)


class EventDateQuerySet(EventDateFilterMixin, QuerySet):
  pass


class EventDateManager(EventDateFilterMixin, models.Manager):

  def get_queryset(self):
    return EventDateQuerySet(self.model, using=self._db)


@python_2_unicode_compatible
class EventDate(models.Model):

  date = models.DateField('Datum', db_index=True)
  start = models.TimeField('Anfangszeit', blank=True, null=True)
  end = models.TimeField('Endzeit', blank=True, null=True)
  event = models.ForeignKey('Event')

  objects = EventDateManager()

  def __str__(self):
    return "{}: {}".format(self.date.isoformat(), self.title)

  def get_absolute_url(self):
    return reverse('events:details', args=[str(self.event_id)])

  @property
  def title(self):
    try:
      return self.event.title
    except Event.DoesNotExists:
      return '?'

  @property
  def is_published(self):
    try:
      return self.event.published
    except Event.DoesNotExists:
      return False

  @property
  def is_pending(self):
    today = now().date()
    return self.date >= today

  class Meta:
    verbose_name = ('Event Termin')
    verbose_name_plural = ('Event Termine')
    ordering = ('date', 'start', 'end')


@python_2_unicode_compatible
class Event(TimeStampedModel):

  title = models.CharField(max_length=200)
  text = models.TextField()
  published = models.BooleanField('freigeschaltet', default=False, db_index=True)

  def __str__(self):
    return self.title

  def get_absolute_url(self):
    return reverse('events:details', args=[str(self.id)])

  def publish(self):
    if not self.published:
      self.published = True
      self.save()

  def unpublish(self):
    if self.published:
      self.published = False
      self.save()

  @property
  def dates(self):
    return self.eventdate_set.all()

  @property
  def dates_pending(self):
    return [edate for edate in self.dates if edate.is_pending]
    # return self.eventdate_set.filter(date__gte=now().date())

  @property
  def next_date(self):
    try:
      # return self.eventdate_set.filter(date__gte=now().date()).first()
      return self.dates_pending[0]
    except IndexError:
      return None

  def _date_count(self):
    return len(self.dates)
    # return self.eventdate_set.count()

  def _pending_count(self):
    return len(self.dates_pending)
    # return self.eventdate_set.filter(date__gte=now().date()).count()

  def _is_pending(self):
    return bool(self.pending_count)

  def _next_date_as_string(self):
    try:
      return self.next_date.date
    except AttributeError:
      return 'abgelaufen'

  _date_count.short_description = 'Anzahl Termine'
  date_count = property(_date_count)

  _pending_count.short_description = 'Bevorstehende Termine'
  pending_count = property(_pending_count)

  _is_pending.short_description = 'Bevorstehend'
  is_pending = property(_is_pending)

  _next_date_as_string.short_description = 'Nächster Termin'
  next_date_as_string = property(_next_date_as_string)

  class Meta:
    verbose_name = ('Event Beschreibung')
    verbose_name_plural = ('Event Beschreibungen')