1 from django.contrib.admin.views.decorators import staff_member_required

     2 from django.core import validators

     3 from django import template, oldforms

     4 from django.template import loader

     5 from django.shortcuts import render_to_response

     6 from django.contrib.sites.models import Site

     7 from django.conf import settings

     8 

     9 def template_validator(request):

    10     """

    11     Displays the template validator form, which finds and displays template

    12     syntax errors.

    13     """

    14     # get a dict of {site_id : settings_module} for the validator

    15     settings_modules = {}

    16     for mod in settings.ADMIN_FOR:

    17         settings_module = __import__(mod, {}, {}, [''])

    18         settings_modules[settings_module.SITE_ID] = settings_module

    19     manipulator = TemplateValidator(settings_modules)

    20     new_data, errors = {}, {}

    21     if request.POST:

    22         new_data = request.POST.copy()

    23         errors = manipulator.get_validation_errors(new_data)

    24         if not errors:

    25             request.user.message_set.create(message='The template is valid.')

    26     return render_to_response('admin/template_validator.html', {

    27         'title': 'Template validator',

    28         'form': oldforms.FormWrapper(manipulator, new_data, errors),

    29     }, context_instance=template.RequestContext(request))

    30 template_validator = staff_member_required(template_validator)

    31 

    32 class TemplateValidator(oldforms.Manipulator):

    33     def __init__(self, settings_modules):

    34         self.settings_modules = settings_modules

    35         site_list = Site.objects.in_bulk(settings_modules.keys()).values()

    36         self.fields = (

    37             oldforms.SelectField('site', is_required=True, choices=[(s.id, s.name) for s in site_list]),

    38             oldforms.LargeTextField('template', is_required=True, rows=25, validator_list=[self.isValidTemplate]),

    39         )

    40 

    41     def isValidTemplate(self, field_data, all_data):

    42         # get the settings module

    43         # if the site isn't set, we don't raise an error since the site field will

    44         try:

    45             site_id = int(all_data.get('site', None))

    46         except (ValueError, TypeError):

    47             return

    48         settings_module = self.settings_modules.get(site_id, None)

    49         if settings_module is None:

    50             return

    51 

    52         # so that inheritance works in the site's context, register a new function

    53         # for "extends" that uses the site's TEMPLATE_DIRS instead.

    54         def new_do_extends(parser, token):

    55             node = loader.do_extends(parser, token)

    56             node.template_dirs = settings_module.TEMPLATE_DIRS

    57             return node

    58         register = template.Library()

    59         register.tag('extends', new_do_extends)

    60         template.builtins.append(register)

    61 

    62         # Now validate the template using the new template dirs

    63         # making sure to reset the extends function in any case.

    64         error = None

    65         try:

    66             tmpl = loader.get_template_from_string(field_data)

    67             tmpl.render(template.Context({}))

    68         except template.TemplateSyntaxError, e:

    69             error = e

    70         template.builtins.remove(register)

    71         if error:

    72             raise validators.ValidationError, e.args