ssify/decorators.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of django-ssify, licensed under GNU Affero GPLv3 or later.
   3 # Copyright © Fundacja Nowoczesna Polska. See README.md for more information.
   4 #
   5 """
   6 Defines decorators for use in ssify-enabled projects.
   7 """
   8 from __future__ import unicode_literals
   9 import functools
  10 from inspect import getargspec
  11 import warnings
  12 from django.conf import settings
  13 from django.http import Http404
  14 from django.template.base import parse_bits
  15 from django.utils.translation import get_language, activate
  16 from .cache import cache_include, DEFAULT_TIMEOUT
  17 from . import exceptions
  18 from .variables import SsiVariable
  19
  20
  21 def ssi_included(view=None, use_lang=True,
  22         timeout=DEFAULT_TIMEOUT, version=None,
  23         get_ssi_vars=None, patch_response=None):
  24     """
  25     Marks a view to be used as a snippet to be included with SSI.
  26
  27     If use_lang is True (which is default), the URL pattern for such
  28     a view must provide a keyword argument named 'lang' for language.
  29     SSI included views don't use language or content negotiation, so
  30     everything they need to know has to be included in the URL.
  31
  32     get_ssi_vars should be a callable which takes the view's arguments
  33     and returns the names of SSI variables it uses.
  34
  35     """
  36     def dec(view):
  37         @functools.wraps(view)
  38         def new_view(request, *args, **kwargs):
  39             if use_lang:
  40                 try:
  41                     lang = kwargs.pop('lang')
  42                 except KeyError:
  43                     raise exceptions.NoLangFieldError(request)
  44                 if lang not in [language[0] for language in settings.LANGUAGES]:
  45                     raise Http404
  46                 current_lang = get_language()
  47                 activate(lang)
  48                 request.LANGUAGE_CODE = lang
  49             response = view(request, *args, **kwargs)
  50             if use_lang:
  51                 activate(current_lang)
  52             if response.status_code == 200:
  53                 # We don't want this view to be cached in
  54                 # UpdateCacheMiddleware. We'll just cache the contents
  55                 # ourselves, and point the webserver to use this cache.
  56                 request._cache_update_cache = False
  57
  58                 def _check_included_vars(response):
  59                     used_vars = getattr(request, 'ssi_vars_needed', {})
  60                     if get_ssi_vars:
  61                         # Remove the ssi vars that should be provided
  62                         # by the including view.
  63                         pass_vars = get_ssi_vars(*args, **kwargs)
  64
  65                         for var in pass_vars:
  66                             if not isinstance(var, SsiVariable):
  67                                 var = SsiVariable(*var)
  68                             try:
  69                                 del used_vars[var.name]
  70                             except KeyError:
  71                                 warnings.warn(
  72                                     exceptions.UnusedSsiVarsWarning(
  73                                         request, var))
  74                     if used_vars:
  75                         raise exceptions.UndeclaredSsiVarsError(
  76                             request, used_vars)
  77                     request.ssi_vars_needed = {}
  78
  79                     # Don't use default django response caching for this view,
  80                     # just save the contents instead.
  81                     cache_include(request.path, response.content,
  82                         timeout=timeout, version=version)
  83
  84                 if hasattr(response, 'render') and callable(response.render):
  85                     response.add_post_render_callback(_check_included_vars)
  86                 else:
  87                     _check_included_vars(response)
  88
  89             return response
  90
  91         # Remember get_ssi_vars so that in can be computed from args/kwargs
  92         # by including view.
  93         new_view.get_ssi_vars = get_ssi_vars
  94         new_view.ssi_patch_response = patch_response
  95         return new_view
  96     return dec(view) if view else dec
  97
  98
  99 def ssi_variable(register, name=None, patch_response=None):
 100     """
 101     Creates a template tag representing an SSI variable from a function.
 102
 103     The function must take 'request' as its first argument.
 104     It may take other arguments, which should be provided when using
 105     the template tag.
 106
 107     """
 108     # Cache control?
 109     def dec(func):
 110
 111         # Find own path.
 112         function_name = (name or
 113                          getattr(func, '_decorated_function', func).__name__)
 114         lib_name = func.__module__.rsplit('.', 1)[-1]
 115         tagpath = "%s.%s" % (lib_name, function_name)
 116         # Make sure the function takes request parameter.
 117         params, varargs, varkw, defaults = getargspec(func)
 118         assert params and params[0] == 'request', '%s is decorated with '\
 119             'request_info_tag, so it must take `request` for '\
 120             'its first argument.' % (tagpath)
 121
 122         @register.tag(name=function_name)
 123         def _ssi_var_tag(parser, token):
 124             """
 125             Creates a SSI variable reference for a request-dependent info.
 126
 127             Use as:
 128                 {% ri_tag args... %}
 129             or:
 130                 {% ri_tag args... as variable %}
 131                 {{ variable.if }}
 132                     {{ variable }}, or
 133                     {% ssi_include 'some-snippet' variable %}
 134                 {{ variable.else }}
 135                     Default text
 136                 {{ variable.endif }}
 137
 138             """
 139             bits = token.split_contents()[1:]
 140
 141             # Is it the 'as' form?
 142             if len(bits) >= 2 and bits[-2] == 'as':
 143                 asvar = bits[-1]
 144                 bits = bits[:-2]
 145             else:
 146                 asvar = None
 147
 148             # Parse the arguments like Django's generic tags do.
 149             args, kwargs = parse_bits(parser, bits,
 150                                       ['context'] + params[1:], varargs, varkw,
 151                                       defaults, takes_context=True,
 152                                       name=function_name)
 153             return SsiVariableNode(tagpath, args, kwargs, patch_response, asvar)
 154         _ssi_var_tag.get_value = func
 155         #return _ssi_var_tag
 156         return func
 157
 158     return dec
 159
 160
 161 from .variables import SsiVariableNode