def render(self, context):
try:
place = template.resolve_variable(self.place, context)
except:
return ""
try:
table = template.resolve_variable(self.table, context)
except:
table = self.table
try:
fieldname = template.resolve_variable(self.fieldname, context)
except:
fieldname = self.fieldname
data = get_data_aggregates(
place,
table,
fieldname
)
if (not data) or (not data.has_key(self.aggregate_type)):
return ""
return "%s" % humanize.intcomma(data[self.aggregate_type])
def get_poll_dict(context, slug=None):
user = resolve_variable('user', context)
ip_address = resolve_variable('request.META.REMOTE_ADDR', context)
template_dict = context
template_dict.update({'poll_exists': True, 'already_voted': False, 'user': user, 'not_auth': False})
try:
if slug != None:
poll = get_object_or_404(Poll, slug=slug)
else:
poll = Poll.published_objects.all().latest('pub_date')
if poll == None:
raise Http404
if int(poll.state) != settings.STATE_PUBLISHED:
raise Http404
template_dict.update({'poll': poll})
VoteForm = forms.models.form_for_model(Vote)
#TODO forms.ModelChoiceField(label=u'Choice', required=True, queryset=poll.choice_set.all())
VoteForm.base_fields['choice'].widget = forms.widgets.RadioSelect(choices=((choice.id, choice.choice) for choice in poll.choice_set.all()))
VoteForm.base_fields['choice'].required = True
VoteForm.base_fields['user'].widget = forms.widgets.HiddenInput()
VoteForm.base_fields['user'].initial = user.id
VoteForm.base_fields['ip_address'].widget = forms.widgets.HiddenInput()
VoteForm.base_fields['ip_address'].initial = ip_address
VoteForm.base_fields['poll'].widget = forms.widgets.HiddenInput()
VoteForm.base_fields['poll'].initial = poll.id
VoteForm.base_fields.update({'slug': forms.CharField()})
VoteForm.base_fields['slug'].widget = forms.widgets.HiddenInput()
VoteForm.base_fields['slug'].initial = poll.slug
form = VoteForm()
template_dict.update({'form': form})
if user.is_authenticated() and Vote.objects.filter(poll=poll).filter(user=user):
template_dict.update({'already_voted': True})
except Poll.DoesNotExist:
template_dict.update({'poll_exists': False})
return template_dict
def render(self, context):
page = template.resolve_variable(self.page, context)
language = self.language \
and template.resolve_variable(self.language, context) \
or get_language()
if isinstance(page, int):
try:
page = Page.objects.get(pk=page)
except Page.DoesNotExist:
return self.html and '<a href="#">(none)</a>' or '#'
link = page.get_absolute_url(language)
if self.html:
page_content = page.get_content(language)
extra_class = ''
try:
active_page = template.resolve_variable('page', context)
if active_page == page:
extra_class = ' class="active"'
elif page in active_page.get_path():
extra_class = ' class="active_path"'
except template.VariableDoesNotExist:
pass
return '<a%s href="%s">%s</a>' % (extra_class, link,
escape(page_content and page_content.title
or page.title))
else:
return link
def render(self, context):
if self.object_id_var is not None:
try:
object_id=template.resolve_variable(self.object_id_var, context)
except template.VariableDoesNotExist:
return ''
try:
self.content_type.get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist:
context['display_form_comment'] = False
else:
context['display_form_comment'] = True
else:
context['display_form_comment'] = False
if self.redirect_to != None:
try:
redirect_to=template.resolve_variable(self.redirect_to, context)
except:
redirect_to=self.redirect_to
form = CommentForm({
'content_type': self.content_type.id,
'object_id': object_id,
'redirect': redirect_to,
})
else:
form = CommentForm({
'content_type': self.content_type.id,
'object_id': object_id,
})
context['form_comment']=form
context['form_comment_action']=reverse('comments.views.add')
return ''
def render(self, context):
from_user = template.resolve_variable(self.from_user, context)
to_user = template.resolve_variable(self.to_user, context)
self.status = template.resolve_variable(self.status, context)
if from_user.is_anonymous() or to_user.is_anonymous():
return self.nodelist_false.render(context)
try:
status = RelationshipStatus.objects.by_slug(self.status)
print "*******IfRelationshipNode***********"
print status
except RelationshipStatus.DoesNotExist:
raise template.TemplateSyntaxError('RelationshipStatus not found')
if status.from_slug == self.status:
val = from_user.relationships.exists(to_user, status)
elif status.to_slug == self.status:
val = to_user.relationships.exists(from_user, status)
else:
val = from_user.relationships.exists(to_user, status, symmetrical=True)
print "***** IfRelationshipNode VALUE****"
print val
if val:
return self.nodelist_true.render(context)
return self.nodelist_false.render(context)
def render(self, context):
posts_to_show = cache_expires = None
try:
feed_url = template.resolve_variable(self.feed_url, context)
except:
if settings.DEBUG:
raise
context[self.var_name] = []
return ''
if self.posts_to_show is not None:
try:
posts_to_show = template.resolve_variable(self.posts_to_show,
context)
except template.VariableDoesNotExist:
if settings.DEBUG:
raise
if self.cache_expires is not None:
try:
cache_expires = template.resolve_variable(self.cache_expires,
context)
except template.VariableDoesNotExist:
if settings.DEBUG:
raise
context[self.var_name] = pull_feed(feed_url,
posts_to_show,
cache_expires)
return ''
def render(self, context):
try:
place_type = template.resolve_variable(self.place_type, context)
except:
place_type = self.place_type
try:
slug = template.resolve_variable(self.slug, context)
except:
slug = self.slug
try:
PlaceClass = get_model("places",place_type)
if not PlaceClass:
return ""
place = PlaceClass.objects.get(slug__iexact=slug)
if place_type == 'state':
return '\n<img src="http://chart.apis.google.com/chart?cht=t&chs=400x200&chd=s:_&chtm=usa&chco=BBBBBB,000066,0000FF&chld=%s&chd=t:100">' % (
place.abbr
)
elif place.center:
return '\n<img src="http://maps.google.com/maps/api/staticmap?markers=color:blue|%s,%s¢er=%s,%s&zoom=5&maptype=terrain&size=300x200&key=%s&sensor=false">' % (
place.latitude,
place.longitude,
place.latitude,
place.longitude,
settings.GOOGLE_MAPS_API_KEY
)
else:
return ""
except Exception:
from traceback import print_exc
print_exc()
return ""
def render(self, context):
picks = template.resolve_variable(self.var1, context)
match_id = template.resolve_variable(self.var2, context)
which = template.resolve_variable(self.var3, context)
try:
for p in picks:
if p.match_id == match_id:
if which == "home":
return p.home_score
elif which == "away":
return p.away_score
elif which == "points":
if int(p.points) > 0:
return "<span style='color: green'>+" + str(p.points) + " " + _("pkt") + ".</span>"
else:
return "<span style='color: red'>" + str(p.points) + " " + _("pkt") + ".</span>"
# context['home_pred_score'] = p.home_score
# context['away_pred_score'] = p.away_score
# context['pred_points'] = "+" + str(p.points) + " {% trans 'pkt' %}."
return ""
return ""
except:
return ""
def render(self, context): try: stars = resolve_variable(self.stars, context) except VariableDoesNotExist: try: stars = float(self.stars) except: return "" try: identifier = resolve_variable(self.identifier, context) except VariableDoesNotExist: identifier = self.identifier stars = round(stars * self.rounder) / self.rounder fraction, integer = math.modf(stars) output = [] if self.handler: output.append(DIV_TEMPLATE % identifier) for i in range(self.total_stars): if i<integer: output.append(self.merge_star(i, 1.0, identifier)) elif i==integer and fraction: output.append(self.merge_star(i, fraction, identifier)) else: output.append(self.merge_star(i, 0.0, identifier)) if self.handler: output.append(END_DIV_TEMPLATE) return "".join(output)
def render(self, context):
user = resolve_variable('user', context)
groups = resolve_variable('request.groups', context)
if not user.is_authenticated():
return self.nodelist_false.render(context)
allowed = False
for checkgroup in self.groups:
if checkgroup.startswith('"') and checkgroup.endswith('"'):
checkgroup = checkgroup[1:-1]
if checkgroup.startswith("'") and checkgroup.endswith("'"):
checkgroup = checkgroup[1:-1]
try:
group = Group.objects.get(name=checkgroup)
except Group.DoesNotExist:
break
if group in groups:
allowed = True
break
if allowed:
return self.nodelist_true.render(context)
else:
return self.nodelist_false.render(context)
def render(self, context):
object = resolve_variable(self.object, context)
if isinstance(object, str):
raise TemplateSyntaxError('Given object is string ("%s") of length %d'
% (object, len(object)))
args = []
kwargs = {}
if self.args:
for arg in self.args:
args.append(resolve_variable(arg, context))
if self.kwargs:
for key in self.kwargs:
kwargs[key] = resolve_variable(self.kwargs[key],context)
method = getattr(object, self.method, None)
if method:
if hasattr(method, '__call__'):
result = method(*args, **kwargs)
else:
result = method
if self.context_name:
context[self.context_name] = result
return ''
else:
if not result == None:
return result
else:
return ''
else:
raise TemplateSyntaxError('Model %s doesn\'t have method "%s"'
% (object._meta.object_name, self.method))
def render(self, context):
try:
self.step = int(self.step)
except ValueError:
self.step = int(template.resolve_variable(self.step, context))
try:
self.segment = int(self.segment)
except ValueError:
self.segment = int(template.resolve_variable(self.segment, context))
objects = template.resolve_variable(self.objects_var, context)
page = template.resolve_variable(self.page_var, context)
if not page:
page = 1
page = int(page) - 1
count = len(objects)
pages = math.ceil(float(count) / self.step)
try:
context[self.variable] = objects[page * self.step : (page + 1) * self.step]
context["pagination"] = Pages(self.view, page, pages, self.segment)
except:
pass
return ""
def render(self, context):
from_user = template.resolve_variable(self.from_user, context)
to_user = template.resolve_variable(self.to_user, context)
if from_user.is_anonymous() or to_user.is_anonymous():
return self.nodelist_false.render(context)
try:
status = RelationshipStatus.objects.get(
Q(from_slug=self.status) |
Q(to_slug=self.status) |
Q(symmetrical_slug=self.status))
except RelationshipStatus.DoesNotExist:
raise template.TemplateSyntaxError('RelationshipStatus not found')
if status.from_slug == self.status:
val = from_user.relationships.exists(to_user, status)
elif status.to_slug == self.status:
val = to_user.relationships.exists(from_user, status)
else:
val = from_user.relationships.symmetrical_exists(to_user, status)
if val:
return self.nodelist_true.render(context)
return self.nodelist_false.render(context)
def render(self, context):
if self.unique_id is not None:
unique_id = "?unique_id=%s" % str(resolve_variable(self.unique_id, context))
else:
unique_id = ""
options = {'fileObjName': mark_safe('"Filedata"')}
for key, value in self.options.items():
options[key] = mark_safe(value)
# js_options = options
auto = options.get('auto', False)
data = {
'fileObjName': options['fileObjName'],
'sender': mark_safe(str(resolve_variable(self.sender, context))),
}
for key, value in self.data.items():
data[key] = resolve_variable(value, context)
context.update({
'uploadify_query': unique_id,
'uploadify_data': data,
'uploadify_path': settings.UPLOADIFY_PATH,
'uploadify_version': settings.UPLOADIFY_VERSION,
'uploadify_options': options,
'uploadify_filename': options['fileObjName'],
'uploadify_auto': auto,
})
t = template.loader.get_template('uploadify/multi_file_upload.html')
return t.render(context)
def render(self, context):
try:
val1 = resolve_variable(self.var1, context)
except VariableDoesNotExist:
val1 = None
try:
val2 = resolve_variable(self.var2, context)
except VariableDoesNotExist:
val2 = None
try:
if self.lessthan:
if self.orequal:
if val1 <= val2:
return self.nodelist_true.render(context)
else:
if val1 < val2:
return self.nodelist_true.render(context)
else:
if self.orequal:
if val1 >= val2:
return self.nodelist_true.render(context)
else:
if val1 > val2:
return self.nodelist_true.render(context)
except:
pass
return self.nodelist_false.render(context)
def render(self, context):
user_obj = template.resolve_variable('user', context)
obj = template.resolve_variable(self.objname, context)
if not user_obj.is_authenticated:
user_obj = AnonymousUser()
context[self.varname] = user_obj.has_perm(self.codename, obj)
return ''
def render(self, context):
if self.unique_id is not None:
unique_id = "?unique_id=%s" % str(resolve_variable(self.unique_id, context))
else:
unique_id = ""
options = {'fileDataName': 'Filedata'}
for key, value in self.options.items():
options[key] = resolve_variable(value, context)
js_options = ",".join(map(lambda item: "'%s': '%s'" % (item[0], item[1]),
options.items()))
auto = options.get('auto', False)
data = {
'fileDataName': options['fileDataName'],
'sender': str(resolve_variable(self.sender, context)),
}
for key, value in self.data.items():
data[key] = resolve_variable(value, context)
context.update({
'uploadify_query': unique_id,
'uploadify_data': simplejson.dumps(data)[1:-1],
'uploadify_path': settings.UPLOADIFY_PATH,
'uploadify_version': settings.UPLOADIFY_VERSION,
'uploadify_options': js_options,
'uploadify_filename': options['fileDataName'],
'uploadify_auto': auto,
})
t = template.loader.get_template('uploadify/multi_file_upload.html')
return t.render(context)
def render(self, context):
try:
request = resolve_variable(self.request, context)
except VariableDoesNotExist:
request = None
try:
pagination = resolve_variable(self.pagination, context)
except VariableDoesNotExist:
pagination = None
try:
get_param_name = resolve_variable(self.get_param_name, context)
except VariableDoesNotExist:
get_param_name = None
if(request.GET.has_key(get_param_name)):
current_page = int(request.GET[get_param_name])
else:
current_page = 0;
has_previous = pagination.has_previous(current_page)
has_next = pagination.has_next(current_page)
need_pagination = has_previous or has_next
if need_pagination:
return self.nodelist_true.render(context)
return self.nodelist_false.render(context)
def render(self, context):
location_sysname = template.resolve_variable(
self.location_sysname,
context,
)
template_path = ""
if self.template_path:
template_path = template.resolve_variable(
self.template_path,
context,
)
context.push()
WeatherLog = models.get_model("climate_change", "WeatherLog")
logs = WeatherLog.objects.filter(
location__sysname=location_sysname,
).order_by("-timestamp")
if logs:
context['weather'] = logs[0]
output = loader.render_to_string(
[template_path, "climate_change/current_weather.html"],
context,
)
context.pop()
if self.var_name:
context[self.var_name] = output
return ""
else:
return output
def render(self, context): question_id = template.resolve_variable(self.question_id, context) student_id = template.resolve_variable(self.student_id, context) precision = calc_show_const(question_id, student_id) return str(precision)
def render(self, context):
try:
year_val = resolve_variable(self.year, context)
except VariableDoesNotExist:
year_val = self.year
try:
month_val = resolve_variable(self.month, context)
except VariableDoesNotExist:
month_val = self.month
try:
day_val = resolve_variable(self.day, context)
except VariableDoesNotExist:
day_val = self.day
try:
start_val = resolve_variable(self.startdate, context)
except VariableDoesNotExist:
start_val = self.startdate
try:
end_val = resolve_variable(self.enddate, context)
except VariableDoesNotExist:
end_val = self.enddate
yyyymmdd = "%04d%02d%02d" % (int(year_val), int(month_val),
int(day_val))
start_val = str(start_val)
end_val = str(end_val)
if start_val <= yyyymmdd <= end_val:
return self.nodelist_true.render(context)
else:
return self.nodelist_false.render(context)
def render(self, context):
truncated = template.resolve_variable(self.value, context)
size = int(template.resolve_variable(self.cutoff, context))
if len(truncated) > size and size > 3:
truncated = truncated[0:(size - 3)] + '...'
return truncated
def render(self, context):
result_file = normpath(join(settings.STATIC_ROOT,
resolve_variable(self.result_file, context)))
url = urljoin(settings.STATIC_URL,
resolve_variable(self.result_file, context))
last_write_time = exists(result_file) and gettime(result_file) or '0'
files = resolve_variable(self.files, context).split(',')
fs_files = [normpath(join(settings.STATIC_ROOT, x)) for x in files]
need_regeneration = False
if exists(result_file):
for f in fs_files:
if not exists(f):
raise template.TemplateSyntaxError, "%s file doesn't exists" % f
if last_write_time < gettime(f):
need_regeneration = True
break
else:
need_regeneration = True
if self.ftype in ('js_gclosure', 'js'):
tpl = u'<script type="text/javascript" src="%s"></script>'
else: # this is css
media = self.additional and resolve_variable(self.additional, context) or u'screen'
tpl = u'<link href="%s" rel="stylesheet" type="text/css" media="' + media + '" />'
if need_regeneration:
res = open(result_file, 'w')
if self.ftype == 'js_gclosure':
compress_level = self.additional and \
resolve_variable(self.additional, context) or "SIMPLE_OPTIMIZATIONS"
full_static_path = urljoin(u'http://%s/' %
(context['request'].get_host()), settings.STATIC_URL)
files = ['%s?%s' % (urljoin(full_static_path, x), last_write_time) for x in files]
try:
squeeze.JSMinify_GClosure(compress_level).minify(files, res)
except IOError:
self.ftype = 'js'
if self.ftype == 'js' or self.ftype == 'css':
files = fs_files
src = StringIO()
for f in files:
tmp = open(f, 'rb').read()
src.write(tmp)
src.seek(0)
if self.ftype == 'js':
squeeze.JavascriptMinify().minify(src, res)
else: # this is css
squeeze.CSSMinify().minify(src, res)
res.close()
last_write_time = last_write_time == '0' and gettime(result_file) or last_write_time
return_tag = tpl % ('%s?%s' % (url, last_write_time))
return return_tag
def render(self, context):
try:
user = template.resolve_variable(self.user, context)
object = template.resolve_variable(self.object, context)
except template.VariableDoesNotExist:
return ''
context[self.context_var] = Bookmark.objects.get_for_user(object, user)
return ''
def render(self, context):
try:
user = template.resolve_variable(self.user, context)
objects = template.resolve_variable(self.objects, context)
except template.VariableDoesNotExist:
return ''
context[self.context_var] = Vote.objects.get_for_user_in_bulk(user, objects)
return ''
def render(self, context):
try:
dictionary = template.resolve_variable(self.dictionary, context)
item = template.resolve_variable(self.item, context)
except template.VariableDoesNotExist:
return ''
context[self.context_var] = dictionary.get("%s" % item.id, None)
return ''
def render(self, context):
try:
user = template.resolve_variable(self.user, context)
song = template.resolve_variable(self.song, context)
context['is_favorite'] = song.is_favorite(user)
except:
pass
return ''
def render(self, context):
from_user = template.resolve_variable(self.from_user, context)
to_user = template.resolve_variable(self.to_user, context)
is_following = Relationship.objects.is_following(from_user, to_user)
context[self.varname] = is_following
return ''
def render(self, context):
try:
form = template.resolve_variable(self.form, context)
job = template.resolve_variable(self.job, context)
except template.VariableDoesNotExist:
return u''
context[self.context_var] = form.__getitem__(u'number%s' % job.id)
return u''
def render(self, context):
try:
user = template.resolve_variable(self.user, context)
song = template.resolve_variable(self.song, context)
context['vote_value'] = song.get_vote(user)
except:
pass
return ''
def add_book(request):
context_instance = RequestContext(request)
user = resolve_variable('user', context_instance)
if not settings.ALLOW_PUBLIC_ADD_BOOKS and not user.is_authenticated():
next = reverse('pathagar.books.views.add_book')
return redirect('/accounts/login/?next=%s' % next)
extra_context = {'action': 'add'}
return create_object(
request,
form_class=BookForm,
extra_context=extra_context,
)
def render(self, context):
from django.conf import settings
manager = self.free and FreeComment.objects or Comment.objects
if self.context_var_name is not None:
self.obj_id = template.resolve_variable(self.context_var_name,
context)
comment_count = manager.filter(
object_id__exact=self.obj_id,
content_type__app_label__exact=self.package,
content_type__model__exact=self.module,
site__id__exact=settings.SITE_ID).count()
context[self.var_name] = comment_count
return ''
def render(self, context):
product = resolve_variable(self.product, context)
coupon = resolve_variable(self.coupon, context)
wholesale = resolve_variable(self.wholesale, context)
wholesale = True if wholesale else False
price = product.getCurrentRightPrice('', wholesale, coupon)
if self.display == 'price':
return "AU$" + price
elif self.display == 'comboprice':
if product.productsizeprice_set.all():
return '''<div class="price">AU$<span id='price'>%s</span></div>''' % product.getFirstPrice(
wholesale, coupon)
else:
return '''<div class="price">AU$%s</div>''' % price
else:
if price != product.getNormalPrice(wholesale):
return '''<strike>$AU %s </strike><br/>
<strong class="discounted">$AU %s </strong></a>''' % (
product.getNormalPrice(wholesale), price)
else:
return '''<strong>$AU %s</strong></a>''' % price
def render(self, context):
# Resolve the value; if it's a non-existant variable don't even bother
# checking the values of the cases since they'll never match.
try:
value = template.resolve_variable(self.value, context)
except VariableDoesNotExist:
return ""
# Check each case, and if it matches return the rendered content
# of that case (short-circuit).
for case in self.cases:
if case.equals(value, context):
return case.render(context)
def render(self, context):
title = resolve_variable(self.title, context)
if title.find("'") == -1 and title.find('"') == -1:
try:
title = resolve_variable(self.title, context)
except:
title = ''
else:
title = title.strip("'").strip('"')
title = unicode(title)
url = resolve_variable(self.url, context)
if url.find("'") == -1 and title.find('"') == -1:
try:
url = resolve_variable(self.url, context)
except:
url = None
else:
url = url.strip("'").strip('"')
url = unicode(url)
return create_crumb(title, url)
def render(self, context):
user = User.objects.get(pk=int(template.resolve_variable(self.user, context)))
target_object = self.object_expr.resolve(context)
ctype = ContentType.objects.get_for_model(target_object)
if Like.objects.if_user_like_object(user, target_object.pk, ctype):
context['message'] = _("you Like this")
return self.nodelist_true.render(context)
elif Like.objects.if_user_dislike_object(user, target_object.pk, ctype):
context['message'] = _("you Dislike this")
return self.nodelist_true.render(context)
else:
#raise template.TemplateSyntaxError('RelationshipStatus not found')
return self.nodelist_false.render(context)
def render(self, context):
try:
object = template.resolve_variable(self.object, context)
except template.VariableDoesNotExist:
return ''
if self.news_type:
news = object.related_news_set.filter(news_type=self.news_type)
else:
news = object.related_news_set.all()
context[self.context_var] = news.order_by('-created').reverse()[0:15]
return ''
def render(self, context):
from_user = template.resolve_variable(self.from_user, context)
to_user = template.resolve_variable(self.to_user, context)
if from_user.is_anonymous() or to_user.is_anonymous():
return self.nodelist_false.render(context)
try:
status = RelationshipStatus.objects.by_slug(self.status)
except RelationshipStatus.DoesNotExist:
raise template.TemplateSyntaxError('RelationshipStatus not found')
if status.from_slug == self.status:
val = from_user.relationships.exists(to_user, status)
elif status.to_slug == self.status:
val = to_user.relationships.exists(from_user, status)
else:
val = from_user.relationships.exists(to_user, status, symmetrical=True)
if val:
return self.nodelist_true.render(context)
return self.nodelist_false.render(context)
def render(self, context):
if not (self.title[0] == self.title[-1]
and self.title[0] in ('"', "'")):
self.title = resolve_variable(self.title, context)
else:
self.title = self.title[1:-1]
output = self.nodelist.render(context)
return """<div id="%s" class="sidebar-body">
<div class="sidebar-wrapper">
%s
</div>
</div>
""" % (self.tab_id, output)
def render(self, context):
taxer = _get_taxprocessor(context['request'])
try:
item = template.resolve_variable(self.cartitem, context)
except template.VariableDoesNotExist:
raise template.TemplateSyntaxError("No such variable: %s",
self.cartitem)
total = item.line_total + taxer.by_price(item.product.taxClass,
item.line_total)
if self.currency:
return moneyfmt(total)
return total
def render(self, context):
#br
valid_tags = 'p i strong b u a h1 h2 h3 pre img'.split()
valid_attrs = 'href src'.split()
soup = BeautifulSoup(template.resolve_variable(self.data, context))
for comment in soup.findAll(
text=lambda text: isinstance(text, Comment)):
comment.extract()
for tag in soup.findAll(True):
if tag.name not in valid_tags:
tag.hidden = True
tag.attrs = [(attr, val) for attr, val in tag.attrs
if attr in valid_attrs]
return soup.renderContents().decode('utf8').replace('javascript:', '')
def render(self, context):
discountId = template.resolve_variable(self.tokenString, context)
if discountId:
discountInfo = discount.objects.filter(id=discountId)
discountValue = discountInfo[0].discountValue
else:
discountValue = "None"
#cursor=connection.cursor()
#cursor.execute("""select d.discountValue from groupDiscountService gcs,discount d where gcs.customerGroupId=%s and gcs.discountId=d.id""",[cusGroupId])
#discountValue = cursor.fetchall()
return discountValue
def render(self, context):
taxer = _get_taxprocessor(context['request'])
try:
price = template.resolve_variable(self.price, context)
except template.VariableDoesNotExist:
raise template.TemplateSyntaxError("No such variable: %s",
self.price)
total = price + taxer.by_price(self.taxclass, price)
if self.currency:
return moneyfmt(total)
return total
def render(self, context):
template_value = template.resolve_variable(self.template_value,
context)
t = template.Template(template_value)
context_vars = {}
for d in list(context):
for var, val in d.items():
context_vars[var] = val
result = t.render(
template.RequestContext(context["request"], context_vars))
if self.var_name:
context[self.var_name] = result
return ""
return result
def render(self, context):
obj = None
try:
obj = template.resolve_variable(self.obj, context)
except template.VariableDoesNotExist:
return ''
try:
qs = Comment.objects.for_model(obj.__class__).filter(object_pk=obj.pk)
qs = qs.order_by("-submit_date")[:self.limit]
context[self.varname] = qs
return ''
except:
context[self.context_var] = ''
return ''
def render(self, context):
taxer = _get_taxprocessor(context['request'])
if self.order:
try:
order = template.resolve_variable(self.order, context)
taxer.order = order
except template.VariableDoesNotExist:
pass
pcnt = taxer.get_percent(taxclass=self.taxclass)
if self.digits == 0:
q = Decimal('0')
else:
q = Decimal('0.1')**self.digits
return pcnt.quantize(q)
def render(self, context):
try:
path = template.resolve_variable('path', context)
except template.VariableDoesNotExist:
return ''
if self.level >= 0 and self.level <= len(path):
pages = Page.objects.in_navigation()
if self.level == 0:
pages = pages.filter(parent__isnull=True)
else:
pages = pages.filter(parent=path[self.level - 1])
context[self.varname] = pages
else:
context[self.varname] = None
return ''
def render(self, context):
user = resolve_variable('user', context)
if not user.is_authenticated():
return self.nodelist_false.render(context)
for group in self.group.split("|"):
group = group[1:-1] if group.startswith('"') and group.endswith('"') else group
try:
if Group.objects.get(name=group) in user.groups.all():
return self.nodelist_true.render(context)
except Group.DoesNotExist:
pass
return self.nodelist_false.render(context)
def render(self, context):
try:
field = resolve_variable(self.field, context)
except template.VariableDoesNotExist:
raise template.VariableDoesNotExist, "Variable %s has not been found in the context" % self.field
data_type = field['type']
pt_list = ["values/" + data_type + ".xml", "values/str.xml"]
context['value'] = field['value']
t = select_template(pt_list)
rendered_data = t.render(context)
return rendered_data
def render(self, context):
if self.doctype[0] in ('"', "'"):
doctype = self.doctype[1:-1]
else:
try:
doctype = template.resolve_variable(self.doctype, context)
except template.VariableDoesNotExist:
# Cheeky! Assume that they typed a doctype without quotes
doctype = self.doctype
# Set doctype in the context
context._doctype = doctype
if self.is_silent:
return ''
else:
return doctypes.get(doctype, '')
def render(self, context):
if self.obj.isdigit():
object_id = self.obj
else:
try:
object_id = template.resolve_variable(self.obj, context)
except template.VariableDoesNotExist:
return ''
try:
count = ViewCounter.objects.get(content_type=self.content_type,
object_id=object_id).count
except ViewCounter.DoesNotExist:
count = 0
context[self.var] = count
return ''
def render(self, context):
args = []
kwargs = {}
for t in self.tokens:
try:
args.append(resolve_variable(t,context))
except:
try:
args.append(float(t))
except:
arg = str(t)
if arg.find('=')>-1:
k,v = arg.split('=')[:2]
kwargs[k] = v
else:
args.append(arg)
if len(args) == 1 and type(args[0]) in map(type,[[],()]):
args = args[0]
if self.type in dir(GChartWrapper):
chart = getattr(GChartWrapper,self.type)(args,**kwargs)
elif self.type in GChartWrapper.constants.TYPES:
chart = GChartWrapper.GChart(self.type,args,**kwargs)
else:
raise TypeError('Chart type %s not recognized'%self.type)
imgkwargs = {}
for n in self.nodelist:
rend = n.render(context)
if type(rend) == type([]):
if rend[0] == 'img':
for k,v in map(lambda x: x.split('='), rend[1:]):
imgkwargs[k] = v
continue
if rend[0] == 'axes':
getattr(getattr(chart, rend[0]), rend[1])(*rend[2:])
else:
if isinstance(rend[1], list) or isinstance(rend[1], tuple):
getattr(chart, rend[0])(*rend[1])
else:
getattr(chart, rend[0])(*rend[1:])
if self.mode:
if self.mode == 'img':
return chart.img(**imgkwargs)
elif self.mode == 'url':
return str(chart)
else:
context[self.mode] = chart
else:
return chart.img(**imgkwargs)
def render(self, context):
"""
Create OpensocialInviteUrl and return it
argument:
parser
return value:
opensocial_invite_url
Opensocial Invite URLを生成し、返す
引数
context
返り値
opensocial_invite_url
"""
from django.core.urlresolvers import reverse
args = [arg.resolve(context) for arg in self.args]
kwargs = dict([(smart_str(k,'ascii'), v.resolve(context))
for k, v in self.kwargs.items()])
callback_url = reverse(self.view_name, args=args, kwargs=kwargs, current_app=context.current_app)
if not settings.OPENSOCIAL_DEBUG:
# mixi
if settings.OPENSOCIAL_CONTAINER == 'mixi.jp':
opensocial_invite_url = 'invite:friends?callback=' + urllib.quote(
'http://' + settings.SITE_DOMAIN + callback_url)
# mobage
elif settings.OPENSOCIAL_CONTAINER[-7:] == 'mbga.jp':
opensocial_invite_url = 'invite:friends?guid=ON&url=' + urllib.quote(
'http://' + settings.SITE_DOMAIN + callback_url)
# gree
elif settings.OPENSOCIAL_CONTAINER.endswith(GREE):
opensocial_invite_url = 'invite:friends?callbackurl=' + urllib.quote(
'http://' + settings.SITE_DOMAIN + callback_url)
if self.body:
body = resolve_variable(self.body, context)
from mobilejp.middleware.mobile import get_current_request, get_current_device
device = get_current_device()
if device.is_softbank: # and request.encoding == 'x_utf8_softbank':
body = body.encode('utf-8')
else:
body = body.encode('shift_jis')
opensocial_invite_url += '&body=' + urllib.quote_plus(body)
else:
opensocial_invite_url = callback_url
else:
opensocial_invite_url = callback_url
return opensocial_invite_url
def render(self, context):
# First we ensure we have a user
try:
user_obj = template.resolve_variable(self.user, context)
except template.VariableDoesNotExist:
if self.user == "AnonymousUser" or self.user == "None":
user_obj = AnonymousUser()
else:
raise template.VariableDoesNotExist, "Argument to miniblog_for_user, %s, did not exist" % self.user
if not isinstance(user_obj, (User, AnonymousUser)):
raise template.TemplateSyntaxError(
"Requires a user object, recieved '%s'" % user_obj)
context[self.var_name] = get_visible_announcements(
user_obj, self.limit, self.tl)
return ''
def render(self, context):
relation = template.resolve_variable(self.rel_var, context)
context.push()
if relation.field.rel.edit_inline == models.TABULAR:
bound_related_object_class = TabularBoundRelatedObject
elif relation.field.rel.edit_inline == models.STACKED:
bound_related_object_class = StackedBoundRelatedObject
else:
bound_related_object_class = relation.field.rel.edit_inline
original = context.get('original', None)
bound_related_object = relation.bind(context['form'], original, bound_related_object_class)
context['bound_related_object'] = bound_related_object
t = loader.get_template(bound_related_object.template_name())
output = t.render(context)
context.pop()
return output
def render(self, context):
try:
obj = template.resolve_variable(self.object_name, context)
template_name = '%s.%s.html' % (obj._meta.app_label, obj._meta.module_name)
template_list = [
'%s/%s' % (self.template_dir, template_name),
'%s/default.html' % self.template_dir
]
context['object'] = obj
return render_to_string(template_list, context)
except AttributeError:
if (type(obj) in (int, unicode, str)):
return obj
return ''
except template.VariableDoesNotExist:
return ''
def render (self, context):
for k,v in self.params.items():
try:
self.params[k] = resolve_variable(v, context)
except:
pass
if k == "view":
if v=="satellite":
v = 1
elif v=="map":
v = 0
else:
v = 2
self.params[k] = v
self.params["message"] = self.nodelist.render(context).replace("\n", "<br />")
return BASIC_TEMPLATE % (self.params['name'], self.params['width'], self.params['height'], self.params['name'], self.params['name'], self.params['latitude'], self.params['longitude'], self.params['zoom'], self.params['view'], self.params['message'])
def render(self, context):
user = resolve_variable('user', context)
if not user.is_authenticated():
return self.nodelist_false.render(context)
try:
for group in self.group.split("|"):
if Group.objects.get(name=group) in user.groups.all():
return self.nodelist_true.render(context)
except Group.DoesNotExist:
return self.nodelist_false.render(context)
return self.nodelist_false.render(context)
def render(in_self, context):
resolved_vars = []
for var in in_self.vars_to_resolve:
try:
resolved_vars.append(template.resolve_variable(var, context))
except:
resolved_vars.append(None)
if takes_context:
args = [context] + resolved_vars
else:
args = resolved_vars
in_self._context = context
return in_self.render_given_args(args)
def render(self, context):
taxer = _get_taxprocessor(context['request'])
try:
cart = template.resolve_variable(self.cart, context)
except template.VariableDoesNotExist:
raise template.TemplateSyntaxError("No such variable: %s",
self.cart)
total = Decimal('0.00')
for item in cart:
total += item.line_total + taxer.by_price(item.product.taxClass,
item.line_total)
if self.currency:
return money_format(total)
return total
