class CurrentMenuItemNode(Node):
def __init__(self, path, menu_slug, context_var):
self.path = Variable(path)
if menu_slug:
self.menu_slug = Variable(menu_slug)
self.context_var = context_var
def render(self, context):
menu_ids = Menu.objects.all().values_list('id', flat=True)
if getattr(self, 'menu_slug', None):
menu_slug = self.menu_slug.resolve(context)
menu_ids = Menu.objects.filter(slug=menu_slug).values_list(
'id', flat=True,
)
menu_items = MenuItem.objects.filter(
menu__id__in=menu_ids,
)
try:
current_item = menu_items.current_for_path(
self.path.resolve(context)
)
context[self.context_var] = current_item
except:
raise
pass
return ''
class VersionObjectNode(Node):
def __init__(self, src, version_prefix, var_name):
self.var_name = var_name
self.src = Variable(src)
if (version_prefix[0] == version_prefix[-1] and version_prefix[0] in ('"', "'")):
self.version_prefix = version_prefix[1:-1]
else:
self.version_prefix = None
self.version_prefix_var = Variable(version_prefix)
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
try:
version_path = _get_version_path(_url_to_path(source), version_prefix)
if not os.path.isfile(os.path.join(MEDIA_ROOT, version_path)):
# create version
version_path = _version_generator(_url_to_path(source), version_prefix)
elif os.path.getmtime(os.path.join(MEDIA_ROOT, _url_to_path(source))) > os.path.getmtime(os.path.join(MEDIA_ROOT, version_path)):
# recreate version if original image was updated
version_path = _version_generator(_url_to_path(source), version_prefix, force=True)
context[self.var_name] = FileObject(version_path)
except:
context[self.var_name] = ""
return ''
class HasPermNode(Node):
def __init__(self, user, perm, object=None, context_var=None):
self.perm = perm
self.context_var = context_var
self.user = Variable(user)
if object:
self.object = Variable(object)
else:
self.object = object
def render(self, context):
if not self.user and not self.perm:
return False
has_perm = False
user = self.user.resolve(context)
if isinstance(user, User):
# return true for admins
if user.profile.is_superuser:
has_perm = True
else:
if self.object:
object = self.object.resolve(context)
has_perm = utils.has_perm(user, self.perm, object)
else:
has_perm = utils.has_perm(user, self.perm)
if self.context_var:
context[self.context_var] = has_perm
return ''
else:
return has_perm
class ProtocolCounterNode(Node):
"""
Class for protocol_counter template tag
"""
#----------------------------------------------------------------------
def __init__(self, model, team, release, varname):
"""Constructor"""
self.model = get_model(*model.split('.'))
self.varname = varname
self.team = Variable(team)
self.release = Variable(release)
#----------------------------------------------------------------------
def render(self,context):
"""
Render the count from the asset model of choice
"""
try:
team = self.team.resolve(context)
release = self.release.resolve(context)
context[self.varname] = self.model.active.filter(team__exact=team.id,
release__exact=release.id).count()
except template.VariableDoesNotExist:
return ''
return ''
class TagNode(Node):
type = Variable('""')
closed = Variable('""')
def __init__(self, tag, nodelist, title, closed=False, type=None):
self.tag = tag
self.title = Variable(title)
if type:
self.type = Variable(type)
if closed:
self.closed = Variable(closed)
self.nodelist = nodelist
def render(self, context):
inner = self.nodelist.render(context)
t = loader.get_template('issues/core/%s.html' % self.tag)
if self.closed:
self.closed = self.closed.resolve(context)
context = Context({
'title': self.title.resolve(context),
'closed': self.closed,
'type': self.type.resolve(context),
'inner': inner,
})
return t.render(context)
class ImageFromPresetNode(Node):
def __init__(self, path, preset_name, cast_as=None):
self.path = Variable(path)
self.preset_name = Variable(preset_name)
self.cast_as = cast_as
def render(self, context):
try:
preset_name = str(self.preset_name.resolve(context))
path = str(self.path.resolve(context))
if os.path.isabs(path):
source = path
else:
source = os.path.join(settings.MEDIA_ROOT, path)
image = get_cached_image(preset_name, source)
if self.cast_as:
url = u"%s%s%s/%s" % (
settings.MEDIA_URL,
settings.PRESETS_PREFIX,
preset_name,
os.path.basename(image.filename).decode("utf-8"),
)
width, height = image.size
context[self.cast_as] = {"url": url, "width": width, "height": height, "file": image.filename}
return ""
url = u"%s%s/%s" % (settings.PRESETS_PREFIX, preset_name, os.path.basename(image.filename).decode("utf-8"))
return url
except (IOError, OSError), e:
if not settings.FAIL_SILENTLY:
raise e
if self.cast_as:
context[self.cast_as] = ""
return ""
class VersionNode(Node):
def __init__(self, src, version_prefix):
self.src = Variable(src)
if (version_prefix[0] == version_prefix[-1] and version_prefix[0] in ('"', "'")):
self.version_prefix = version_prefix[1:-1]
else:
self.version_prefix = None
self.version_prefix_var = Variable(version_prefix)
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
try:
source = force_unicode(source)
version_path = get_version_path(url_to_path(source), version_prefix)
if not os.path.isfile(smart_str(os.path.join(MEDIA_ROOT, version_path))):
# create version
version_path = version_generator(url_to_path(source), version_prefix)
elif os.path.getmtime(smart_str(os.path.join(MEDIA_ROOT, url_to_path(source)))) > os.path.getmtime(smart_str(os.path.join(MEDIA_ROOT, version_path))):
# recreate version if original image was updated
version_path = version_generator(url_to_path(source), version_prefix, force=True)
return path_to_url(version_path)
except:
return ""
class IsFollowingListNode(Node):
def __init__(self, var1, var2):
self.var1 = Variable(var1)
self.var2 = Variable(var2)
def __repr__(self):
return "<IsFollowingListNode>"
def render(self, context):
try:
val1 = self.var1.resolve(context)
except VariableDoesNotExist:
val1 = None
try:
val2 = self.var2.resolve(context)
except VariableDoesNotExist:
val2 = None
user_1 = get_object_or_404(User, id=val1)
user_2 = get_object_or_404(User, id=val2)
following_2 = isfollowing(user_1,user_2)
if user_1!=user_2:
if not following_2:
html="<a href=\"/follow/"+user_2.username+"?to_do=follow\" id=\"follow\" > <span class=\"follow_icon\"><img src=\"/images/icons/plus.gif\" /></span> follow </a>"
return html
else:
html="<span class=\"grey_bg\">you are already following</span>"
return html
else:
return "yourself"
class PlayerScoreNode(template.Node):
def __init__(self, player_id, game_id, coursehole_id, context_name):
self.player_id = Variable(player_id)
self.game_id = Variable(game_id)
self.coursehole_id = Variable(coursehole_id)
self.context_name = context_name
def render(self, context):
super(PlayerScoreNode, self).render(context)
try:
gamehole = GameHole.objects.get(
game__id=self.game_id.resolve(context),
coursehole__id=self.coursehole_id.resolve(
context),
player__id=self.player_id.resolve(context),
)
context[self.context_name] = gamehole
except GameHole.DoesNotExist:
if self.context_name in context:
del context[self.context_name]
return ''
class Thumbnail(template.Node):
"""
"""
def __init__(self, width, height, uber_wide):
self.width = Variable(width)
self.height = Variable(height)
self.uber_wide = uber_wide
def render(self, context):
w = self.width.resolve(context)
h = self.height.resolve(context)
dw = w
dh = h
context['a'] = [w, h]
max_h = 200.0
max_w = 50.0
if h > max_h:
w = int((max_h/h) * w)
h = int(max_h)
if w > max_w:# and not self.uber_wide:
dh = int((max_w/w) * h)
dw = int(max_w)
context['thumbnail_desired_width'] = dw
context['thumbnail_desired_height'] = dh
context['thumbnail_width'] = w
context['thumbnail_height'] = h
return ""
class LazythumbNode(Node):
usage = 'Expected invocation is {% lazythumb url|ImageFile|Object action geometry as variable %}'
def __init__(self, parser, token):
# simple alias
tse = lambda m: TemplateSyntaxError('lazythumb: %s' % m)
bits = token.contents.split()
try:
_, thing, action, geometry, _, as_var = bits
except ValueError:
raise tse(self.usage)
self.as_var = as_var
if action not in SUPPORTED_ACTIONS:
raise tse('supported actions are %s' % SUPPORTED_ACTIONS)
self.action = action
self.thing = Variable(thing)
self.geometry = Variable(geometry)
self.nodelist = parser.parse(('endlazythumb',))
parser.delete_first_token()
def render(self, context):
thing = self.thing.resolve(context)
action = self.action
geometry = self.geometry.resolve(context)
context.push()
context[self.as_var] = compute_img(thing, action, geometry)
output = self.nodelist.render(context)
context.pop()
return output
class UserCharityDonationsNode(Node):
"""Get all the donations for a user, charity in range."""
def __init__(self, user, charity, day_range, context_var_name):
self.user = Variable(user)
self.charity = Variable(charity)
self.day_range = day_range
self.context_var_name = context_var_name
def render(self, context):
user = self.user.resolve(context)
charity = self.charity.resolve(context)
delta = datetime.now() - timedelta(int(self.day_range))
donations = Donation.objects.filter(
user=user,
charity=charity,
date__gte=delta,
)
total = donations.aggregate(Sum('amount'))['amount__sum']
context[self.context_var_name] = {
'donations': donations,
'total': "%s%s" % (
user.get_profile().currency,
total,
)
}
return ''
class CardNode(template.Node):
def __init__(self, slug, text=None):
self.slug = Variable(slug)
self.text = Variable(text) if text else None
def render(self, context):
slug = self.slug.resolve(context)
try:
card = Card.objects.get(slug=slug)
except Card.DoesNotExist:
card = None
text = ""
if self.text:
text = self.text.resolve(context)
if not text and card:
text = card.name
if not text:
text = "{card: %s}" % slug
if card:
url = card.get_absolute_url()
else:
url = "/admin/cards/card/add/?slug=%s" % slug
title = "Learn more about %s" % text
pos = int(context.get('pos', 0))
if card and card.died and pos > card.died:
dead_class = ' dead'
else:
dead_class = ''
text = text.replace(" ", " ")
return "<a href='%s' class='cardlink%s' title='%s'>%s</a>" % (url, dead_class, title, text)
def render(self, context):
import feedparser
cache_timeout = 300
if 'cache' in self.kwargs:
try:
cache_timeout = Variable(self.kwargs['cache'])
cache_timeout = cache_timeout.resolve(context)
except:
cache_timeout = self.kwargs['cache']
try:
url = Variable(self.url)
url = url.resolve(context)
self.url = url
except:
pass
cache_key = md5(self.url).hexdigest()
url_content = cache.get(cache_key)
if url_content is None:
url_content = feedparser.parse(self.url)
# We are going to try to pop out the errors in the
# feed because they raise an exception that can't be
# pickled when we try to cache the content.
if 'bozo_exception' in url_content:
url_content['bozo_exception'] = ''
cache.set(cache_key, url_content, int(cache_timeout))
context[self.context_var] = url_content
return ''
class VersionObjectNode(Node):
def __init__(self, src, version_prefix, var_name):
self.var_name = var_name
self.src = Variable(src)
if (version_prefix[0] == version_prefix[-1] and version_prefix[0] in ('"', "'")):
self.version_prefix = version_prefix[1:-1]
else:
self.version_prefix = None
self.version_prefix_var = Variable(version_prefix)
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
try:
source = force_unicode(source)
version_path = get_version_path(source, version_prefix)
if not os.path.isfile(version_path):
version_path = version_generator(source, version_prefix)
elif os.path.getmtime(source) > os.path.getmtime(version_path):
version_path = version_generator(source, version_prefix, force=True)
context[self.var_name] = FileObject(version_path)
except:
context[self.var_name] = ""
return ''
class VersionNode(Node):
def __init__(self, src, version_prefix):
self.src = Variable(src)
if (version_prefix[0] == version_prefix[-1] and version_prefix[0] in ('"', "'")):
self.version_prefix = version_prefix[1:-1]
else:
self.version_prefix = None
self.version_prefix_var = Variable(version_prefix)
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
media_root = context.get('media_root', MEDIA_ROOT)
media_url = context.get('media_url', MEDIA_URL)
try:
if isinstance(source, FileObject):
source = source.path
source = force_unicode(source)
version_path = get_version_path(source, version_prefix)
if not os.path.isfile(version_path):
version_path = version_generator(source, version_prefix, media_root=media_root)
elif os.path.getmtime(source) > os.path.getmtime(version_path):
version_path = version_generator(source, version_prefix, force=True, media_root=media_root)
return path_to_url(version_path, media_root=media_root, media_url=media_url)
except:
return ""
class IfInNode(Node):
def __init__(self, nodelist_in, nodelist_not_in, element_var, sequence_var):
self.nodelist_in = nodelist_in
self.nodelist_not_in = nodelist_not_in
self.element_var = Variable(element_var)
self.sequence_var = Variable(sequence_var)
def render(self, context):
try:
element = self.element_var.resolve(context)
sequence = self.sequence_var.resolve(context)
except VariableDoesNotExist:
return self.nodelist_not_in.render(context)
if isinstance(sequence, QuerySet):
# QuerySets are checked at the database level,
# by comparing primary keys
if not hasattr(element, 'pk'):
return self.nodelist_not_in.render(context)
if sequence.filter(pk=element.pk).count() > 0:
return self.nodelist_in.render(context)
else:
return self.nodelist_not_in.render(context)
if (element in sequence):
return self.nodelist_in.render(context)
else:
return self.nodelist_not_in.render(context)
class SectionInfoNode(Node):
def __init__(self, section, current_section=None, counter=0):
self.section = Variable(section)
if current_section is not None:
self.current_section = Variable(current_section)
else:
self.current_section = None
def render(self,context):
rendered_sect = self.section.resolve(context)
if self.current_section is not None:
current_sect = self.current_section.resolve(context)
current_order = current_sect.order
else:
current_order = -1
req = context.get('request')
if req is None:
return "<span class='error'>Called outside of a request context</span>"
user = req.user
if _user_can_view(user,rendered_sect) and rendered_sect.order != current_order:
return """<li>
<a href='%s' title='%s'>%s</a>
</li>""" % ( rendered_sect.get_absolute_url(), rendered_sect.title, truncate(rendered_sect.title,28))
return """<li class="current">
<span title="%s">%s</span>
</li>""" % ( rendered_sect.title, truncate(rendered_sect.title, 28) )
class MDCTNode(Node):
def __init__(self,var_name,fmt_name=settings.DEFAULT_TIME_FORMAT,
tz_var=None):
self.var_name = Variable(var_name)
if tz_var is None:
self.tz_var = None
else:
self.tz_var = Variable(tz_var)
self.fmt_name = fmt_name
def render(self, context):
tz_name = settings.DEFAULT_TZ
if self.tz_var is None:
user = Variable('user').resolve(context)
if user.is_authenticated():
tz_name = user.get_profile().time_zone
else:
tz_name = self.tz_var.resolve(context)
dt = self.var_name.resolve(context)
utc = pytz.timezone('UTC')
tz = pytz.timezone(tz_name)
dt = utc.localize(dt)
dt = dt.astimezone(tz)
return dt.strftime(settings.TIME_FORMATS[self.fmt_name])
class PlayerCourseGraphNode(template.Node):
def __init__(self, player, course):
self.player = Variable(player)
self.course = Variable(course)
def render(self, context):
super(PlayerCourseGraphNode, self).render(context)
player = self.player.resolve(context)
course = self.course.resolve(context)
# Build a data structure for a players games
data = {
'course': course.id,
}
results = []
for game in player.finishedgameplayer_set.filter(
game__course=course).exclude(dnf=True).order_by('game__started'):
results.append({
'score': game.score,
'game': 'Game %i' % (game.game.id),
})
data['results'] = results
return json.dumps(data)
class VersionNode(Node):
def __init__(self, src, version_prefix):
self.src = Variable(src)
if (version_prefix[0] == version_prefix[-1] and version_prefix[0] in ('"', "'")):
self.version_prefix = version_prefix[1:-1]
else:
self.version_prefix = None
self.version_prefix_var = Variable(version_prefix)
def render(self, context):
try:
source = self.src.resolve(context)
except VariableDoesNotExist:
return None
if self.version_prefix:
version_prefix = self.version_prefix
else:
try:
version_prefix = self.version_prefix_var.resolve(context)
except VariableDoesNotExist:
return None
try:
version_path = _get_version_path(str(source), version_prefix)
if not _exists(version_path):
# create version
version_path = _version_generator(str(source), version_prefix)
elif _last_mod(os.path.join(MEDIA_ROOT, _url_to_path(str(source)))) > _last_mod(os.path.join(MEDIA_ROOT, version_path)):
# recreate version if original image was updated
version_path = _version_generator(_url_to_path(str(source)), version_prefix, force=True)
fo = FileObject(version_path)
return fo.url_full
except:
return ""
class FormatQuipQueryNode(Node):
def __init__(self, var1, var2):
self.var1 = Variable(var1)
self.var2 = Variable(var2)
def __repr__(self):
return "<FormatQuipQueryNode>"
def render(self, context):
try:
val1 = self.var1.resolve(context)
except VariableDoesNotExist:
val1 = None
try:
val2 = self.var2.resolve(context)
except VariableDoesNotExist:
val2 = None
query = val1
text = val2
location = string.find(text.upper(),query.upper())
if location>40:
cropped_text = text[location-40:location+40]
text = "..."+cropped_text+"..."
else:
cropped_text = text[:location+40]
text = cropped_text+"..."
replacement = '<span class="highlighter">'+query+'</span>'
data_object = ireplace(text,query,replacement)
return data_object
class ExtendFilesNode(template.Node): def __init__(self, type, id, limit): self.type = Variable(type) self.id = Variable(id) self.limit = limit def render(self, context): try: id = self.id.resolve(context) type = self.type.resolve(context) except VariableDoesNotExist: id = None if type == 'Project': project = Project.objects.get(id = int(id)) if self.limit != None: context['files'] = project.link2project_set.all()[0:int(self.limit)] else: context['files'] = project.link2project_set.all() context['count'] = project.link2project_set.count() if type == 'Battery': battery = Battery.objects.get(id = int(id)) if self.limit != None: context['files'] = battery.link2battery_set.all()[0:int(self.limit)] else: context['files'] = battery.link2battery_set.all() context['count'] = battery.link2battery_set.count() return ''
class YandexMapByAddressNode(Node):
def __init__(self, address, title, wh):
self.address = Variable(address)
self.title = Variable(title)
self.wh = wh
def render(self, context):
if not YANDEXMAPS_API_KEY:
raise TemplateSyntaxError('YANDEXMAPS_API_KEY is undefined in settings.py')
address = self.address.resolve(context)
title = self.title.resolve(context)
ctx = {
'map_width':DEFAULT_WIDTH,
'map_height':DEFAULT_HEIGHT,
"title":title,
"address":address,
"API_KEY":YANDEXMAPS_API_KEY,
"copyright":Site.objects.get_current().domain,
}
if self.wh:
ctx.update({
'map_width':self.wh[0],
'map_height':self.wh[1],
})
t = get_template("yandexmaps/map_by_address.html")
return t.render(Context(ctx))
def render(self, context):
kwargs = {}
try:
kwargs['q'] = self.q.resolve(context)
except:
kwargs['q'] = self.q
try:
kwargs['o'] = self.o.resolve(context)
except:
kwargs['o'] = self.o
try:
kwargs['ot'] = self.ot.resolve(context)
except:
kwargs['ot'] = self.ot
if self.where_field:
try:
wf = Variable(self.where_field)
where_field = wf.resolve(context)
except Exception as e:
where_field = self.where_field
try:
wd = Variable(self.where_id)
where_id = wd.resolve(context)
except Exception as e:
where_id = self.where_id
kwargs['where'] = where_field + '.dummy:' + str(where_id)
cols, rows = forms_get_entries(self.slug, **kwargs)
context[self.columns] = cols
context[self.rows] = rows
return ''
class MetaDataNode(template.Node):
def __init__(self, record, fieldset):
self.record = Variable(record)
self.fieldset = Variable(fieldset) if fieldset else None
def render(self, context):
record = self.record.resolve(context)
fieldvalues = list(record.get_fieldvalues(owner=context['request'].user,
fieldset=self.fieldset.resolve(context) if self.fieldset else None))
if fieldvalues:
fieldvalues[0].subitem = False
for i in range(1, len(fieldvalues)):
fieldvalues[i].subitem = (fieldvalues[i].field == fieldvalues[i - 1].field and
fieldvalues[i].group == fieldvalues[i - 1].group and
fieldvalues[i].resolved_label == fieldvalues[i - 1].resolved_label)
collections = filter_by_access(context['request'].user, record.collection_set.all())
return render_to_string('data_metadata.html',
dict(
values=fieldvalues,
record=record,
collections=collections,
),
context_instance=context)
class NearbyPages(Node):
"""
Takes a paginator and calculates the pages surrounding the current
page number. Useful for creating rich content paginators.
:param paginator: A paginator object from the Template context.
:param page_num: The current page number (int)
:param varname: An optional variable name to use when injecting
the result into the Template context.
"""
def __init__(self, paginator, page_num, varname='nearby_pages'):
self.paginator = Variable(paginator)
self.page_num = Variable(page_num)
self.varname = varname
def render(self, context):
paginator = self.paginator.resolve(context)
page_num = self.page_num.resolve(context)
nearby_pages = [n for n in range(page_num-2, page_num+3) \
if n > 0 and n <= paginator.num_pages]
if len(nearby_pages) < 3:
nearby_pages = None
# Inject variable into template context
context[self.varname] = nearby_pages
return ''
class GamePlayerScoreNode(template.Node):
def __init__(self, game, player):
self.game = Variable(game)
self.player = Variable(player)
def render(self, context):
super(GamePlayerScoreNode, self).render(context)
game = self.game.resolve(context)
player = self.player.resolve(context)
score = 0
# TODO: Should DNF state be handled here ?
# Check if we have FinishedGamePlayer and DNF,
# and return string "DNF"
try:
fgp = FinishedGamePlayer.objects.get(
player=player,
game=game)
if fgp.dnf:
return "DNF"
except FinishedGamePlayer.DoesNotExist:
pass
for gamehole in game.gamehole_set.filter(player=player):
score_hole = gamehole.throws - \
gamehole.coursehole.hole.par
score += score_hole
return score
class MetaDataNode(template.Node):
def __init__(self, record, fieldset):
self.record = Variable(record)
self.fieldset = Variable(fieldset) if fieldset else None
def render(self, context):
record = self.record.resolve(context)
fieldvalues = list(
record.get_fieldvalues(
owner=context["request"].user, fieldset=self.fieldset.resolve(context) if self.fieldset else None
)
)
# ensure only the visible fieldvalues get rendered
fieldvalues = [f for f in fieldvalues if f.field.visible]
if fieldvalues:
fieldvalues[0].subitem = False
for i in range(1, len(fieldvalues)):
fieldvalues[i].subitem = (
fieldvalues[i].field == fieldvalues[i - 1].field
and fieldvalues[i].group == fieldvalues[i - 1].group
and fieldvalues[i].resolved_label == fieldvalues[i - 1].resolved_label
)
return render_to_string("data_metadata.html", dict(values=fieldvalues, record=record), context_instance=context)
class AgencyCountryIndicatorNode(Node):
def __init__(self, agency, country, out_var):
self.agency = Variable(agency)
self.country = Variable(country)
self.out_var = out_var
def render(self, context):
try:
try:
agency = self.agency.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError('"agencycountryindicators" tag got an unknown variable: %r' % self.agency)
try:
country = self.country.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError('"agencycountryindicators" tag got an unknown variable: %r' % self.country)
indicators = calc_agency_country_indicators(agency, country)
for ind in ["2DPa", "4DP", "5DPa", "5DPb"]:
(base_val, base_year, latest_val, latest_year), comments = indicators[ind]
if not base_val in (None, NA_STR) and not latest_val in (None, NA_STR) and base_val != 0:
target_val = (latest_val - base_val) / base_val * 100
indicators[ind] = ((base_val, base_year, latest_val, latest_year, target_val), comments)
(base_val, base_year, latest_val, latest_year), comments = indicators["5DPc"]
if not base_val in (None, NA_STR) and not latest_val in (None, NA_STR) and base_val != 0:
target_val = (1.0 - (latest_val / float(base_val))) * 100
indicators["5DPc"] = ((base_val, base_year, latest_val, latest_year, target_val), comments)
context[self.out_var] = indicators
return ""
except:
traceback.print_exc()
class ImagePreviewNode(Node):
def __init__(self, instance, size, **kwargs):
# set the context var
self.instance = Variable(instance)
self.size = size
self.context = None
# get the context vars
for k, v in kwargs.items():
if k == 'context':
self.context = v
def render(self, context):
instance = self.instance.resolve(context)
app_label = instance._meta.app_label
model = instance._meta.object_name.lower()
url = reverse('image_preview',
args=(app_label, model, instance.id, self.size))
if not url_exists(url):
url = None
if self.context:
context[self.context] = url
else:
context['image_preview'] = url
return ''
class get_story_node(template.Node):
def __init__(self, story, var_name):
self.story = Variable(story)
self.var_name = var_name
def render(self, context):
request = context['request']
s = self.story.resolve(context)
allowed_objects = get_allowed_objects(
request.user, ArticleCategory, 'reader')
mao = get_allowed_objects(
request.user, ArticleCategory, 'manager')
stories = ArticleStory.objects.select_related().filter(
categories__in=allowed_objects, pk=int(s))
if stories:
story = stories[0]
story.current_categories = story.categories.all()
story.current_category = story.current_categories[0]
story.url = reverse('view_story', args=[story.current_category.pk, story.pk, story.slug])
intersect = set(mao).intersection( set([category.pk for category in story.current_categories]))
if intersect:
story.edit__url = reverse('edit_story', args=[story.pk])
context[self.var_name] = story
else:
context[self.var_name] = None
return ''
def navigation(context, nav_id):
"""
Renders the nav and its nav items.
This will call nav_item that will call itself recursively nesting
the subnavs
"""
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
nav_id = Variable(nav_id)
nav_id = nav_id.resolve(context)
except:
pass
try:
filters = get_query_filters(user, 'navs.view_nav')
navs = Nav.objects.filter(filters).filter(id=nav_id)
if user.is_authenticated():
if not user.profile.is_superuser:
navs = navs.distinct()
nav = navs[0]
except:
return None
context.update({
"nav": nav,
"items": nav.top_items,
})
return context
def render(self, context):
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
pk = Variable(self.pk)
pk = pk.resolve(context)
except:
pk = self.pk
try:
filters = get_query_filters(user, 'navs.view_nav')
nav = Nav.objects.filter(filters).filter(pk=pk)
if user.is_authenticated():
if not user.profile.is_superuser:
nav = nav.distinct()
context[self.context_var] = nav[0]
except:
pass
return unicode()
class PublicPhotosNode(Node):
def __init__(self, context_var, user_var=None, use_pool=False):
self.context_var = context_var
if user_var is not None:
self.user_var = Variable(user_var)
else:
self.user_var = None
self.use_pool = use_pool
def render(self, context):
use_pool = self.use_pool
if use_pool:
queryset = Pool.objects.filter(
photo__is_public=True, ).select_related("photo")
else:
queryset = Image.objects.filter(
is_public=True).order_by('-date_added')
if self.user_var is not None:
user = self.user_var.resolve(context)
if use_pool:
queryset = queryset.filter(photo__member=user)
else:
queryset = queryset.filter(member=user)
context[self.context_var] = queryset
return ""
class RelatedNode(Node):
"""
Main related object node that handles multiple template tags:
* **get_related_content**
* **get_related_content_type**
* **get_relation_type**
"""
def __init__(self, obj, var_name, content_type=None, relation_type=None):
self.content_type = content_type
self.relation_type = relation_type
self.obj = Variable(obj)
self.var_name = var_name
def render(self, context):
try:
obj = self.obj.resolve(context)
except VariableDoesNotExist:
return ''
if self.content_type:
items = obj.get_related_content_type(self.content_type)
elif self.relation_type:
items = obj.get_relation_type(self.relation_type)
else:
items = obj.storyrelation_set.all()
context[self.var_name] = items
return ''
class CategoryNode(template.Node):
def __init__(self, nodes, roots):
self.nodes = nodes
self.roots = Variable(roots)
self.tree_query_set = None
def _render_category(self, context, category):
nodes = []
context.push()
for child in category.get_children():
nodes.append(self._render_category(context, child))
context['category'] = category
context['children'] = mark_safe(''.join(nodes))
rendered = self.nodes.render(context)
context.pop()
return rendered
def render(self, context):
roots = self.roots.resolve(context)
nodes = [
self._render_category(context, category) for category in roots
]
return ''.join(nodes)
class WidgetNode(Node):
"""A template tag for rendering a widget with the outer context available.
This is useful for for instance for using floppyforms with
django-sekizai."""
def __init__(self, field):
self.field = Variable(field)
def render(self, context):
field = self.field.resolve(context)
if callable(getattr(field.field.widget, 'get_context', None)):
name = field.html_name
attrs = {'id': field.auto_id}
value = field.value()
widget_ctx = field.field.widget.get_context(name, value, attrs)
template = field.field.widget.template_name
else:
widget_ctx = {'field': field}
template = 'floppyforms/dummy.html'
template = get_template(context, template)
context.update(widget_ctx)
rendered = template.render(context)
context.pop()
return rendered
@classmethod
def parse(cls, parser, tokens):
bits = tokens.split_contents()
if len(bits) != 2:
raise TemplateSyntaxError(
"{% widget %} takes one and only one argument")
field = bits.pop(1)
return cls(field)
class DisplayActivityFollowUrl(Node):
def __init__(self, actor, actor_only=True):
self.actor = Variable(actor)
self.actor_only = actor_only
def render(self, context):
actor_instance = self.actor.resolve(context)
content_type = ContentType.objects.get_for_model(actor_instance).pk
if Follow.objects.is_following(context.get('user'), actor_instance):
return reverse('actstream_unfollow',
kwargs={
'content_type_id': content_type,
'object_id': actor_instance.pk
})
if self.actor_only:
return reverse('actstream_follow',
kwargs={
'content_type_id': content_type,
'object_id': actor_instance.pk
})
return reverse('actstream_follow_all',
kwargs={
'content_type_id': content_type,
'object_id': actor_instance.pk
})
def render(self, context):
file = self.file.resolve(context)
if file and file.pk:
cache_key = generate_image_cache_key(file=str(file.id),
size=self.size,
pre_key=FILE_IMAGE_PRE_KEY,
crop=self.crop,
unique_key=str(file.id),
quality=self.quality,
constrain=self.constrain)
cached_image_url = cache.get(cache_key)
if cached_image_url:
return cached_image_url
args = [file.pk]
if self.size:
try:
size = Variable(self.size)
size = size.resolve(context)
except:
size = self.size
args.append(size)
if self.crop:
args.append("crop")
if self.constrain:
args.append("constrain")
if self.quality:
args.append(self.quality)
url = reverse('file', args=args)
return url
# return the default image url
return static(settings.DEFAULT_IMAGE_URL)
def render(self, context):
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
pk = Variable(self.pk)
pk = pk.resolve(context)
except:
pk = self.pk
try:
filters = get_query_filters(user, 'boxes.view_box')
box = Box.objects.filter(filters).filter(pk=pk)
if user.is_authenticated():
if not user.profile.is_superuser:
box = box.distinct()
context['box'] = box[0]
template = get_template('boxes/edit-link.html')
output = '<div id="box-%s" class="boxes">%s %s</div>' % (
box[0].pk,
box[0].content,
template.render(context),
)
return output
except:
return unicode()
class SlideShow(template.Node):
def __init__(self, images, image_size, rendered_template):
self.images = Variable(images)
self.image_size = image_size
self.rendered_template = rendered_template
def render(self, context):
try:
images = self.images.resolve(context)
except VariableDoesNotExist:
images = None
counter = 1
image_objects = []
for image in images:
image_object = type('ImageObject', (object, ), {})
image_object.image = image
image_object.object = image
image_object.counter = counter
image_object.css_id = 'dynamic_lead_' + str(counter)
counter = counter + 1
image_objects.append(image_object)
rendered_template = render_to_string(self.rendered_template, {'images':image_objects}, context)
return rendered_template
class GetXtdCommentTreeNode(Node):
def __init__(self, obj, var_name, with_feedback):
self.obj = Variable(obj)
self.var_name = var_name
self.with_feedback = with_feedback
def render(self, context):
obj = self.obj.resolve(context)
ctype = ContentType.objects.get_for_model(obj)
flags_qs = CommentFlag.objects.filter(flag__in=[
CommentFlag.SUGGEST_REMOVAL, LIKEDIT_FLAG, DISLIKEDIT_FLAG
]).prefetch_related('user')
prefetch = Prefetch('flags', queryset=flags_qs)
queryset = XtdComment\
.objects\
.prefetch_related(prefetch)\
.filter(
content_type=ctype,
object_pk=obj.pk,
site__pk=get_current_site_id(context.get('request')),
is_public=True
)
dic_list = XtdComment.tree_from_queryset(
queryset, with_feedback=self.with_feedback, user=context['user'])
context[self.var_name] = dic_list
return ''
class IfStartsWithNode(Node):
def __init__(self, string, start_string, nodelist_true, nodelist_false,
negate):
self.start_string, self.string = Variable(start_string), Variable(
string)
self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
self.negate = negate
self.negate = negate
def __repr__(self):
return "<IfStartsWithNode>"
def render(self, context):
try:
string = self.string.resolve(context)
except VariableDoesNotExist:
string = None
try:
start_string = self.start_string.resolve(context)
except VariableDoesNotExist:
start_string = None
if (self.negate and not string.startswith(start_string)) or (
not self.negate and string.startswith(start_string)):
return self.nodelist_true.render(context)
return self.nodelist_false.render(context)
class DynamicLead(template.Node):
def __init__(self, images, image_size, rendered_template):
self.images = Variable(images)
self.image_size = image_size
self.rendered_template = rendered_template
def render(self, context):
try:
images = self.images.resolve(context)
except VariableDoesNotExist:
images = None
counter = 1
image_objects = []
for image in images:
image_object = type('ImageObject', (object, ), {})
image_object.image = image
image_object.object = image
image_object.counter = counter
image_object.css_id = 'dynamic_lead_' + str(counter)
if counter == 1:
image_object.css_class = 'block'
image_object.style = ''
else:
image_object.css_class = 'hidden'
image_object.style = 'display: none;'
counter = counter + 1
image_objects.append(image_object)
rendered_template = render_to_string(self.rendered_template, {'images':image_objects}, context)
return rendered_template
class WidgetNode(Node):
"""A template tag for rendering a widget with the outer context available.
This is useful for for instance for using floppyforms with
django-sekizai."""
def __init__(self, field):
self.field = Variable(field)
def render(self, context):
field = self.field.resolve(context)
renderer = field.form.renderer
try:
field.form.renderer = ExtContextTemplates(renderer, context)
return field.as_widget()
finally:
field.form.renderer = renderer
@classmethod
def parse(cls, parser, tokens):
bits = tokens.split_contents()
if len(bits) != 2:
raise TemplateSyntaxError(
"{% widget %} takes one and only one argument")
field = bits.pop(1)
return cls(field)
class PrintColumnNode(template.Node):
def __init__(self, column, row, controller):
self.column = Variable(column)
self.row = Variable(row)
self.controller = Variable(controller)
def render(self, context):
try:
column = self.column.resolve(context)
row = self.row.resolve(context)
controller = self.controller.resolve(context)
col_data = controller.resolve_column_data(column, row)
return column.print_column(col_data, controller)
except template.VariableDoesNotExist:
return ''
class PhotoImageURL(Node):
def __init__(self, photo, *args, **kwargs):
self.size = kwargs.get("size", "100x100")
self.crop = kwargs.get("crop", False)
self.constrain = kwargs.get("constrain", False)
self.quality = kwargs.get("quality", 90)
self.photo = Variable(photo)
def render(self, context):
photo = self.photo.resolve(context)
# We can't crop and constrain, so we need
# to pick one if both are passed
if self.crop and self.constrain:
self.constrain = False
# return empty unicode string
if not photo.pk:
return static(settings.DEFAULT_IMAGE_URL)
cache_key = generate_image_cache_key(file=str(photo.pk), size=self.size, pre_key="photo", crop=self.crop, unique_key=str(photo.pk), quality=self.quality, constrain=self.constrain)
cached_image_url = cache.get(cache_key)
if cached_image_url:
return cached_image_url
args = [photo.pk, self.size]
if self.crop:
args.append("crop")
if self.constrain:
args.append("constrain")
if self.quality:
args.append(self.quality)
url = reverse('photo.size', args=args)
return url
class MultiBundleNode(template.Node):
"""Node loading a complete bundle by name."""
bundle_type_handlers = {
"javascript": JavascriptNode,
"css": CssNode,
}
def __init__(self, bundle_name_var, **kwargs):
self.bundle_name_var = Variable(bundle_name_var)
for attr_name, attr_value in kwargs.items():
if hasattr(self, attr_name):
setattr(self, attr_name, attr_value)
def render(self, context):
bundle_name = self.bundle_name_var.resolve(context)
bundle = bundler.get_bundles()[bundle_name]
type_handler = self.bundle_type_handlers[bundle.type]
def process_file(file_name):
return type_handler(self.bundle_name_var,
file_name).render(context)
tags = [process_file(file_name) for file_name in bundle.files]
return "\n".join(tags)
class GetCommentBoxPropsNode(Node):
def __init__(self, obj):
self.obj = Variable(obj)
def render(self, context):
obj = self.obj.resolve(context)
form = CommentSecurityForm(obj)
ctype = ContentType.objects.get_for_model(obj)
queryset = XtdComment.objects.filter(content_type=ctype,
object_pk=obj.pk,
site__pk=settings.SITE_ID,
is_public=True)
ctype_slug = "%s-%s" % (ctype.app_label, ctype.model)
d = {
"comment_count": queryset.count(),
"allow_comments": True,
"current_user": "******",
"request_name": False,
"request_email_address": False,
"is_authenticated": False,
"allow_flagging": False,
"allow_feedback": False,
"show_feedback": False,
"can_moderate": False,
"poll_interval": 2000,
"feedback_url": reverse("comments-xtd-api-feedback"),
"delete_url": reverse("comments-delete", args=(0,)),
"reply_url": reverse("comments-xtd-reply", kwargs={'cid': 0}),
"flag_url": reverse("comments-flag", args=(0,)),
"list_url": reverse('comments-xtd-api-list',
kwargs={'content_type': ctype_slug,
'object_pk': obj.id}),
"count_url": reverse('comments-xtd-api-count',
kwargs={'content_type': ctype_slug,
'object_pk': obj.id}),
"send_url": reverse("comments-xtd-api-create"),
"form": {
"content_type": form['content_type'].value(),
"object_pk": form['object_pk'].value(),
"timestamp": form['timestamp'].value(),
"security_hash": form['security_hash'].value()
}
}
user = context.get('user', None)
try:
user_is_authenticated = user.is_authenticated()
except TypeError: # Django >= 1.11
user_is_authenticated = user.is_authenticated
if user and user_is_authenticated:
d['current_user'] = "******" % (
user.pk, settings.COMMENTS_XTD_API_USER_REPR(user))
d['is_authenticated'] = True
d['can_moderate'] = user.has_perm("django_comments.can_moderate")
d['request_name'] = True if not len(user.get_full_name()) else False
d['request_email_address'] = True if not user.email else False
else:
d['login_url'] = "/admin/login/"
d['like_url'] = reverse("comments-xtd-like", args=(0,))
d['dislike_url'] = reverse("comments-xtd-dislike", args=(0,))
return json.dumps(d)
class TaggedGetRelatedNode(Node):
def __init__(self, obj, queryset_or_model, context_var, **kwargs):
self.obj = Variable(obj)
self.queryset_or_model = queryset_or_model
self.context_var = context_var
self.kwargs = kwargs
def render(self, context):
try:
param = get_model(*self.queryset_or_model.split('.'))
except:
param = Variable(self.queryset_or_model).resolve(context)
if param is None:
raise TemplateSyntaxError(
_('tagged_get_related tag was given an invalid input: %s') %
self.queryset_or_model)
objs = list(
TaggedItem.objects.get_related(self.obj.resolve(context), param,
**self.kwargs))
for obj in objs:
if hasattr(obj, 'status'):
if obj.status != 2:
objs.remove(obj)
context[self.context_var] = objs
return ''
class CacheNode(Node):
def __init__(self, nodelist, expire_time_var, fragment_name, vary_on):
self.nodelist = nodelist
self.expire_time_var = Variable(expire_time_var)
self.fragment_name = fragment_name
self.vary_on = vary_on
def render(self, context):
try:
expire_time = self.expire_time_var.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError(
'"cache" tag got an unknkown variable: %r' %
self.expire_time_var.var)
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError(
'"cache" tag got a non-integer timeout value: %r' %
expire_time)
# Build a unicode key for this fragment and all vary-on's.
cache_key = u':'.join(
[self.fragment_name] +
[urlquote(resolve_variable(var, context)) for var in self.vary_on])
value = cache.get(cache_key)
if value is None:
value = self.nodelist.render(context)
cache.set(cache_key, value, expire_time)
return value
class FlowPlayerNode(Node):
"Renderer class for the flowplayer template tag."
def __init__(self, video_url, player_url):
"""
Constructor.
Parameters:
file_url
Video url.
player_url
Flowplayer url.
"""
self.player_url = player_url
self.video_url = Variable(video_url)
def render(self, context):
try:
video_url = self.video_url.resolve(context)
except VariableDoesNotExist:
video_url = self.video_url
t = loader.get_template('videoplayer/flowplayer.html')
code_context = Context(
{
"player_url": self.player_url,
"video_url": video_url,
},
autoescape=context.autoescape)
return t.render(code_context)
class TEYearButton(Node):
DIRECTION_PREVIOUS = 1
DIRECTION_NEXT = 2
def __init__(self, year, direction):
self.direction = direction
self.year_token = Variable(year)
def render(self, context):
year = self.year_token.resolve(context)
if year:
if self.direction == self.DIRECTION_PREVIOUS:
return '<a href="#" onclick="changeYear(%d); return false;" class="left_arrow"></a> ' % (
year)
else:
return ' <a href="#" onclick="changeYear(%d); return false;" class="right_arrow"></a>' % (
year)
else:
return ''
def render(self, context):
self.filter_expression.var.translate = not self.noop
if self.message_context:
self.filter_expression.var.message_context = (
self.message_context.resolve(context))
output = self.filter_expression.resolve(context)
value = render_value_in_context(output, context)
# Restore percent signs. Percent signs in template text are doubled
# so they are not interpreted as string format flags.
is_safe = isinstance(value, SafeData)
value = value.replace('%%', '%')
formatvalues = []
for formatvalue in self.formatvalues:
try:
variable = Variable(formatvalue)
formatvalues.append(variable.resolve(context))
except VariableDoesNotExist:
formatvalues.append(formatvalue)
value = value.format(*formatvalues)
value = mark_safe(value) if is_safe else value
if self.asvar:
context[self.asvar] = value
return ''
else:
return value
class natural_date(template.Node):
def __init__(self, value, var_name):
self.var_name = var_name
self.value = Variable(value)
def render(self, context):
"""
For date values that are tomorrow, today or yesterday compared to
present day returns representing string. Otherwise, returns an empty string.
"""
value = self.value.resolve(context)
try:
value = date(value.year, value.month, value.day)
except AttributeError:
# Passed value wasn't a date object
ret = ''
except ValueError:
# Date arguments out of range
ret = ''
delta = value - date.today()
if delta.days == 0:
ret = 'today'
elif delta.days == 1:
ret = 'tomorrow'
elif delta.days == -1:
ret = 'yesterday'
else:
ret = ''
context[self.var_name] = ret
return ''
class DisplayActionShort(Node):
def __init__(self, action, varname=None):
self.action = Variable(action)
self.varname = varname
def render(self, context):
action_instance = self.action.resolve(context)
try:
action_output = render_to_string(
('activity/%(verb)s/action.html' % {
'verb': action_instance.verb.replace(' ', '_')
}), {
'hide_actor': True,
'action': action_instance
}, context)
except TemplateDoesNotExist:
action_output = render_to_string(('activity/action.html'), {
'hide_actor': True,
'action': action_instance
}, context)
if self.varname is not None:
context[self.varname] = action_output
return ""
else:
return action_output
class ShowIfCachedNode(Node):
def __init__(self, key):
self.key = Variable(key)
def render(self, context):
key = self.key.resolve(context)
return cache.get(key) or ""
class DisplayActionLabel(Node):
def __init__(self, actor, varname=None):
self.actor = Variable(actor)
self.varname = varname
def render(self, context):
actor_instance = self.actor.resolve(context)
try:
user = Variable("request.user").resolve(context)
except:
user = None
try:
if user and user == actor_instance.user:
result = " your "
else:
result = " %s's " % (actor_instance.user.get_full_name()
or actor_instance.user.username)
except ValueError:
result = ""
result += actor_instance.get_label()
if self.varname is not None:
context[self.varname] = result
return ""
else:
return result
class DisplayItemNode(Node):
def __init__(self, item_var):
self.item_var = Variable(item_var)
def render(self, context):
item = self.item_var.resolve(context)
return item.display(context)
