def render(self, name, value, attrs=None):
attrs.setdefault("class", "cropduster")
media_url = reverse("cropduster-static", kwargs={"path":""})
cropduster_url = reverse("cropduster-upload")
input = super(HiddenInput, self).render(name, value, attrs)
try:
image = CropDusterImage.objects.get(id=value)
except:
image = None
t = loader.get_template(self.template)
c = Context({
"image": image,
"size_set": self.size_set,
"media_url": media_url,
"cropduster_url": cropduster_url,
"input": input,
"attrs": attrs,
})
return t.render(c)
def get_image(image, size_name=None, template_name="image.html", retina=False, **kwargs):
""" Templatetag to get the HTML for an image from a cropduster image object """
if image:
if CROPDUSTER_CROP_ONLOAD:
# If set, will check for thumbnail existence
# if not there, will create the thumb based on predefiend crop/size settings
thumb_path = image.thumbnail_path(size_name)
if not exists(thumb_path) and exists(image.image.path):
try:
size = image.size_set.size_set.get(slug=size_name)
except Size.DoesNotExist:
return ""
try:
image.create_thumbnail(size, force_crop=True)
except:
raven_client.captureException(exc_info=sys.exc_info())
return ""
if retina:
image_url = image.retina_thumbnail_url(size_name)
else:
image_url = image.thumbnail_url(size_name)
if not image_url:
return ""
try:
image_size = IMAGE_SIZE_MAP[(image.size_set_id, size_name)]
except KeyError:
return ""
# Set all the args that get passed to the template
kwargs["image_url"] = image_url
if hasattr(image_size, "auto_size") and image_size.auto_size != AUTO_SIZE:
kwargs["width"] = image_size.width if hasattr(image_size, "width") else ""
kwargs["height"] = image_size.height if hasattr(image_size, "height") else ""
if CROPDUSTER_PLACEHOLDER_MODE:
kwargs["image_url"] = "http://placehold.it/%sx%s" % (kwargs["width"], kwargs["height"])
kwargs["size_name"] = size_name
kwargs["attribution"] = image.attribution
if hasattr(image, "caption"): kwargs["alt"] = image.caption
if "title" not in kwargs: kwargs["title"] = kwargs["alt"]
tmpl = get_template("templatetags/" + template_name)
context = template.Context(kwargs)
return tmpl.render(context)
else:
return ""
def render_js_ad(self,
pos,
template=STANDARD_JS_AD_TEMPLATE,
desc_text="",
omit_noscript=False,
backup_pos=None,
**kwargs):
"""
Renders a DART JS tag to the ad HTML template
"""
if self.template and template == STANDARD_JS_AD_TEMPLATE:
template = self.template
context_vars = {
"js_url": self.js_url(pos, **kwargs),
"link_url": self.link_url(pos, **kwargs),
"image_url": self.image_url(pos, **kwargs),
"tile": self.tile,
"desc_text": desc_text,
"pos": pos,
"omit_noscript": omit_noscript,
"kwargs": kwargs,
}
if backup_pos is not None:
context_vars["backup_link_url"] = self.link_url(
backup_pos, **kwargs)
context_vars["backup_image_url"] = self.image_url(
backup_pos, **kwargs)
t = loader.get_template(template)
c = Context(context_vars)
return t.render(c)
def resolve_template(self, template):
if isinstance(template, (list, tuple)):
return loader.select_template(template)
elif isinstance(template, basestring):
return loader.get_template(template)
else:
return template
def render_js_ad(self, pos, template=STANDARD_JS_AD_TEMPLATE, desc_text="", omit_noscript=False, backup_pos=None, **kwargs):
"""
Renders a DART JS tag to the ad HTML template
"""
if self.template and template == STANDARD_JS_AD_TEMPLATE: template = self.template
context_vars = {
"js_url": self.js_url(pos, **kwargs),
"link_url": self.link_url(pos, **kwargs),
"image_url": self.image_url(pos, **kwargs),
"tile": self.tile,
"desc_text": desc_text,
"pos": pos,
"omit_noscript": omit_noscript,
"kwargs": kwargs,
}
if backup_pos is not None:
context_vars["backup_link_url"] = self.link_url(backup_pos, **kwargs)
context_vars["backup_image_url"] = self.image_url(backup_pos, **kwargs)
t = loader.get_template(template)
c = Context(context_vars)
return t.render(c)
def render_fatpage(request, f):
"""
Internal interface to the fat page view.
"""
# If registration is required for accessing this page, and the user isn't
# logged in, redirect to the login page.
if f.registration_required and not request.user.is_authenticated():
from django.contrib.auth.views import redirect_to_login
return redirect_to_login(request.path)
if f.template_name:
t = loader.select_template((f.template_name, DEFAULT_TEMPLATE))
else:
t = loader.get_template(DEFAULT_TEMPLATE)
# To avoid having to always use the "|safe" filter in fatpage templates,
# mark the title and content as already safe (since they are raw HTML
# content in the first place).
f.title = mark_safe(f.title)
f.content = mark_safe(f.content)
c = RequestContext(request, {
'fatpage': f,
})
response = HttpResponse(t.render(c))
populate_xheaders(request, response, FatPage, f.id)
return response
def render_custom_ad(self,
pos,
custom_ad,
template=STANDARD_CUSTOM_AD_TEMPLATE,
text_version=False,
desc_text="",
omit_noscript=False,
**kwargs):
""" Renders the custom ad, determining which template to use based on custom ad settings """
if self.template:
template = self.template
if text_version:
return custom_ad.text_version
elif custom_ad.embed:
return custom_ad.embed
elif custom_ad.url:
t = loader.get_template(template)
c = Context({
"pos": pos,
"link_url": custom_ad.url,
"image": custom_ad.image,
"desc_text": desc_text,
"omit_noscript": omit_noscript,
})
return t.render(c)
else:
return ""
def render_iframe_ad(self,
pos,
template=STANDARD_IFRAME_AD_TEMPLATE,
desc_text="",
omit_noscript=False,
**kwargs):
"""
Renders a DART Iframe tag to the ad HTML template
"""
if self.template:
template = self.template
width, height = self.dimensions(kwargs["size"])
context_vars = {
"iframe_url": self.iframe_url(pos, **kwargs),
"desc_text": desc_text,
"width": width,
"height": height,
"pos": pos,
"kwargs": kwargs,
}
t = loader.get_template(template)
c = Context(context_vars)
return t.render(c)
def load_template(self, template_name, template_dirs=None):
if self.is_enabled(template_name):
try:
template = get_template(template_name)
except TemplateNotFound:
raise TemplateDoesNotExist(template_name)
return template, template.filename
else:
return get_django_template(template_name, template_dirs)
def load_template(self, template_name, template_dirs=None):
if template_dirs is not None:
raise NotImplementedError('template dirs is ignored now')
if self.is_enabled(template_name):
try:
template = get_template(template_name)
except TemplateNotFound:
raise TemplateDoesNotExist(template_name)
return template, template.filename
else:
return get_django_template(template_name, template_dirs)
def render_to_response(self, context, template_name=None):
"""like a django's shortcut, except will use
template_name from self, if `template_name` is not given.
Also, response is packaged as json with an html fragment
for the pjax consumption
"""
if template_name is None:
template_name = self.template_name
template = get_template(template_name)
html = template.render(context)
json = simplejson.dumps({'html': html, 'success': True})
return HttpResponse(json, mimetype='application/json')
def load_template(self, template_name, template_dirs=None):
""" the main method: load a template using jinja2 if needed, otherwise
fallback on default django loaders.
"""
if self.is_enabled(template_name):
try:
template = get_template(template_name)
except TemplateNotFound:
raise TemplateDoesNotExist(template_name)
return template, template.filename
else:
return self.get_django_template(template_name, template_dirs)
def render_to_response(self, context, template_name=None):
"""like a django's shortcut, except will use
template_name from self, if `template_name` is not given.
Also, response is packaged as json with an html fragment
for the pjax consumption
"""
if template_name is None:
template_name = self.template_name
template = get_template(template_name)
html = template.render(context)
json = simplejson.dumps({'html': html, 'success': True})
return HttpResponse(json, mimetype='application/json')
def _render_custom_ad(self, pos, custom_ad, text_version=False, desc_text="", **kwargs):
if text_version:
return custom_ad.text_version
elif custom_ad.embed:
return custom_ad.embed
else :
t = loader.get_template("dart/embed.html")
c = Context({
"pos": pos,
"link": custom_ad.url,
"image": custom_ad.image,
"desc_text": desc_text
})
return t.render(c)
def load_template(self, template_name, template_dirs=None):
# Render packages apps with django system
pos = template_name.find('/')
folder = pos and template_name[0:pos] or None
if folder in ('admin', 'debug_toolbar', 'rest_framework', ):
return super(LoaderMixin, self).load_template(template_name, template_dirs)
# Render through Jinja
try:
template = get_template(template_name)
except jinja2.TemplateNotFound, e:
if settings.DEBUG:
print "Jinja loader failed: %s" % str(e)
raise TemplateDoesNotExist(template_name)
def get_template_source(template_name, response_format='html'):
"Returns source of the template file"
if not response_format or 'pdf' in response_format or not response_format in settings.HARDTREE_RESPONSE_FORMATS:
response_format = 'html'
if not ("." + response_format) in template_name:
template_name += "." + response_format
template_name = response_format + "/" + template_name
t = loader.get_template(template_name)
f = open(t.filename, 'r')
return f.read()
def get_template_source(template_name, response_format='html'):
"Returns source of the template file"
if not response_format or 'pdf' in response_format or not response_format in settings.HARDTREE_RESPONSE_FORMATS:
response_format = 'html'
if not ("." + response_format) in template_name:
template_name += "." + response_format
template_name = response_format + "/" + template_name
t = loader.get_template(template_name)
f = open(t.filename, 'r')
return f.read()
def _render_js_ad(self, pos, size="0x0", template="dart/ad.html", desc_text="", **kwargs):
self.attributes["pos"] = pos
self.attributes["sz"] = size
link = self.get_link(**kwargs)
context_vars = {
"pos": pos,
"link": link,
"tile": self.tile(),
"desc_text": desc_text
}
context_vars.update(kwargs)
t = loader.get_template(template)
c = Context(context_vars)
return t.render(c)
def load_template(self, template_name, template_dirs=None):
# Render packages apps with django system
pos = template_name.find('/')
folder = pos and template_name[0:pos] or None
if folder in (
'admin',
'debug_toolbar',
'rest_framework',
):
return super(LoaderMixin,
self).load_template(template_name, template_dirs)
# Render through Jinja
try:
template = get_template(template_name)
except jinja2.TemplateNotFound, e:
if settings.DEBUG:
print "Jinja loader failed: %s" % str(e)
raise TemplateDoesNotExist(template_name)
class Loader(BaseLoader):
"""
A template loader to be used
"""
is_usable = True
def load_template(self, template_name, template_dirs=None):
if template_dirs is not None:
raise NotImplementedError('template dirs is ignored now')
try:
if template_name.split('/', 1)[0] in settings.JINJA2_DISABLED_APPS:
return get_django_template(template_name, template_dirs)
except IndexError, AttributeError:
pass
try:
template = get_template(template_name)
except TemplateNotFound:
raise TemplateDoesNotExist(template_name)
return template, template.filename
def render_iframe_ad(self, pos, template=STANDARD_IFRAME_AD_TEMPLATE, desc_text="", omit_noscript=False, **kwargs):
"""
Renders a DART Iframe tag to the ad HTML template
"""
if self.template: template = self.template
width, height = self.dimensions(kwargs["size"])
context_vars = {
"iframe_url": self.iframe_url(pos, **kwargs),
"desc_text": desc_text,
"width": width,
"height": height,
"pos": pos,
"kwargs": kwargs,
}
t = loader.get_template(template)
c = Context(context_vars)
return t.render(c)
def multilingual_flatpage(request, url):
"""
Multilingual flat page view.
Models: `multilingual.flatpages.models`
Templates: Uses the template defined by the ``template_name`` field,
or `flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.endswith('/') and settings.APPEND_SLASH:
return HttpResponseRedirect("%s/" % request.path)
if not url.startswith('/'):
url = "/" + url
f = get_object_or_404(MultilingualFlatPage, url__exact=url, sites__id__exact=settings.SITE_ID)
# If registration is required for accessing this page, and the user isn't
# logged in, redirect to the login page.
if f.registration_required and not request.user.is_authenticated():
from django.contrib.auth.views import redirect_to_login
return redirect_to_login(request.path)
# Serve the content in the language defined by the Django translation module
# if possible else serve the default language.
f._default_language = get_language()
if f.template_name:
t = loader.select_template((f.template_name, DEFAULT_TEMPLATE))
else:
t = loader.get_template(DEFAULT_TEMPLATE)
# To avoid having to always use the "|safe" filter in flatpage templates,
# mark the title and content as already safe (since they are raw HTML
# content in the first place).
f.title = mark_safe(f.title)
f.content = mark_safe(f.content)
c = RequestContext(request, {
'flatpage': f,
})
response = HttpResponse(t.render(c))
populate_xheaders(request, response, MultilingualFlatPage, f.id)
return response
def flatpage(request, url):
"""
Flat page view.
Models: `flatpages.flatpages`
Templates: Uses the template defined by the ``template_name`` field,
or `flatpages/default.html` if template_name is not defined.
Context:
flatpage
`flatpages.flatpages` object
"""
if not url.endswith('/') and settings.APPEND_SLASH:
return HttpResponseRedirect("%s/" % request.path)
if not url.startswith('/'):
url = "/" + url
f = get_object_or_404(FlatPage,
url__exact=url,
sites__id__exact=settings.SITE_ID)
# If registration is required for accessing this page, and the user isn't
# logged in, redirect to the login page.
if f.registration_required and not request.user.is_authenticated():
from django.contrib.auth.views import redirect_to_login
return redirect_to_login(request.path)
if f.template_name:
t = loader.select_template((f.template_name, DEFAULT_TEMPLATE))
else:
t = loader.get_template(DEFAULT_TEMPLATE)
# To avoid having to always use the "|safe" filter in flatpage templates,
# mark the title and content as already safe (since they are raw HTML
# content in the first place).
f.title = mark_safe(f.title)
f.content = mark_safe(f.content)
c = RequestContext(request, {
'flatpage': f,
})
response = HttpResponse(t.render(c))
populate_xheaders(request, response, FlatPage, f.id)
return response
def render_custom_ad(self, pos, custom_ad, template=STANDARD_CUSTOM_AD_TEMPLATE, text_version=False, desc_text="", omit_noscript=False, **kwargs):
""" Renders the custom ad, determining which template to use based on custom ad settings """
if self.template: template = self.template
if text_version:
return custom_ad.text_version
elif custom_ad.embed:
return custom_ad.embed
elif custom_ad.url:
t = loader.get_template(template)
c = Context({
"pos": pos,
"link_url": custom_ad.url,
"image": custom_ad.image,
"desc_text": desc_text,
"omit_noscript": omit_noscript,
})
return t.render(c)
else:
return ""
def get_image(image, size_name="large", template_name="image.html", width=None, height=None, **kwargs):
if image:
image_url = image.thumbnail_url(size_name)
if image_url is None or image_url == "":
return ""
try:
image_size = image_size_map[(image.size_set_id,size_name)]
except KeyError:
return ""
kwargs["image_url"] = image_url
kwargs["width"] = width or image_size.width or ""
kwargs["height"] = height or image_size.height or ""
if hasattr(settings, "CROPDUSTER_KITTY_MODE") and settings.CROPDUSTER_KITTY_MODE:
kwargs["image_url"] = "http://placekitten.com/{0}/{1}".format(kwargs["width"], kwargs["height"])
kwargs["size_name"] = size_name
kwargs["attribution"] = image.attribution
kwargs["alt"] = kwargs["alt"] if "alt" in kwargs else image.caption
kwargs["title"] = kwargs["title"] if "title" in kwargs else kwargs["alt"]
tpl = get_template("templatetags/" + template_name)
ctx = template.Context(kwargs)
return tpl.render(ctx)
else:
return ""
def render_placeholder(self, ad=None, size=(), pos=None, **kwargs):
"""
Renders an image placeholder to test ad placements
"""
if not ad and not size and not pos:
return ""
elif ad:
size = ad.position.size_list[0]
slug = ad.position.slug
elif size and pos:
slug = pos
size = self.dimensions(size)
context_vars = {
"js_url": self.js_url(slug, **kwargs),
"pos": slug,
"width": size[0],
"height": size[1],
"kwargs": kwargs,
}
t = loader.get_template(DART_PLACEHOLDER_TEMPLATE)
c = Context(context_vars)
return t.render(c)
def render(self, name, value, attrs=None):
attrs.setdefault("class", "cropduster")
cropduster_url = reverse("cropduster-upload")
input = super(HiddenInput, self).render(name, value, attrs)
image = None
if value:
try:
image = CropDusterImage.objects.get(id=value)
except CropDusterImage.DoesNotExist:
pass
template = loader.get_template(self.template)
context = Context({
"image": image,
"size_set": self.size_set,
"static_url": settings.STATIC_URL,
"cropduster_url": cropduster_url,
"input": input,
"attrs": attrs,
})
return template.render(context)
def render_placeholder(self, ad=None, size=(), pos=None, **kwargs):
"""
Renders an image placeholder to test ad placements
"""
if not ad and not size and not pos:
return ""
elif ad:
size = ad.position.size_list[0]
slug = ad.position.slug
elif size and pos:
slug = pos
size = self.dimensions(size)
context_vars = {
"js_url": self.js_url(slug, **kwargs),
"pos": slug,
"width": size[0],
"height": size[1],
"kwargs": kwargs,
}
t = loader.get_template(DART_PLACEHOLDER_TEMPLATE)
c = Context(context_vars)
return t.render(c)
def render(self, name, value, attrs=None):
attrs.setdefault("class", "cropduster")
cropduster_url = reverse("cropduster-upload")
input = super(HiddenInput, self).render(name, value, attrs)
image = None
if value:
try:
image = CropDusterImage.objects.get(id=value)
except CropDusterImage.DoesNotExist:
pass
template = loader.get_template(self.template)
context = Context({
"image": image,
"size_set": self.size_set,
"static_url": settings.STATIC_URL,
"cropduster_url": cropduster_url,
"input": input,
"attrs": attrs,
})
return template.render(context)
def omniture_embed(omniture):
dict = {"omniture": omniture}
ctx = Context(dict)
return get_template('embed.html').render(ctx)
