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_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 _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 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 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 omniture_embed(omniture): dict = {"omniture": omniture} ctx = Context(dict) return get_template('embed.html').render(ctx)