"""Integrates Dojo with Django."""
import json
import uuid
# Used to convert Django Field attributes to Dojo attributes.
#
# Key is Django Field attribute name.
# Value is tuple.
# [0] == Dijit attribute name
# [1] == callable to convert Django value to Dijit value
default_attr_map = {
'required': ('required', None),
'min_length': ('minLength', None),
'max_length': ('maxLength', None),
'regex': ('regExp', lambda a: a.pattern)
}
def dojo_field(field, dojo_type, attr_map=None, dojo_attrs=None):
"""
Instruments a Django form.Field with Dijit parameters.
arguments
==========
* field - Django form.Field to instrument.
* dojo_type - str, qualified class name of dijit class to use.
* attr_map - dict, optional mapping between Django and Dojo
attrs, see default_attr_map comments for format.
* dojo_attrs - dict, Attributes to apply to Dijit.
"""
# Specifies mapping between Django field attributes
# and Dijit attributes
if attr_map is not None:
map = dict(default_attr_map)
map.update(attr_map)
else:
map = default_attr_map
# Get mapped attributes from Django field
attrs = {}
for attr, mapper in map.iteritems():
val = getattr(field, attr, None)
if val is None:
continue
if mapper[1] is not None:
val = mapper[1](val)
attrs[mapper[0]] = val
# Convert Error message
error_msgs = getattr(field, 'error_messages', None)
if error_msgs is not None:
invalid_msg = error_msgs.get('invalid', None)
if invalid_msg is not None:
# Django uses a
# lazy proxy when this property is not
# explicitly set. json encoder will choke
# on the proxy object. Calling a method
# causes the proxy to be evaluated and
# json encoder is happy.
attrs['invalidMessage'] = invalid_msg.rstrip()
# Add user defined attributes
if dojo_attrs is not None:
attrs.update(dojo_attrs)
# Attach Dojo attributes to field
field._dojo_type = dojo_type
field._dojo_params = attrs
class Dojo(object):
"""Keeps track of Dojo properties."""
def __init__(self, src, enabled=True, theme='tundra',
dj_config=None, form_function=None):
self.enabled = enabled
self.dj_config = dj_config
self.form_function = form_function
self._src = src
self._stylesheets = ['/'.join((self._src, 'dojo', 'resources', 'dojo.css'))]
self._modules = [] #required_modules
self._aols = [] # addOnLoad functions
self.theme = theme
def get_src(self):
return self._src
src = property(get_src)
def get_theme(self):
return self._theme
def set_theme(self, val):
def _get_theme_css(theme):
return '/'.join((self._src, 'dijit', 'themes',
theme, '%s.css' % theme))
current_theme = getattr(self, '_theme', None)
if current_theme is not None:
theme_css = _get_theme_css(current_theme)
if theme_css in self._stylesheets:
self._stylesheets.remove(theme_css)
self._theme = val
theme_css = _get_theme_css(self._theme)
self.append_stylesheet(theme_css)
theme = property(get_theme, set_theme)
def get_modules(self):
return self._modules
def set_modules(self, val):
self._modules = val
modules = property(get_modules, set_modules)
def get_stylesheets(self):
return self._stylesheets
def set_stylesheets(self, val):
self._stylesheets = val
stylesheets = property(get_stylesheets, set_stylesheets)
def get_aols(self):
return self._aols
def set_aols(self, val):
self._aols = val
aols = property(get_aols, set_aols)
def set_module_path(self, module, path):
"""Short cut for setting module path in djConfig."""
if 'modulePaths' not in self.dj_config:
self.dj_config['modulePaths'] = {}
self.dj_config['modulePaths'][module] = path
def append_module(self, module):
"""Add a required module."""
if module not in self._modules:
self._modules.append(module)
def append_stylesheet(self, stylesheet):
"""Add a stylesheet."""
if stylesheet not in self._stylesheets:
self._stylesheets.append(stylesheet)
def append_aol(self, aol):
"""Add an addOnLoad function."""
self._aols.append(aol)
def prepend_aol(self, aol):
self._aols.insert(0, aol)
def dojo_form(self, form, form_function=None):
"""
Generates Javascript to instrument a Dijit form.
Adds an addOnLoad handler that instantiates a
Dijit form when the page loads.
Any fields that have been setup with dojo_field
will also be instantiated as Dijits.
"""
dijits = []
for bound_field in form:
field = bound_field.field
dojo_type = getattr(field, '_dojo_type', None)
if dojo_type is not None:
# This is a dojo enabled widget
params = getattr(field, '_dojo_params', {})
params['dojoType'] = dojo_type
self.append_module(dojo_type)
dijits.append({'name': bound_field.name, 'params': params})
json_dijits = json.dumps(dijits)
self.append_module('dijit.form.Form')
if getattr(form, 'id', None) is None:
# Form must have a unique id for
# JS form instrumentation to work
# correctly.
form.id = str(uuid.uuid1())
if form_function is None:
# Form function wasn't passed,
# use form_function member var instead
form_function = self.form_function
if form_function is None:
# Generate JS
self.append_module('dojo.parser')
self.append_aol(self._build_form_js(form.id, json_dijits))
else:
# Call existing JS function
self.append_module(form_function[0])
function_name = '.'.join(form_function)
function_call = "function() {%s('%s', %s);}" % (function_name, form.id, json_dijits)
self.append_aol(function_call)
def _build_form_js(self, form_id, json_dijits):
"""Builds a JS function string used to dijitize a form."""
return """
function () {
var dijitForm = dojo.byId('%(form_id)s');
if (dijitForm != null) {
var elements = [];
var dijits = %(json_dijits)s;
dojo.forEach(dijits, function(dijit) {
var n = dijitForm.elements[dijit.name];
if (n != null) {
dojo.attr(n, dijit.params);
elements.push(n);
}
});
dojo.attr(dijitForm, {dojoType: 'dijit.form.Form'});
elements.push(dijitForm);
dojo.parser.instantiate(elements);
}
}
""" % {'form_id': form_id, 'json_dijits': json_dijits}