Пример #1
0
def question_vote(request, question_id):
    """I have this problem too."""
    question = get_object_or_404(Question, pk=question_id)
    if question.is_locked:
        raise PermissionDenied

    if not question.has_voted(request):
        vote = QuestionVote(question=question)

        if request.user.is_authenticated():
            vote.creator = request.user
        else:
            vote.anonymous_id = request.anonymous.anonymous_id

        vote.save()

        if "referrer" in request.REQUEST:
            referrer = request.REQUEST.get("referrer")
            vote.add_metadata("referrer", referrer)

            if referrer == "search" and "query" in request.REQUEST:
                vote.add_metadata("query", request.REQUEST.get("query"))

        ua = request.META.get("HTTP_USER_AGENT")
        if ua:
            vote.add_metadata("ua", ua[:1000])  # 1000 max_length
        statsd.incr("questions.votes.question")

        if request.is_ajax():
            tmpl = "questions/includes/question_vote_thanks.html"
            form = WatchQuestionForm(request.user)
            html = jingo.render_to_string(request, tmpl, {"question": question, "watch_form": form})
            return HttpResponse(json.dumps({"html": html}))

    return HttpResponseRedirect(question.get_absolute_url())
Пример #2
0
def refund_reason(request, contribution, wizard):
    if not contribution.can_we_refund():
        return http.HttpResponseForbidden()

    addon = contribution.addon
    if not 'request' in wizard.get_progress():
        return redirect('support', contribution.pk, 'request')

    if contribution.transaction_id is None:
        messages.error(request,
            _('A refund cannot be applied for yet. Please try again later. '
              'If this error persists contact [email protected].'))
        paypal_log.info('Refund requested for contribution with no '
                        'transaction_id: %r' % contribution.pk)
        return redirect('account.purchases')

    if contribution.is_instant_refund():
        try:
            paypal.refund(contribution.paykey)
        except PaypalError:
            paypal_log.error('Paypal error with refund', exc_info=True)
            messages.error(request, _('There was an error with your instant '
                                      'refund.'))
            return redirect('account.purchases')

        refund = contribution.enqueue_refund(amo.REFUND_APPROVED_INSTANT)
        paypal_log.info('Refund %r issued for contribution %r' %
                        (refund.pk, contribution.pk))
        # Note: we have to wait for PayPal to issue an IPN before it's
        # completely refunded.
        messages.success(request, _('Refund is being processed.'))
        return redirect('account.purchases')

    form = forms.ContactForm(request.POST or None)
    if request.method == 'POST' and form.is_valid():
        reason = form.cleaned_data['text']
        template = jingo.render_to_string(request,
            wizard.tpl('emails/refund-request.txt'),
            context={'product': addon,
                     'form': form,
                     'user': request.amo_user,
                     'contribution': contribution,
                     'refund_url': contribution.get_absolute_refund_url(),
                     'refund_reason': reason})
        log.info('Refund request sent by user: %s for addon: %s' %
                 (request.amo_user.pk, addon.pk))

        # L10n: %s is the app name.
        support_mail(_(u'New Refund Request for %s' % addon.name),
                     template, sender=settings.NOBODY_EMAIL,
                     recipients=[smart_str(addon.support_email)])

        # Add this refund request to the queue.
        contribution.enqueue_refund(amo.REFUND_PENDING, reason)
        return redirect(reverse('support',
                                args=[contribution.pk, 'refund-sent']))

    return wizard.render(request, wizard.tpl('refund.html'),
                         {'product': addon, 'contribution': contribution,
                          'form': form, 'title': _('Request Refund')})
Пример #3
0
def question_vote(request, question_id):
    """I have this problem too."""
    question = get_object_or_404(Question, pk=question_id)
    if question.is_locked:
        raise PermissionDenied

    if not question.has_voted(request):
        vote = QuestionVote(question=question)

        if request.user.is_authenticated():
            vote.creator = request.user
        else:
            vote.anonymous_id = request.anonymous.anonymous_id

        vote.save()
        ua = request.META.get('HTTP_USER_AGENT')
        if ua:
            vote.add_metadata('ua', ua[:1000])  # 1000 max_length
        statsd.incr('questions.votes.question')

        if request.is_ajax():
            tmpl = 'questions/includes/question_vote_thanks.html'
            form = _init_watch_form(request)
            html = jingo.render_to_string(request, tmpl, {'question': question,
                                                          'watch_form': form})
            return HttpResponse(json.dumps({'html': html}))

    return HttpResponseRedirect(question.get_absolute_url())
Пример #4
0
def refund_reason(request, contribution, wizard):
    addon = contribution.addon
    if not 'request' in wizard.get_progress():
        return redirect(reverse('users.support',
                                args=[contribution.pk, 'request']))

    form = forms.ContactForm(request.POST or None)
    if request.method == 'POST':
        if form.is_valid():
            # if under 30 minutes, refund
            # TODO(ashort): add in the logic for under 30 minutes.
            template = jingo.render_to_string(request,
                                wizard.tpl('emails/refund-request.txt'),
                                context={'addon': addon, 'form': form,
                                         'user': request.amo_user,
                                         'contribution': contribution})
            log.info('Refund request sent by user: %s for addon: %s' %
                     (request.amo_user.pk, addon.pk))
            # L10n: %s is the addon name.
            send_mail(_(u'New Refund Request for %s' % addon.name),
                      template, request.amo_user.email,
                      [smart_str(addon.support_email)])
            return redirect(reverse('users.support',
                                    args=[contribution.pk, 'refund-sent']))

    return wizard.render(request, wizard.tpl('refund.html'),
                         {'contribut': addon, 'form': form})
Пример #5
0
def support_mozilla(request, contribution, wizard):
    addon = contribution.addon
    form = forms.ContactForm(request.POST or None)
    if request.method == "POST" and form.is_valid():
        template = jingo.render_to_string(
            request,
            wizard.tpl("emails/support-request.txt"),
            context={"product": addon, "form": form, "contribution": contribution, "user": request.amo_user},
        )
        log.info("Support request to mozilla by user: %s for addon: %s" % (request.amo_user.pk, addon.pk))

        # L10n: %s is the app name.
        support_mail(
            _(u"New Support Request for %s" % addon.name),
            template,
            sender=request.amo_user.email,
            recipients=[settings.MARKETPLACE_EMAIL],
        )

        return redirect(reverse("support", args=[contribution.pk, "mozilla-sent"]))
    return wizard.render(
        request,
        wizard.tpl("mozilla.html"),
        {"product": addon, "contribution": contribution, "form": form, "title": _("Contact Mozilla")},
    )
Пример #6
0
def firefox_footer_links(ctx, channel='release', platform='all'):
    """ Outputs Firefox footer links
    :param ctx: context from calling template.
    :param channel: name of channel: 'release', 'beta' or 'alpha'.
    :param platform: Target platform: 'desktop', 'android', or 'ios'.
    :return: The footer links html.
    """

    show_desktop = platform in ['all', 'desktop']
    show_android = platform in ['all', 'android']
    show_ios = platform in ['all', 'ios']
    alt_channel = '' if channel == 'release' else channel

    # Gather data about the build for each platform
    builds = []

    if show_android:
        builds = android_builds(channel, builds)

    data = {
        'show_desktop': show_desktop,
        'show_android': show_android,
        'show_ios': show_ios,
        'channel': alt_channel,
        'builds': builds,
    }

    html = jingo.render_to_string(
        ctx['request'], 'firefox/includes/firefox-footer-links.html', data)
    return jinja2.Markup(html)
Пример #7
0
def rendered_content(self):
    template = self.template_name

    if 'user' not in self.context_data:
        self.context_data['user'] = self._request.user

    context_instance = self.resolve_context(self.context_data)

    # Gross, let's figure out if we're in the admin.
    if getattr(self._request, 'current_app', None) == 'admin':
        source = loader.render_to_string(
            template, RequestContext(self._request, context_instance))
        template = jingo.get_env().from_string(source)

        # This interferes with our media() helper.
        if 'media' in self.context_data:
            del self.context_data['media']

    # ``render_to_string`` only accepts a Template instance or a template name,
    # not a list.
    if isinstance(template, (list, tuple)):
        template = loader.select_template(template)
    if isinstance(template, Template):
        template = template.template
    return jingo.render_to_string(
        self._request, template, self.context_data)
Пример #8
0
def render_email(template, context):
    """Renders a template in the currently set locale."""
    req = RequestFactory()
    req.META = {}
    req.locale = translation.get_language()

    return jingo.render_to_string(req, template, context)
Пример #9
0
def question_vote(request, question_id):
    """I have this problem too."""
    question = get_object_or_404(Question, pk=question_id)
    if question.is_locked:
        raise PermissionDenied

    if not question.has_voted(request):
        vote = QuestionVote(question=question)

        if request.user.is_authenticated():
            vote.creator = request.user
        else:
            vote.anonymous_id = request.anonymous.anonymous_id

        vote.save()
        ua = request.META.get('HTTP_USER_AGENT')
        if ua:
            vote.add_metadata('ua', ua[:1000])  # 1000 max_length
        statsd.incr('questions.votes.question')

        if request.is_ajax():
            tmpl = 'questions/includes/question_vote_thanks.html'
            form = _init_watch_form(request)
            html = jingo.render_to_string(request, tmpl, {'question': question,
                                                          'watch_form': form})
            return HttpResponse(json.dumps({'html': html}))

    return HttpResponseRedirect(question.get_absolute_url())
Пример #10
0
 def item_description(self, submission):
     return jingo.render_to_string(
         self.request,
         'demos/feed_item_description.html', dict(
             request=self.request, submission=submission
         )
     )
Пример #11
0
def _install_button(context, addon, version=None, show_eula=True,
                   show_contrib=True, show_warning=True, src='',
                   collection=None, size='', detailed=False,
                   mobile=False, impala=False):
    """If version isn't given, we use the latest version."""
    request = context['request']
    app, lang = context['APP'], context['LANG']
    show_eula = bool(request.GET.get('eula', show_eula))
    src = src or context.get('src') or request.GET.get('src', '')
    collection = ((collection.uuid if hasattr(collection, 'uuid') else None)
                   or collection
                   or context.get('collection')
                   or request.GET.get('collection')
                   or request.GET.get('collection_id')
                   or request.GET.get('collection_uuid'))
    button = install_button_factory(addon, app, lang, version,
                                    show_eula, show_contrib, show_warning,
                                    src, collection, size, detailed, impala)
    installed = (request.user.is_authenticated() and
                 addon.id in request.amo_user.mobile_addons)
    c = {'button': button, 'addon': addon, 'version': button.version,
         'installed': installed}
    if addon.is_webapp():
        template = 'webapps/button.html'
    elif impala:
        template = 'addons/impala/button.html'
    elif mobile:
        template = 'addons/mobile/button.html'
    else:
        template = 'addons/button.html'
    t = jingo.render_to_string(request, template, c)
    return jinja2.Markup(t)
Пример #12
0
def refund_reason(request, contribution, wizard):
    addon = contribution.addon
    if not 'request' in wizard.get_progress():
        return redirect('users.support', contribution.pk, 'request')

    if contribution.is_instant_refund():
        paypal.refund(contribution.paykey)
        paypal_log.info('Refund issued for contribution %r' % contribution.pk)
        # Note: we have to wait for PayPal to issue an IPN before it's
        # completely refunded.
        messages.success(request, _('Refund is being processed.'))
        return redirect('users.purchases')

    form = forms.ContactForm(request.POST or None)
    if request.method == 'POST' and form.is_valid():
        url = absolutify(urlparams(addon.get_dev_url('issue_refund'),
                                   transaction_id=contribution.transaction_id))
        template = jingo.render_to_string(request,
            wizard.tpl('emails/refund-request.txt'),
            context={'addon': addon,
                     'form': form,
                     'user': request.amo_user,
                     'contribution': contribution,
                     'refund_url': url})
        log.info('Refund request sent by user: %s for addon: %s' %
                 (request.amo_user.pk, addon.pk))
        # L10n: %s is the addon name.
        send_mail(_(u'New Refund Request for %s' % addon.name),
                  template, settings.NOBODY_EMAIL,
                  [smart_str(addon.support_email)])
        return redirect(reverse('users.support',
                                args=[contribution.pk, 'refund-sent']))

    return wizard.render(request, wizard.tpl('refund.html'), {'form': form})
Пример #13
0
def email_newsletter_form(ctx, newsletters='mozilla-and-you', title=None,
                          include_country=True, include_language=True,
                          use_thankyou=True, footer=True, process_form=True):
    request = ctx['request']
    context = ctx.get_all()

    success = bool(ctx.get('success'))
    if success and not use_thankyou:
        return

    form = ctx.get('newsletter_form', None)
    if not form:
        form = NewsletterFooterForm(newsletters, get_locale(request))

    context.update(dict(
        id=newsletters,
        title=title,
        include_country=include_country,
        include_language=include_language,
        use_thankyou=use_thankyou,
        footer=footer,
        form=form,
        success=success,
    ))

    html = jingo.render_to_string(request, 'newsletter/includes/form.html', context)
    return jinja2.Markup(html)
Пример #14
0
def email_newsletter_form(ctx, newsletters='mozilla-and-you', title=None,
                          include_country=True, include_language=True,
                          details=None, use_thankyou=True, thankyou_head=None,
                          thankyou_content=None, footer=True, process_form=True,
                          include_title=None, submit_text=None):
    request = ctx['request']
    context = ctx.get_all()

    success = bool(ctx.get('success'))
    if success and not use_thankyou:
        return

    form = ctx.get('newsletter_form', None)
    if not form:
        form = NewsletterFooterForm(newsletters, get_locale(request))

    context.update(dict(
        id=newsletters,
        title=title,
        include_country=include_country,
        include_language=include_language,
        details=details,
        use_thankyou=use_thankyou,
        thankyou_head=thankyou_head,
        thankyou_content=thankyou_content,
        footer=footer,
        include_title=include_title if include_title is not None else footer,
        form=form,
        submit_text=submit_text,
        success=success,
    ))

    html = jingo.render_to_string(request, 'newsletter/includes/form.html', context)
    return jinja2.Markup(html)
Пример #15
0
 def test_rtl_dir_attribute(self):
     """Make sure dir attr is set to 'rtl' when specified as so."""
     html = jingo.render_to_string(self.request, self.template,
                                   {'dir': 'rtl'})
     doc = pq(html)
     dir_attr = doc('html').attr['dir']
     eq_('rtl', dir_attr)
Пример #16
0
    def render(self, name, value, attrs=None):
        topics_and_subtopics = Topic.objects.all()
        topics = [t for t in topics_and_subtopics if t.parent_id is None]

        for topic in topics:
            self.process_topic(value, topic)

            topic.my_subtopics = [t for t in topics_and_subtopics
                                  if t.parent_id == topic.id]

            for subtopic in topic.my_subtopics:
                self.process_topic(value, subtopic)

        # Create a fake request to make jingo happy.
        req = RequestFactory()
        req.META = {}
        req.locale = settings.WIKI_DEFAULT_LANGUAGE

        return jingo.render_to_string(
            req,
            'wiki/includes/product_topics_widget.html',
            {
                'topics': topics,
                'name': name,
            })
Пример #17
0
def submit_form(request, form):
    form_submitted = True

    if form.is_valid():
        form_error = False
        data = form.cleaned_data

        subject = FRAUD_REPORT_EMAIL_SUBJECT % (data['input_url'],
                                                data['input_category'])
        sender = FRAUD_REPORT_EMAIL_FROM
        to = FRAUD_REPORT_EMAIL_TO
        msg = jingo.render_to_string(request, 'legal/emails/fraud-report.txt', data)

        email = EmailMessage(subject, msg, sender, to)

        attachment = data['input_attachment']

        if attachment:
            email.attach(attachment.name, attachment.read(), attachment.content_type)

        email.send()
    else:
        form_error = True

    return {'form_submitted': form_submitted, 'form_error': form_error}
Пример #18
0
def send(request, data):
    """Forward contributor's email to our contacts.

    All emails are sent to [email protected]

    For locales with points of contact, it is also sent to them.
    For locales without, it is also sent to functional area contacts.
    """
    functional_area = FUNCTIONAL_AREAS_DICT[data['interest']]

    from_ = '*****@*****.**'
    subject = 'Inquiry about Mozilla %s' % functional_area.subject
    msg = jingo.render_to_string(request, 'mozorg/emails/infos.txt', data)
    headers = {'Reply-To': data['email']}

    to = ['*****@*****.**']

    cc = None
    if request.locale in LOCALE_CONTACTS:
        cc = LOCALE_CONTACTS[request.locale]
    else:
        cc = functional_area.contacts

    email = EmailMessage(subject, msg, from_, to, cc=cc, headers=headers)
    email.send()
Пример #19
0
def autorespond(request, data):
    """Send an auto-respond email based on chosen field of interest and locale.

    You can add localized responses by creating email messages in
    mozorg/emails/<category.txt>
    """
    functional_area = FUNCTIONAL_AREAS_DICT[data['interest']]

    subject = 'Inquiry about Mozilla %s' % functional_area.subject
    to = [data['email']]
    from_ = '*****@*****.**'
    headers = {}
    msg = ''

    template = 'mozorg/emails/%s.txt' % functional_area.id
    if request.locale != 'en-US' and request.locale in LOCALE_CONTACTS:
        template = '%s/templates/%s' % (request.locale, template)
        reply_to = LOCALE_CONTACTS[request.locale]
    else:
        reply_to = functional_area.contacts

    try:
        msg = jingo.render_to_string(request, template, data)
    except TemplateNotFound:
        # No template found means no auto-response
        return False

    # FIXME Why ?
    msg = msg.replace('\n', '\r\n')
    headers = {'Reply-To': ','.join(reply_to)}

    email = EmailMessage(subject, msg, from_, to, headers=headers)
    email.send()
Пример #20
0
def refund_reason(request, contribution, wizard):
    addon = contribution.addon
    if not 'request' in wizard.get_progress():
        return redirect('users.support', contribution.pk, 'request')

    if contribution.is_instant_refund():
        paypal.refund(contribution.paykey)
        paypal_log.info('Refund issued for contribution %r' % contribution.pk)
        # Note: we have to wait for PayPal to issue an IPN before it's
        # completely refunded.
        messages.success(request, _('Refund is being processed.'))
        return redirect('users.purchases')

    form = forms.ContactForm(request.POST or None)
    if request.method == 'POST' and form.is_valid():
        url = absolutify(urlparams(addon.get_dev_url('issue_refund'),
                                   transaction_id=contribution.transaction_id))
        template = jingo.render_to_string(request,
            wizard.tpl('emails/refund-request.txt'),
            context={'addon': addon,
                     'form': form,
                     'user': request.amo_user,
                     'contribution': contribution,
                     'refund_url': url})
        log.info('Refund request sent by user: %s for addon: %s' %
                 (request.amo_user.pk, addon.pk))
        # L10n: %s is the addon name.
        send_mail(_(u'New Refund Request for %s' % addon.name),
                  template, settings.NOBODY_EMAIL,
                  [smart_str(addon.support_email)])
        return redirect(reverse('users.support',
                                args=[contribution.pk, 'refund-sent']))

    return wizard.render(request, wizard.tpl('refund.html'), {'form': form})
Пример #21
0
def watch_question(request, question_id):
    """Start watching a question for replies or solution."""
    question = get_object_or_404(Question, pk=question_id)
    form = WatchQuestionForm(request.POST)

    # Process the form
    if form.is_valid():
        if request.user.is_authenticated():
            email = request.user.email
        else:
            email = form.cleaned_data['email']
        event_type = form.cleaned_data['event_type']
        create_watch(Question, question.id, email, event_type)

    # Respond to ajax request
    if request.is_ajax():
        if form.is_valid():
            msg = _('You will be notified of updates by email.')
            return HttpResponse(json.dumps({'message': msg}))

        if request.POST.get('from_vote'):
            tmpl = 'questions/includes/question_vote_thanks.html'
        else:
            tmpl = 'questions/includes/email_subscribe.html'

        html = jingo.render_to_string(request, tmpl, {'question': question,
                                                      'watch_form': form})
        return HttpResponse(json.dumps({'html': html}))

    # Respond to normal request
    if form.is_valid():
        return HttpResponseRedirect(question.get_absolute_url())

    return answers(request, question.id, watch_form=form)
Пример #22
0
def mobile_download_button(ctx, id, format='large', build=None):
    if build == 'aurora':
        android_link = download_urls['aurora-mobile']
        version = product_details.mobile_details['alpha_version']
    elif build == 'beta':
        android_link = ('https://market.android.com/details?'
                        'id=org.mozilla.firefox_beta')
        version = product_details.mobile_details['beta_version']
    else:
        android_link = ('https://market.android.com/details?'
                        'id=org.mozilla.firefox')
        version = product_details.mobile_details['version']

    builds = [{'platform': '',
               'platform_pretty': 'Android',
               'download_link': android_link,
               'download_link_direct': android_link}]

    data = {
        'locale_name': 'en-US',
        'version': version,
        'product': 'firefox-mobile',
        'builds': builds,
        'id': id
    }

    html = jingo.render_to_string(ctx['request'],
                                  'mozorg/download_button_%s.html' % format,
                                  data)
    return jinja2.Markup(html)
Пример #23
0
def submit_form(request, form):
    form_submitted = False

    if form.is_valid():
        form_submitted = True
        form_error = False

        honeypot = form.cleaned_data.pop('office_fax')

        if honeypot:
            form_error = True
        else:
            subject = 'Message sent from Privacy Hub'
            sender = form.cleaned_data['sender']
            to = ['yourprivacyis#[email protected]']
            msg = jingo.render_to_string(request,
                                         'privacy/includes/email-info.txt',
                                         form.cleaned_data)
            headers = {'Reply-To': sender}

            email = EmailMessage(subject, msg, sender, to, headers=headers)
            email.send()
    else:
        form_error = True

    return {'form_submitted': form_submitted, 'form_error': form_error}
Пример #24
0
def refund_reason(request, contribution, wizard):
    addon = contribution.addon
    if not 'request' in wizard.get_progress():
        return redirect(
            reverse('users.support', args=[contribution.pk, 'request']))

    form = forms.ContactForm(request.POST or None)
    if request.method == 'POST':
        if form.is_valid():
            # if under 30 minutes, refund
            # TODO(ashort): add in the logic for under 30 minutes.
            template = jingo.render_to_string(
                request,
                wizard.tpl('emails/refund-request.txt'),
                context={
                    'addon': addon,
                    'form': form,
                    'user': request.amo_user,
                    'contribution': contribution
                })
            log.info('Refund request sent by user: %s for addon: %s' %
                     (request.amo_user.pk, addon.pk))
            # L10n: %s is the addon name.
            send_mail(_(u'New Refund Request for %s' % addon.name), template,
                      request.amo_user.email, [smart_str(addon.support_email)])
            return redirect(
                reverse('users.support', args=[contribution.pk,
                                               'refund-sent']))

    return wizard.render(request, wizard.tpl('refund.html'), {
        'contribut': addon,
        'form': form
    })
Пример #25
0
 def test_dir_rtl(self):
     """Make sure dir attr is set to 'rtl' for RTL language."""
     translation.activate('he')
     self.request.LANGUAGE_CODE = 'he'
     html = jingo.render_to_string(self.request, self.template)
     eq_('rtl', pq(html)('html').attr['dir'])
     translation.deactivate()
Пример #26
0
def firefox_footer_links(ctx, channel='release', platform='all'):
    """ Outputs Firefox footer links
    :param ctx: context from calling template.
    :param channel: name of channel: 'release', 'beta' or 'alpha'.
    :param platform: Target platform: 'desktop', 'android', or 'ios'.
    :return: The footer links html.
    """

    show_desktop = platform in ['all', 'desktop']
    show_android = platform in ['all', 'android']
    show_ios = platform in ['all', 'ios']
    alt_channel = '' if channel == 'release' else channel

    # Gather data about the build for each platform
    builds = []

    if show_android:
        builds = android_builds(channel, builds)

    data = {
        'show_desktop': show_desktop,
        'show_android': show_android,
        'show_ios': show_ios,
        'channel': alt_channel,
        'builds': builds,
    }

    html = jingo.render_to_string(ctx['request'],
                                  'firefox/includes/firefox-footer-links.html',
                                  data)
    return jinja2.Markup(html)
Пример #27
0
 def test_dir_rtl(self):
     """Make sure dir attr is set to 'rtl' for RTL language."""
     translation.activate("he")
     self.request.LANGUAGE_CODE = "he"
     html = jingo.render_to_string(self.request, self.template)
     eq_("rtl", pq(html)("html").attr["dir"])
     translation.deactivate()
Пример #28
0
def rendered_content(self):
    template = self.template_name

    if 'user' not in self.context_data:
        self.context_data['user'] = self._request.user

    context_instance = self.resolve_context(self.context_data)

    # Gross, let's figure out if we're in the admin.
    if getattr(self._request, 'current_app', None) == 'admin':
        source = loader.render_to_string(
            template, RequestContext(self._request, context_instance))
        template = jingo.get_env().from_string(source)

        # This interferes with our media() helper.
        if 'media' in self.context_data:
            del self.context_data['media']

    # ``render_to_string`` only accepts a Template instance or a template name,
    # not a list.
    if isinstance(template, (list, tuple)):
        template = loader.select_template(template)
    if isinstance(template, Template):
        template = template.template
    return jingo.render_to_string(self._request, template, self.context_data)
Пример #29
0
 def render(self, module_context="discovery"):
     if module_context == "home":
         self.platform = "ALL"
         self.version = None
     c = dict(promo=self, module_context=module_context, descriptions=self.get_descriptions())
     if self.collection:
         c.update(addons=self.get_addons())
     return jinja2.Markup(jingo.render_to_string(self.request, self.template, c))
Пример #30
0
    def send_email(self, form):
        subject = PRESS_INQUIRY_EMAIL_SUBJECT
        sender = PRESS_INQUIRY_EMAIL_FROM
        to = PRESS_INQUIRY_EMAIL_TO
        msg = jingo.render_to_string(self.request, 'press/emails/press-inquiry.txt', form.cleaned_data)

        email = EmailMessage(subject, msg, sender, to)
        email.send()
Пример #31
0
 def send_activation_email(self, request, link):
     """
     Send an email to an Affiliates user to confirm that they consent to
     linking their account with a Facebook account.
     """
     subject = _("Link your Firefox Affiliates account")
     message = jingo.render_to_string(request, "facebook/link_activation_email.html", {"link": link})
     send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [link.affiliates_user.email])
Пример #32
0
def video(ctx, *args, **kwargs):
    """
    HTML5 Video tag helper.

    Accepted kwargs:
    prefix, w, h, autoplay, poster, preload, id

    Use like this:
    {{ video('http://example.com/myvid.mp4', 'http://example.com/myvid.webm',
             poster='http://example.com/myvid.jpg',
             w=640, h=360) }}

    You can also use a prefix like:
    {{ video('myvid.mp4', 'myvid.webm', prefix='http://example.com') }}

    The prefix does not apply to the poster attribute.

    Finally, MIME type detection happens by file extension. Supported: webm,
    mp4, ogv. If you want anything else, patches welcome.
    """

    filetypes = ('webm', 'ogv', 'mp4')
    mime = {
        'webm': 'video/webm',
        'ogv': 'video/ogg; codecs="theora, vorbis"',
        'mp4': 'video/mp4'
    }

    videos = {}
    for v in args:
        try:
            ext = v.rsplit('.', 1)[1].lower()
        except IndexError:
            # TODO: Perhaps we don't want to swallow this quietly in the future
            continue
        if ext not in filetypes:
            continue
        videos[ext] = (v if 'prefix' not in kwargs else urlparse.urljoin(
            kwargs['prefix'], v))

    if not videos:
        return ''

    # defaults
    data = {
        'w': 640,
        'h': 360,
        'autoplay': False,
        'preload': False,
        'id': 'htmlPlayer'
    }

    data.update(**kwargs)
    data.update(filetypes=filetypes, mime=mime, videos=videos)

    return jinja2.Markup(
        jingo.render_to_string(ctx['request'], 'mozorg/videotag.html', data))
Пример #33
0
def send_mail(request, template, subject, emails, context, perm_setting=None):
    # Link to our newfangled "Account Settings" page.
    manage_url = absolutify(reverse('account.settings')) + '#notifications'
    amo_send_mail(subject, jingo.render_to_string(request, template, context),
                  recipient_list=emails,
                  from_email=settings.NOBODY_EMAIL,
                  use_blacklist=False, perm_setting=perm_setting,
                  manage_url=manage_url,
                  headers={'Reply-To': settings.MKT_REVIEWERS_EMAIL})
Пример #34
0
def download_button(ctx, id, format='large', build=None):
    locale = ctx['request'].locale

    def latest(locale):
        if build == 'aurora':
            return latest_aurora_version(locale)
        elif build == 'beta':
            return latest_beta_version(locale)
        else:
            return latest_version(locale)

    version, platforms = latest(locale) or latest('en-US')

    # Gather data about the build for each platform
    builds = []
    for platform in ['Windows', 'Linux', 'OS X']:
        # Fallback to en-US if this platform/version isn't available
        # for the current locale
        _locale = locale
        if platform not in platforms:
            _locale = 'en-US'

        # Normalize the platform name
        platform = 'os_%s' % platform.lower().replace(' ', '')
        platform_pretty = {
            'os_osx': 'Mac OS X',
            'os_windows': 'Windows',
            'os_linux': 'Linux'
        }[platform]

        # And generate all the info
        download_link = make_download_link('firefox', build, version,
                                           platform, locale)
        download_link_direct = make_download_link('firefox', build, version,
                                                  platform, locale, True)
        builds.append({'platform': platform,
                       'platform_pretty': platform_pretty,
                       'download_link': download_link,
                       'download_link_direct': download_link_direct})

    # Get the native name for current locale
    langs = product_details.languages
    locale_name = langs[locale]['native'] if locale in langs else locale

    data = {
        'locale_name': locale_name,
        'version': version,
        'product': 'firefox',
        'builds': builds,
        'id': id
    }

    html = jingo.render_to_string(ctx['request'],
                                  'mozorg/download_button_%s.html' % format,
                                  data)
    return jinja2.Markup(html)
Пример #35
0
def test_template_substitution_crash():
    translation.activate('xx')

    env = get_env()

    # The localized string has the wrong variable name in it
    s = '{% trans string="heart" %}Broken {{ string }}{% endtrans %}'
    template = env.from_string(s)
    rendered = render_to_string(sentinel.request, template, {})
    eq_(rendered, 'Broken heart')
Пример #36
0
    def test_multi_feeds(self):
        """Ensure that multiple feeds are put into the page when set."""

        feed_urls = (("/feed_one", "First Feed"), ("/feed_two", "Second Feed"))

        doc = pq(jingo.render_to_string(self.request, self.template, {"feeds": feed_urls}))
        feeds = doc('link[type="application/atom+xml"]')
        eq_(2, len(feeds))
        eq_("First Feed", feeds[0].attrib["title"])
        eq_("Second Feed", feeds[1].attrib["title"])
Пример #37
0
def test_template_substitution_crash():
    translation.activate('xx')

    env = get_env()

    # The localized string has the wrong variable name in it
    s = '{% trans string="heart" %}Broken {{ string }}{% endtrans %}'
    template = env.from_string(s)
    rendered = render_to_string(sentinel.request, template, {})
    eq_(rendered, 'Broken heart')
Пример #38
0
    def send_email(self, form):
        subject = PRESS_INQUIRY_EMAIL_SUBJECT
        sender = PRESS_INQUIRY_EMAIL_FROM
        to = PRESS_INQUIRY_EMAIL_TO
        msg = jingo.render_to_string(self.request,
                                     'press/emails/press-inquiry.txt',
                                     form.cleaned_data)

        email = EmailMessage(subject, msg, sender, to)
        email.send()
Пример #39
0
def video(ctx, *args, **kwargs):
    """
    HTML5 Video tag helper.

    Accepted kwargs:
    prefix, w, h, autoplay, poster, preload, id

    Use like this:
    {{ video('http://example.com/myvid.mp4', 'http://example.com/myvid.webm',
             poster='http://example.com/myvid.jpg',
             w=640, h=360) }}

    You can also use a prefix like:
    {{ video('myvid.mp4', 'myvid.webm', prefix='http://example.com') }}

    The prefix does not apply to the poster attribute.

    Finally, MIME type detection happens by file extension. Supported: webm,
    mp4, ogv. If you want anything else, patches welcome.
    """

    filetypes = ('webm', 'ogv', 'mp4')
    mime = {'webm': 'video/webm',
            'ogv': 'video/ogg; codecs="theora, vorbis"',
            'mp4': 'video/mp4'}

    videos = {}
    for v in args:
        try:
            ext = v.rsplit('.', 1)[1].lower()
        except IndexError:
            # TODO: Perhaps we don't want to swallow this quietly in the future
            continue
        if ext not in filetypes:
            continue
        videos[ext] = (v if 'prefix' not in kwargs else
                       urlparse.urljoin(kwargs['prefix'], v))

    if not videos:
        return ''

    # defaults
    data = {
        'w': 640,
        'h': 360,
        'autoplay': False,
        'preload': False,
        'id': 'htmlPlayer'
    }

    data.update(**kwargs)
    data.update(filetypes=filetypes, mime=mime, videos=videos)

    return jinja2.Markup(jingo.render_to_string(
        ctx['request'], 'mozorg/videotag.html', data))
Пример #40
0
def helpful_vote(request, document_slug):
    """Vote for Helpful/Not Helpful document"""
    if 'revision_id' not in request.POST:
        return HttpResponseBadRequest()

    revision = get_object_or_404(
        Revision, id=smart_int(request.POST['revision_id']))
    survey = None

    if revision.document.category == TEMPLATES_CATEGORY:
        return HttpResponseBadRequest()

    if not revision.has_voted(request):
        ua = request.META.get('HTTP_USER_AGENT', '')[:1000]  # 1000 max_length
        vote = HelpfulVote(revision=revision, user_agent=ua)

        if 'helpful' in request.POST:
            vote.helpful = True
            message = _('Glad to hear it &mdash; thanks for the feedback!')
        else:
            message = _('Sorry to hear that.')

        # If user is over the limit, don't save but pretend everything is ok.
        if not request.limited:
            if request.user.is_authenticated():
                vote.creator = request.user
            else:
                vote.anonymous_id = request.anonymous.anonymous_id

            vote.save()
            statsd.incr('wiki.vote')

            # Send a survey if flag is enabled and vote wasn't helpful.
            if 'helpful' not in request.POST:
                survey = jingo.render_to_string(
                    request, 'wiki/includes/unhelpful_survey.html',
                    {'vote_id': vote.id})

            # Save vote metadata: referrer and search query (if available)
            for name in ['referrer', 'query', 'source']:
                val = request.POST.get(name)
                if val:
                    vote.add_metadata(name, val)
    else:
        message = _('You already voted on this Article.')

    if request.is_ajax():
        r = {'message': message}
        if survey:
            r.update(survey=survey)

        return HttpResponse(json.dumps(r))

    return HttpResponseRedirect(revision.document.get_absolute_url())