Example #1
0
def gallery_detail(request, gallery_slug, is_xml=False, is_flash=False):
    """
    Gallery detail page

    Templates: `media/gallery_detail`
    Context:
        gallery:
            `media.galleries` object
        photo_list:
            list of `media.galleryphotos` in the gallery
    """
    try:
        gal = Gallery.on_site.get(slug__exact=gallery_slug)
    except Gallery.DoesNotExist:
        raise Http404
    if is_xml:
        t = loader.select_template(["media/gallery_xml_%s_detail.html" % gal.template_prefix, "media/gallery_xml_detail.html"])
    elif is_flash:
        t = loader.select_template(["media/gallery_flash_%s_detail.html" % gal.template_prefix, "media/gallery_flash_detail.html"])
    else:
        t = loader.select_template(["media/gallery_%s_detail.html" % gal.template_prefix, "media/gallery_detail.html"])
    c = Context(request, {
        'gallery': gal,
        'photo_list': gal.galleryphoto_set.all(),
    })
    response = HttpResponse(t.render(c))
    populate_xheaders(request, response, 'media', Gallery, gal.id)
    return response
Example #2
0
    def get_templates(self, action):
        """
        Return a subject, text, HTML tuple with e-mail templates for
        a particular action. Returns a tuple with subject, text and e-mail
        template.
        """

        assert action in ACTIONS + ("message",), "Unknown action: %s" % action

        # Common substitutions for filenames
        tpl_subst = {"action": action, "newsletter": self.slug}

        # Common root path for all the templates
        tpl_root = "newsletter/message/"

        subject_template = select_template(
            [
                tpl_root + "%(newsletter)s/%(action)s_subject.txt" % tpl_subst,
                tpl_root + "%(action)s_subject.txt" % tpl_subst,
            ]
        )

        text_template = select_template(
            [tpl_root + "%(newsletter)s/%(action)s.txt" % tpl_subst, tpl_root + "%(action)s.txt" % tpl_subst]
        )

        if self.send_html:
            html_template = select_template(
                [tpl_root + "%(newsletter)s/%(action)s.html" % tpl_subst, tpl_root + "%(action)s.html" % tpl_subst]
            )
        else:
            # HTML templates are not required
            html_template = None

        return (subject_template, text_template, html_template)
Example #3
0
def gallery_set_detail(request, slug, is_xml=None, is_flash=None):
    try:
        set = GallerySet.on_site.get(slug=slug)
    except GallerySet.DoesNotExist:
        raise Http404
    pag = paginator.ObjectPaginator(set.gallery_set.all(), 20)
    try:
        page_number = int(request.GET.get('page', 1)) - 1
    except ValueError:
        page_number = 0
    try:
        gallery_list = pag.get_page(page_number)
    except paginator.InvalidPage:
        raise Http404
    if is_xml:
        t = loader.select_template(["%s_xml" % set.template_name, 'media/galleryset_xml_detail.html'])
    elif is_flash:
        t = loader.select_template(["%s_flash" % set.template_name, 'media/galleryset_flash_detail.html'])
    else:
        t = loader.select_template([set.template_name, 'media/galleryset_detail.html'])
    c = Context(request, {
        'object': set,
        'gallery_list': gallery_list,
        'has_next_page': pag.has_next_page(page_number),
        'has_previous_page': pag.has_previous_page(page_number),
        'pages': pag.pages,
        'next_page': page_number + 2,
        'previous_page': page_number,
    })
    response = HttpResponse(t.render(c))
    populate_xheaders(request, response, 'media', GallerySet, set.id)
    return response
Example #4
0
def delete_account(request):
    context = {}
    if request.method == 'POST':
        confirma = request.POST.get('borrar', False)
        if confirma:
            try:
                token = str(uuid4())
                user = request.user
                cache.set(token, user.username,
                          timeout=settings.USER_DELETION_TTL)
                emails = ['registration/default/delete_email_subject.txt',
                          'registration/default/delete_email_subject.txt']
                subject = render_to_string(select_template(emails).name,
                                           {'site': settings.SITE_URL})
                delete_url = 'accounts:registration-confirm-deletion'
                mail_vars = {'site': settings.SITE_URL,
                             'path': reverse(delete_url, args=[token])}
                emails = ['registration/default/delete_email.html',
                          'registration/default/delete_email.html']
                html_content = render_to_string(select_template(emails).name,
                                                mail_vars)
                msg = EmailMessage(subject.strip("\n"), html_content,
                                   settings.DEFAULT_FROM_EMAIL, [user.email])
                # Main content is now text/html
                msg.content_subtype = "html"
                msg.send()
                mensaje = _(u'Te enviamos instrucciones para completar el cierre de tu cuenta.')
                messages.success(request, mensaje)
                auth_logout(request)
            except Exception as e:
                logger.error("Obtained error {e}".format(e=e.message))
            return render(request, 'accounts/delete_account_success.html',
                          context)
    return render(request, 'accounts/delete_account.html', context)
Example #5
0
    def get_templates(self, action, lang='pl'):
        """
        Return a subject, text, HTML tuple with e-mail templates for
        a particular action. Returns a tuple with subject, text and e-mail
        template.
        """

        # Common substitutions for filenames
        template_subst = {
            'action': action,
            'newsletter': self.slug
            }

        assert action in [
            'subscribe', 'unsubscribe', 'update', 'message'
        ], 'Unknown action %s' % action

        # Common root path for all the templates
        template_root = 'newsletter/message/'
        # activate current translation for the message
        translation.activate(lang)

        subject_template = select_template([
            template_root + '%(newsletter)s/%(action)s_subject.txt' % template_subst,
            template_root + '%(action)s_subject.txt' % template_subst,
        ])

        text_template = select_template([
            template_root + '%(newsletter)s/%(action)s.txt' % template_subst,
            template_root + '%(action)s.txt' % template_subst,
        ])

        html_template = self.get_html_template()

        return (subject_template, text_template, html_template)
Example #6
0
 def send_confirmation(self, obj, email_address, additional_context=None,
         subject_template_path=None, body_template_path=None):
     confirmation_key = generate_key()
     current_site = Site.objects.get_current()
     activate_url = generate_activation_url(confirmation_key)
     context = Context({
         'activate_url': activate_url,
         'current_site': current_site,
         'confirmation_key': confirmation_key,
         'target': obj,
         'days': getattr(settings, 'EMAIL_CONFIRMATION_DAYS', 10),
     })
     if additional_context is not None:
         context.update(additional_context)
     templates = [
         'confirmation/%s_confirmation_email_subject.txt' % obj._meta.model_name,
         'confirmation/confirmation_email_subject.txt',
     ]
     if subject_template_path:
         template = loader.get_template(subject_template_path)
     else:
         template = loader.select_template(templates)
     subject = template.render(context).strip().replace(u'\n', u' ') # no newlines, please
     templates = [
         'confirmation/%s_confirmation_email_body.txt' % obj._meta.model_name,
         'confirmation/confirmation_email_body.txt',
     ]
     if body_template_path:
         template = loader.get_template(body_template_path)
     else:
         template = loader.select_template(templates)
     body = template.render(context)
     send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [email_address])
     return self.create(content_object=obj, date_sent=now(), confirmation_key=confirmation_key)
Example #7
0
File: base.py Project: hylje/Lyra
    def get_response(self, request, context={}, template=None,
                     denominator=None, extend_template=None,
                     template_select=None):

        if extend_template is None:
            extend_templates = [getattr(self, "base_template", "base")]
        else:
            extend_templates = [extend_template]

        if (request.is_ajax() 
            or (settings.DEBUG and "_lyra_ajax" in request.GET)):
            extend_templates.insert(0, "ajax_base")

        if template and template_select is None:
            template_select = [template]
        elif template_select is None:
            raise ValueError("provide one of template or "
                             "template_select, not both or neither")
        
        tpl = loader.select_template(
            self.get_template_names(template_select, denominator))

        base_context = dict(
            self.extra_context,
            **{
                "base": loader.select_template(
                    self.get_template_names(extend_templates, denominator))}
            )
        context = dict(base_context, **context)
        ctx = template_module.RequestContext(request, context)
        ctx.current_app = self.app_namespace

        return http.HttpResponse(tpl.render(ctx))
Example #8
0
def notify_new_reply_by_email(reply):
    helprequest = reply.helprequest

    recipient = None
    if reply.author != helprequest.requester:
        recipient = helprequest.requester
    elif helprequest.bikeanjo:
        recipient = helprequest.bikeanjo

    if not recipient:
        return

    site = Site.objects.filter(id=settings.SITE_ID).first()
    subject = u'Você recebeu uma nova mensagem de %s!' % reply.author.get_full_name()
    from_email = settings.DEFAULT_FROM_EMAIL
    data = {
        'helprequest': helprequest,
        'recipient': recipient,
        'sender': reply.author,
        'site': site,
    }

    with translation.override(set_language(recipient)):
        template_name = 'emails/new_msg_to_%s.html' % recipient.role
        html = select_template([template_name]).render(data)

        template_name = 'emails/new_msg_to_%s.txt' % recipient.role
        text = select_template([template_name]).render(data)

    msg = EmailMultiAlternatives(subject, text, from_email, [recipient.email])
    msg.attach_alternative(html, "text/html")
    msg.send()
Example #9
0
def page(request, page_name):
    page = get_object_or_404(Page, name=page_name)

    if not page.active and not request.user.is_staff:
        return HttpResponseRedirect(reverse(settings.PERMISSION_DENIED_URL))

    if page.restricted:
        if request.user.is_anonymous():
            return HttpResponseRedirect(
                reverse('website:restricted_page_not_logged_in')
            )
        elif not request.user.is_staff and not \
            request.user.has_perm('website.can_view_restricted'):
            return HttpResponseRedirect(reverse(settings.PERMISSION_DENIED_URL))

    template = TEMPLATES['no-img']
    if page.pictures.count() > 0:
        template = TEMPLATES[page.layout]

    try:
        select_template(
            ['website/{}_extra.html'.format(page_name)]
        )
        include_html = 'website/{}_extra.html'.format(page_name)
    except TemplateDoesNotExist:
        include_html = ''

    return TemplateResponse(
        request, template, {'page': page, 'include_html': include_html}
    )
Example #10
0
	def get_templates(self, action):
		"""
		Return a subject, text, HTML tuple with e-mail templates for
		a particular action. Returns a tuple with subject, text and e-mail
		template.
		"""

		assert action in ACTIONS + ('message', ), 'Unknown action: %s' % action

		# Common substitutions for filenames
		tpl_subst = {
			'action': action,
			'newsletter': self.slug
		}

		# Common root path for all the templates
		tpl_root = 'newsletter/message/'

		
		text_template = select_template([
			tpl_root + '%(newsletter)s/%(action)s.txt' % tpl_subst,
			tpl_root + '%(action)s.txt' % tpl_subst,
		])

		if self.send_html:
			html_template = select_template([
				tpl_root + '%(newsletter)s/%(action)s.html' % tpl_subst,
				tpl_root + '%(action)s.html' % tpl_subst,
			])
		else:
			# HTML templates are not required
			html_template = None

		return (text_template, html_template)
Example #11
0
 def send_registration_approval(self):
     template_txt = select_template([
         'leprikon/registration-approved-mail/{}.txt'.format(self.subject.subject_type.slug),
         'leprikon/registration-approved-mail/{}.txt'.format(self.subject.subject_type.subject_type),
         'leprikon/registration-approved-mail/subject.txt',
     ])
     template_html = select_template([
         'leprikon/registration-approved-mail/{}.html'.format(self.subject.subject_type.slug),
         'leprikon/registration-approved-mail/{}.html'.format(self.subject.subject_type.subject_type),
         'leprikon/registration-approved-mail/subject.html',
     ])
     site = LeprikonSite.objects.get_current()
     context = {
         'object': self,
         'site': site,
     }
     content_txt = template_txt.render(context)
     content_html = template_html.render(context)
     msg = EmailMultiAlternatives(
         subject = self.registration_approval_subject,
         body        = content_txt,
         from_email  = settings.SERVER_EMAIL,
         to          = self.all_recipients,
         headers     = {'X-Mailer': 'Leprikon (http://leprikon.cz/)'},
     )
     msg.attach_alternative(content_html, 'text/html')
     msg.send()
Example #12
0
 def save(self):
     subject_template = select_template([
         '{}/email/password-reset-subject.txt'.format(app_settings.APP_LABEL),
         'shop/email/password-reset-subject.txt',
     ])
     body_text_template = select_template([
         '{}/email/password-reset-body.txt'.format(app_settings.APP_LABEL),
         'shop/email/password-reset-body.txt',
     ])
     body_html_template = select_template([
         '{}/email/password-reset-body.html'.format(app_settings.APP_LABEL),
         'shop/email/password-reset-body.html',
     ])
     try:
         page = Page.objects.select_related('node').get(reverse_id='password-reset-confirm', publisher_is_draft=False)
     except Page.DoesNotExist:
         try:
             password_reset_confirm_url = reverse('password-reset-confirm')
         except NoReverseMatch:
             password_reset_confirm_url = self.invalid_password_reset_confirm_url
     else:
         language = get_language_from_request(self.context['request'])
         password_reset_confirm_url = page.get_absolute_url(language)
     opts = {
         'use_https': self.context['request'].is_secure(),
         'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'),
         'request': self.context['request'],
         'subject_template_name': subject_template.template.name,
         'email_template_name': body_text_template.template.name,
         'html_email_template_name': body_html_template.template.name,
         'extra_email_context': {'password_reset_confirm_url': password_reset_confirm_url}
     }
     self.reset_form.save(**opts)
Example #13
0
 def send_payment_request(self):
     template_txt = select_template([
         'leprikon/payment-request-mail/{}.txt'.format(self.subject.subject_type.slug),
         'leprikon/payment-request-mail/{}.txt'.format(self.subject.subject_type.subject_type),
         'leprikon/payment-request-mail/subject.txt',
     ])
     template_html = select_template([
         'leprikon/payment-request-mail/{}.html'.format(self.subject.subject_type.slug),
         'leprikon/payment-request-mail/{}.html'.format(self.subject.subject_type.subject_type),
         'leprikon/payment-request-mail/subject.html',
     ])
     site = LeprikonSite.objects.get_current()
     context = {
         'object': self,
         'site': site,
     }
     content_txt = template_txt.render(context)
     content_html = template_html.render(context)
     msg = EmailMultiAlternatives(
         subject = self.payment_request_subject,
         body        = content_txt,
         from_email  = settings.SERVER_EMAIL,
         to          = self.all_recipients,
         headers     = {'X-Mailer': 'Leprikon (http://leprikon.cz/)'},
     )
     msg.attach_alternative(content_html, 'text/html')
     if site.bank_account:
         qr_code = MIMEImage(self.get_qr_code())
         qr_code.add_header('Content-ID', '<qr_code>')
         msg.attach(qr_code)
     msg.send()
Example #14
0
 def send_mail(self):
     template_txt = select_template([
         'leprikon/{}-mail/{}.txt'.format(self.pdf_export, self.subject.subject_type.slug),
         'leprikon/{}-mail/{}.txt'.format(self.pdf_export, self.subject.subject_type.subject_type),
         'leprikon/{}-mail/subject.txt'.format(self.pdf_export),
     ])
     template_html = select_template([
         'leprikon/{}-mail/{}.html'.format(self.pdf_export, self.subject.subject_type.slug),
         'leprikon/{}-mail/{}.html'.format(self.pdf_export, self.subject.subject_type.subject_type),
         'leprikon/{}-mail/subject.html'.format(self.pdf_export),
     ])
     context = {
         'object': self,
         'site': LeprikonSite.objects.get_current(),
     }
     content_txt = template_txt.render(context)
     content_html = template_html.render(context)
     msg = EmailMultiAlternatives(
         subject = self.mail_subject,
         body        = content_txt,
         from_email  = settings.SERVER_EMAIL,
         to          = self.all_recipients,
         headers     = {'X-Mailer': 'Leprikon (http://leprikon.cz/)'},
     )
     msg.attach_alternative(content_html, 'text/html')
     msg.attach(self.pdf_filename, self.get_pdf(), 'application/pdf')
     for attachment in self.all_attachments:
         msg.attach_file(attachment.file.file.path)
     msg.send()
Example #15
0
 def _send_password(self, request, user, password):
     current_site = get_current_site(request)
     context = {
         'site_name': current_site.name,
         'absolute_base_uri': request.build_absolute_uri('/'),
         'email': user.email,
         'password': password,
         'user': user,
     }
     subject_template = select_template([
         '{}/email/register-user-subject.txt'.format(app_settings.APP_LABEL),
         'shop/email/register-user-subject.txt',
     ])
     # Email subject *must not* contain newlines
     subject = ''.join(subject_template.render(context).splitlines())
     body_text_template = select_template([
         '{}/email/register-user-body.txt'.format(app_settings.APP_LABEL),
         'shop/email/register-user-body.txt',
     ])
     body_html_template = select_template([
         '{}/email/register-user-body.html'.format(app_settings.APP_LABEL),
         'shop/email/register-user-body.html',
     ], using='post_office')
     message = body_text_template.render(context)
     html_message = body_html_template.render(context)
     from_email = getattr(settings, 'DEFAULT_FROM_EMAIL')
     user.email_user(subject, message, from_email=from_email, html_message=html_message)
     email_queued()
Example #16
0
def base_templates(request):
    ''' 
    To be used as a context_processor so as to provide a fallback if the hosting
    project does not have either base.html or base_site.html templates
    '''
    _docengine_registration = getattr(settings, 'DOCENGINE_REGISTRATION', False)
    _registration_open = getattr(settings, 'REGISTRATION_OPEN', True)
    _USER_PROFILE = getattr(settings, 'REGISTER_USER_PROFILE', getattr(settings,
                                                                       'DOCENGINE_USER_PROFILE',
                                                                      None))
    _base_prefix=''
    if hasattr(request, 'session') and 'subdomain' in request.session:
        if hasattr(settings, 'DOMAINS_PATHS'):
            _base_prefix = dict(settings.DOMAINS_PATHS).get(request.session['subdomain'], '')
        else:
            _base_prefix = request.session['subdomain'] + '/'
    
    context = {
            'client_project': getattr(settings, 'CLIENT_PROJECT', 'DocEngine'),
            'base_template': loader.select_template([_base_prefix+'base.html', 'base.html', 'common/base.html']),
            'base_site_template': loader.select_template([_base_prefix+'base_site.html', 'base_site.html', 'common/base_site.html']),
            'REGISTRATION_OPEN': _docengine_registration and _registration_open,
            'HAS_PROFILE': isinstance(_USER_PROFILE, basestring),
            'PROJECT_TITLE': os.path.split(settings.ENVIRON_DIR)[1]
        }
    
    return context
Example #17
0
File: base.py Project: asavoy/Lyra
    def get_response(self, request, context={}, template=None,
                     denominator=None, extend_template=None,
                     template_select=None):

        if extend_template is None:
            extend_template = getattr(self, "base_template", "base")

        if template and template_select is None:
            template_select = [template]
        elif template_select is None:
            raise ValueError("provide one of template or "
                             "template_select, not both or neither")
        
        tpl = loader.select_template(
            self.get_template_names(template_select, denominator))

        base_context = dict(
            self.extra_context,
            **{
                "base": loader.select_template(
                    self.get_template_names([extend_template], denominator))}
            )
        context = dict(base_context, **context)
        ctx = template_module.RequestContext(request, context)
        ctx.current_app = self.app_namespace

        return http.HttpResponse(tpl.render(ctx))
Example #18
0
def queryset_render_multiple_original(queryset, name, attr_str, data, parent=None):
    try:
            t_item=loader.select_template(["select_multiple_widget_items_original.html"])
    except TemplateDoesNotExist:
            t_item=Template(default_select_multiple_template_original[0])
    try:
            t=loader.select_template(["select_multiple_widget_original.html"])
    except TemplateDoesNotExist:
            t=Template(default_select_multiple_template_original[1])

    if parent and len(parent)>0 and (type(parent) in (type((1,)), type([1,]))):
            parent1, parent2=name
    else:
            parent1, parent2=parent, None
    if data==None: data=[]#当新增数据时,执行此语句
    roots=queryset_group(queryset, parent1, data)
    
    #多对多多选框没有内容可以显示时,显示返回模型中Admin类中定义的报错信息
    rootserror=''
    if roots=={}:
            model=queryset.model
            if hasattr(model.Admin,"blankerror_text"):
                            rootserror=model.Admin.blankerror_text

    return t.render(
            Context({'roots': 
                    dict([(root, t_item.render(Context({'queryset': value,
                            'id':root and root.pk or "",
                            'name':name, 
                            'attrs': attr_str}))) for root, value in roots.items()]),
                    'name': name, 'attrs': attr_str, 'error':rootserror}
                    )
            )
def parse(markup, sections=None):

    parser = EMarkupParser()
    parser.parse(markup)
    sections = parser.sections

    rendered_sections = SectionsDictionary()

    error_template = select_template(['markupchunks/error.html'])

    rendered_sections.vars.update(sections.vars)

    for section, chunks in sections.iteritems():

        content_chunks = Section(chunks.name)
        content_chunks.vars.update(chunks.vars)

        for chunk in chunks:

            chunk_filename = "markupchunks/%s.html" % chunk.chunk_type.encode()
            chunk_template = select_template([chunk_filename, "markupchunks/paragraph.html"])

            chunk_data = dict(vars=vars, chunk=chunk, content="\n".join(chunk))
            try:
                chunk_html = chunk_template.render(Context(chunk_data))
            except Exception, e:
                error = str(e)
                chunk_html = unicode(error_template.render(Context(dict(error=error))))

            new_chunk = Chunk(chunk_html, chunk.chunk_type)
            new_chunk.vars.update(chunk.vars)
            content_chunks.append(new_chunk)

        rendered_sections[section] = content_chunks
Example #20
0
def enqueue_30days_notification_for_closed_requests(helprequest):
    site = Site.objects.filter(id=settings.SITE_ID).first()
    subject = u'Seu pedido #%d foi atendido?' % helprequest.id
    from_email = settings.DEFAULT_FROM_EMAIL
    recipient = helprequest.requester
    tag = '30_days_closed_%d' % helprequest.id

    data = {
        'helprequest': helprequest,
        'recipient': recipient,
        'site': site,
    }

    mail = QueuedMail.objects.filter(tag=tag).first()
    if mail:
        return mail

    with translation.override(set_language(recipient)):
        template_name = 'emails/30days_notification_for_closed_requests.html'
        html = select_template([template_name]).render(data)

        template_name = 'emails/30days_notification_for_closed_requests.txt'
        text = select_template([template_name]).render(data)

    return QueuedMail.objects.create(
        to=recipient,
        date=(now() + timedelta(30)).date(),
        subject=subject,
        html_content=html,
        text_content=text,
        tag=tag
    )
Example #21
0
    def dispatch(self, object, *args, **kwargs):
        self.object = object
        languages = [get_language(), self.fallback_language]
        receivers = self.get_receiver_emails()
        context = self.get_context()
        context.update(kwargs)
        attachments = self.get_attachments()
        template = self.template_name

        subject = select_template([
            'emails/{}.{}.subject'.format(template, lang) for lang in languages
        ])
        plaintext = select_template([
            'emails/{}.{}.txt'.format(template, lang) for lang in languages
         ])
        html = select_template([
            'emails/{}.{}.html'.format(template, lang) for lang in languages
        ])
        mail = EmailMultiAlternatives(
            subject=subject.render(context).strip(),
            body=plaintext.render(context),
            from_email=settings.DEFAULT_FROM_EMAIL,
            to=receivers,
        )
        if len(attachments) > 0:
            mail.mixed_subtype = 'related'

            for attachment in attachments:
                mail.attach(attachment)

        mail.attach_alternative(html.render(context), 'text/html')
        mail.send()
        return mail
def process(sections, context_data):

    if sections is None:
        return sections

    error_template = select_template(['blog/modules/error.html'])

    for section, chunks in sections.iteritems():

        for chunk in chunks:
            module = chunk.vars.get('module')

            if module is not None:

                module_template = select_template(["blog/modules/%s.html"%module])

                td = {}
                td.update(context_data)

                td.update( dict(  vars = chunk.vars,
                                  content = chunk.text ) )

                try:
                    chunk_html = module_template.render(Context(td))
                except Exception, e:
                    error = str(e)
                    chunk_html = unicode(error_template.render(Context(dict(error=error))))

                chunk.text = chunk_html
Example #23
0
    def render(self, context, **options):
        template_pack = context['form_template_pack']
        form = context['form']
        bound_field = form[self.field_name]

        try:
            if 'template' in options:
                template = select_template(["{}/{}".format(template_pack, options['template'])])
            elif 'widget' in options:
                widget_templates = [
                    '{}/fields/{}_{}.html'.format(template_pack, cls.__module__.split('.', 1)[0], cls.__name__.lower())
                    for cls in type(options['widget']).mro()[:-2]]
                template = select_template(widget_templates)
            else:
                template = _get_field_template(template_pack, bound_field.field)
        except TemplateDoesNotExist:
            # fallback to default field render
            warnings.warn("Unknown field and widget {} {}".format(
                bound_field.field.__class__, bound_field.field.widget.__class__))
            return smart_text(bound_field)
        else:
            hidden_initial = ''

            if bound_field.field.show_hidden_initial:
                hidden_initial = bound_field.as_hidden(only_initial=True)

            context.push()
            try:
                context['bound_field'] = bound_field
                context['field'] = bound_field.field
                context['hidden_initial'] = hidden_initial
                return template.render(context.flatten())
            finally:
                context.pop()
Example #24
0
def enqueue_15days_notification_for_open_requests(helprequest):
    site = Site.objects.filter(id=settings.SITE_ID).first()
    subject = _('Did you answer the request #%d?') % helprequest.id
    from_email = settings.DEFAULT_FROM_EMAIL
    recipient = helprequest.bikeanjo
    tag = '15_days_open_%d' % helprequest.id

    data = {
        'helprequest': helprequest,
        'recipient': recipient,
        'site': site,
    }

    mail = QueuedMail.objects.filter(tag=tag).first()
    if mail:
        return mail

    with translation.override(set_language(recipient)):
        template_name = 'emails/15days_notification_for_open_requests.html'
        html = select_template([template_name]).render(data)

        template_name = 'emails/15days_notification_for_open_requests.txt'
        text = select_template([template_name]).render(data)

    return QueuedMail.objects.create(
        to=recipient,
        date=(now() + timedelta(15)).date(),
        subject=subject,
        html_content=html,
        text_content=text,
        tag=tag
    )
Example #25
0
 def test_select_template_not_found(self):
     with self.assertRaises(TemplateDoesNotExist) as e:
         select_template(["template_loader/unknown.html", "template_loader/missing.html"])
     self.assertEqual(e.exception.chain[0].tried[0][0].template_name, "template_loader/unknown.html")
     self.assertEqual(e.exception.chain[0].backend.name, "dummy")
     self.assertEqual(e.exception.chain[-1].tried[0][0].template_name, "template_loader/missing.html")
     self.assertEqual(e.exception.chain[-1].backend.name, "django")
Example #26
0
 def clean_style(self):
     style = self.cleaned_data.get('style')
     # Check if template for style exists:
     try:
         select_template(['aldryn_quote/plugins/%s/quote.html' % style])
     except TemplateDoesNotExist:
         raise forms.ValidationError(_('Template not found'))
     return style
Example #27
0
 def test_select_template_string(self):
     with self.assertRaisesMessage(
         TypeError,
         "select_template() takes an iterable of template names but got a "
         "string: 'template_loader/hello.html'. Use get_template() if you "
         "want to load a single template by name.",
     ):
         select_template("template_loader/hello.html")
Example #28
0
 def clean_style(self):
     style = self.cleaned_data.get('style')
     # Check if template for style exists:
     try:
         select_template(['aldryn_gallery/plugins/%s/gallery.html' % style])
     except TemplateDoesNotExist:
         raise forms.ValidationError("Not a valid style (Template does not exist)")
     return style
Example #29
0
 def get_template_names(self):
     template_name = "webpage/{}.html".format(self.kwargs.get("template", 'index'))
     try:
         loader.select_template([template_name])
         template_name = "webpage/{}.html".format(self.kwargs.get("template", 'index'))
     except Exception as e:
         template_name = "webpage/index.html"
     return [template_name]
Example #30
0
 def test_select_template_not_found(self):
     with self.assertRaises(TemplateDoesNotExist) as e:
         select_template(["template_loader/unknown.html",
                          "template_loader/missing.html"])
     self.assertEqual(
         e.exception.tried[0][0].template_name,
         'template_loader/unknown.html',
     )
     self.assertEqual(
         e.exception.tried[-1][0].template_name,
         'template_loader/missing.html',
     )
Example #31
0
    def changelist_view(self, request, extra_context=None):
        """Handle grouper filtering on the changelist"""
        if not request.GET:
            # redirect to grouper form when there's no GET parameters
            opts = self.model._meta
            return redirect(
                reverse("admin:{}_{}_grouper".format(opts.app_label,
                                                     opts.model_name)))
        extra_context = extra_context or {}
        versionable = versionables.for_content(self.model._source_model)

        try:
            grouper = versionable.get_grouper_with_fallbacks(
                int(request.GET.get(versionable.grouper_field_name)))
        except (TypeError, ValueError):
            grouper = None
        else:
            if grouper is None:
                # no exception and no grouper, thus the querydict is invalid
                raise Http404

        if grouper:
            # CAVEAT: as the breadcrumb trails expect a value for latest content in the template
            extra_context["latest_content"] = ({'pk': None})

            extra_context.update(
                grouper=grouper,
                title=_('Displaying versions of "{grouper}"').format(
                    grouper=grouper),
            )
            breadcrumb_opts = self.model._source_model._meta
            extra_context["breadcrumb_opts"] = breadcrumb_opts
            # Check if custom breadcrumb template defined, otherwise
            # fallback on default
            breadcrumb_templates = [
                "admin/djangocms_versioning/{app_label}/{model_name}/versioning_breadcrumbs.html"
                .format(
                    app_label=breadcrumb_opts.app_label,
                    model_name=breadcrumb_opts.model_name,
                ),
                "admin/djangocms_versioning/versioning_breadcrumbs.html",
            ]
            extra_context["breadcrumb_template"] = select_template(
                breadcrumb_templates)

        response = super().changelist_view(request, extra_context)

        # This is a slightly hacky way of accessing the instance of
        # the changelist that the admin changelist_view instantiates.
        # We do this to make sure that the latest content object is
        # picked from the same queryset as is being displayed in the
        # version table.
        if grouper and response.status_code == 200:
            # Catch the edge case where a grouper can have empty contents
            # when additional filters are present and the result set will be
            # empty for the additional values.
            try:
                response.context_data["latest_content"] = (
                    response.context_data["cl"].get_queryset(request).latest(
                        "created").content)
            except ObjectDoesNotExist:
                pass
        return response
Example #32
0
 def get_template(self, context, **kwargs):
     template = select_template([
         '{}/templatetags/cart-icon.html'.format(app_settings.APP_LABEL),
         'shop/templatetags/cart-icon.html',
     ])
     return template.template.name
Example #33
0
def template_view(request):
    """
    View that uses a template instance
    """
    template = loader.select_template(["basic.html"])
    return TemplateResponse(request, template)
Example #34
0
 def get(self, request, *args, **kwargs):
     entity = kwargs['entity'].lower()
     pk = kwargs['pk']
     entity_model = ContentType.objects.get(app_label='apis_entities',
                                            model=entity).model_class()
     instance = get_object_or_404(entity_model, pk=pk)
     relations = ContentType.objects.filter(app_label='apis_relations',
                                            model__icontains=entity)
     side_bar = []
     for rel in relations:
         print(str(rel))
         match = str(rel).split()
         prefix = "{}{}-".format(match[0].title()[:2], match[1].title()[:2])
         table = get_generic_relations_table(''.join(match),
                                             entity,
                                             detail=True)
         title_card = ''
         if match[0] == match[1]:
             title_card = entity.title()
             dict_1 = {'related_' + entity.lower() + 'A': instance}
             dict_2 = {'related_' + entity.lower() + 'B': instance}
             if 'apis_highlighter' in settings.INSTALLED_APPS:
                 object_pre = rel.model_class(
                 ).annotation_links.filter_ann_proj(
                     request=request).filter(Q(**dict_1) | Q(**dict_2))
             else:
                 object_pre = rel.model_class().objects.filter(
                     Q(**dict_1) | Q(**dict_2))
             objects = []
             for x in object_pre:
                 objects.append(x.get_table_dict(instance))
         else:
             if match[0].lower() == entity.lower():
                 title_card = match[1].title()
             else:
                 title_card = match[0].title()
             dict_1 = {'related_' + entity.lower(): instance}
             if 'apis_highlighter' in settings.INSTALLED_APPS:
                 objects = list(
                     rel.model_class().annotation_links.filter_ann_proj(
                         request=request).filter(**dict_1))
             else:
                 objects = list(rel.model_class().objects.filter(**dict_1))
         tb_object = table(objects, prefix=prefix)
         tb_object_open = request.GET.get(prefix + 'page', None)
         RequestConfig(request, paginate={
             "per_page": 10
         }).configure(tb_object)
         side_bar.append(
             (title_card, tb_object, ''.join([x.title() for x in match]),
              tb_object_open))
     object_lod = Uri.objects.filter(entity=instance)
     object_texts, ann_proj_form = get_highlighted_texts(request, instance)
     object_labels = Label.objects.filter(temp_entity=instance)
     tb_label = EntityDetailViewLabelTable(object_labels,
                                           prefix=entity.title()[:2] + 'L-')
     tb_label_open = request.GET.get('PL-page', None)
     side_bar.append(('Label', tb_label, 'PersonLabel', tb_label_open))
     RequestConfig(request, paginate={"per_page": 10}).configure(tb_label)
     template = select_template([
         'apis_entities/detail_views/{}_detail_generic.html'.format(entity),
         'apis_entities/detail_views/entity_detail_generic.html'
     ])
     tei = getattr(settings, "APIS_TEI_TEXTS", [])
     if tei:
         tei = set(tei) & set([x.kind.name for x in instance.text.all()])
     ceteicean_css = getattr(settings, "APIS_CETEICEAN_CSS", None)
     ceteicean_js = getattr(settings, "APIS_CETEICEAN_JS", None)
     openseadragon_js = getattr(settings, "APIS_OSD_JS", None)
     openseadragon_img = getattr(settings, "APIS_OSD_IMG_PREFIX", None)
     iiif_field = getattr(settings, "APIS_IIIF_WORK_KIND", None)
     if iiif_field:
         try:
             if "{}".format(instance.kind) == "{}".format(iiif_field):
                 iiif = True
             else:
                 iiif = False
         except AttributeError:
             iiif = False
     else:
         iiif = False
     iiif_server = getattr(settings, "APIS_IIIF_SERVER", None)
     iiif_info_json = instance.name
     no_merge_labels = [
         x for x in object_labels
         if not x.label_type.name.startswith('Legacy')
     ]
     return HttpResponse(
         template.render(request=request,
                         context={
                             'entity_type': entity,
                             'object': instance,
                             'right_card': side_bar,
                             'no_merge_labels': no_merge_labels,
                             'object_lables': object_labels,
                             'object_texts': object_texts,
                             'object_lod': object_lod,
                             'tei': tei,
                             'ceteicean_css': ceteicean_css,
                             'ceteicean_js': ceteicean_js,
                             'iiif': iiif,
                             'openseadragon_js': openseadragon_js,
                             'openseadragon_img': openseadragon_img,
                             'iiif_field': iiif_field,
                             'iiif_info_json': iiif_info_json,
                             'iiif_server': iiif_server,
                         }))
Example #35
0
    def render_field(self, field):
        """ Render a named field to HTML. """

        try:
            field_instance = self.fields[field]
        except KeyError:
            raise NoSuchFormField("Could not resolve form field '%s'." % field)

        bf = forms.forms.BoundField(self, field_instance, field)

        output = ''

        if bf.errors:
            # If the field contains errors, render the errors to a <ul>
            # using the error_list helper function.
            # bf_errors = error_list([escape(error) for error in bf.errors])
            bf_errors = ', '.join([e for e in bf.errors])
        else:
            bf_errors = ''

        if bf.is_hidden:
            # If the field is hidden, add it at the top of the form
            self.prefix_fields.append(unicode(bf))

            # If the hidden field has errors, append them to the top_errors
            # list which will be printed out at the top of form
            if bf_errors:
                self.top_errors.extend(bf.errors)

        else:

            # Find field + widget type css classes
            css_class = type(field_instance).__name__ + " " + type(
                field_instance.widget).__name__

            # Add an extra class, Required, if applicable
            if field_instance.required:
                css_class += " required"

            if field_instance.help_text:
                # The field has a help_text, construct <span> tag
                help_text = '<span class="help-%s">%s</span>' % (
                    self.help_style, force_unicode(field_instance.help_text))
            else:
                help_text = u''

            field_hash = {
                'class': mark_safe(css_class),
                'label': mark_safe(bf.label or ''),
                'help_text': mark_safe(help_text),
                'field': field_instance,
                'bf': mark_safe(unicode(bf)),
                'bf_raw': bf,
                'errors': mark_safe(bf_errors),
                'field_type': mark_safe(field.__class__.__name__),
                'label_id': bf._auto_id(),
            }

            if self.custom_fields.has_key(field):
                template = get_template(self.custom_fields[field])
            else:
                template = select_template([
                    os.path.join(
                        self.template_base, 'field_%s.html' %
                        type(field_instance.widget).__name__.lower()),
                    os.path.join(self.template_base, 'field_default.html'),
                ])

            # Finally render the field
            output = template.render(Context(field_hash))

        return mark_safe(output)
Example #36
0
def render_flatpage(request, f):
    """
    Internal interface to the flat page view.
    """
    # If the page is a draft, only show it to users who are staff.
    if f.status == 'd' and not request.user.is_authenticated():
        raise Http404
    # 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)
    
    # Track pageviews (but not of owner).
    # if request.user != f.owner:
    #     f.views += 1
    #     f.save()
    #
    # 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)
    
    # Create breadcrumb navigation links.
    # breadcrumb_urls = f.url.lstrip('/').rstrip('/').split('/')
    # breadcrumb_urls.insert(0, '/')
    # 
    # for i, u in enumerate(breadcrumb_urls):
    #     try: # Try and get a flatpage instance from the URL.
    #         if u != '/':
    #             u = '/%s/' % u
    #         fp = FlatPage.objects.get(url__exact=u)
    #         bt = fp.title
    #         bu = fp.url
    #     except: # Default to the URL slug, capitalized if no flatpage was found.
    #         bt = u.capitalize()
    #         bu = None
    #     breadcrumbs += [{ # Contsruct a dictionary for the breadcrumb entity.
    #         'url': bu,
    #         'title': bt,
    #     }]

    breadcrumb_urls = []
    breadcrumbs = []

    def trim_page(url):
        """Trim the last section off a URL."""
        regex = re.compile(r'(?P<url>.*/)[-\w\.]+/?$')
        try:
            trimmed_url = regex.match(url).group('url')  # Return the parent page
        except:
            trimmed_url = None  # Return None to indicate no parent.
        return trimmed_url

    def do_trimming(url):
        """Perform the trimming operations recursively."""
        breadcrumb_urls.append(url)
        trimmed_url = trim_page(url)
        if trimmed_url:
            do_trimming(trimmed_url)
        else:
            return True
    
    # Trim the flatpage's URL.
    do_trimming(f.url)
    
    # Reverse the list of breadcrumbs so the parent pages start first.
    breadcrumb_urls.reverse()
    
    # Loop through the list of pages and construct a list of url/title dictionaries
    # for each page to use in the templates.
    for i, u in enumerate(breadcrumb_urls):
        bn = ''
        bu = ''
        try:  # Try and get a flatpage instance from the URL.
            # if u != '/':
            #     u = '/%s/' % u
            fp = FlatPage.objects.get(url__exact=u)
            bn = fp.name
            bu = fp.url
        except:  # Try to handle missing pages cleanly.
            regex = re.compile(r'.*/(?P<url>[-\w\.]+)/?$')
            try:
                # Default to the URL slug of the last segment of the URL 
                # (capitalized) if no flatpage was found. This gives us an 
                # OK default for missing pages.
                bn = regex.match(u).group('url')
            except:
                # Worst case scenario we show the URL as the title if we can't 
                # grab the last bit of the URL...
                bn = u
            bn = bn.capitalize() # Capitalize it to make it look a little nicer.
            # Return None if the flatpage doesn't exist so we don't link to it, 
            # because it would cause a 404 error if we did.
            bu = None
        breadcrumbs += [{  # Contsruct a dictionary for the breadcrumb entity.
            'url': bu,
            'name': bn,
        }]
    
    c = RequestContext(request, {
        'flatpage': f,
        'breadcrumbs': breadcrumbs,
    })
    response = HttpResponse(t.render(c))
    populate_xheaders(request, response, FlatPage, f.id)
    return response
Example #37
0
def history_item(item):
    template_name = f"barriers/history/partials/{item.model}/{item.field}.html"
    default_template_name = "barriers/history/partials/default.html"
    item_template = select_template([template_name, default_template_name])
    return item_template.render({'item': item})
Example #38
0
    def section(self, request, slug=None):
        try:
            section = Section.objects.get(slug=slug)
        except:
            return self.page(request, slug)

        order = request.GET.get('order', 'newest')

        if order == 'newest':
            order_by = '-published_at'
        else:
            order_by = 'published_at'

        query = request.GET.get('q', False)

        featured_articles = Article.objects.filter(
            section=section, is_published=True).order_by('-published_at')

        subsections = SubsectionHelper.get_subsections(section)

        featured_subsection = None
        featured_subsection_articles = None

        if subsections:
            featured_subsection = subsections[0]
            featured_subsection_articles = SubsectionHelper.get_featured_subsection_articles(
                featured_subsection, featured_articles)

        article_list = Article.objects.filter(
            section=section, is_published=True).order_by(order_by)

        if query:
            article_list = article_list.filter(headline__icontains=query)

        paginator = Paginator(article_list, 15)  # Show 15 articles per page

        page = request.GET.get('page')

        try:
            articles = paginator.page(page)
        except PageNotAnInteger:
            # If page is not an integer, deliver first page.
            articles = paginator.page(1)
        except EmptyPage:
            # If page is out of range (e.g. 9999), deliver last page of results.
            articles = paginator.page(paginator.num_pages)

        context = {
            'meta': {
                'title': section.name,
            },
            'section': section,
            'subsections': subsections,
            'featured_subsection': {
                'subsection': featured_subsection,
                'articles': featured_subsection_articles
            },
            'type': 'section',
            'featured_articles': {
                'first': featured_articles[0],
                'rest': featured_articles[1:4]
            },
            'articles': articles,
            'order': order,
            'q': query
        }

        t = loader.select_template(
            ['%s/%s' % (section.slug, 'section.html'), 'section.html'])
        return HttpResponse(t.render(context))
Example #39
0
    def article(self, request, section=None, slug=None):
        try:
            article = ArticleHelper.get_article(request, slug)
        except:
            raise Http404('Article could not be found.')

        article.add_view()

        breaking = ArticleHelper.get_breaking_news().exclude(
            id=article.id).first()

        # determine if user is viewing from mobile
        article_type = 'desktop'
        user_agent = get_user_agent(request)
        if user_agent.is_mobile:
            article_type = 'mobile'

        if article.template == 'timeline':
            timeline_tag = article.tags.filter(name__icontains='timeline-')
            timelineArticles = Article.objects.filter(tags__in=timeline_tag,
                                                      is_published=True)
            temp = list(
                timelineArticles.values('parent_id', 'template_data', 'slug',
                                        'headline', 'featured_image'))
            try:
                temp = sorted(temp,
                              key=lambda article: json.loads(article[
                                  'template_data'])['timeline_date'])
            except:
                pass
            for i, a in enumerate(timelineArticles):
                try:
                    temp[i][
                        'featured_image'] = a.featured_image.image.get_thumbnail_url(
                        )
                except:
                    temp[i]['featured_image'] = None
            article.timeline_articles = json.dumps(temp)
            article.timeline_title = list(timeline_tag)[0].name.replace(
                'timeline-', '').replace('-', ' ')

        if article.template == 'soccer-nationals':
            teamData = NationalsHelper.prepare_data(article.content)
            article.content = teamData['content']
            article.team_data = json.dumps(teamData['code'])

        if article.template == 'food-insecurity':
            data = FoodInsecurityHelper.prepare_data(article.content)
            article.content = data['content']
            article.point_data = json.dumps(
                data['code']) if data['code'] is not None else None

        ref = request.GET.get('ref', None)
        dur = request.GET.get('dur', None)

        if not ArticleHelper.is_explicit(article):
            article.content = ArticleHelper.insert_ads(article.content,
                                                       article_type)

        popular = ArticleHelper.get_popular()[:5]

        context = {
            'title':
            '%s - %s' % (article.headline, self.SITE_TITLE),
            'meta':
            ArticleHelper.get_meta(article),
            'article':
            article,
            'reading_list':
            ArticleHelper.get_reading_list(article, ref=ref, dur=dur),
            # 'suggested': lambda: ArticleHelper.get_random_articles(2, section, exclude=article.id),
            'base_template':
            'base.html',
            'popular':
            popular,
            'reading_time':
            ArticleHelper.get_reading_time(article),
            'explicit':
            ArticleHelper.is_explicit(article),
            'breaking':
            breaking,
        }

        template = article.get_template_path()
        t = loader.select_template([
            '%s/%s' % (article.section.slug, template), template,
            'article/default.html'
        ])
        return HttpResponse(t.render(context))
Example #40
0
 def get_template(self):
     return select_template([
         '{}/templatetags/cart-icon.html'.format(app_settings.APP_LABEL),
         'shop/templatetags/cart-icon.html',
     ]).template
Example #41
0
 def get_render_template(self, context, instance, placeholder):
     template_names = [
         '{}/checkout/process-bar.html'.format(app_settings.APP_LABEL),
         'shop/checkout/process-bar.html',
     ]
     return select_template(template_names)
Example #42
0
def get_template(template):
    if isinstance(template, (tuple, list)):
        return loader.select_template(template)
    return loader.get_template(template)
Example #43
0
    def render(self,
               template=None,
               suffix=None,
               extra_context={},
               context_instance=None):
        """
        Render the content using template search in the following order:

        1. Supplied template
        2. positions/render/<position>/<app><combine_string><model><combine_string><suffix>.html
        3. positions/render/<position>/<app><combine_string><model>.html
        4. positions/render/<app><combine_string><model>.html
        5. positions/render/<position>/default.html
        6. positions/render/default.html
        """
        t, model, app = None, "", ""

        model = self.content_type.model.lower()
        app = self.content_type.app_label.lower()

        # The default render template path
        default_tmpl_path = 'positions/render/%s'
        # The supplied position template path
        pos_tmpl_path = default_tmpl_path % self.position.name + '/'
        # The default template
        default_tmpl = u'default.html'

        template_list = []
        if template:
            template_list.append(template)

        if suffix:
            tmpl_name = '%s%s%s%s%s.html' % (app, settings.CONBINE_STRING,
                                             model, settings.CONBINE_STRING,
                                             suffix)
            template_list.append("".join([pos_tmpl_path, tmpl_name]))

        # set the content type template name
        tmpl_name = '%s%s%s.html' % (app, settings.CONBINE_STRING, model)

        # position_name + content type template
        template_list.append("".join([pos_tmpl_path, tmpl_name]))

        # default path + content type template
        template_list.append("".join([default_tmpl_path % tmpl_name]))

        # position name + default template
        template_list.append("".join([pos_tmpl_path, default_tmpl]))

        # default path + default template
        template_list.append(default_tmpl_path % default_tmpl)

        t = select_template(template_list)
        if not t:
            return None

        context = Context()
        if context_instance:
            context.update(context_instance.__dict__)

        context.update({'obj': self.content_object, 'content': self})
        context.update(extra_context)

        return t.render(context)
Example #44
0
 def value(self, view: TemplateResponseMixin) -> Optional[datetime.datetime]:
     t = select_template(view.get_template_names())
     local_tz = datetime.datetime.now().astimezone().tzinfo
     return datetime.datetime.fromtimestamp(os.stat(t.origin.name).st_mtime, tz=local_tz)
Example #45
0
def about(request):
    context = {}
    c = RequestContext(request, context)
    t = select_template(
        ['regulations/custom-about.html', 'regulations/about.html'])
    return HttpResponse(t.render(c))
Example #46
0
 def get_render_template(self, context, instance, placeholder):
     # returns the first template that exists, falling back to bundled template
     return select_template(
         [instance.plugin_template, 'djangocms_embed/default.html'])
Example #47
0
 def select_theme_template(self, templates):
     return select_template(self.add_theme_to_template_names(templates))
Example #48
0
File: views.py Project: wuxxin/ecs
def _get_notification_template(notification, pattern):
    template_names = [pattern % name for name in (notification.type.form_cls.__name__, 'base')]
    return loader.select_template(template_names)
Example #49
0
 def _get_template(self, value):
     if isinstance(value, (list, tuple)):
         return select_template(value)
     else:
         return get_template(value)
Example #50
0
 def get_render_template(self, context, instance, placeholder):
     return select_template([
         '{}/catalog/product-list.html'.format(shop_settings.APP_LABEL),
         'shop/catalog/product-list.html',
     ])
Example #51
0
 def assert_matching_template_origin(self, actual, expected_template_name):
     expected = select_template([expected_template_name])
     self.assertEqual(actual.origin, expected.origin)
Example #52
0
def index(request):
    context = {'products': Product.objects.filter(store=request.store)}
    t = select_template(['shoppingcart/' + request.store.sub_domain + \
        '/index.html', 'shoppingcart/index.html'])
    return HttpResponse(t.render(RequestContext(request, context)))
 def resolve_template(self, template_names):
     return loader.select_template(template_names)
Example #54
0
def orders(request):
    orders = request.user.order_set.all()
    context = {'orders': orders}
    t = select_template(['shoppingcart/' + request.store.sub_domain + \
            '/orders.html', 'shoppingcart/orders.html'])
    return HttpResponse(t.render(RequestContext(request, context)))
Example #55
0
 def get_render_template(self, context, instance, placeholder):
     return select_template([
         '{}/checkout/forms-set.html'.format(app_settings.APP_LABEL),
         'shop/checkout/forms-set.html',
     ])
Example #56
0
def order_detail(request, id):
    order_details = OrderDetail.objects.filter(order=id)
    context = {'order_details': order_details}
    t = select_template(['shoppingcart/' + request.store.sub_domain + \
            '/order_detail.html', 'shoppingcart/order_detail.html'])
    return HttpResponse(t.render(RequestContext(request, context)))
Example #57
0
 def test_select_template(self):
     for dirs in self.dirs_iter:
         template = loader.select_template(['test_dirs.html'], dirs=dirs)
         self.assertEqual(template.render(Context({})), 'spam eggs\n')
Example #58
0
 def get_template(self, meta):
     return loader.select_template([
         f'renderers/iqy/{meta.app_label}/{meta.model_name}.txt',
         f'renderers/iqy/{meta.app_label}/iqy.txt', 'renderers/iqy.txt'
     ])
def home(request):
    """Home page."""
    login_template = select_template(["login.html", "no_login.html"])
    return render(request, "home.html", {"login_template": login_template})
Example #60
0
def get_template(template):
    from django.template import loader

    if isinstance(template, (tuple, list)):
        return loader.select_template(template)
    return loader.get_template(template)