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 }))