You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
352 lines
13 KiB
352 lines
13 KiB
import datetime |
|
import time |
|
|
|
from django.template import loader, RequestContext |
|
from django.core.exceptions import ObjectDoesNotExist |
|
from django.core.xheaders import populate_xheaders |
|
from django.db.models.fields import DateTimeField |
|
from django.http import Http404, HttpResponse |
|
|
|
def archive_index(request, queryset, date_field, num_latest=15, |
|
template_name=None, template_loader=loader, |
|
extra_context=None, allow_empty=True, context_processors=None, |
|
mimetype=None, allow_future=False, template_object_name='latest'): |
|
""" |
|
Generic top-level archive of date-based objects. |
|
|
|
Templates: ``<app_label>/<model_name>_archive.html`` |
|
Context: |
|
date_list |
|
List of years |
|
latest |
|
Latest N (defaults to 15) objects by date |
|
""" |
|
if extra_context is None: extra_context = {} |
|
model = queryset.model |
|
if not allow_future: |
|
queryset = queryset.filter(**{'%s__lte' % date_field: datetime.datetime.now()}) |
|
date_list = queryset.dates(date_field, 'year')[::-1] |
|
if not date_list and not allow_empty: |
|
raise Http404, "No %s available" % model._meta.verbose_name |
|
|
|
if date_list and num_latest: |
|
latest = queryset.order_by('-'+date_field)[:num_latest] |
|
else: |
|
latest = None |
|
|
|
if not template_name: |
|
template_name = "%s/%s_archive.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
t = template_loader.get_template(template_name) |
|
c = RequestContext(request, { |
|
'date_list' : date_list, |
|
template_object_name : latest, |
|
}, context_processors) |
|
for key, value in extra_context.items(): |
|
if callable(value): |
|
c[key] = value() |
|
else: |
|
c[key] = value |
|
return HttpResponse(t.render(c), mimetype=mimetype) |
|
|
|
def archive_year(request, year, queryset, date_field, template_name=None, |
|
template_loader=loader, extra_context=None, allow_empty=False, |
|
context_processors=None, template_object_name='object', mimetype=None, |
|
make_object_list=False, allow_future=False): |
|
""" |
|
Generic yearly archive view. |
|
|
|
Templates: ``<app_label>/<model_name>_archive_year.html`` |
|
Context: |
|
date_list |
|
List of months in this year with objects |
|
year |
|
This year |
|
object_list |
|
List of objects published in the given month |
|
(Only available if make_object_list argument is True) |
|
""" |
|
if extra_context is None: extra_context = {} |
|
model = queryset.model |
|
now = datetime.datetime.now() |
|
|
|
lookup_kwargs = {'%s__year' % date_field: year} |
|
|
|
# Only bother to check current date if the year isn't in the past and future objects aren't requested. |
|
if int(year) >= now.year and not allow_future: |
|
lookup_kwargs['%s__lte' % date_field] = now |
|
date_list = queryset.filter(**lookup_kwargs).dates(date_field, 'month') |
|
if not date_list and not allow_empty: |
|
raise Http404 |
|
if make_object_list: |
|
object_list = queryset.filter(**lookup_kwargs) |
|
else: |
|
object_list = [] |
|
if not template_name: |
|
template_name = "%s/%s_archive_year.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
t = template_loader.get_template(template_name) |
|
c = RequestContext(request, { |
|
'date_list': date_list, |
|
'year': year, |
|
'%s_list' % template_object_name: object_list, |
|
}, context_processors) |
|
for key, value in extra_context.items(): |
|
if callable(value): |
|
c[key] = value() |
|
else: |
|
c[key] = value |
|
return HttpResponse(t.render(c), mimetype=mimetype) |
|
|
|
def archive_month(request, year, month, queryset, date_field, |
|
month_format='%b', template_name=None, template_loader=loader, |
|
extra_context=None, allow_empty=False, context_processors=None, |
|
template_object_name='object', mimetype=None, allow_future=False): |
|
""" |
|
Generic monthly archive view. |
|
|
|
Templates: ``<app_label>/<model_name>_archive_month.html`` |
|
Context: |
|
month: |
|
(date) this month |
|
next_month: |
|
(date) the first day of the next month, or None if the next month is in the future |
|
previous_month: |
|
(date) the first day of the previous month |
|
object_list: |
|
list of objects published in the given month |
|
""" |
|
if extra_context is None: extra_context = {} |
|
try: |
|
date = datetime.date(*time.strptime(year+month, '%Y'+month_format)[:3]) |
|
except ValueError: |
|
raise Http404 |
|
|
|
model = queryset.model |
|
now = datetime.datetime.now() |
|
|
|
# Calculate first and last day of month, for use in a date-range lookup. |
|
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) |
|
lookup_kwargs = { |
|
'%s__gte' % date_field: first_day, |
|
'%s__lt' % date_field: last_day, |
|
} |
|
|
|
# Only bother to check current date if the month isn't in the past and future objects are requested. |
|
if last_day >= now.date() and not allow_future: |
|
lookup_kwargs['%s__lte' % date_field] = now |
|
object_list = queryset.filter(**lookup_kwargs) |
|
if not object_list and not allow_empty: |
|
raise Http404 |
|
|
|
# Calculate the next month, if applicable. |
|
if allow_future: |
|
next_month = last_day + datetime.timedelta(days=1) |
|
elif last_day < datetime.date.today(): |
|
next_month = last_day + datetime.timedelta(days=1) |
|
else: |
|
next_month = None |
|
|
|
if not template_name: |
|
template_name = "%s/%s_archive_month.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
t = template_loader.get_template(template_name) |
|
c = RequestContext(request, { |
|
'%s_list' % template_object_name: object_list, |
|
'month': date, |
|
'next_month': next_month, |
|
'previous_month': first_day - datetime.timedelta(days=1), |
|
}, context_processors) |
|
for key, value in extra_context.items(): |
|
if callable(value): |
|
c[key] = value() |
|
else: |
|
c[key] = value |
|
return HttpResponse(t.render(c), mimetype=mimetype) |
|
|
|
def archive_week(request, year, week, queryset, date_field, |
|
template_name=None, template_loader=loader, |
|
extra_context=None, allow_empty=True, context_processors=None, |
|
template_object_name='object', mimetype=None, allow_future=False): |
|
""" |
|
Generic weekly archive view. |
|
|
|
Templates: ``<app_label>/<model_name>_archive_week.html`` |
|
Context: |
|
week: |
|
(date) this week |
|
object_list: |
|
list of objects published in the given week |
|
""" |
|
if extra_context is None: extra_context = {} |
|
try: |
|
date = datetime.date(*time.strptime(year+'-0-'+week, '%Y-%w-%U')[:3]) |
|
except ValueError: |
|
raise Http404 |
|
|
|
model = queryset.model |
|
now = datetime.datetime.now() |
|
|
|
# Calculate first and last day of week, for use in 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, |
|
} |
|
|
|
# Only bother to check current date if the week isn't in the past and future objects aren't requested. |
|
if last_day >= now.date() and not allow_future: |
|
lookup_kwargs['%s__lte' % date_field] = now |
|
object_list = queryset.filter(**lookup_kwargs) |
|
if not object_list and not allow_empty: |
|
raise Http404 |
|
if not template_name: |
|
template_name = "%s/%s_archive_week.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
t = template_loader.get_template(template_name) |
|
c = RequestContext(request, { |
|
'%s_list' % template_object_name: object_list, |
|
'week': date, |
|
}) |
|
for key, value in extra_context.items(): |
|
if callable(value): |
|
c[key] = value() |
|
else: |
|
c[key] = value |
|
return HttpResponse(t.render(c), mimetype=mimetype) |
|
|
|
def archive_day(request, year, month, day, queryset, date_field, |
|
month_format='%b', day_format='%d', template_name=None, |
|
template_loader=loader, extra_context=None, allow_empty=False, |
|
context_processors=None, template_object_name='object', |
|
mimetype=None, allow_future=False): |
|
""" |
|
Generic daily archive view. |
|
|
|
Templates: ``<app_label>/<model_name>_archive_day.html`` |
|
Context: |
|
object_list: |
|
list of objects published that day |
|
day: |
|
(datetime) the day |
|
previous_day |
|
(datetime) the previous day |
|
next_day |
|
(datetime) the next day, or None if the current day is today |
|
""" |
|
if extra_context is None: extra_context = {} |
|
try: |
|
date = datetime.date(*time.strptime(year+month+day, '%Y'+month_format+day_format)[:3]) |
|
except ValueError: |
|
raise Http404 |
|
|
|
model = queryset.model |
|
now = datetime.datetime.now() |
|
|
|
if isinstance(model._meta.get_field(date_field), DateTimeField): |
|
lookup_kwargs = {'%s__range' % date_field: (datetime.datetime.combine(date, datetime.time.min), datetime.datetime.combine(date, datetime.time.max))} |
|
else: |
|
lookup_kwargs = {date_field: date} |
|
|
|
# Only bother to check current date if the date isn't in the past and future objects aren't requested. |
|
if date >= now.date() and not allow_future: |
|
lookup_kwargs['%s__lte' % date_field] = now |
|
object_list = queryset.filter(**lookup_kwargs) |
|
if not allow_empty and not object_list: |
|
raise Http404 |
|
|
|
# Calculate the next day, if applicable. |
|
if allow_future: |
|
next_day = date + datetime.timedelta(days=1) |
|
elif date < datetime.date.today(): |
|
next_day = date + datetime.timedelta(days=1) |
|
else: |
|
next_day = None |
|
|
|
if not template_name: |
|
template_name = "%s/%s_archive_day.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
t = template_loader.get_template(template_name) |
|
c = RequestContext(request, { |
|
'%s_list' % template_object_name: object_list, |
|
'day': date, |
|
'previous_day': date - datetime.timedelta(days=1), |
|
'next_day': next_day, |
|
}, context_processors) |
|
for key, value in extra_context.items(): |
|
if callable(value): |
|
c[key] = value() |
|
else: |
|
c[key] = value |
|
return HttpResponse(t.render(c), mimetype=mimetype) |
|
|
|
def archive_today(request, **kwargs): |
|
""" |
|
Generic daily archive view for today. Same as archive_day view. |
|
""" |
|
today = datetime.date.today() |
|
kwargs.update({ |
|
'year': str(today.year), |
|
'month': today.strftime('%b').lower(), |
|
'day': str(today.day), |
|
}) |
|
return archive_day(request, **kwargs) |
|
|
|
def object_detail(request, year, month, day, queryset, date_field, |
|
month_format='%b', day_format='%d', object_id=None, slug=None, |
|
slug_field='slug', template_name=None, template_name_field=None, |
|
template_loader=loader, extra_context=None, context_processors=None, |
|
template_object_name='object', mimetype=None, allow_future=False): |
|
""" |
|
Generic detail view from year/month/day/slug or year/month/day/id structure. |
|
|
|
Templates: ``<app_label>/<model_name>_detail.html`` |
|
Context: |
|
object: |
|
the object to be detailed |
|
""" |
|
if extra_context is None: extra_context = {} |
|
try: |
|
date = datetime.date(*time.strptime(year+month+day, '%Y'+month_format+day_format)[:3]) |
|
except ValueError: |
|
raise Http404 |
|
|
|
model = queryset.model |
|
now = datetime.datetime.now() |
|
|
|
if isinstance(model._meta.get_field(date_field), DateTimeField): |
|
lookup_kwargs = {'%s__range' % date_field: (datetime.datetime.combine(date, datetime.time.min), datetime.datetime.combine(date, datetime.time.max))} |
|
else: |
|
lookup_kwargs = {date_field: date} |
|
|
|
# Only bother to check current date if the date isn't in the past and future objects aren't requested. |
|
if date >= now.date() and not allow_future: |
|
lookup_kwargs['%s__lte' % date_field] = now |
|
if object_id: |
|
lookup_kwargs['%s__exact' % model._meta.pk.name] = object_id |
|
elif slug and slug_field: |
|
lookup_kwargs['%s__exact' % slug_field] = slug |
|
else: |
|
raise AttributeError, "Generic detail view must be called with either an object_id or a slug/slugfield" |
|
try: |
|
obj = queryset.get(**lookup_kwargs) |
|
except ObjectDoesNotExist: |
|
raise Http404, "No %s found for" % model._meta.verbose_name |
|
if not template_name: |
|
template_name = "%s/%s_detail.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
if template_name_field: |
|
template_name_list = [getattr(obj, template_name_field), template_name] |
|
t = template_loader.select_template(template_name_list) |
|
else: |
|
t = template_loader.get_template(template_name) |
|
c = RequestContext(request, { |
|
template_object_name: obj, |
|
}, context_processors) |
|
for key, value in extra_context.items(): |
|
if callable(value): |
|
c[key] = value() |
|
else: |
|
c[key] = value |
|
response = HttpResponse(t.render(c), mimetype=mimetype) |
|
populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.name)) |
|
return response
|
|
|