Removed backwards-compatibility for database template loader. Added VERSION information.
[philo.git] / contrib / julian / models.py
1 from django.conf import settings
2 from django.conf.urls.defaults import url, patterns, include
3 from django.contrib.auth.models import User
4 from django.contrib.contenttypes.generic import GenericForeignKey
5 from django.contrib.contenttypes.models import ContentType
6 from django.contrib.sites.models import Site
7 from django.core.exceptions import ValidationError, ObjectDoesNotExist
8 from django.core.validators import RegexValidator
9 from django.db import models
10 from django.db.models.query import QuerySet
11 from django.http import HttpResponse, Http404
12 from django.utils.encoding import force_unicode
13 from philo.contrib.julian.feedgenerator import ICalendarFeed
14 from philo.contrib.penfield.models import FeedView, FEEDS
15 from philo.exceptions import ViewCanNotProvideSubpath
16 from philo.models import Tag, Entity, Page, TemplateField
17 from philo.utils import ContentTypeRegistryLimiter
18 import datetime, calendar
19
20
21 __all__ = ('register_location_model', 'unregister_location_model', 'Location', 'TimedModel', 'Event', 'Calendar', 'CalendarView',)
22
23
24 ICALENDAR = ICalendarFeed.mime_type
25 FEEDS[ICALENDAR] = ICalendarFeed
26 try:
27         DEFAULT_SITE = Site.objects.get_current()
28 except:
29         DEFAULT_SITE = None
30 _languages = dict(settings.LANGUAGES)
31 try:
32         _languages[settings.LANGUAGE_CODE]
33         DEFAULT_LANGUAGE = settings.LANGUAGE_CODE
34 except KeyError:
35         try:
36                 lang = settings.LANGUAGE_CODE.split('-')[0]
37                 _languages[lang]
38                 DEFAULT_LANGUAGE = lang
39         except KeyError:
40                 DEFAULT_LANGUAGE = None
41
42
43 location_content_type_limiter = ContentTypeRegistryLimiter()
44
45
46 def register_location_model(model):
47         location_content_type_limiter.register_class(model)
48
49
50 def unregister_location_model(model):
51         location_content_type_limiter.unregister_class(model)
52
53
54 class Location(Entity):
55         name = models.CharField(max_length=255)
56         slug = models.SlugField(max_length=255, unique=True)
57         
58         def __unicode__(self):
59                 return self.name
60
61
62 register_location_model(Location)
63
64
65 class TimedModel(models.Model):
66         start_date = models.DateField(help_text="YYYY-MM-DD")
67         start_time = models.TimeField(blank=True, null=True, help_text="HH:MM:SS - 24 hour clock")
68         end_date = models.DateField()
69         end_time = models.TimeField(blank=True, null=True)
70         
71         def is_all_day(self):
72                 return self.start_time is None and self.end_time is None
73         
74         def clean(self):
75                 if bool(self.start_time) != bool(self.end_time):
76                         raise ValidationError("A %s must have either a start time and an end time or neither.")
77                 
78                 if self.start_date > self.end_date or self.start_date == self.end_date and self.start_time > self.end_time:
79                         raise ValidationError("A %s cannot end before it starts." % self.__class__.__name__)
80         
81         def get_start(self):
82                 return datetime.datetime.combine(self.start_date, self.start_time) if self.start_time else self.start_date
83         
84         def get_end(self):
85                 return datetime.datetime.combine(self.end_date, self.end_time) if self.end_time else self.end_date
86         
87         class Meta:
88                 abstract = True
89
90
91 class EventManager(models.Manager):
92         def get_query_set(self):
93                 return EventQuerySet(self.model)
94
95 class EventQuerySet(QuerySet):
96         def upcoming(self):
97                 return self.filter(start_date__gte=datetime.date.today())
98         def current(self):
99                 return self.filter(start_date__lte=datetime.date.today(), end_date__gte=datetime.date.today())
100         def single_day(self):
101                 return self.filter(start_date__exact=models.F('end_date'))
102         def multiday(self):
103                 return self.exclude(start_date__exact=models.F('end_date'))
104
105 class Event(Entity, TimedModel):
106         name = models.CharField(max_length=255)
107         slug = models.SlugField(max_length=255, unique_for_date='start_date')
108         
109         location_content_type = models.ForeignKey(ContentType, limit_choices_to=location_content_type_limiter, blank=True, null=True)
110         location_pk = models.TextField(blank=True)
111         location = GenericForeignKey('location_content_type', 'location_pk')
112         
113         description = TemplateField()
114         
115         tags = models.ManyToManyField(Tag, related_name='events', blank=True, null=True)
116         
117         parent_event = models.ForeignKey('self', blank=True, null=True)
118         
119         # TODO: "User module"
120         owner = models.ForeignKey(User, related_name='owned_events')
121         
122         created = models.DateTimeField(auto_now_add=True)
123         last_modified = models.DateTimeField(auto_now=True)
124         
125         site = models.ForeignKey(Site, default=DEFAULT_SITE)
126         
127         @property
128         def uuid(self):
129                 return "%s@%s" % (self.created.isoformat(), getattr(self.site, 'domain', 'None'))
130         
131         objects = EventManager()
132         
133         def __unicode__(self):
134                 return self.name
135         
136         class Meta:
137                 unique_together = ('site', 'created')
138
139
140 class Calendar(Entity):
141         name = models.CharField(max_length=100)
142         slug = models.SlugField(max_length=100)
143         description = models.TextField(blank=True)
144         events = models.ManyToManyField(Event, related_name='calendars', blank=True)
145         
146         site = models.ForeignKey(Site, default=DEFAULT_SITE)
147         language = models.CharField(max_length=5, choices=settings.LANGUAGES, default=DEFAULT_LANGUAGE)
148         
149         def __unicode__(self):
150                 return self.name
151         
152         @property
153         def fpi(self):
154                 # See http://xml.coverpages.org/tauber-fpi.html or ISO 9070:1991 for format information.
155                 return "-//%s//%s//%s" % (self.site.name, self.name, self.language.split('-')[0].upper())
156         
157         class Meta:
158                 unique_together = ('name', 'site', 'language')
159
160
161 class CalendarView(FeedView):
162         calendar = models.ForeignKey(Calendar)
163         index_page = models.ForeignKey(Page, related_name="calendar_index_related")
164         event_detail_page = models.ForeignKey(Page, related_name="calendar_detail_related")
165         
166         timespan_page = models.ForeignKey(Page, related_name="calendar_timespan_related", blank=True, null=True)
167         tag_page = models.ForeignKey(Page, related_name="calendar_tag_related", blank=True, null=True)
168         location_page = models.ForeignKey(Page, related_name="calendar_location_related", blank=True, null=True)
169         owner_page = models.ForeignKey(Page, related_name="calendar_owner_related", blank=True, null=True)
170         
171         tag_archive_page = models.ForeignKey(Page, related_name="calendar_tag_archive_related", blank=True, null=True)
172         location_archive_page = models.ForeignKey(Page, related_name="calendar_location_archive_related", blank=True, null=True)
173         owner_archive_page = models.ForeignKey(Page, related_name="calendar_owner_archive_related", blank=True, null=True)
174         
175         tag_permalink_base = models.CharField(max_length=30, default='tags')
176         owner_permalink_base = models.CharField(max_length=30, default='owners')
177         location_permalink_base = models.CharField(max_length=30, default='locations')
178         events_per_page = models.PositiveIntegerField(blank=True, null=True)
179         
180         item_context_var = "events"
181         object_attr = "calendar"
182         
183         def get_reverse_params(self, obj):
184                 if isinstance(obj, User):
185                         return 'events_for_user', [], {'username': obj.username}
186                 elif isinstance(obj, Event):
187                         return 'event_detail', [], {
188                                 'year': str(obj.start_date.year).zfill(4),
189                                 'month': str(obj.start_date.month).zfill(2),
190                                 'day': str(obj.start_date.day).zfill(2),
191                                 'slug': obj.slug
192                         }
193                 elif isinstance(obj, Tag) or isinstance(obj, models.query.QuerySet) and obj.model == Tag:
194                         if isinstance(obj, Tag):
195                                 obj = [obj]
196                         return 'entries_by_tag', [], {'tag_slugs': '/'.join(obj)}
197                 raise ViewCanNotProvideSubpath
198         
199         def timespan_patterns(self, pattern, timespan_name):
200                 return self.feed_patterns(pattern, 'get_events_by_timespan', 'timespan_page', "events_by_%s" % timespan_name)
201         
202         @property
203         def urlpatterns(self):
204                 # Perhaps timespans should be done with GET parameters? Or two /-separated
205                 # date slugs? (e.g. 2010-02-1/2010-02-2) or a start and duration?
206                 # (e.g. 2010-02-01/week/ or ?d=2010-02-01&l=week)
207                 urlpatterns = self.feed_patterns(r'^', 'get_all_events', 'index_page', 'index') + \
208                         self.timespan_patterns(r'^(?P<year>\d{4})', 'year') + \
209                         self.timespan_patterns(r'^(?P<year>\d{4})/(?P<month>\d{2})', 'month') + \
210                         self.timespan_patterns(r'^(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})', 'day') + \
211                         self.feed_patterns(r'^%s/(?P<username>[^/]+)' % self.owner_permalink_base, 'get_events_by_owner', 'owner_page', 'events_by_user') + \
212                         self.feed_patterns(r'^%s/(?P<app_label>\w+)/(?P<model>\w+)/(?P<pk>[^/]+)' % self.location_permalink_base, 'get_events_by_location', 'location_page', 'events_by_location') + \
213                         self.feed_patterns(r'^%s/(?P<tag_slugs>[-\w]+[-+/\w]*)' % self.tag_permalink_base, 'get_events_by_tag', 'tag_page', 'events_by_tag') + \
214                         patterns('',
215                                 url(r'(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/(?P<slug>[\w-]+)$', self.event_detail_view, name="event_detail"),
216                         )
217                         
218                         # Some sort of shortcut for a location would be useful. This could be on a per-calendar
219                         # or per-calendar-view basis.
220                         #url(r'^%s/(?P<slug>[\w-]+)' % self.location_permalink_base, ...)
221                 
222                 if self.tag_archive_page:
223                         urlpatterns += patterns('',
224                                 url(r'^%s$' % self.tag_permalink_base, self.tag_archive_view, name='tag_archive')
225                         )
226                 
227                 if self.owner_archive_page:
228                         urlpatterns += patterns('',
229                                 url(r'^%s$' % self.owner_permalink_base, self.owner_archive_view, name='owner_archive')
230                         )
231                 
232                 if self.location_archive_page:
233                         urlpatterns += patterns('',
234                                 url(r'^%s$' % self.location_permalink_base, self.location_archive_view, name='location_archive')
235                         )
236                 return urlpatterns
237         
238         # Basic QuerySet fetchers.
239         def get_event_queryset(self):
240                 return self.calendar.events.all()
241         
242         def get_timespan_queryset(self, year, month=None, day=None):
243                 qs = self.get_event_queryset()
244                 # See python documentation for the min/max values.
245                 if year and month and day:
246                         year, month, day = int(year), int(month), int(day)
247                         start_datetime = datetime.datetime(year, month, day, 0, 0)
248                         end_datetime = datetime.datetime(year, month, day, 23, 59)
249                 elif year and month:
250                         year, month = int(year), int(month)
251                         start_datetime = datetime.datetime(year, month, 1, 0, 0)
252                         end_datetime = datetime.datetime(year, month, calendar.monthrange(year, month)[1], 23, 59)
253                 else:
254                         year = int(year)
255                         start_datetime = datetime.datetime(year, 1, 1, 0, 0)
256                         end_datetime = datetime.datetime(year, 12, 31, 23, 59)
257                 
258                 return qs.exclude(end_date__lt=start_datetime, end_time__lt=start_datetime).exclude(start_date__gt=end_datetime, start_time__gt=end_datetime, start_time__isnull=False).exclude(start_time__isnull=True, start_date__gt=end_datetime)
259         
260         def get_tag_queryset(self):
261                 return Tag.objects.filter(events__calendars=self.calendar).distinct()
262         
263         def get_location_querysets(self):
264                 # Potential bottleneck?
265                 location_map = {}
266                 locations = Event.objects.values_list('location_content_type', 'location_pk')
267                 
268                 for ct, pk in locations:
269                         location_map.setdefault(ct, []).append(pk)
270                 
271                 location_cts = ContentType.objects.in_bulk(location_map.keys())
272                 location_querysets = {}
273                 
274                 for ct_pk, pks in location_map.items():
275                         ct = location_cts[ct_pk]
276                         location_querysets[ct] = ct.model_class()._default_manager.filter(pk__in=pks)
277                 
278                 return location_querysets
279         
280         def get_owner_queryset(self):
281                 return User.objects.filter(owned_events__calendars=self.calendar).distinct()
282         
283         # Event QuerySet parsers for a request/args/kwargs
284         def get_all_events(self, request, extra_context=None):
285                 return self.get_event_queryset(), extra_context
286         
287         def get_events_by_timespan(self, request, year, month=None, day=None, extra_context=None):
288                 context = extra_context or {}
289                 context.update({
290                         'year': year,
291                         'month': month,
292                         'day': day
293                 })
294                 return self.get_timespan_queryset(year, month, day), context
295         
296         def get_events_by_owner(self, request, username, extra_context=None):
297                 try:
298                         owner = self.get_owner_queryset().get(username=username)
299                 except User.DoesNotExist:
300                         raise Http404
301                 
302                 qs = self.get_event_queryset().filter(owner=owner)
303                 context = extra_context or {}
304                 context.update({
305                         'owner': owner
306                 })
307                 return qs, context
308         
309         def get_events_by_tag(self, request, tag_slugs, extra_context=None):
310                 tag_slugs = tag_slugs.replace('+', '/').split('/')
311                 tags = self.get_tag_queryset().filter(slug__in=tag_slugs)
312                 
313                 if not tags:
314                         raise Http404
315                 
316                 # Raise a 404 on an incorrect slug.
317                 found_slugs = [tag.slug for tag in tags]
318                 for slug in tag_slugs:
319                         if slug and slug not in found_slugs:
320                                 raise Http404
321
322                 events = self.get_event_queryset()
323                 for tag in tags:
324                         events = events.filter(tags=tag)
325                 
326                 context = extra_context or {}
327                 context.update({'tags': tags})
328                 
329                 return events, context
330         
331         def get_events_by_location(self, request, app_label, model, pk, extra_context=None):
332                 try:
333                         ct = ContentType.objects.get(app_label=app_label, model=model)
334                         location = ct.model_class()._default_manager.get(pk=pk)
335                 except ObjectDoesNotExist:
336                         raise Http404
337                 
338                 events = self.get_event_queryset().filter(location_content_type=ct, location_pk=location.pk)
339                 
340                 context = extra_context or {}
341                 context.update({
342                         'location': location
343                 })
344                 return events, context
345         
346         # Detail View.
347         def event_detail_view(self, request, year, month, day, slug, extra_context=None):
348                 try:
349                         event = Event.objects.select_related('parent_event').get(start_date__year=year, start_date__month=month, start_date__day=day, slug=slug)
350                 except Event.DoesNotExist:
351                         raise Http404
352                 
353                 context = self.get_context()
354                 context.update(extra_context or {})
355                 context.update({
356                         'event': event
357                 })
358                 return self.event_detail_page.render_to_response(request, extra_context=context)
359         
360         # Archive Views.
361         def tag_archive_view(self, request, extra_context=None):
362                 tags = self.get_tag_queryset()
363                 context = self.get_context()
364                 context.update(extra_context or {})
365                 context.update({
366                         'tags': tags
367                 })
368                 return self.tag_archive_page.render_to_response(request, extra_context=context)
369         
370         def location_archive_view(self, request, extra_context=None):
371                 # What datastructure should locations be?
372                 locations = self.get_location_querysets()
373                 context = self.get_context()
374                 context.update(extra_context or {})
375                 context.update({
376                         'locations': locations
377                 })
378                 return self.location_archive_page.render_to_response(request, extra_context=context)
379         
380         def owner_archive_view(self, request, extra_context=None):
381                 owners = self.get_owner_queryset()
382                 context = self.get_context()
383                 context.update(extra_context or {})
384                 context.update({
385                         'owners': owners
386                 })
387                 return self.owner_archive_page.render_to_response(request, extra_context=context)
388         
389         # Process page items
390         def process_page_items(self, request, items):
391                 if self.events_per_page:
392                         page_num = request.GET.get('page', 1)
393                         paginator, paginated_page, items = paginate(items, self.events_per_page, page_num)
394                         item_context = {
395                                 'paginator': paginator,
396                                 'paginated_page': paginated_page,
397                                 self.item_context_var: items
398                         }
399                 else:
400                         item_context = {
401                                 self.item_context_var: items
402                         }
403                 return items, item_context
404         
405         # Feed information hooks
406         def title(self, obj):
407                 return obj.name
408         
409         def link(self, obj):
410                 # Link is ignored anyway...
411                 return ""
412         
413         def feed_guid(self, obj):
414                 return obj.fpi
415         
416         def description(self, obj):
417                 return obj.description
418         
419         def feed_extra_kwargs(self, obj):
420                 return {'filename': "%s.ics" % obj.slug}
421         
422         def item_title(self, item):
423                 return item.name
424         
425         def item_description(self, item):
426                 return item.description
427         
428         def item_link(self, item):
429                 return self.reverse(item)
430         
431         def item_guid(self, item):
432                 return item.uuid
433         
434         def item_author_name(self, item):
435                 if item.owner:
436                         return item.owner.get_full_name()
437         
438         def item_author_email(self, item):
439                 return getattr(item.owner, 'email', None) or None
440         
441         def item_pubdate(self, item):
442                 return item.created
443         
444         def item_categories(self, item):
445                 return [tag.name for tag in item.tags.all()]
446         
447         def item_extra_kwargs(self, item):
448                 return {
449                         'start': item.get_start(),
450                         'end': item.get_end(),
451                         'last_modified': item.last_modified,
452                         # Is forcing unicode enough, or should we look for a "custom method"?
453                         'location': force_unicode(item.location),
454                 }
455         
456         def __unicode__(self):
457                 return u"%s for %s" % (self.__class__.__name__, self.calendar)
458
459 field = CalendarView._meta.get_field('feed_type')
460 field._choices += ((ICALENDAR, 'iCalendar'),)
461 field.default = ICALENDAR