601 lines
19 KiB
Python
601 lines
19 KiB
Python
import time
|
|
import datetime
|
|
from django.db import models
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.http import Http404
|
|
from django.views.generic.base import View
|
|
from django.views.generic.detail import BaseDetailView, SingleObjectTemplateResponseMixin
|
|
from django.views.generic.list import MultipleObjectMixin, MultipleObjectTemplateResponseMixin
|
|
|
|
|
|
class YearMixin(object):
|
|
year_format = '%Y'
|
|
year = None
|
|
|
|
def get_year_format(self):
|
|
"""
|
|
Get a year format string in strptime syntax to be used to parse the
|
|
year from url variables.
|
|
"""
|
|
return self.year_format
|
|
|
|
def get_year(self):
|
|
"Return the year for which this view should display data"
|
|
year = self.year
|
|
if year is None:
|
|
try:
|
|
year = self.kwargs['year']
|
|
except KeyError:
|
|
try:
|
|
year = self.request.GET['year']
|
|
except KeyError:
|
|
raise Http404("No year specified")
|
|
return year
|
|
|
|
|
|
class MonthMixin(object):
|
|
month_format = '%b'
|
|
month = None
|
|
|
|
def get_month_format(self):
|
|
"""
|
|
Get a month format string in strptime syntax to be used to parse the
|
|
month from url variables.
|
|
"""
|
|
return self.month_format
|
|
|
|
def get_month(self):
|
|
"Return the month for which this view should display data"
|
|
month = self.month
|
|
if month is None:
|
|
try:
|
|
month = self.kwargs['month']
|
|
except KeyError:
|
|
try:
|
|
month = self.request.GET['month']
|
|
except KeyError:
|
|
raise Http404("No month specified")
|
|
return month
|
|
|
|
def get_next_month(self, date):
|
|
"""
|
|
Get the next valid month.
|
|
"""
|
|
first_day, last_day = _month_bounds(date)
|
|
next = (last_day + datetime.timedelta(days=1)).replace(day=1)
|
|
return _get_next_prev_month(self, next, is_previous=False, use_first_day=True)
|
|
|
|
def get_previous_month(self, date):
|
|
"""
|
|
Get the previous valid month.
|
|
"""
|
|
first_day, last_day = _month_bounds(date)
|
|
prev = (first_day - datetime.timedelta(days=1)).replace(day=1)
|
|
return _get_next_prev_month(self, prev, is_previous=True, use_first_day=True)
|
|
|
|
|
|
class DayMixin(object):
|
|
day_format = '%d'
|
|
day = None
|
|
|
|
def get_day_format(self):
|
|
"""
|
|
Get a month format string in strptime syntax to be used to parse the
|
|
month from url variables.
|
|
"""
|
|
return self.day_format
|
|
|
|
def get_day(self):
|
|
"Return the day for which this view should display data"
|
|
day = self.day
|
|
if day is None:
|
|
try:
|
|
day = self.kwargs['day']
|
|
except KeyError:
|
|
try:
|
|
day = self.request.GET['day']
|
|
except KeyError:
|
|
raise Http404("No day specified")
|
|
return day
|
|
|
|
def get_next_day(self, date):
|
|
"""
|
|
Get the next valid day.
|
|
"""
|
|
next = date + datetime.timedelta(days=1)
|
|
return _get_next_prev_month(self, next, is_previous=False, use_first_day=False)
|
|
|
|
def get_previous_day(self, date):
|
|
"""
|
|
Get the previous valid day.
|
|
"""
|
|
prev = date - datetime.timedelta(days=1)
|
|
return _get_next_prev_month(self, prev, is_previous=True, use_first_day=False)
|
|
|
|
|
|
class WeekMixin(object):
|
|
week_format = '%U'
|
|
week = None
|
|
|
|
def get_week_format(self):
|
|
"""
|
|
Get a week format string in strptime syntax to be used to parse the
|
|
week from url variables.
|
|
"""
|
|
return self.week_format
|
|
|
|
def get_week(self):
|
|
"Return the week for which this view should display data"
|
|
week = self.week
|
|
if week is None:
|
|
try:
|
|
week = self.kwargs['week']
|
|
except KeyError:
|
|
try:
|
|
week = self.request.GET['week']
|
|
except KeyError:
|
|
raise Http404("No week specified")
|
|
return week
|
|
|
|
|
|
class DateMixin(object):
|
|
"""
|
|
Mixin class for views manipulating date-based data.
|
|
"""
|
|
date_field = None
|
|
allow_future = False
|
|
|
|
def get_date_field(self):
|
|
"""
|
|
Get the name of the date field to be used to filter by.
|
|
"""
|
|
if self.date_field is None:
|
|
raise ImproperlyConfigured(u"%s.date_field is required." % self.__class__.__name__)
|
|
return self.date_field
|
|
|
|
def get_allow_future(self):
|
|
"""
|
|
Returns `True` if the view should be allowed to display objects from
|
|
the future.
|
|
"""
|
|
return self.allow_future
|
|
|
|
|
|
class BaseDateListView(MultipleObjectMixin, DateMixin, View):
|
|
"""
|
|
Abstract base class for date-based views display a list of objects.
|
|
"""
|
|
allow_empty = False
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
self.date_list, self.object_list, extra_context = self.get_dated_items()
|
|
context = self.get_context_data(object_list=self.object_list,
|
|
date_list=self.date_list)
|
|
context.update(extra_context)
|
|
return self.render_to_response(context)
|
|
|
|
def get_dated_items(self):
|
|
"""
|
|
Obtain the list of dates and itesm
|
|
"""
|
|
raise NotImplementedError('A DateView must provide an implementation of get_dated_items()')
|
|
|
|
def get_dated_queryset(self, **lookup):
|
|
"""
|
|
Get a queryset properly filtered according to `allow_future` and any
|
|
extra lookup kwargs.
|
|
"""
|
|
qs = self.get_queryset().filter(**lookup)
|
|
date_field = self.get_date_field()
|
|
allow_future = self.get_allow_future()
|
|
allow_empty = self.get_allow_empty()
|
|
|
|
if not allow_future:
|
|
qs = qs.filter(**{'%s__lte' % date_field: datetime.datetime.now()})
|
|
|
|
if not allow_empty and not qs:
|
|
raise Http404(u"No %s available" % unicode(qs.model._meta.verbose_name_plural))
|
|
|
|
return qs
|
|
|
|
def get_date_list(self, queryset, date_type):
|
|
"""
|
|
Get a date list by calling `queryset.dates()`, checking along the way
|
|
for empty lists that aren't allowed.
|
|
"""
|
|
date_field = self.get_date_field()
|
|
allow_empty = self.get_allow_empty()
|
|
|
|
date_list = queryset.dates(date_field, date_type)[::-1]
|
|
if date_list is not None and not date_list and not allow_empty:
|
|
raise Http404(u"No %s available" % unicode(qs.model._meta.verbose_name_plural))
|
|
|
|
return date_list
|
|
|
|
|
|
|
|
def get_context_data(self, **kwargs):
|
|
"""
|
|
Get the context. Must return a Context (or subclass) instance.
|
|
"""
|
|
items = kwargs.pop('object_list')
|
|
context = super(BaseDateListView, self).get_context_data(object_list=items)
|
|
context.update(kwargs)
|
|
return context
|
|
|
|
|
|
class BaseArchiveIndexView(BaseDateListView):
|
|
"""
|
|
Base class for archives of date-based items.
|
|
|
|
Requires a response mixin.
|
|
"""
|
|
context_object_name = 'latest'
|
|
|
|
def get_dated_items(self):
|
|
"""
|
|
Return (date_list, items, extra_context) for this request.
|
|
"""
|
|
qs = self.get_dated_queryset()
|
|
date_list = self.get_date_list(qs, 'year')
|
|
|
|
if date_list:
|
|
object_list = qs.order_by('-'+self.get_date_field())
|
|
else:
|
|
object_list = qs.none()
|
|
|
|
return (date_list, object_list, {})
|
|
|
|
|
|
class ArchiveIndexView(MultipleObjectTemplateResponseMixin, BaseArchiveIndexView):
|
|
"""
|
|
Top-level archive of date-based items.
|
|
"""
|
|
template_name_suffix = '_archive'
|
|
|
|
|
|
class BaseYearArchiveView(YearMixin, BaseDateListView):
|
|
"""
|
|
List of objects published in a given year.
|
|
"""
|
|
make_object_list = False
|
|
|
|
def get_dated_items(self):
|
|
"""
|
|
Return (date_list, items, extra_context) for this request.
|
|
"""
|
|
# Yes, no error checking: the URLpattern ought to validate this; it's
|
|
# an error if it doesn't.
|
|
year = self.get_year()
|
|
date_field = self.get_date_field()
|
|
qs = self.get_dated_queryset(**{date_field+'__year': year})
|
|
date_list = self.get_date_list(qs, 'month')
|
|
|
|
if self.get_make_object_list():
|
|
object_list = qs.order_by('-'+date_field)
|
|
else:
|
|
# We need this to be a queryset since parent classes introspect it
|
|
# to find information about the model.
|
|
object_list = qs.none()
|
|
|
|
return (date_list, object_list, {'year': year})
|
|
|
|
def get_make_object_list(self):
|
|
"""
|
|
Return `True` if this view should contain the full list of objects in
|
|
the given year.
|
|
"""
|
|
return self.make_object_list
|
|
|
|
|
|
class YearArchiveView(MultipleObjectTemplateResponseMixin, BaseYearArchiveView):
|
|
"""
|
|
List of objects published in a given year.
|
|
"""
|
|
template_name_suffix = '_archive_year'
|
|
|
|
|
|
class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView):
|
|
"""
|
|
List of objects published in a given year.
|
|
"""
|
|
def get_dated_items(self):
|
|
"""
|
|
Return (date_list, items, extra_context) for this request.
|
|
"""
|
|
year = self.get_year()
|
|
month = self.get_month()
|
|
|
|
date_field = self.get_date_field()
|
|
date = _date_from_string(year, self.get_year_format(),
|
|
month, self.get_month_format())
|
|
|
|
# Construct a date-range lookup.
|
|
first_day, last_day = _month_bounds(date)
|
|
lookup_kwargs = {
|
|
'%s__gte' % date_field: first_day,
|
|
'%s__lt' % date_field: last_day,
|
|
}
|
|
|
|
qs = self.get_dated_queryset(**lookup_kwargs)
|
|
date_list = self.get_date_list(qs, 'day')
|
|
|
|
return (date_list, qs, {
|
|
'month': date,
|
|
'next_month': self.get_next_month(date),
|
|
'previous_month': self.get_previous_month(date),
|
|
})
|
|
|
|
|
|
|
|
class MonthArchiveView(MultipleObjectTemplateResponseMixin, BaseMonthArchiveView):
|
|
"""
|
|
List of objects published in a given year.
|
|
"""
|
|
template_name_suffix = '_archive_month'
|
|
|
|
|
|
class BaseWeekArchiveView(YearMixin, WeekMixin, BaseDateListView):
|
|
"""
|
|
List of objects published in a given week.
|
|
"""
|
|
|
|
def get_dated_items(self):
|
|
"""
|
|
Return (date_list, items, extra_context) for this request.
|
|
"""
|
|
year = self.get_year()
|
|
week = self.get_week()
|
|
|
|
date_field = self.get_date_field()
|
|
week_format = self.get_week_format()
|
|
week_start = {
|
|
'%W': '1',
|
|
'%U': '0',
|
|
}[week_format]
|
|
date = _date_from_string(year, self.get_year_format(),
|
|
week_start, '%w',
|
|
week, week_format)
|
|
|
|
# Construct a date-range lookup.
|
|
first_day = date
|
|
last_day = date + datetime.timedelta(days=7)
|
|
lookup_kwargs = {
|
|
'%s__gte' % date_field: first_day,
|
|
'%s__lt' % date_field: last_day,
|
|
}
|
|
|
|
qs = self.get_dated_queryset(**lookup_kwargs)
|
|
|
|
return (None, qs, {'week': date})
|
|
|
|
|
|
class WeekArchiveView(MultipleObjectTemplateResponseMixin, BaseWeekArchiveView):
|
|
"""
|
|
List of objects published in a given week.
|
|
"""
|
|
template_name_suffix = '_archive_week'
|
|
|
|
|
|
class BaseDayArchiveView(YearMixin, MonthMixin, DayMixin, BaseDateListView):
|
|
"""
|
|
List of objects published on a given day.
|
|
"""
|
|
def get_dated_items(self):
|
|
"""
|
|
Return (date_list, items, extra_context) for this request.
|
|
"""
|
|
year = self.get_year()
|
|
month = self.get_month()
|
|
day = self.get_day()
|
|
|
|
date = _date_from_string(year, self.get_year_format(),
|
|
month, self.get_month_format(),
|
|
day, self.get_day_format())
|
|
|
|
return self._get_dated_items(date)
|
|
|
|
def _get_dated_items(self, date):
|
|
"""
|
|
Do the actual heavy lifting of getting the dated items; this accepts a
|
|
date object so that TodayArchiveView can be trivial.
|
|
"""
|
|
date_field = self.get_date_field()
|
|
|
|
field = self.get_queryset().model._meta.get_field(date_field)
|
|
lookup_kwargs = _date_lookup_for_field(field, date)
|
|
|
|
qs = self.get_dated_queryset(**lookup_kwargs)
|
|
|
|
return (None, qs, {
|
|
'day': date,
|
|
'previous_day': self.get_previous_day(date),
|
|
'next_day': self.get_next_day(date),
|
|
'previous_month': self.get_previous_month(date),
|
|
'next_month': self.get_next_month(date)
|
|
})
|
|
|
|
|
|
|
|
class DayArchiveView(MultipleObjectTemplateResponseMixin, BaseDayArchiveView):
|
|
"""
|
|
List of objects published on a given day.
|
|
"""
|
|
template_name_suffix = "_archive_day"
|
|
|
|
|
|
class BaseTodayArchiveView(BaseDayArchiveView):
|
|
"""
|
|
List of objects published today.
|
|
"""
|
|
|
|
def get_dated_items(self):
|
|
"""
|
|
Return (date_list, items, extra_context) for this request.
|
|
"""
|
|
return self._get_dated_items(datetime.date.today())
|
|
|
|
|
|
class TodayArchiveView(MultipleObjectTemplateResponseMixin, BaseTodayArchiveView):
|
|
"""
|
|
List of objects published today.
|
|
"""
|
|
template_name_suffix = "_archive_day"
|
|
|
|
|
|
class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailView):
|
|
"""
|
|
Detail view of a single object on a single date; this differs from the
|
|
standard DetailView by accepting a year/month/day in the URL.
|
|
"""
|
|
def get_object(self, queryset=None):
|
|
"""
|
|
Get the object this request displays.
|
|
"""
|
|
year = self.get_year()
|
|
month = self.get_month()
|
|
day = self.get_day()
|
|
date = _date_from_string(year, self.get_year_format(),
|
|
month, self.get_month_format(),
|
|
day, self.get_day_format())
|
|
|
|
qs = self.get_queryset()
|
|
|
|
if not self.get_allow_future() and date > datetime.date.today():
|
|
raise Http404("Future %s not available because %s.allow_future is False." % (
|
|
qs.model._meta.verbose_name_plural, self.__class__.__name__)
|
|
)
|
|
|
|
# Filter down a queryset from self.queryset using the date from the
|
|
# URL. This'll get passed as the queryset to DetailView.get_object,
|
|
# which'll handle the 404
|
|
date_field = self.get_date_field()
|
|
field = qs.model._meta.get_field(date_field)
|
|
lookup = _date_lookup_for_field(field, date)
|
|
qs = qs.filter(**lookup)
|
|
|
|
return super(BaseDetailView, self).get_object(queryset=qs)
|
|
|
|
|
|
|
|
class DateDetailView(SingleObjectTemplateResponseMixin, BaseDateDetailView):
|
|
"""
|
|
Detail view of a single object on a single date; this differs from the
|
|
standard DetailView by accepting a year/month/day in the URL.
|
|
"""
|
|
template_name_suffix = '_detail'
|
|
|
|
|
|
def _date_from_string(year, year_format, month, month_format, day='', day_format='', delim='__'):
|
|
"""
|
|
Helper: get a datetime.date object given a format string and a year,
|
|
month, and possibly day; raise a 404 for an invalid date.
|
|
"""
|
|
format = delim.join((year_format, month_format, day_format))
|
|
datestr = delim.join((year, month, day))
|
|
try:
|
|
return datetime.date(*time.strptime(datestr, format)[:3])
|
|
except ValueError:
|
|
raise Http404(u"Invalid date string '%s' given format '%s'" % (datestr, format))
|
|
|
|
def _month_bounds(date):
|
|
"""
|
|
Helper: return the first and last days of the month for the given date.
|
|
"""
|
|
first_day = date.replace(day=1)
|
|
if first_day.month == 12:
|
|
last_day = first_day.replace(year=first_day.year + 1, month=1)
|
|
else:
|
|
last_day = first_day.replace(month=first_day.month + 1)
|
|
|
|
return first_day, last_day
|
|
|
|
def _get_next_prev_month(generic_view, naive_result, is_previous, use_first_day):
|
|
"""
|
|
Helper: Get the next or the previous valid date. The idea is to allow
|
|
links on month/day views to never be 404s by never providing a date
|
|
that'll be invalid for the given view.
|
|
|
|
This is a bit complicated since it handles both next and previous months
|
|
and days (for MonthArchiveView and DayArchiveView); hence the coupling to generic_view.
|
|
|
|
However in essance the logic comes down to:
|
|
|
|
* If allow_empty and allow_future are both true, this is easy: just
|
|
return the naive result (just the next/previous day or month,
|
|
reguardless of object existence.)
|
|
|
|
* If allow_empty is true, allow_future is false, and the naive month
|
|
isn't in the future, then return it; otherwise return None.
|
|
|
|
* If allow_empty is false and allow_future is true, return the next
|
|
date *that contains a valid object*, even if it's in the future. If
|
|
there are no next objects, return None.
|
|
|
|
* If allow_empty is false and allow_future is false, return the next
|
|
date that contains a valid object. If that date is in the future, or
|
|
if there are no next objects, return None.
|
|
|
|
"""
|
|
date_field = generic_view.get_date_field()
|
|
allow_empty = generic_view.get_allow_empty()
|
|
allow_future = generic_view.get_allow_future()
|
|
|
|
# If allow_empty is True the naive value will be valid
|
|
if allow_empty:
|
|
result = naive_result
|
|
|
|
# Otherwise, we'll need to go to the database to look for an object
|
|
# whose date_field is at least (greater than/less than) the given
|
|
# naive result
|
|
else:
|
|
# Construct a lookup and an ordering depending on weather we're doing
|
|
# a previous date or a next date lookup.
|
|
if is_previous:
|
|
lookup = {'%s__lte' % date_field: naive_result}
|
|
ordering = '-%s' % date_field
|
|
else:
|
|
lookup = {'%s__gte' % date_field: naive_result}
|
|
ordering = date_field
|
|
|
|
qs = generic_view.get_queryset().filter(**lookup).order_by(ordering)
|
|
|
|
# Snag the first object from the queryset; if it doesn't exist that
|
|
# means there's no next/previous link available.
|
|
try:
|
|
result = getattr(qs[0], date_field)
|
|
except IndexError:
|
|
result = None
|
|
|
|
# Convert datetimes to a dates
|
|
if hasattr(result, 'date'):
|
|
result = result.date()
|
|
|
|
# For month views, we always want to have a date that's the first of the
|
|
# month for consistancy's sake.
|
|
if result and use_first_day:
|
|
result = result.replace(day=1)
|
|
|
|
# Check against future dates.
|
|
if result and (allow_future or result < datetime.date.today()):
|
|
return result
|
|
else:
|
|
return None
|
|
|
|
def _date_lookup_for_field(field, date):
|
|
"""
|
|
Get the lookup kwargs for looking up a date against a given Field. If the
|
|
date field is a DateTimeField, we can't just do filter(df=date) because
|
|
that doesn't take the time into account. So we need to make a range lookup
|
|
in those cases.
|
|
"""
|
|
if isinstance(field, models.DateTimeField):
|
|
date_range = (
|
|
datetime.datetime.combine(date, datetime.time.min),
|
|
datetime.datetime.combine(date, datetime.time.max)
|
|
)
|
|
return {'%s__range' % field.name: date_range}
|
|
else:
|
|
return {field.name: date}
|
|
|