class Constant(TestTag):
start = ttag.Arg()
to = ttag.ConstantArg()
finish = ttag.Arg()
def output(self, data):
return '%s - %s' % (data['start'], data['finish'])
class DotCombineDefault(DotCombine):
default = ttag.Arg(named=True)
def output(self, data):
args = [
arg and force_text(arg) or data['default'] for arg in data['args']
]
return '.'.join(args)
class Placeholder(ttag.Tag):
"""
Outputs an ``<img>`` tag containing an inline base64 encoded placeholder
image. For example::
{% placeholder 100x30 "some text" %}
The text is optional. Some optional keyword arguments are available which
can be used to adjust the output image:
``background``
The background color of the placeholder image.
``border``
The border color (and also that of the 'x' lines crossing the image).
``text_color``
The color of the text.
``text_size``
The size of the text.
``class``
The HTML class to use for this image tag.
``no_antialias``
Don't antialias the final image.
"""
size = SizeArg()
text = ttag.Arg(required=False)
background = ttag.Arg(keyword=True, required=False)
border = ttag.Arg(keyword=True, required=False)
text_color = ttag.Arg(keyword=True, required=False)
text_size = ttag.IntegerArg(keyword=True, required=False)
class_ = ttag.Arg(keyword=True, required=False)
no_antialias = ttag.BooleanArg()
def clean(self, cleaned_data):
cleaned_data['antialias'] = not cleaned_data.pop('no_antialias', None)
return cleaned_data
def output(self, data):
img = StringIO()
html_class = data.pop('class', None)
create_placeholder(**data).save(img, 'PNG')
img.seek(0)
return mark_safe('<img alt="%s" src="data:image/png;base64,%s" %s/>' %
(data.get('text') or '', img.read().encode('base64'),
html_class and ' class="%s"' % html_class or ''))
class OutputAs(ttag.helpers.AsTag):
value = ttag.Arg()
class Meta:
as_required = False
def as_value(self, data, context):
return data['value']
def as_output(self, data, context):
return 'yes_as'
class GetOrderedRows(ttag.helpers.AsTag, ConfigMixin):
forms_list = ttag.Arg()
def as_value(self, data, context):
rows = []
for form in data['forms_list']:
for bound_field in form:
position = self.get_config('position', data, context,
fields=[bound_field]) or 0
# For now, there's nothing to put more than one field in a row.
rows.append((position, [bound_field]))
rows.sort(key=lambda bits: bits[0], reverse=True)
return [bits[1] for bits in rows]
class Sort(SorterAsTag):
"""
{% sort queryset [with NAME] as VARIABLE %}
{% sort object_list with "objects" as sorted_objects %}
"""
data = ttag.Arg()
with_ = ttag.Arg(named=True,
required=False,
default=settings.SORTER_DEFAULT_QUERY_NAME)
def as_value(self, data, context):
value = data['data']
ordering = self.ordering(context, data['with'])
if ordering:
return value.order_by(*ordering)
return value
def ordering(self, context, name):
"""
Given the template context and the name of the sorting
should return a list of ordering values.
"""
try:
sort_fields = context['request'].GET[name].split(',')
except (KeyError, ValueError, TypeError):
return []
result = []
allowed_criteria = settings.SORTER_ALLOWED_CRITERIA.get(name)
if allowed_criteria is None:
return result
for sort_field in sort_fields:
for criteria in allowed_criteria:
if fnmatch(sort_field.lstrip('-'), criteria):
result.append(sort_field)
return result
class Field(BaseFormTag):
field = ttag.Arg()
class Meta:
default_template = 'forms/fields/base.html'
def get_fields(self, data):
return [data['field']]
def get_extra_context(self, data):
field = data['field']
context = {}
for attr in ('value', 'errors', 'label', 'help_text', 'form', 'field',
'id_for_label', 'name', 'html_name'):
context[attr] = getattr(field, attr)
context['id'] = field.auto_id
return context
class GameboardTag(ttag.Tag):
"""
Tag will ...
Usage:
{% gameboard 'my_game_name' %}
"""
game = ttag.Arg()
def render(self, context):
data = self.resolve(context)
game = data['game']
#game_dir = "/%s%s/" % (settings.ARCADE_URL, game)
url = "%s/%s/game.html" % (settings.ARCADE_PATH, game)
text = open(url, 'rb').read()
t = Template(text)
c = Context({'STATIC_URL': '/static/'})
return t.render(c)
class SortURL(SorterAsTag):
"""
Parses a tag that's supposed to be in this format:
{% sorturl [with NAME] [rel REL] [class CLASS] [as VARIABLE] by ORDER_A1[,ORDER_A2,..] [ORDER_B1[,ORDER_B2,..]] .. %}
{% sorturl with "objects" by "creation_date,-title" %}
"""
__metaclass__ = TemplateAsTagMetaclass
with_ = ttag.Arg(required=False,
named=True,
default=settings.SORTER_DEFAULT_QUERY_NAME)
rel = ttag.Arg(required=False, named=True)
class_ = ttag.Arg(required=False, named=True)
by = ttag.MultiArg(named=True)
class Meta:
as_required = False
template_name = 'sorturl'
name = 'sorturl'
def as_value(self, data, context):
# The queries of the current URL, not using sequences here
# since the order of sorting arguments matter
url = URLObject(context['request'].get_full_path())
queries = url.query.dict
name, orderings = data['with'], data['by']
query = self.find_query(queries.get(name), orderings, orderings[0])
url = url.set_query_param(name, query)
# If this isn't a block tag we probably only want the URL
if not self._meta.block:
return url
label = self.nodelist.render(context)
if not label.strip():
raise TemplateSyntaxError("No label was specified")
parts = []
for part in query.split(','):
part = part.strip()
if part.startswith('-'):
part = part.lstrip('-')
# Translators: Used in title of descending sort fields
text = _("'%(sort_field)s' (desc)")
else:
# Translators: Used in title of ascending sort fields
text = _("'%(sort_field)s' (asc)")
parts.append(text % {'sort_field': part})
# Translators: Used for the link/form input title excluding the sort fields
title = (_('Sort by: %(sort_fields)s') % {
'sort_fields': get_text_list(parts, _('and'))
})
extra_context = dict(data,
title=title,
label=label,
url=url,
query=query)
return render_to_string(self.using(data), extra_context, context)
def find_query(self, wanted, orderings, default):
"""
Given the list of order statements and a query that is currently
found in the request's querystring returns the next in line,
or falls back to the given default.
"""
for current, next in cycle_pairs(orderings):
if current == wanted:
return next
return default
def using(self, data):
"""
This template tag will use 'sorter/sorturl.html' by default,
but uses 'sorter/sorturl_NAME.html' additionally if the
'with' argument is given.
"""
name = data.get('with')
template_names = [self._meta.template_name]
if name and name != settings.SORTER_DEFAULT_QUERY_NAME:
template_names.append(u'%s_%s' % (self._meta.template_name, name))
return [u"sorter/%s.html" % name for name in template_names]
class IncludeCompact(BaseInclude):
template = ttag.Arg()
with_ = ttag.KeywordsArg(named=True, required=False)
class Tag(ttag.Tag):
start = ttag.Arg(positional=True, required=False)
end = ttag.Arg(positional=True)
class IncludeMixed(BaseInclude):
template = ttag.Arg(positional=True)
with_ = ttag.KeywordsArg(required=False, verbose=True)
class BadTag(ttag.helpers.AsTag):
as_ = ttag.Arg(named=True)
class Tag(ttag.Tag):
start = ttag.Arg(required=False)
end = ttag.Arg()
class PositionalMixedkw(TestTag):
value = ttag.Arg(required=False, null=True)
default = ttag.Arg(keyword=True)
def output(self, data):
return six.text_type(data.get('value') or data['default'])
class IncludeCompact(BaseInclude):
template = ttag.Arg(positional=True)
with_ = ttag.KeywordsArg(required=False)
class Ask(SelfReferentialTag):
value = ttag.Arg()
def output(self, data):
if "date" in data['value']:
return datetime.datetime.today()
class IncludeMixed(BaseInclude):
template = ttag.Arg()
with_ = ttag.KeywordsArg(named=True, required=False, verbose=True)
class MapJS(ttag.Tag):
class Meta:
name = 'maps_js'
objects = ttag.Arg()
as_ = ttag.ConstantArg()
prefix = ttag.Arg()
counter = ttag.Arg(required=False)
zoom = ttag.Arg(required=False, keyword=True)
static = ttag.Arg(required=False, keyword=True)
center_on = ttag.Arg(required=False, keyword=True)
cluster = ttag.Arg(required=False, keyword=True)
simple = ttag.Arg(required=False, keyword=True)
width = ttag.Arg(required=False, keyword=True)
height = ttag.Arg(required=False, keyword=True)
enumerate = ttag.Arg(required=False, keyword=True)
def render(self, context):
data = self.resolve(context)
prefix = data.get('prefix', None)
counter = data.get('counter', None)
objects = data.get('objects', None)
zoom = data.get('zoom', None)
static = data.get('static', None) == "true"
center_on = data.get('center_on', None)
cluster = data.get('extra', None) == "true"
simple = data.get('simple', None) == "true"
width = data.get('width', 200)
height = data.get('height', 200)
enumerate = data.get('enumerate', '')
# This should go to cache or use context.render_context
context['request'].session['geotagging_map_counter'] = (
context['request'].session.get('geotagging_map_counter', 0) + 1)
count = context['request'].session['geotagging_map_counter']
if isinstance(objects, PointGeoTag):
coords = objects.get_point_coordinates(as_string=True)
if coords:
latlng = Point(*map(float, coords.split(',')))
markers = latlng and [{
'point': latlng,
'object': objects,
'display': get_display(objects),
'style': objects.get_map_style()
}] or []
else:
markers = []
sets = {'everything': markers}
elif isinstance(objects, models.Model):
latlng = Point(
*map(float,
objects.get_point_coordinates(as_string=True).split(',')))
markers = latlng and [{
'point': latlng,
'display': get_display(objects),
'style': objects.get_map_style()
}] or []
sets = {'everything': markers}
elif isinstance(objects, QuerySet) or isinstance(objects, list):
markers = [{
'point': i.geotagging_point,
'object': i,
'display': get_display(i),
'style': get_style(i)
} for i in objects if i.geotagging_point]
sets = {'everything': markers}
elif isinstance(objects, dict):
sets = {}
for k, v in objects.items():
markers = [{
'point': i.geotagging_point,
'object': i,
'display': get_display(i),
'style': get_style(i)
} for i in v if i.geotagging_point]
sets[k] = markers
else:
raise template.TemplateSyntaxError(
'The first parameter must be either a PointGeoTag subclass, '
'a queryset of PointGeoTag subclasses, '
'a list of PointGeoTag subclases, implement get_point_coordinates '
'or be a LatLong string. '
'A %s was given' % type(objects))
layers = []
for name, markers in sets.items():
for marker in markers:
marker['point'].srid = 4326
# obj = marker['object']
# marker['style']['gt_identifier'] = ('.'.join(("map-"+str(count),
# obj.__class__.__name__,
# str(obj.id))))
layers.append({'name': name, 'items': markers})
#map configuration
template_name = 'geotagging/maps_js.html'
options = {
'static': static,
'center_on': center_on,
'simple': simple,
'width': width,
'height': height,
'enumerate': enumerate
}
#if cluster:
# options.extend({ 'cluster': True,
# 'cluster_display': 'list', })
t = template.loader.get_template(template_name)
map_id = counter and (prefix % counter) or prefix
print map_id
return t.render(
template.RequestContext(context['request'], {
'layers': layers,
'map_id': map_id,
'options': options
}))
