Fixed #18033 -- Removed function-based generic views, as per official... (1858e476) · Commits · Dom Sekotill / django

django/views/generic/create_update.py

deleted100644 → 0

+0 −221

Original line number	Diff line number	Diff line
		from django.forms.models import ModelFormMetaclass, ModelForm
		from django.template import RequestContext, loader
		from django.http import Http404, HttpResponse, HttpResponseRedirect
		from django.core.xheaders import populate_xheaders
		from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
		from django.utils.translation import ugettext
		from django.contrib.auth.views import redirect_to_login
		from django.views.generic import GenericViewError
		from django.contrib import messages

		import warnings
		warnings.warn(
		'Function-based generic views have been deprecated; use class-based views instead.',
		DeprecationWarning
		)


		def apply_extra_context(extra_context, context):
		"""
		Adds items from extra_context dict to context. If a value in extra_context
		is callable, then it is called and the result is added to context.
		"""
		for key, value in extra_context.iteritems():
		if callable(value):
		context[key] = value()
		else:
		context[key] = value

		def get_model_and_form_class(model, form_class):
		"""
		Returns a model and form class based on the model and form_class
		parameters that were passed to the generic view.

		If ``form_class`` is given then its associated model will be returned along
		with ``form_class`` itself. Otherwise, if ``model`` is given, ``model``
		itself will be returned along with a ``ModelForm`` class created from
		``model``.
		"""
		if form_class:
		return form_class._meta.model, form_class
		if model:
		# The inner Meta class fails if model = model is used for some reason.
		tmp_model = model
		# TODO: we should be able to construct a ModelForm without creating
		# and passing in a temporary inner class.
		class Meta:
		model = tmp_model
		class_name = model.__name__ + 'Form'
		form_class = ModelFormMetaclass(class_name, (ModelForm,), {'Meta': Meta})
		return model, form_class
		raise GenericViewError("Generic view must be called with either a model or"
		" form_class argument.")

		def redirect(post_save_redirect, obj):
		"""
		Returns a HttpResponseRedirect to ``post_save_redirect``.

		``post_save_redirect`` should be a string, and can contain named string-
		substitution place holders of ``obj`` field names.

		If ``post_save_redirect`` is None, then redirect to ``obj``'s URL returned
		by ``get_absolute_url()``. If ``obj`` has no ``get_absolute_url`` method,
		then raise ImproperlyConfigured.

		This function is meant to handle the post_save_redirect parameter to the
		``create_object`` and ``update_object`` views.
		"""
		if post_save_redirect:
		return HttpResponseRedirect(post_save_redirect % obj.__dict__)
		elif hasattr(obj, 'get_absolute_url'):
		return HttpResponseRedirect(obj.get_absolute_url())
		else:
		raise ImproperlyConfigured(
		"No URL to redirect to. Either pass a post_save_redirect"
		" parameter to the generic view or define a get_absolute_url"
		" method on the Model.")

		def lookup_object(model, object_id, slug, slug_field):
		"""
		Return the ``model`` object with the passed ``object_id``. If
		``object_id`` is None, then return the object whose ``slug_field``
		equals the passed ``slug``. If ``slug`` and ``slug_field`` are not passed,
		then raise Http404 exception.
		"""
		lookup_kwargs = {}
		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 GenericViewError(
		"Generic view must be called with either an object_id or a"
		" slug/slug_field.")
		try:
		return model.objects.get(**lookup_kwargs)
		except ObjectDoesNotExist:
		raise Http404("No %s found for %s"
		% (model._meta.verbose_name, lookup_kwargs))

		def create_object(request, model=None, template_name=None,
		template_loader=loader, extra_context=None, post_save_redirect=None,
		login_required=False, context_processors=None, form_class=None):
		"""
		Generic object-creation function.

		Templates: ``<app_label>/<model_name>_form.html``
		Context:
		form
		the form for the object
		"""
		if extra_context is None: extra_context = {}
		if login_required and not request.user.is_authenticated():
		return redirect_to_login(request.path)

		model, form_class = get_model_and_form_class(model, form_class)
		if request.method == 'POST':
		form = form_class(request.POST, request.FILES)
		if form.is_valid():
		new_object = form.save()

		msg = ugettext("The %(verbose_name)s was created successfully.") %\
		{"verbose_name": model._meta.verbose_name}
		messages.success(request, msg, fail_silently=True)
		return redirect(post_save_redirect, new_object)
		else:
		form = form_class()

		# Create the template, context, response
		if not template_name:
		template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
		t = template_loader.get_template(template_name)
		c = RequestContext(request, {
		'form': form,
		}, context_processors)
		apply_extra_context(extra_context, c)
		return HttpResponse(t.render(c))

		def update_object(request, model=None, object_id=None, slug=None,
		slug_field='slug', template_name=None, template_loader=loader,
		extra_context=None, post_save_redirect=None, login_required=False,
		context_processors=None, template_object_name='object',
		form_class=None):
		"""
		Generic object-update function.

		Templates: ``<app_label>/<model_name>_form.html``
		Context:
		form
		the form for the object
		object
		the original object being edited
		"""
		if extra_context is None: extra_context = {}
		if login_required and not request.user.is_authenticated():
		return redirect_to_login(request.path)

		model, form_class = get_model_and_form_class(model, form_class)
		obj = lookup_object(model, object_id, slug, slug_field)

		if request.method == 'POST':
		form = form_class(request.POST, request.FILES, instance=obj)
		if form.is_valid():
		obj = form.save()
		msg = ugettext("The %(verbose_name)s was updated successfully.") %\
		{"verbose_name": model._meta.verbose_name}
		messages.success(request, msg, fail_silently=True)
		return redirect(post_save_redirect, obj)
		else:
		form = form_class(instance=obj)

		if not template_name:
		template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
		t = template_loader.get_template(template_name)
		c = RequestContext(request, {
		'form': form,
		template_object_name: obj,
		}, context_processors)
		apply_extra_context(extra_context, c)
		response = HttpResponse(t.render(c))
		populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.attname))
		return response

		def delete_object(request, model, post_delete_redirect, object_id=None,
		slug=None, slug_field='slug', template_name=None,
		template_loader=loader, extra_context=None, login_required=False,
		context_processors=None, template_object_name='object'):
		"""
		Generic object-delete function.

		The given template will be used to confirm deletetion if this view is
		fetched using GET; for safty, deletion will only be performed if this
		view is POSTed.

		Templates: ``<app_label>/<model_name>_confirm_delete.html``
		Context:
		object
		the original object being deleted
		"""
		if extra_context is None: extra_context = {}
		if login_required and not request.user.is_authenticated():
		return redirect_to_login(request.path)

		obj = lookup_object(model, object_id, slug, slug_field)

		if request.method == 'POST':
		obj.delete()
		msg = ugettext("The %(verbose_name)s was deleted.") %\
		{"verbose_name": model._meta.verbose_name}
		messages.success(request, msg, fail_silently=True)
		return HttpResponseRedirect(post_delete_redirect)
		else:
		if not template_name:
		template_name = "%s/%s_confirm_delete.html" % (model._meta.app_label, model._meta.object_name.lower())
		t = template_loader.get_template(template_name)
		c = RequestContext(request, {
		template_object_name: obj,
		}, context_processors)
		apply_extra_context(extra_context, c)
		response = HttpResponse(t.render(c))
		populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.attname))
		return response

django/views/generic/date_based.py

deleted100644 → 0

+0 −376

Original line number	Diff line number	Diff line
		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
		from django.utils import timezone

		import warnings
		warnings.warn(
		'Function-based generic views have been deprecated; use class-based views instead.',
		DeprecationWarning
		)


		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: timezone.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 = timezone.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:
		date_list:
		List of days in this month with objects
		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:
		tt = time.strptime("%s-%s" % (year, month), '%s-%s' % ('%Y', month_format))
		date = datetime.date(*tt[:3])
		except ValueError:
		raise Http404

		model = queryset.model
		now = timezone.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)
		date_list = object_list.dates(date_field, 'day')
		if not object_list and not allow_empty:
		raise Http404

		# Calculate the next month, if applicable.
		if allow_future:
		next_month = last_day
		elif last_day <= datetime.date.today():
		next_month = last_day
		else:
		next_month = None

		# Calculate the previous month
		if first_day.month == 1:
		previous_month = first_day.replace(year=first_day.year-1,month=12)
		else:
		previous_month = first_day.replace(month=first_day.month-1)

		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, {
		'date_list': date_list,
		'%s_list' % template_object_name: object_list,
		'month': date,
		'next_month': next_month,
		'previous_month': previous_month,
		}, 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:
		tt = time.strptime(year+'-0-'+week, '%Y-%w-%U')
		date = datetime.date(*tt[:3])
		except ValueError:
		raise Http404

		model = queryset.model
		now = timezone.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:
		tt = time.strptime('%s-%s-%s' % (year, month, day),
		'%s-%s-%s' % ('%Y', month_format, day_format))
		date = datetime.date(*tt[:3])
		except ValueError:
		raise Http404

		model = queryset.model
		now = timezone.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:
		tt = time.strptime('%s-%s-%s' % (year, month, day),
		'%s-%s-%s' % ('%Y', month_format, day_format))
		date = datetime.date(*tt[:3])
		except ValueError:
		raise Http404

		model = queryset.model
		now = timezone.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

django/views/generic/list_detail.py

deleted100644 → 0

+0 −152

File deleted.

Preview size limit exceeded, changes collapsed.

django/views/generic/simple.py

deleted100644 → 0

+0 −68

File deleted.

Preview size limit exceeded, changes collapsed.

docs/glossary.txt

+1 −1

Original line number	Diff line number	Diff line
		@@ -16,7 +16,7 @@ Glossary
		A higher-order :term:`view` function that provides an abstract/generic
		implementation of a common idiom or pattern found in view development.

		See :doc:`/ref/generic-views`.
		See :doc:`/ref/class-based-views`.

		model
		Models store your application's data.