Fixed name method in soc/models/role.py
Patch by: Lennard de Rijk
Reviewed by: to-be-reviewed
#!/usr/bin/python2.5
#
# Copyright 2008 the Melange authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""A Django template tag library containing forms helpers.
"""
__authors__ = [
'"Todd Larsen" <tlarsen@google.com>',
'"Pawel Solyga" <pawel.solyga@gmail.com>',
'"Sverre Rabbelier" <sverre@rabbelier.nl>',
]
import operator
import re
from google.appengine.ext import db
from django import template
from django.forms import forms as forms_in
from django.utils.encoding import force_unicode
from django.utils.html import escape
from soc.logic import dicts
from soc.views.helper import widgets
register = template.Library()
@register.inclusion_tag('soc/templatetags/_field_as_table_row.html')
def field_as_table_row(field):
"""Prints a newforms field as a table row.
This function actually does very little, simply passing the supplied
form field instance in a simple context used by the _field_as_table_row.html
template (which is actually doing all of the work).
See soc/templates/soc/templatetags/_field_as_table_row.html for the CSS
styles used by this template tag.
Usage:
{% load forms_helpers %}
...
<table>
{% field_as_table_row form.fieldname %}
...
</table>
Args:
field: a Django newforms field instance
Returns:
a simple context containing the supplied newforms field instance:
{ 'field': field }
"""
return {'field': field}
@register.inclusion_tag('soc/templatetags/_readonly_field_as_table_row.html')
def readonly_field_as_table_row(field_label, field_value):
"""Prints a field value and it's verbose name as a table row.
This function actually does very little, simply passing the
supplied field_label and field_value in a simple context used by the
_readonly_field_as_table_row.html template (which is actually
doing all of the work).
See soc/templates/soc/templatetags/_readonly_field_as_table_row.html for
the CSS styles used by this template tag.
Usage:
{% load forms_helpers %}
...
<table>
{% readonly_field_as_table_row field_label field_value %}
...
</table>
Args:
field_label: label of the field to render
field_value: value of the field to render
Returns:
a simple context containing the supplied newforms field instance:
{ 'field_label': field_label',
'field_value': field_value'}
"""
return {'field_label': field_label,
'field_value': field_value}
@register.inclusion_tag('soc/templatetags/_readonly_field_as_twoline_table_row.html')
def readonly_field_as_twoline_table_row(field_label, field_value):
"""See readonly_field_as_table_row().
"""
return {'field_label': field_label,
'field_value': field_value}
@register.inclusion_tag(
'soc/templatetags/_readonly_multiline_field_as_table_row.html')
def readonly_multiline_field_as_table_row(field_label, field_value):
"""See readonly_field_as_table_row, but with a different template tag.
"""
return {'field_label': field_label,
'field_value': field_value}
@register.inclusion_tag('soc/templatetags/_as_readonly_table.html',
takes_context=True)
def as_readonly_table(context, form):
"""Outputs a form as a properly formatted html table.
Args:
form: the form that should be converted to a table
"""
# create the bound fields
fields = [forms_in.BoundField(form, field, name) for name, field in
form.fields.items() if field]
return {'fields': fields}
@register.inclusion_tag('soc/templatetags/_as_table.html', takes_context=True)
def as_table(context, form):
"""Outputs a form as a properly formatted html table.
Args:
form: the form that should be converted to a table
"""
return as_table_helper(context, form)
@register.inclusion_tag('soc/templatetags/_as_twoline_table.html',
takes_context=True)
def as_twoline_table(context, form):
"""Outputs a form as a properly formatted html table.
Args:
form: the form that should be converted to a table
"""
return as_table_helper(context, form)
def as_table_helper(context, form):
fields = []
hidden_fields = []
hidden_fields_errors = []
entity = context['entity']
# Iterate over all fields and prepare it for adding
for name, field in form.fields.items():
if not field:
continue
bf = forms_in.BoundField(form, field, name)
attrs = {}
if isinstance(field, widgets.ReferenceField):
attrs = field.rf
# If the field is hidden we display it elsewhere
if not bf.is_hidden:
example_text = ''
group = '0. '
if hasattr(field, 'group'):
group = field.group
if hasattr(field, 'example_text'):
example_text = force_unicode(field.example_text)
item = {
'field': bf,
'required': field.required,
'example_text': example_text,
'group': group,
}
item.update(attrs)
fields.append(item)
else:
hidden_fields.append(unicode(bf))
for e in bf.errors:
item = (name, force_unicode(e))
hidden_fields_errors.append(item)
grouped = dicts.groupby(fields, 'group')
rexp = re.compile(r"\d+. ")
fields = [(rexp.sub('',key), grouped[key]) for key in sorted(grouped)]
context.update({
'top_errors': form.non_field_errors() or '',
'hidden_field_errors': hidden_fields_errors or '',
'groups': fields if fields else '',
'hidden_fields': hidden_fields or '',
})
return context
@register.inclusion_tag('soc/templatetags/_as_table_row.html',
takes_context=True)
def as_table_row(context, item):
"""Outputs a field as a properly formatted html row.
Args:
item: the item that is being rendered
"""
return as_table_row_helper(context, item)
@register.inclusion_tag('soc/templatetags/_as_twoline_table_row.html',
takes_context=True)
def as_twoline_table_row(context, item):
"""See as_table_row().
"""
return as_table_row_helper(context, item)
def as_table_row_helper(context, item):
"""See as_table_row().
"""
field = item['field']
required = item['required']
example_text = item['example_text']
form = context['form']
entity = context['entity']
reference = item.get('reference_url')
filter = item.get('filter')
filter_fields = item.get('filter_fields')
# Escape and cache in local variable.
errors = [force_unicode(escape(error)) for error in field.errors]
if reference:
from soc.views.helper import redirects
params = {
'url_name': reference,
}
if entity:
args = {}
for filter_field, filter_value in filter_fields.iteritems():
args[filter_field] = filter_value
for filter_field in (i for i in filter if hasattr(entity, i)):
args[filter_field] = getattr(entity, filter_field)
if '__scoped__' in filter:
args['scope_path'] = entity.key().name()
params['args'] = '&'.join(['%s=%s' % item for item in args.iteritems()])
select_url = redirects.getSelectRedirect(params)
if field.label:
label = escape(force_unicode(field.label))
# Only add the suffix if the label does not end in punctuation.
if form.label_suffix and (label[-1] not in ':?.!'):
label += form.label_suffix
label = field.label_tag(label) or ''
field_class_type = 'formfield%slabel' % ('error' if errors else '')
help_text = field.help_text
context.update({
'help_text': force_unicode(help_text) if help_text else '',
'field_class_type': field_class_type,
'label': force_unicode(label) if field.label else '',
'field': field,
'field_id': field.auto_id,
'required': required,
'example_text': example_text,
'select_url': select_url if reference else None,
'errors': errors,
})
return context