def newsletter_subscribe(request):
if request.method == 'POST':
newsletters = request.POST.get('newsletters', None)
form = NewsletterFooterForm(newsletters,
l10n_utils.get_locale(request),
request.POST)
errors = []
if form.is_valid():
data = form.cleaned_data
kwargs = {'format': data['fmt']}
# add optional data
kwargs.update(dict((k, data[k]) for k in ['country',
'lang',
'source_url',
'first_name',
'last_name', ]
if data[k]))
try:
basket.subscribe(data['email'], data['newsletters'],
**kwargs)
except basket.BasketException as e:
if e.code == basket.errors.BASKET_INVALID_EMAIL:
errors.append(unicode(invalid_email_address))
else:
log.exception("Error subscribing %s to newsletter %s" %
(data['email'], data['newsletters']))
errors.append(unicode(general_error))
else:
if 'email' in form.errors:
errors.append(_('Please enter a valid email address'))
if 'privacy' in form.errors:
errors.append(_('You must agree to the privacy notice'))
for fieldname in ('fmt', 'lang', 'country'):
if fieldname in form.errors:
errors.extend(form.errors[fieldname])
# form error messages may contain unsanitized user input
errors = map(escape, errors)
if request.is_ajax():
# return JSON
if errors:
resp = {
'success': False,
'errors': errors,
}
else:
resp = {'success': True}
return HttpResponseJSON(resp)
else:
ctx = {'newsletter_form': form}
if not errors:
ctx['success'] = True
return l10n_utils.render(request, 'newsletter/mozilla-and-you.html', ctx)
return l10n_utils.render(request, 'newsletter/mozilla-and-you.html')
def release_notes(request, fx_version, product="Firefox"):
if product == "Firefox OS" and fx_version in ("1.0.1", "1.1", "1.2"):
return l10n_utils.render(request, "firefox/os/notes-%s.html" % fx_version)
try:
release = get_release_or_404(fx_version, product)
except Http404:
release = get_release_or_404(fx_version + "beta", product)
return HttpResponseRedirect(releasenotes_url(release))
new_features, known_issues = release.notes(public_only=not settings.DEV)
return l10n_utils.render(
request,
release_notes_template(release.channel, product, int(release.major_version())),
{
"version": fx_version,
"download_url": get_download_url(release),
"support_url": SUPPORT_URLS.get(product, "https://support.mozilla.org/"),
"release": release,
"equivalent_release_url": equivalent_release_url(release),
"new_features": new_features,
"known_issues": known_issues,
},
)
def process_partnership_form(request, template, success_url_name, template_vars=None, form_kwargs=None):
template_vars = template_vars or {}
form_kwargs = form_kwargs or {}
if request.method == "POST":
form = WebToLeadForm(data=request.POST, **form_kwargs)
msg = "Form invalid"
stat = 400
success = False
if form.is_valid():
data = form.cleaned_data.copy()
honeypot = data.pop("office_fax")
if honeypot:
msg = "Visitor invalid"
stat = 400
else:
interest = data.pop("interest")
data["00NU0000002pDJr"] = interest
data["oid"] = "00DU0000000IrgO"
data["lead_source"] = form_kwargs.get("lead_source", "www.mozilla.org/about/partnerships/")
# As we're doing the Salesforce POST in the background here,
# `retURL` is never visited/seen by the user. I believe it
# is required by Salesforce though, so it should hang around
# as a placeholder (with a valid URL, just in case).
data["retURL"] = "http://www.mozilla.org/en-US/about/" "partnerships?success=1"
r = requests.post("https://www.salesforce.com/servlet/" "servlet.WebToLead?encoding=UTF-8", data)
msg = requests.status_codes._codes.get(r.status_code, ["error"])[0]
stat = r.status_code
success = True
if request.is_ajax():
return HttpResponseJSON({"msg": msg, "errors": form.errors}, status=stat)
# non-AJAX POST
else:
# if form is not valid, render template to retain form data/error messages
if not success:
template_vars.update(csrf(request))
template_vars["form"] = form
template_vars["form_success"] = success
return l10n_utils.render(request, template, template_vars)
# if form is valid, redirect to avoid refresh double post possibility
else:
return HttpResponseRedirect("%s?success" % (reverse(success_url_name)))
# no form POST - build form, add CSRF, & render template
else:
# without auto_id set, all id's get prefixed with 'id_'
form = WebToLeadForm(auto_id="%s", **form_kwargs)
template_vars.update(csrf(request))
template_vars["form"] = form
template_vars["form_success"] = True if ("success" in request.GET) else False
return l10n_utils.render(request, template, template_vars)
def hello(request):
videos = {
'ar': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_arabic',
'de': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_german',
'en-US': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_english',
'es-AR': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_spanish',
'es-CL': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_spanish',
'es-ES': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_spanish',
'es-MX': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_spanish',
'fr': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_french',
'id': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_indonesian',
'it': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_italian',
'ja': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_japanese',
'pl': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_polish',
'pt-BR': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_portugese',
'ru': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_russian',
'tr': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_turkish',
'zh-TW': 'https://videos.cdn.mozilla.net/uploads/FirefoxHello/firefoxhello_intro_chinese'
}
if (waffle.switch_is_active('firefox-hello-2016')):
return l10n_utils.render(request, 'firefox/hello/index-2016.html')
else:
return l10n_utils.render(request, 'firefox/hello/index.html',
{'video_url': videos.get(request.locale, videos.get('en-US'))})
def test_render_no_locale(self, django_render, get_lang_path):
# Our render method doesn't blow up if the request has no .locale
# (can happen on 500 error path, for example)
get_lang_path.return_value = None
request = Mock(spec=object)
# Note: no .locale on request
# Should not cause an exception
render(request, '500.html')
def test_enUS_render(self, django_render):
"""
en-US requests do not look for localized templates and should render the
originally requested template.
"""
request = self.rf.get('/')
request.locale = 'en-US'
render(request, 'firefox/new.html')
django_render.assert_called_with(request, 'firefox/new.html', ANY)
def test_l10n_render(self, django_render):
"""
Non en-US requests with an l10n template should render the l10n
template.
"""
request = self.rf.get('/')
request.locale = 'es-ES'
render(request, 'firefox/new.html')
django_render.assert_called_with(request, 'es-ES/templates/firefox/new.html', ANY)
def test_bedrock_locale_render(self, django_render):
"""
Non en-US requests with a locale-specific template should render the
locale-specific template.
"""
django_render.side_effect = [TemplateDoesNotExist, True]
request = self.rf.get('/')
request.locale = 'es-ES'
render(request, 'firefox/new.html')
django_render.assert_called_with(request, 'firefox/new.es-ES.html', ANY)
def windows_billboards(req):
major_version = req.GET.get('majorVersion')
minor_version = req.GET.get('minorVersion')
if major_version and minor_version:
major_version = float(major_version)
minor_version = float(minor_version)
if major_version == 5 and minor_version == 1:
return l10n_utils.render(req, 'firefox/unsupported/winxp.html')
return l10n_utils.render(req, 'firefox/unsupported/win2k.html')
def firefox_os_index(request):
locale = l10n_utils.get_locale(request)
lang_file = 'firefox/os/index-new'
old_home = 'firefox/os/index.html'
new_home = 'firefox/os/index-new.html'
if waffle.switch_is_active('firefox-os-index-2015') and lang_file_is_active(lang_file, locale):
return l10n_utils.render(request, new_home)
else:
return l10n_utils.render(request, old_home)
def test_default_render(self, django_render):
"""
Non en-US requests without l10n or locale template should render the
originally requested template.
"""
django_render.side_effect = [TemplateDoesNotExist, TemplateDoesNotExist,
True]
request = self.rf.get('/')
request.locale = 'de'
render(request, 'firefox/new.html')
django_render.assert_called_with(request, 'firefox/new.html', ANY)
def latest_fx_redirect(request, fake_version, template_name):
"""
Redirect visitors based on their user-agent.
- Up-to-date Firefox users see the whatsnew page.
- Other Firefox users go to the new page.
- Non Firefox users go to the new page.
"""
query = request.META.get('QUERY_STRING')
query = '?' + query if query else ''
user_agent = request.META.get('HTTP_USER_AGENT', '')
if not 'Firefox' in user_agent:
url = reverse('firefox.new') + query
# TODO : Where to redirect bug 757206
return HttpResponsePermanentRedirect(url)
user_version = '0'
match = UA_REGEXP.search(user_agent)
if match:
user_version = match.group(1)
if not is_current_or_newer(user_version):
url = reverse('firefox.new') + query
return HttpResponsePermanentRedirect(url)
# display alternate firstrun content for en-US with proper funnelcake param in URL
# remove when firstrun test is complete
context = funnelcake_param(request)
if (template_name == 'firefox/firstrun.html'
and request.locale == 'en-US' and
context.get('funnelcake_id', 0) == FX_FIRSTRUN_FUNNELCAKE_CAMPAIGN):
return l10n_utils.render(request, 'firefox/firstrun/a.html')
else:
locales_with_video = {
'en-US': 'american',
'en-GB': 'british',
'de': 'german_final',
'it': 'italian_final',
'ja': 'japanese_final',
'es-AR': 'spanish_final',
'es-CL': 'spanish_final',
'es-ES': 'spanish_final',
'es-MX': 'spanish_final',
}
return l10n_utils.render(request, template_name,
{'locales_with_video': locales_with_video})
def contribute(request, template, return_to_form):
newsletter_form = NewsletterFooterForm('about-mozilla', l10n_utils.get_locale(request))
contribute_success = False
form = ContributeForm(request.POST or None, auto_id=u'id_contribute-%s')
if form.is_valid():
data = form.cleaned_data.copy()
honeypot = data.pop('office_fax')
if not honeypot:
contribute_success = email_contribute.handle_form(request, form)
if contribute_success:
# If form was submitted successfully, return a new, empty
# one.
form = ContributeForm()
else:
# send back a clean form if honeypot was filled in
form = ContributeForm()
return l10n_utils.render(request,
template,
{'form': form,
'newsletter_form': newsletter_form,
'contribute_success': contribute_success,
'return_to_form': return_to_form,
'hide_form': hide_contrib_form(request.locale)})
def sms_send(request):
form = SMSSendForm(request.POST or None)
if request.method == "POST":
error_msg = _("An error occurred in our system. Please try again later.")
error = None
if form.is_valid():
try:
basket.send_sms(form.cleaned_data["number"], SMS_MESSAGES["android"], form.cleaned_data["optin"])
except basket.BasketException:
error = error_msg
else:
number_errors = form.errors.get("number")
if number_errors:
# form error messages may contain unsanitized user input
error = escape(number_errors[0])
else:
error = error_msg
if request.is_ajax():
# return JSON
if error:
resp = {"success": False, "error": error}
else:
resp = {"success": True}
return HttpResponseJSON(resp)
else:
if error:
form.errors["__all__"] = form.error_class([error])
else:
return HttpResponseRedirect(reverse("firefox.android.sms-thankyou"))
return l10n_utils.render(request, "firefox/android/sms-send.html", {"sms_form": form})
def plugincheck(request):
template = 'mozorg/plugincheck.html'
if lang_file_is_active('mozorg/plugincheck-redesign',
l10n_utils.get_locale(request)):
template = 'mozorg/plugincheck-redesign.html'
return l10n_utils.render(request, template)
def releases_index(request, product):
releases = {}
# Starting with Firefox 10, ESR had been offered every 7 major releases, but
# Firefox 59 wasn't ESR. Firefox 60 became the next ESR instead, and since
# then ESR is offered every 8 major releases.
esr_major_versions = (range(10, 59, 7) +
range(60, int(firefox_desktop.latest_version().split('.')[0]), 8))
if product == 'Firefox':
major_releases = firefox_desktop.firefox_history_major_releases
minor_releases = firefox_desktop.firefox_history_stability_releases
for release in major_releases:
major_version = float(re.findall(r'^\d+\.\d+', release)[0])
# The version numbering scheme of Firefox changes sometimes. The second
# number has not been used since Firefox 4, then reintroduced with
# Firefox ESR 24 (Bug 870540). On this index page, 24.1.x should be
# fallen under 24.0. This pattern is a tricky part.
converter = '%g' if int(major_version) in esr_major_versions else '%s'
major_pattern = r'^' + re.escape(converter % round(major_version, 1))
releases[major_version] = {
'major': release,
'minor': sorted(filter(lambda x: re.findall(major_pattern, x),
minor_releases),
key=lambda x: map(lambda y: int(y), x.split('.')))
}
return l10n_utils.render(
request, '{product}/releases/index.html'.format(product=product.lower()),
{'releases': sorted(releases.items(), reverse=True)}
)
def updated(request):
"""View that users come to after submitting on the `existing`
or `updated` pages.
Optional query args:
:param unsub: '1' means we are coming here after the user requested
to unsubscribe all. We want to ask them why. '2' means we are coming
back here after they submitted the form saying why they unsubscribed
all.
"""
unsub = request.REQUEST.get('unsub', '0')
try:
unsub = int(unsub)
except ValueError:
unsub = 0
# Did they do an unsubscribe all? then unsub=1 was passed
unsubscribed_all = unsub == UNSUB_UNSUBSCRIBED_ALL
# Did they submit their reason? then unsub=2 was passed
reasons_submitted = unsub == UNSUB_REASONS_SUBMITTED
# Token might also have been passed (on remove_all only)
token = request.REQUEST.get('token', None)
# token must be a UUID
if token is not None and not UUID_REGEX.match(token):
token = None
# Say thank you unless we're saying something more specific
if not unsub:
messages.add_message(request, messages.INFO, thank_you)
if request.method == 'POST' and reasons_submitted and token:
# Tell basket about their reasons
reasons = []
# Paste together all the reasons that they submitted. Actually,
# paste together the English versions of the reasons they submitted,
# so we can read them. (Well, except for the free-form reason.)
for i, reason in enumerate(REASONS):
if 'reason%d' % i in request.REQUEST:
reasons.append(unicode(reason))
if 'reason-text-p' in request.REQUEST:
reasons.append(request.REQUEST.get('reason-text', ''))
reason_text = "\n\n".join(reasons) + "\n\n"
utils.custom_unsub_reason(token, reason_text)
context = {
'unsubscribed_all': unsubscribed_all,
'reasons_submitted': reasons_submitted,
'token': token,
'reasons': enumerate(REASONS),
}
return l10n_utils.render(request,
'newsletter/updated.html',
context)
def releases_index(request, product):
releases = {}
esr_major_versions = range(
10, int(firefox_get_latest_version(product).split('.')[0]), 7)
if product == 'Firefox':
major_releases = firefox_details.firefox_history_major_releases
minor_releases = firefox_details.firefox_history_stability_releases
elif product == 'Thunderbird':
major_releases = product_details.thunderbird_history_major_releases
minor_releases = product_details.thunderbird_history_stability_releases
for release in major_releases:
major_version = float(re.findall(r'^\d+\.\d+', release)[0])
# The version numbering scheme of Firefox changes sometimes. The second
# number has not been used since Firefox 4, then reintroduced with
# Firefox ESR 24 (Bug 870540). On this index page, 24.1.x should be
# fallen under 24.0. This pattern is a tricky part.
converter = '%g' if int(major_version) in esr_major_versions else '%s'
major_pattern = r'^' + re.escape(converter % round(major_version, 1))
releases[major_version] = {
'major': release,
'minor': sorted(filter(lambda x: re.findall(major_pattern, x),
minor_releases),
key=lambda x: map(lambda y: int(y), x.split('.')))
}
return l10n_utils.render(
request, '{product}/releases/index.html'.format(product=product.lower()),
{'releases': sorted(releases.items(), reverse=True)}
)
def all_downloads(request, channel):
if channel is None:
channel = "release"
if channel == "developer":
channel = "alpha"
if channel == "organizations":
channel = "esr"
version = firefox_desktop.latest_version(channel)
query = request.GET.get("q")
channel_names = {
"release": _("Firefox"),
"beta": _("Firefox Beta"),
"alpha": _("Developer Edition"),
"esr": _("Firefox Extended Support Release"),
}
context = {
"full_builds_version": version.split(".", 1)[0],
"full_builds": firefox_desktop.get_filtered_full_builds(channel, version, query),
"test_builds": firefox_desktop.get_filtered_test_builds(channel, version, query),
"query": query,
"channel": channel,
"channel_name": channel_names[channel],
}
if channel == "esr":
next_version = firefox_desktop.latest_version("esr_next")
if next_version:
context["full_builds_next_version"] = next_version.split(".", 1)[0]
context["full_builds_next"] = firefox_desktop.get_filtered_full_builds("esr_next", next_version, query)
context["test_builds_next"] = firefox_desktop.get_filtered_test_builds("esr_next", next_version, query)
return l10n_utils.render(request, "firefox/all.html", context)
def confirm(request, token):
"""
Confirm subscriptions.
"""
success = generic_error = token_error = False
try:
result = basket.confirm(token)
except basket.BasketException as e:
log.exception("Exception confirming token %s" % token)
if e.code == basket.errors.BASKET_UNKNOWN_TOKEN:
token_error = True
else:
# Any other exception
generic_error = True
else:
if result['status'] == 'ok':
success = True
else:
# Shouldn't happen (errors should raise exception),
# but just in case:
generic_error = True
return l10n_utils.render(
request,
'newsletter/confirm.html',
{'success': success,
'generic_error': generic_error,
'token_error': token_error})
def ios_testflight(request):
# no country field, so no need to send locale
newsletter_form = NewsletterFooterForm('ios-beta-test-flight', '')
return l10n_utils.render(request,
'firefox/testflight.html',
{'newsletter_form': newsletter_form})
def community(request, template, return_to_form):
has_contribute_form = (request.method == 'POST' and
'contribute-form' in request.POST)
contribute_success = False
# This is ugly, but we need to handle two forms. I would love if
# these forms could post to separate pages and get redirected
# back, but we're forced to keep the error/success workflow on the
# same page. Please change this.
if has_contribute_form:
form = ContributeForm(request.POST)
contribute_success = email_contribute.handle_form(request, form)
if contribute_success:
# If form was submitted successfully, return a new, empty
# one.
form = ContributeForm()
else:
form = ContributeForm()
return l10n_utils.render(request,
template,
{'form': form,
'return_to_form': return_to_form,
'contribute_success': contribute_success})
def _view(request):
if newrelic:
# Name this in New Relic to differentiate pages
newrelic.agent.set_transaction_name(
'mozorg.util.page:' + name.replace('.', '_'))
kwargs.setdefault('urlname', name)
return l10n_utils.render(request, tmpl, kwargs)
def one_newsletter_signup(request, template_name):
success = False
# not in a footer, but we use the same form
form = NewsletterFooterForm(request.locale, request.POST or None)
if form.is_valid():
data = form.cleaned_data
request.newsletter_lang = data.get('lang', 'en') or 'en'
kwargs = {
'format': data['fmt'],
}
# add optional data
kwargs.update(dict((k, data[k]) for k in ['country',
'lang',
'source_url']
if data[k]))
try:
basket.subscribe(data['email'], data['newsletter'],
**kwargs)
except basket.BasketException:
log.exception("Error subscribing %s to newsletter %s" %
(data['email'], data['newsletter']))
form.errors['__all__'] = form.error_class([general_error])
else:
success = True
request.newsletter_form = form
request.newsletter_success = success
return l10n_utils.render(request,
template_name,
{})
def one_newsletter_subscribe(request, template_name, target=None):
success = False
# not in a footer, but we use the same form
form = NewsletterFooterForm(request.locale, request.POST or None)
if form.is_valid():
data = form.cleaned_data
request.newsletter_lang = data.get('lang', 'en') or 'en'
kwargs = {
'format': data['fmt'],
}
# add optional data
kwargs.update(dict((k, data[k]) for k in ['country',
'lang',
'source_url']
if data[k]))
newsletter_subscribe(data['email'])
success = True
request.newsletter_form = form
request.newsletter_success = success
return l10n_utils.render(request,
template_name,
{'target': target})
def release_notes(request, version, product='Firefox'):
try:
release = get_release_or_404(version, product)
except Http404:
release = get_release_or_404(version + 'beta', product)
return HttpResponseRedirect(releasenotes_url(release))
new_features, known_issues = release.notes(public_only=not settings.DEV)
return l10n_utils.render(
request,
release_notes_template(release.channel, product,
int(release.major_version())),
{
'version':
version,
'download_url':
get_download_url(release),
'support_url':
SUPPORT_URLS.get(product, 'https://support.mozilla.org/'),
'release':
release,
'equivalent_release_url':
equivalent_release_url(release),
'new_features':
new_features,
'known_issues':
known_issues
})
def workshop(request):
posts = cache.get('fsa-workshop-posts')
dates = cache.get('fsa-workshop-dates')
if posts is None or dates is None:
blogsApiUrl = 'https://blog.mozilla.com.tw/api/get_tag_posts?tag=%E7%8B%90%E7%8B%90%E5%B7%A5%E4%BD%9C%E5%9D%8A&nopaging=true'
eventsApiUrl = 'https://blog.mozilla.com.tw/api/get_posts?post_type=event&scope=all&s=%E7%8B%90%E7%8B%90%E5%B7%A5%E4%BD%9C%E5%9D%8A&nopaging=true'
eventsApi2Url = 'https://blog.mozilla.com.tw/api/get_recent_events?search=%E7%8B%90%E7%8B%90%E5%B7%A5%E4%BD%9C%E5%9D%8A'
blogs = json.loads(urllib2.urlopen(blogsApiUrl).read())['posts']
events = json.loads(urllib2.urlopen(eventsApiUrl).read())['posts']
events2 = json.loads(urllib2.urlopen(eventsApi2Url).read())['posts']
for event2 in events2:
for event in events:
if event2['post_id'] == event['id']:
event['content'] = event2['post_content']
posts = sorted(blogs + events, key=lambda k: k['date'], reverse=True)
dates = []
prevMonth = ''
for post in posts:
post['date'] = datetime.strptime(post['date'], '%Y-%m-%d %H:%M:%S')
month = datetime.strftime(post['date'], '%B')
if prevMonth != month:
post['month'] = month
if post['type'] == 'event':
dates += [post['date'].date().__str__()]
cache.set('fsa-workshop-posts', posts, 60*60*24)
cache.set('fsa-workshop-dates', dates, 60*60*24)
context = {'posts': posts, 'dates': dates}
return l10n_utils.render(request, 'mocotw/community/student/workshop.html', context)
def render_to_response(self, context, **response_kwargs):
redirect_url = self.redirect_to()
if redirect_url is not None:
return HttpResponsePermanentRedirect(redirect_url)
else:
return l10n_utils.render(self.request, self.get_template_names(), context, **response_kwargs)
def all_downloads(request, channel):
if channel is None:
channel = 'release'
if channel == 'organizations':
channel = 'esr'
version = get_latest_version('firefox', channel)
query = request.GET.get('q')
channel_names = {
'release': _('Firefox'),
'beta': _('Firefox Beta'),
'aurora': _('Firefox Aurora'),
'esr': _('Firefox Extended Support Release'),
}
context = {
'full_builds_version': version.split('.', 1)[0],
'full_builds': firefox_details.get_filtered_full_builds(version, query),
'test_builds': firefox_details.get_filtered_test_builds(version, query),
'query': query,
'channel': channel,
'channel_name': channel_names[channel]
}
if channel == 'esr':
next_version = get_latest_version('firefox', 'esr_next')
if next_version:
context['full_builds_next_version'] = next_version.split('.', 1)[0]
context['full_builds_next'] = firefox_details.get_filtered_full_builds(next_version,
query)
context['test_builds_next'] = firefox_details.get_filtered_test_builds(next_version,
query)
return l10n_utils.render(request, 'firefox/all.html', context)
def fraud_report(request):
form = FraudReportForm(auto_id='%s')
form_submitted = False
form_error = False
if request.method == 'POST':
form = FraudReportForm(request.POST, request.FILES)
form_results = submit_form(request, form)
form_submitted = form_results['form_submitted']
form_error = form_results['form_error']
template_vars = {
'form': form,
'form_submitted': form_submitted,
'form_error': form_error,
}
if request.POST and not form_error:
# Seeing the form was submitted without error, redirect, do not simply
# send a response to avoid problem described below.
# @see https://bugzilla.mozilla.org/show_bug.cgi?id=873476 (3.2)
response = redirect(reverse('legal.fraud-report'), template_vars)
response['Location'] += '?submitted=%s' % form_submitted
return response
else:
# If the below is called after a redirect the template_vars will be lost, therefore
# we need to update the form_submitted state from the submitted url parameter.
submitted = request.GET.get('submitted') == 'True'
template_vars['form_submitted'] = submitted
return l10n_utils.render(request, 'legal/fraud-report.html', template_vars)
def ios_testflight(request):
# no country field, so no need to send locale
newsletter_form = NewsletterFooterForm('ios-beta-test-flight', '')
return l10n_utils.render(request, 'firefox/testflight.html',
{'newsletter_form': newsletter_form})
def forums_view(request):
"""Display our mailing lists and newsgroups."""
ctx = {'forums': forums_file}
return l10n_utils.render(request, 'mozorg/about/forums/forums.html', ctx)
def infobar_jsonp(request):
resp = l10n_utils.render(request,
'infobar/infobar.jsonp',
content_type='application/javascript')
resp['Access-Control-Allow-Origin'] = '*'
return resp
def contribute_friends(request):
newsletter_form = NewsletterFooterForm('firefox-friends',
l10n_utils.get_locale(request))
return l10n_utils.render(request, 'mozorg/contribute/friends.html',
{'newsletter_form': newsletter_form})
def firefox_concerts(request):
if switch('firefox_concert_series'):
return l10n_utils.render(request, 'firefox/concerts.html')
else:
return HttpResponseRedirect(reverse('firefox'))
def newsletter_subscribe(request):
if request.method == "POST":
newsletters = request.POST.get("newsletters")
form = NewsletterFooterForm(newsletters,
l10n_utils.get_locale(request),
request.POST)
errors = []
if form.is_valid():
data = form.cleaned_data
kwargs = {"format": data["fmt"]}
# add optional data
kwargs.update({
k: data[k]
for k in [
"country",
"lang",
"source_url",
"first_name",
"last_name",
] if data[k]
})
# NOTE this is not a typo; Referrer is misspelled in the HTTP spec
# https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.36
if not kwargs.get("source_url") and request.headers.get("Referer"):
kwargs["source_url"] = request.headers["Referer"]
try:
basket.subscribe(data["email"], data["newsletters"], **kwargs)
except basket.BasketException as e:
if e.code == basket.errors.BASKET_INVALID_EMAIL:
errors.append(str(invalid_email_address))
else:
log.exception(
f"Error subscribing {data['email']} to newsletter {data['newsletters']}"
)
errors.append(str(general_error))
else:
if "email" in form.errors:
errors.append(ftl("newsletter-form-please-enter-a-valid"))
if "privacy" in form.errors:
errors.append(ftl("newsletter-form-you-must-agree-to"))
for fieldname in ("newsletters", "fmt", "lang", "country"):
if fieldname in form.errors:
errors.extend(form.errors[fieldname])
# form error messages may contain unsanitized user input
errors = [escape(e) for e in errors]
if request.headers.get("x-requested-with") == "XMLHttpRequest":
# return JSON
if errors:
resp = {
"success": False,
"errors": errors,
}
else:
resp = {"success": True}
return JsonResponse(resp)
else:
ctx = {"newsletter_form": form}
if not errors:
ctx["success"] = True
return l10n_utils.render(request,
"newsletter/index.html",
ctx,
ftl_files=FTL_FILES)
return l10n_utils.render(request,
"newsletter/index.html",
ftl_files=FTL_FILES)
def existing(request, token=None):
"""Manage subscriptions. If token is provided, user can manage their
existing subscriptions, to subscribe, unsubscribe, change email or
language preferences, etc. If no token is provided, user can
fill in their email and language preferences and sign up for
newsletters.
@param HTTPRequest request: Django request object
@param string token: A UUID that identifies this user to the backend. It's
sent to users in each newsletter as part of a link to this page, so they
can manage their subscriptions without needing an account somewhere with
userid & password.
"""
locale = l10n_utils.get_locale(request)
if not token:
return redirect(reverse("newsletter.recovery"))
if not UUID_REGEX.match(token):
# Bad token
messages.add_message(request, messages.ERROR, bad_token)
# Redirect to the recovery page
return redirect(reverse("newsletter.recovery"))
if waffle.switch("newsletter-maintenance-mode"):
return l10n_utils.render(request,
"newsletter/existing.html",
ftl_files=FTL_FILES)
unsub_parm = None
# Example user:
#
# {u'lang': u'en',
# u'format': u'H',
# u'country': u'us',
# u'newsletters': [u'firefox-tips', u'mobile'],
# u'created-date': u'1/30/2013 12:46:05 PM',
# u'token': u'some-uuid',
# u'email': u'*****@*****.**'
# }
has_fxa = "fxa" in request.GET
user = None
if token:
try:
# ask for fxa status if not passed in the URL
params = None if has_fxa else {"fxa": 1}
user = basket.request("get", "user", token=token, params=params)
except basket.BasketNetworkException:
# Something wrong with basket backend, no point in continuing,
# we'd probably fail to subscribe them anyway.
log.exception("Basket timeout")
messages.add_message(request, messages.ERROR, general_error)
return l10n_utils.render(request,
"newsletter/existing.html",
ftl_files=FTL_FILES)
except basket.BasketException as e:
log.exception("FAILED to get user from token (%s)", e.desc)
if not user:
# Bad or no token
messages.add_message(request, messages.ERROR, bad_token)
# Redirect to the recovery page
return redirect(reverse("newsletter.recovery"))
# if `has_fxa` not returned from basket, set it from the URL
user.setdefault("has_fxa", has_fxa)
# Get the newsletter data - it's a dictionary of dictionaries
newsletter_data = utils.get_newsletters()
# Figure out which newsletters to display, and whether to show them
# as already subscribed.
initial = []
for newsletter, data in newsletter_data.items():
# Only show a newsletter if it has ['active'] == True and
# ['show'] == True or the user is already subscribed
if not data.get("active", False):
continue
if (data.get("show", False) or newsletter in user["newsletters"]
or (user["has_fxa"] and newsletter in settings.FXA_NEWSLETTERS
and any(
locale.startswith(loc)
for loc in settings.FXA_NEWSLETTERS_LOCALES))):
langs = data["languages"]
nstrings = NEWSLETTER_STRINGS.get(newsletter)
if nstrings:
if newsletter == "firefox-accounts-journey" and locale.startswith(
"en"):
# alternate english title
title = "Firefox Account Tips"
else:
title = nstrings["title"]
description = nstrings.get("description", "")
else:
title = data["title"]
description = data["description"]
form_data = {
"title": Markup(title),
"subscribed_radio": newsletter in user["newsletters"],
"subscribed_check": newsletter in user["newsletters"],
"newsletter": newsletter,
"description": Markup(description),
"english_only": len(langs) == 1 and langs[0].startswith("en"),
"indented": data.get("indent", False),
}
if "order" in data:
form_data["order"] = data["order"]
initial.append(form_data)
# Sort by 'order' field if we were given it; otherwise, by title
if initial:
keyfield = "order" if "order" in initial[0] else "title"
initial.sort(key=itemgetter(keyfield))
NewsletterFormSet = formset_factory(NewsletterForm,
extra=0,
max_num=len(initial))
if request.method == "POST":
form_kwargs = {}
# Temporary form so we can see if they checked 'remove_all'. If
# they did, no point in validating the newsletters formset and it would
# look dumb to complain about it.
form = ManageSubscriptionsForm(locale, data=request.POST, initial=user)
remove_all = form.is_valid() and form.cleaned_data["remove_all"]
formset_is_valid = False
if remove_all:
# We don't care about the newsletter formset
formset_is_valid = True
# Make an initialized one in case we fall through to the bottom
formset = NewsletterFormSet(initial=initial)
else:
# We do need to validate the newsletter formset
formset = NewsletterFormSet(request.POST, initial=initial)
# Set `newsletters` to the list of newsletters they want.
# After this, we don't need the formset anymore.
newsletters = None
if formset.is_valid():
formset_is_valid = True
# What newsletters do they say they want to be subscribed to?
newsletters = {
subform.cleaned_data["newsletter"]
for subform in formset
if (subform.cleaned_data["subscribed_radio"]
or subform.cleaned_data["subscribed_check"])
}
form_kwargs["newsletters"] = newsletters
form = ManageSubscriptionsForm(locale,
data=request.POST,
initial=user,
**form_kwargs)
if formset_is_valid and form.is_valid():
data = form.cleaned_data
# Update their format and locale information, if it has changed.
# Also pass their updated list of newsletters they want to be
# subscribed to, for basket to implement.
kwargs = {}
for k in ["lang", "format", "country"]:
if user[k] != data[k]:
kwargs[k] = data[k]
if not remove_all:
kwargs["newsletters"] = ",".join(newsletters)
if kwargs:
if settings.BASKET_API_KEY:
kwargs["api_key"] = settings.BASKET_API_KEY
# always send lang so basket doesn't try to guess
kwargs["lang"] = data["lang"]
try:
basket.update_user(token, **kwargs)
except basket.BasketException:
log.exception("Error updating user in basket")
messages.add_message(request, messages.ERROR,
general_error)
return l10n_utils.render(request,
"newsletter/existing.html",
ftl_files=FTL_FILES)
# If they chose to remove all, tell basket that they've opted out
if remove_all:
try:
basket.unsubscribe(token, user["email"], optout=True)
except (basket.BasketException, requests.Timeout):
log.exception("Error updating subscriptions in basket")
messages.add_message(request, messages.ERROR,
general_error)
return l10n_utils.render(request,
"newsletter/existing.html",
ftl_files=FTL_FILES)
# We need to pass their token to the next view
url = reverse(
"newsletter.updated"
) + f"?unsub={UNSUB_UNSUBSCRIBED_ALL}&token={token}"
return redirect(url)
# We're going to redirect, so the only way to tell the next
# view that we should display the welcome message in the
# template is to modify the URL
url = reverse("newsletter.updated")
if unsub_parm:
url += f"?unsub={unsub_parm}"
return redirect(url)
# FALL THROUGH so page displays errors
else:
form = ManageSubscriptionsForm(locale, initial=user)
formset = NewsletterFormSet(initial=initial)
# For the template, we want a dictionary whose keys are language codes
# and each value is the list of newsletter keys that are available in
# that language code.
newsletter_languages = defaultdict(list)
for newsletter, data in newsletter_data.items():
for lang in data["languages"]:
newsletter_languages[lang].append(newsletter)
newsletter_languages = mark_safe(json.dumps(newsletter_languages))
# We also want a list of the newsletters the user is already subscribed to
already_subscribed = mark_safe(json.dumps(user["newsletters"]))
context = {
"did_confirm": request.GET.get("confirm", None) == "1",
"form": form,
"formset": formset,
"newsletter_languages": newsletter_languages,
"newsletters_subscribed": already_subscribed,
"email": user["email"],
}
return l10n_utils.render(request,
"newsletter/existing.html",
context,
ftl_files=FTL_FILES)
def contribute_embed(request):
return l10n_utils.render(request,
'mozorg/contribute/contribute-embed.html')
def hacks_newsletter(request):
return l10n_utils.render(request,
'mozorg/newsletter/hacks.mozilla.org.html')
def csrf_failure(request, reason=''):
template_vars = {'reason': reason}
return l10n_utils.render(request,
'mozorg/csrf-failure.html',
template_vars,
status=403)
def new(request):
# Remove legacy query parameters (Bug 1236791)
if request.GET.get('product', None) or request.GET.get('os', None):
return HttpResponsePermanentRedirect(reverse('firefox.new'))
scene = request.GET.get('scene', None)
# note: v and xv params only allow a-z, A-Z, 0-9, -, and _ charcaters
experience = request.GET.get('xv', None)
variant = request.GET.get('v', None)
locale = l10n_utils.get_locale(request)
# ensure variant matches pre-defined value
if variant not in ['a', 'b',
'c']: # place expected ?v= values in this list
variant = None
if scene == '2':
# send to new permanent scene2 URL (bug 1438302)
thanks_url = reverse('firefox.download.thanks')
query_string = request.META.get('QUERY_STRING', '')
if query_string:
thanks_url = '?'.join(
[thanks_url,
force_text(query_string, errors='ignore')])
return HttpResponsePermanentRedirect(thanks_url)
# if no/incorrect scene specified, show scene 1
else:
if locale == 'de':
if experience == 'berlin':
template = 'firefox/new/berlin/scene1.html'
elif experience == 'aus-gruenden':
template = 'firefox/new/berlin/scene1-aus-gruenden.html'
elif experience == 'herz':
template = 'firefox/new/berlin/scene1-herz.html'
elif experience == 'geschwindigkeit':
template = 'firefox/new/berlin/scene1-gesch.html'
elif experience == 'privatsphare':
template = 'firefox/new/berlin/scene1-privat.html'
elif experience == 'auf-deiner-seite':
template = 'firefox/new/berlin/scene1-auf-deiner-seite.html'
else:
template = 'firefox/new/scene1.html'
elif switch('firefox-yandex') and locale == 'ru':
template = 'firefox/new/yandex/scene1.html'
elif locale == 'en-US':
if experience == 'betterbrowser':
template = 'firefox/new/better-browser/scene1.html'
elif experience == 'safari':
template = 'firefox/new/compare/scene1-safari.html'
elif experience == 'edge':
template = 'firefox/new/compare/scene1-edge.html'
elif variant in ['a', 'b', 'c']:
template = 'firefox/new/install/scene1.html'
else:
template = 'firefox/new/scene1.html'
else:
template = 'firefox/new/scene1.html'
# no harm done by passing 'v' to template, even when no experiment is running
# (also makes tests easier to maintain by always sending a context)
return l10n_utils.render(request, template, {
'experience': experience,
'v': variant
})
def newsletter_subscribe(request):
if request.method == 'POST':
newsletters = request.POST.get('newsletters', None)
form = NewsletterFooterForm(newsletters,
l10n_utils.get_locale(request),
request.POST)
errors = []
if form.is_valid():
data = form.cleaned_data
kwargs = {'format': data['fmt']}
# add optional data
kwargs.update(
dict((k, data[k]) for k in [
'country',
'lang',
'source_url',
'first_name',
'last_name',
] if data[k]))
# NOTE this is not a typo; Referrer is misspelled in the HTTP spec
# https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.36
if not kwargs.get('source_url') and request.META.get(
'HTTP_REFERER'):
kwargs['source_url'] = request.META['HTTP_REFERER']
try:
basket.subscribe(data['email'], data['newsletters'], **kwargs)
except basket.BasketException as e:
if e.code == basket.errors.BASKET_INVALID_EMAIL:
errors.append(str(invalid_email_address))
else:
log.exception("Error subscribing %s to newsletter %s" %
(data['email'], data['newsletters']))
errors.append(str(general_error))
else:
if 'email' in form.errors:
errors.append(ftl('newsletter-form-please-enter-a-valid'))
if 'privacy' in form.errors:
errors.append(ftl('newsletter-form-you-must-agree-to'))
for fieldname in ('fmt', 'lang', 'country'):
if fieldname in form.errors:
errors.extend(form.errors[fieldname])
# form error messages may contain unsanitized user input
errors = [escape(e) for e in errors]
if request.is_ajax():
# return JSON
if errors:
resp = {
'success': False,
'errors': errors,
}
else:
resp = {'success': True}
return JsonResponse(resp)
else:
ctx = {'newsletter_form': form}
if not errors:
ctx['success'] = True
return l10n_utils.render(request,
'newsletter/index.html',
ctx,
ftl_files=FTL_FILES)
return l10n_utils.render(request,
'newsletter/index.html',
ftl_files=FTL_FILES)
def firefox_all(request):
product_android = firefox_android
product_desktop = firefox_desktop
# Human-readable product labels
products = OrderedDict(
[
('desktop_release', 'Firefox'),
('desktop_beta', 'Firefox Beta'),
('desktop_developer', 'Firefox Developer Edition'),
('desktop_nightly', 'Firefox Nightly'),
('desktop_esr', 'Firefox Extended Support Release'),
('android_release', 'Firefox Android'),
('android_beta', 'Firefox Android Beta'),
('android_nightly', 'Firefox Android Nightly'),
]
)
channel_release = 'release'
channel_beta = 'beta'
channel_dev = 'devedition'
channel_nightly = 'nightly'
channel_esr = 'esr'
channel_esr_next = 'esr_next'
latest_release_version_desktop = product_desktop.latest_version(channel_release)
latest_beta_version_desktop = product_desktop.latest_version(channel_beta)
latest_developer_version_desktop = product_desktop.latest_version(channel_dev)
latest_nightly_version_desktop = product_desktop.latest_version(channel_nightly)
latest_esr_version_desktop = product_desktop.latest_version(channel_esr)
latest_esr_next_version_desktop = product_desktop.latest_version(channel_esr_next)
latest_release_version_android = product_android.latest_version(channel_release)
latest_beta_version_android = product_android.latest_version(channel_beta)
latest_nightly_version_android = product_android.latest_version(channel_nightly)
context = {
'products': products.items(),
'desktop_release_platforms': product_desktop.platforms(channel_release),
'desktop_release_full_builds': product_desktop.get_filtered_full_builds(
channel_release, latest_release_version_desktop
),
'desktop_release_channel_label': product_desktop.channel_labels.get(
channel_release, 'Firefox'
),
'desktop_release_latest_version': latest_release_version_desktop,
'desktop_beta_platforms': product_desktop.platforms(channel_beta),
'desktop_beta_full_builds': product_desktop.get_filtered_full_builds(
channel_beta, latest_beta_version_desktop
),
'desktop_beta_channel_label': product_desktop.channel_labels.get(
channel_beta, 'Firefox'
),
'desktop_beta_latest_version': latest_beta_version_desktop,
'desktop_developer_platforms': product_desktop.platforms(channel_dev),
'desktop_developer_full_builds': product_desktop.get_filtered_full_builds(
channel_dev, latest_developer_version_desktop
),
'desktop_developer_channel_label': product_desktop.channel_labels.get(
channel_dev, 'Firefox'
),
'desktop_developer_latest_version': latest_developer_version_desktop,
'desktop_nightly_platforms': product_desktop.platforms(channel_nightly),
'desktop_nightly_full_builds': product_desktop.get_filtered_full_builds(
channel_nightly, latest_nightly_version_desktop
),
'desktop_nightly_channel_label': product_desktop.channel_labels.get(
channel_nightly, 'Firefox'
),
'desktop_nightly_latest_version': latest_nightly_version_desktop,
'desktop_esr_platforms': product_desktop.platforms(channel_esr),
'desktop_esr_full_builds': product_desktop.get_filtered_full_builds(
channel_esr, latest_esr_version_desktop
),
'desktop_esr_channel_label': product_desktop.channel_labels.get(
channel_esr, 'Firefox'
),
'desktop_esr_latest_version': latest_esr_version_desktop,
'android_release_platforms': product_android.platforms(channel_release),
'android_release_full_builds': product_android.get_filtered_full_builds(
channel_release, latest_release_version_android
),
'android_release_channel_label': product_android.channel_labels.get(
channel_release, 'Firefox'
),
'android_release_latest_version': latest_release_version_android,
'android_beta_platforms': product_android.platforms(channel_beta),
'android_beta_full_builds': product_android.get_filtered_full_builds(
channel_beta, latest_beta_version_android
),
'android_beta_channel_label': product_android.channel_labels.get(
channel_beta, 'Firefox'
),
'android_beta_latest_version': latest_beta_version_android,
'android_nightly_platforms': product_android.platforms(channel_nightly),
'android_nightly_full_builds': product_android.get_filtered_full_builds(
channel_nightly, latest_nightly_version_android
),
'android_nightly_channel_label': product_android.channel_labels.get(
channel_nightly, 'Firefox'
),
'android_nightly_latest_version': latest_nightly_version_android,
}
if latest_esr_next_version_desktop:
context['desktop_esr_platforms_next'] = product_desktop.platforms(
channel_esr_next, True
)
context[
'desktop_esr_full_builds_next'
] = product_desktop.get_filtered_full_builds(
channel_esr_next, latest_esr_next_version_desktop
)
context['desktop_esr_channel_label_next'] = (
product_desktop.channel_labels.get(channel_esr_next, 'Firefox'),
)
context['desktop_esr_next_version'] = latest_esr_next_version_desktop
return l10n_utils.render(request, 'firefox/all-unified.html', context)
def home(request):
return l10n_utils.render(request, 'mozorg/home/home.html')
def system_requirements(request, version, product="Firefox"):
release = get_release_or_404(version, product)
dir = "firefox"
return l10n_utils.render(request, f"{dir}/releases/system_requirements.html", {"release": release, "version": version})
def firefox_home(request):
return l10n_utils.render(request, 'firefox/home/index.html')
def process_partnership_form(request, template, success_url_name, template_vars=None, form_kwargs=None):
template_vars = template_vars or {}
form_kwargs = form_kwargs or {}
if request.method == 'POST':
form = WebToLeadForm(data=request.POST, **form_kwargs)
msg = 'Form invalid'
stat = 400
success = False
if form.is_valid():
data = form.cleaned_data.copy()
honeypot = data.pop('office_fax')
if honeypot:
msg = 'Visitor invalid'
stat = 400
else:
interest = data.pop('interest')
data['00NU0000002pDJr'] = interest
data['oid'] = '00DU0000000IrgO'
data['lead_source'] = form_kwargs.get('lead_source', 'www.mozilla.org/about/partnerships/')
# As we're doing the Salesforce POST in the background here,
# `retURL` is never visited/seen by the user. I believe it
# is required by Salesforce though, so it should hang around
# as a placeholder (with a valid URL, just in case).
data['retURL'] = ('http://www.mozilla.org/en-US/about/'
'partnerships?success=1')
r = requests.post('https://www.salesforce.com/servlet/'
'servlet.WebToLead?encoding=UTF-8', data)
msg = requests.status_codes._codes.get(r.status_code, ['error'])[0]
stat = r.status_code
success = True
if request.is_ajax():
return HttpResponseJSON({'msg': msg, 'errors': form.errors}, status=stat)
# non-AJAX POST
else:
# if form is not valid, render template to retain form data/error messages
if not success:
template_vars.update(csrf(request))
template_vars['form'] = form
template_vars['form_success'] = success
return l10n_utils.render(request, template, template_vars)
# if form is valid, redirect to avoid refresh double post possibility
else:
return HttpResponseRedirect("%s?success" % (reverse(success_url_name)))
# no form POST - build form, add CSRF, & render template
else:
# without auto_id set, all id's get prefixed with 'id_'
form = WebToLeadForm(auto_id='%s', **form_kwargs)
template_vars.update(csrf(request))
template_vars['form'] = form
template_vars['form_success'] = True if ('success' in request.GET) else False
return l10n_utils.render(request, template, template_vars)
def firefox_all(request):
ftl_files = 'firefox/all'
product_android = firefox_android
product_desktop = firefox_desktop
product_ios = firefox_ios
# Human-readable product labels
products = OrderedDict([
('desktop_release',
ftl('firefox-all-product-firefox', ftl_files=ftl_files)),
('desktop_beta',
ftl('firefox-all-product-firefox-beta', ftl_files=ftl_files)),
('desktop_developer',
ftl('firefox-all-product-firefox-developer', ftl_files=ftl_files)),
('desktop_nightly',
ftl('firefox-all-product-firefox-nightly', ftl_files=ftl_files)),
('desktop_esr',
ftl('firefox-all-product-firefox-esr', ftl_files=ftl_files)),
('android_release',
ftl('firefox-all-product-firefox-android', ftl_files=ftl_files)),
('android_beta',
ftl('firefox-all-product-firefox-android-beta', ftl_files=ftl_files)),
('android_nightly',
ftl('firefox-all-product-firefox-android-nightly',
ftl_files=ftl_files)),
('ios_release',
ftl('firefox-all-product-firefox-ios', ftl_files=ftl_files)),
])
channel_release = 'release'
channel_beta = 'beta'
channel_dev = 'devedition'
channel_nightly = 'nightly'
channel_esr = 'esr'
channel_esr_next = 'esr_next'
latest_release_version_desktop = product_desktop.latest_version(
channel_release)
latest_beta_version_desktop = product_desktop.latest_version(channel_beta)
latest_developer_version_desktop = product_desktop.latest_version(
channel_dev)
latest_nightly_version_desktop = product_desktop.latest_version(
channel_nightly)
latest_esr_version_desktop = product_desktop.latest_version(channel_esr)
latest_esr_next_version_desktop = product_desktop.latest_version(
channel_esr_next)
latest_release_version_android = product_android.latest_version(
channel_release)
latest_beta_version_android = product_android.latest_version(channel_beta)
latest_nightly_version_android = product_android.latest_version(
channel_nightly)
latest_release_version_ios = product_ios.latest_version(channel_release)
lang_multi = ftl('firefox-all-lang-multi', ftl_files=ftl_files)
context = {
'products':
products.items(),
'desktop_release_platforms':
product_desktop.platforms(channel_release),
'desktop_release_full_builds':
product_desktop.get_filtered_full_builds(
channel_release, latest_release_version_desktop),
'desktop_release_channel_label':
product_desktop.channel_labels.get(channel_release, 'Firefox'),
'desktop_release_latest_version':
latest_release_version_desktop,
'desktop_beta_platforms':
product_desktop.platforms(channel_beta),
'desktop_beta_full_builds':
product_desktop.get_filtered_full_builds(channel_beta,
latest_beta_version_desktop),
'desktop_beta_channel_label':
product_desktop.channel_labels.get(channel_beta, 'Firefox'),
'desktop_beta_latest_version':
latest_beta_version_desktop,
'desktop_developer_platforms':
product_desktop.platforms(channel_dev),
'desktop_developer_full_builds':
product_desktop.get_filtered_full_builds(
channel_dev, latest_developer_version_desktop),
'desktop_developer_channel_label':
product_desktop.channel_labels.get(channel_dev, 'Firefox'),
'desktop_developer_latest_version':
latest_developer_version_desktop,
'desktop_nightly_platforms':
product_desktop.platforms(channel_nightly),
'desktop_nightly_full_builds':
product_desktop.get_filtered_full_builds(
channel_nightly, latest_nightly_version_desktop),
'desktop_nightly_channel_label':
product_desktop.channel_labels.get(channel_nightly, 'Firefox'),
'desktop_nightly_latest_version':
latest_nightly_version_desktop,
'desktop_esr_platforms':
product_desktop.platforms(channel_esr),
'desktop_esr_full_builds':
product_desktop.get_filtered_full_builds(channel_esr,
latest_esr_version_desktop),
'desktop_esr_channel_label':
product_desktop.channel_labels.get(channel_esr, 'Firefox'),
'desktop_esr_latest_version':
latest_esr_version_desktop,
'android_release_platforms': [('android', 'Android')],
'android_release_full_builds': [{
'locale': 'multi',
'name_en': lang_multi,
'name_native': lang_multi,
'platforms': {
'android': {
'download_url': settings.GOOGLE_PLAY_FIREFOX_LINK_UTMS
}
}
}],
'android_release_channel_label':
product_android.channel_labels.get(channel_release, 'Firefox'),
'android_release_latest_version':
latest_release_version_android,
'android_beta_platforms': [('android', 'Android')],
'android_beta_full_builds': [{
'locale': 'multi',
'name_en': lang_multi,
'name_native': lang_multi,
'platforms': {
'android': {
'download_url': settings.GOOGLE_PLAY_FIREFOX_BETA_LINK
}
}
}],
'android_beta_channel_label':
product_android.channel_labels.get(channel_beta, 'Firefox'),
'android_beta_latest_version':
latest_beta_version_android,
'android_nightly_platforms': [('android', 'Android')],
'android_nightly_full_builds': [{
'locale': 'multi',
'name_en': lang_multi,
'name_native': lang_multi,
'platforms': {
'android': {
'download_url': settings.GOOGLE_PLAY_FIREFOX_NIGHTLY_LINK
}
}
}],
'android_nightly_channel_label':
product_android.channel_labels.get(channel_nightly, 'Firefox'),
'android_nightly_latest_version':
latest_nightly_version_android,
'ios_release_platforms': [('ios', 'iOS')],
'ios_release_full_builds': [{
'locale': 'multi',
'name_en': lang_multi,
'name_native': lang_multi,
'platforms': {
'ios': {
'download_url':
settings.APPLE_APPSTORE_FIREFOX_LINK.replace(
'/{country}/', '/')
}
}
}],
'ios_release_channel_label':
product_ios.channel_labels.get(channel_release, 'Firefox'),
'ios_release_latest_version':
latest_release_version_ios,
}
if latest_esr_next_version_desktop:
context['desktop_esr_platforms_next'] = product_desktop.platforms(
channel_esr_next, True)
context[
'desktop_esr_full_builds_next'] = product_desktop.get_filtered_full_builds(
channel_esr_next, latest_esr_next_version_desktop)
context['desktop_esr_channel_label_next'] = (
product_desktop.channel_labels.get(channel_esr_next, 'Firefox'), )
context['desktop_esr_next_version'] = latest_esr_next_version_desktop
return l10n_utils.render(request,
'firefox/all-unified.html',
context,
ftl_files=ftl_files)
def new(request):
# Remove legacy query parameters (Bug 1236791)
if request.GET.get('product', None) or request.GET.get('os', None):
return HttpResponsePermanentRedirect(reverse('firefox.new'))
scene = request.GET.get('scene', None)
experience = request.GET.get('xv', None)
variant = request.GET.get('v', None)
locale = l10n_utils.get_locale(request)
if scene == '2':
# `batmprivate`, `fast`, `wait-face`, `reggiewatts` variations are currently localized for both en-US and de locales.
if lang_file_is_active('firefox/new/batm', locale) and experience == 'batmprivate':
template = 'firefox/new/batm/scene2.html'
elif lang_file_is_active('firefox/new/sem', locale) and experience == 'fast':
template = 'firefox/new/sem/fast/scene2.html'
elif lang_file_is_active('firefox/new/wait-face', locale) and experience == 'waitface':
template = 'firefox/new/wait-face/scene2.html'
elif lang_file_is_active('firefox/new/reggiewatts', locale) and experience == 'reggiewatts':
template = 'firefox/new/reggie-watts/scene2.html'
elif locale == 'en-US':
if experience == 'breakfree':
template = 'firefox/new/break-free/scene2.html'
elif experience == 'wayofthefox':
template = 'firefox/new/way-of-the-fox/scene2.html'
elif experience == 'privatenotoption':
template = 'firefox/new/fx-lifestyle/private-not-option/scene2.html'
elif experience == 'conformitynotdefault':
template = 'firefox/new/fx-lifestyle/conformity-not-default/scene2.html'
elif experience == 'browseuptoyou':
template = 'firefox/new/fx-lifestyle/browse-up-to-you/scene2.html'
elif experience == 'moreprotection':
template = 'firefox/new/fx-lifestyle/more-protection/scene2.html'
elif experience == 'workingout':
template = 'firefox/new/fx-lifestyle/working-out/scene2.html'
elif experience == 'youdoyou':
template = 'firefox/new/fx-lifestyle/you-do-you/scene2.html'
elif experience == 'itsyourweb':
template = 'firefox/new/fx-lifestyle/its-your-web/scene2.html'
elif experience == 'secure':
template = 'firefox/new/sem/secure/scene2.html'
elif experience == 'nonprofit':
template = 'firefox/new/sem/nonprofit/scene2.html'
elif experience == 'compatible':
template = 'firefox/new/sem/compatible/scene2.html'
elif experience == 'unsupported-browser':
template = 'firefox/new/sem/unsupported-browser/scene2.html'
elif experience in ['batmfree', 'batmnimble', 'batmresist']:
template = 'firefox/new/batm/scene2.html'
else:
template = 'firefox/new/scene2.html'
else:
template = 'firefox/new/scene2.html'
# if no/incorrect scene specified, show scene 1
else:
if lang_file_is_active('firefox/new/batm', locale) and experience == 'batmprivate':
if variant == 'b' and locale == 'en-US':
template = 'firefox/new/batm/machine.html'
else:
template = 'firefox/new/batm/private.html'
elif lang_file_is_active('firefox/new/sem', locale) and experience == 'fast':
template = 'firefox/new/sem/fast/scene1.html'
elif lang_file_is_active('firefox/new/wait-face', locale) and experience == 'waitface':
if variant == 'b':
template = 'firefox/new/wait-face/scene1-video.html'
else:
template = 'firefox/new/wait-face/scene1.html'
elif lang_file_is_active('firefox/new/reggiewatts', locale) and experience == 'reggiewatts':
template = 'firefox/new/reggie-watts/scene1.html'
elif locale == 'en-US':
if experience == 'breakfree':
template = 'firefox/new/break-free/scene1.html'
elif experience == 'wayofthefox':
template = 'firefox/new/way-of-the-fox/scene1.html'
elif experience == 'privatenotoption':
template = 'firefox/new/fx-lifestyle/private-not-option/scene1.html'
elif experience == 'conformitynotdefault':
template = 'firefox/new/fx-lifestyle/conformity-not-default/scene1.html'
elif experience == 'browseuptoyou':
template = 'firefox/new/fx-lifestyle/browse-up-to-you/scene1.html'
elif experience == 'moreprotection':
template = 'firefox/new/fx-lifestyle/more-protection/scene1.html'
elif experience == 'workingout':
template = 'firefox/new/fx-lifestyle/working-out/scene1.html'
elif experience == 'youdoyou':
template = 'firefox/new/fx-lifestyle/you-do-you/scene1.html'
elif experience == 'itsyourweb':
template = 'firefox/new/fx-lifestyle/its-your-web/scene1.html'
elif experience == 'secure':
template = 'firefox/new/sem/secure/scene1.html'
elif experience == 'nonprofit':
template = 'firefox/new/sem/nonprofit/scene1.html'
elif experience == 'compatible':
template = 'firefox/new/sem/compatible/scene1.html'
elif experience == 'unsupported-browser':
template = 'firefox/new/sem/unsupported-browser/scene1.html'
elif experience == 'batmfree':
template = 'firefox/new/batm/free.html'
elif experience == 'batmnimble':
template = 'firefox/new/batm/nimble.html'
elif experience == 'batmresist':
template = 'firefox/new/batm/resist.html'
else:
template = 'firefox/new/scene1.html'
else:
template = 'firefox/new/scene1.html'
return l10n_utils.render(request, template)
def process_partnership_form(request,
template,
success_url_name,
template_vars=None,
form_kwargs=None):
template_vars = template_vars or {}
form_kwargs = form_kwargs or {}
if request.method == 'POST':
form = WebToLeadForm(data=request.POST, **form_kwargs)
msg = 'Form invalid'
stat = 400
success = False
if form.is_valid():
data = form.cleaned_data.copy()
honeypot = data.pop('office_fax')
if honeypot:
msg = 'ok'
stat = 200
else:
# form testing address
if not data['email'] == '*****@*****.**':
data['lead_source'] = form_kwargs.get(
'lead_source', 'www.mozilla.org/about/partnerships/')
subject = PARTNERSHIPS_EMAIL_SUBJECT
sender = PARTNERSHIPS_EMAIL_FROM
to = PARTNERSHIPS_EMAIL_TO
body = render_to_string('mozorg/emails/partnerships.txt',
data,
request=request)
email = EmailMessage(subject, body, sender, to)
email.send()
msg = 'ok'
stat = 200
success = True
if request.is_ajax():
form_errors = {
fn: [escape(msg) for msg in msgs]
for fn, msgs in form.errors.iteritems()
}
return HttpResponseJSON({
'msg': msg,
'errors': form_errors
},
status=stat)
# non-AJAX POST
else:
# if form is not valid, render template to retain form data/error messages
if not success:
template_vars.update(csrf(request))
template_vars['form'] = form
template_vars['form_success'] = success
return l10n_utils.render(request, template, template_vars)
# if form is valid, redirect to avoid refresh double post possibility
else:
return HttpResponseRedirect("%s?success" %
(reverse(success_url_name)))
# no form POST - build form, add CSRF, & render template
else:
# without auto_id set, all id's get prefixed with 'id_'
form = WebToLeadForm(auto_id='%s', **form_kwargs)
template_vars.update(csrf(request))
template_vars['form'] = form
template_vars['form_success'] = True if ('success'
in request.GET) else False
return l10n_utils.render(request, template, template_vars)
def existing(request, token=None):
"""Manage subscriptions. If token is provided, user can manage their
existing subscriptions, to subscribe, unsubscribe, change email or
language preferences, etc. If no token is provided, user can
fill in their email and language preferences and sign up for
newsletters.
@param HTTPRequest request: Django request object
@param string token: A UUID that identifies this user to the backend. It's
sent to users in each newsletter as part of a link to this page, so they
can manage their subscriptions without needing an account somewhere with
userid & password.
"""
locale = getattr(request, 'locale', 'en-US')
if not token:
return redirect(reverse('newsletter.recovery'))
if not UUID_REGEX.match(token):
# Bad token
messages.add_message(request, messages.ERROR, bad_token)
# Redirect to the recovery page
return redirect(reverse('newsletter.recovery'))
unsub_parm = None
# Example user:
#
# {u'lang': u'en',
# u'format': u'H',
# u'country': u'us',
# u'newsletters': [u'firefox-tips', u'mobile'],
# u'created-date': u'1/30/2013 12:46:05 PM',
# u'token': u'some-uuid',
# u'email': u'*****@*****.**'
# }
user_exists = False
if token:
try:
user = basket.user(token)
except basket.BasketNetworkException:
# Something wrong with basket backend, no point in continuing,
# we'd probably fail to subscribe them anyway.
log.exception("Basket timeout")
messages.add_message(request, messages.ERROR, general_error)
return l10n_utils.render(request, 'newsletter/existing.html')
except basket.BasketException as e:
log.exception("FAILED to get user from token (%s)", e.desc)
else:
user_exists = True
if not user_exists:
# Bad or no token
messages.add_message(request, messages.ERROR, bad_token)
# Redirect to the recovery page
return redirect(reverse('newsletter.recovery'))
# Get the newsletter data - it's a dictionary of dictionaries
newsletter_data = utils.get_newsletters()
# Figure out which newsletters to display, and whether to show them
# as already subscribed.
initial = []
for newsletter, data in newsletter_data.iteritems():
# Only show a newsletter if it has ['show'] == True or the
# user is already subscribed
if data.get('show', False) or newsletter in user['newsletters']:
langs = data['languages']
form_data = {
'title': _(data['title']),
'subscribed': newsletter in user['newsletters'],
'newsletter': newsletter,
'description': _(data['description']),
'english_only': len(langs) == 1 and langs[0].startswith('en'),
}
if 'order' in data:
form_data['order'] = data['order']
initial.append(form_data)
# Sort by 'order' field if we were given it; otherwise, by title
if initial:
keyfield = 'order' if 'order' in initial[0] else 'title'
initial.sort(key=itemgetter(keyfield))
NewsletterFormSet = formset_factory(NewsletterForm,
extra=0,
max_num=len(initial))
if request.method == 'POST':
form_kwargs = {}
# Temporary form so we can see if they checked 'remove_all'. If
# they did, no point in validating the newsletters formset and it would
# look dumb to complain about it.
form = ManageSubscriptionsForm(locale, data=request.POST, initial=user)
remove_all = form.is_valid() and form.cleaned_data['remove_all']
formset_is_valid = False
if remove_all:
# We don't care about the newsletter formset
formset_is_valid = True
# Make an initialized one in case we fall through to the bottom
formset = NewsletterFormSet(initial=initial)
else:
# We do need to validate the newsletter formset
formset = NewsletterFormSet(request.POST, initial=initial)
# Set `newsletters` to the list of newsletters they want.
# After this, we don't need the formset anymore.
newsletters = None
if formset.is_valid():
formset_is_valid = True
# What newsletters do they say they want to be subscribed to?
newsletters = set([
subform.cleaned_data['newsletter'] for subform in formset
if subform.cleaned_data['subscribed']
])
form_kwargs['newsletters'] = newsletters
form = ManageSubscriptionsForm(locale,
data=request.POST,
initial=user,
**form_kwargs)
if formset_is_valid and form.is_valid():
data = form.cleaned_data
# Update their format and locale information, if it has changed.
# Also pass their updated list of newsletters they want to be
# subscribed to, for basket to implement.
kwargs = {}
for k in ['lang', 'format', 'country']:
if user[k] != data[k]:
kwargs[k] = data[k]
if not remove_all:
kwargs['newsletters'] = ",".join(newsletters)
if kwargs:
try:
basket.update_user(token, **kwargs)
except basket.BasketException:
log.exception("Error updating user in basket")
messages.add_message(request, messages.ERROR,
general_error)
return l10n_utils.render(request,
'newsletter/existing.html')
# If they chose to remove all, tell basket that they've opted out
if remove_all:
try:
basket.unsubscribe(token, user['email'], optout=True)
except (basket.BasketException, requests.Timeout):
log.exception("Error updating subscriptions in basket")
messages.add_message(request, messages.ERROR,
general_error)
return l10n_utils.render(request,
'newsletter/existing.html')
# We need to pass their token to the next view
url = reverse('newsletter.updated') \
+ "?unsub=%s&token=%s" % (UNSUB_UNSUBSCRIBED_ALL, token)
return redirect(url)
# We're going to redirect, so the only way to tell the next
# view that we should display the welcome message in the
# template is to modify the URL
url = reverse('newsletter.updated')
if unsub_parm:
url += "?unsub=%s" % unsub_parm
return redirect(url)
# FALL THROUGH so page displays errors
else:
form = ManageSubscriptionsForm(locale, initial=user)
formset = NewsletterFormSet(initial=initial)
# For the template, we want a dictionary whose keys are language codes
# and each value is the list of newsletter keys that are available in
# that language code.
newsletter_languages = defaultdict(list)
for newsletter, data in newsletter_data.iteritems():
for lang in data['languages']:
newsletter_languages[lang].append(newsletter)
newsletter_languages = mark_safe(json.dumps(newsletter_languages))
# We also want a list of the newsletters the user is already subscribed
# to
already_subscribed = mark_safe(json.dumps(user['newsletters']))
context = {
'form': form,
'formset': formset,
'newsletter_languages': newsletter_languages,
'newsletters_subscribed': already_subscribed,
'email': user['email'],
}
return l10n_utils.render(request, 'newsletter/existing.html', context)
def contribute_studentambassadors_landing(request):
tweets = TwitterCache.objects.get_tweets_for('mozstudents')
return l10n_utils.render(
request, 'mozorg/contribute/studentambassadors/landing.html',
{'tweets': tweets})
def dnt(request):
dnt = request.META.get('HTTP_DNT')
request.DNT = dnt == '1'
response = l10n_utils.render(request, 'firefox/dnt.html')
response['Vary'] = 'DNT'
return response
def new(request):
# Remove legacy query parameters (Bug 1236791)
if request.GET.get('product', None) or request.GET.get('os', None):
return HttpResponsePermanentRedirect(reverse('firefox.new'))
scene = request.GET.get('scene', None)
experience = request.GET.get('xv', None)
variant = request.GET.get('v', None)
locale = l10n_utils.get_locale(request)
# ensure variant matches pre-defined value
if variant not in ['a', 'b', 'c', 'd', 'e', 'f', '1', '2']: # place expected ?v= values in this list
variant = None
if scene == '2':
# send to new permanent scene2 URL (bug 1438302)
thanks_url = reverse('firefox.download.thanks')
query_string = request.META.get('QUERY_STRING', '')
if query_string:
thanks_url = '?'.join([thanks_url, force_text(query_string, errors='ignore')])
return HttpResponsePermanentRedirect(thanks_url)
# if no/incorrect scene specified, show scene 1
else:
if lang_file_is_active('firefox/new/wait-face', locale) and experience == 'waitface':
template = 'firefox/new/wait-face/scene1.html'
elif lang_file_is_active('firefox/new/reggiewatts', locale) and experience == 'reggiewatts':
template = 'firefox/new/reggie-watts/scene1.html'
elif locale == 'de':
if experience == 'berlin':
template = 'firefox/new/berlin/scene1.html'
elif experience == 'aus-gruenden':
template = 'firefox/new/berlin/scene1-aus-gruenden.html'
elif experience == 'herz':
template = 'firefox/new/berlin/scene1-herz.html'
elif experience == 'geschwindigkeit':
template = 'firefox/new/berlin/scene1-gesch.html'
elif experience == 'privatsphare':
template = 'firefox/new/berlin/scene1-privat.html'
elif experience == 'auf-deiner-seite':
template = 'firefox/new/berlin/scene1-auf-deiner-seite.html'
else:
template = 'firefox/new/scene1.html'
elif switch('firefox-yandex') and locale == 'ru':
template = 'firefox/new/yandex/scene1.html'
elif locale == 'en-US':
if experience in ['portland', 'forgood']:
template = 'firefox/new/portland/scene1.html'
elif experience in ['portland-fast', 'fast']:
template = 'firefox/new/portland/scene1-fast.html'
elif experience in ['portland-safe', 'safe']:
template = 'firefox/new/portland/scene1-safe.html'
elif experience == 'betterbrowser':
template = 'firefox/new/better-browser/scene1.html'
elif experience == 'safari':
if variant == 'a':
template = 'firefox/new/scene1.html'
elif variant == '2':
template = 'firefox/new/compare/scene1-safari-2.html'
else:
template = 'firefox/new/compare/scene1-safari-1.html'
elif experience == 'chrome':
if variant == 'a':
template = 'firefox/new/scene1.html'
elif variant == '2':
template = 'firefox/new/compare/scene1-chrome-2.html'
else:
template = 'firefox/new/compare/scene1-chrome-1.html'
else:
template = 'firefox/new/scene1.html'
else:
template = 'firefox/new/scene1.html'
# no harm done by passing 'v' to template, even when no experiment is running
# (also makes tests easier to maintain by always sending a context)
return l10n_utils.render(request, template, {'experience': experience})
def plugincheck(request, template='mozorg/plugincheck.html'):
"""
Renders the plugncheck template.
"""
return l10n_utils.render(request, template)
def render_to_response(self, context, **response_kwargs):
response_kwargs.setdefault('content_type', self.content_type)
return l10n_utils.render(self.request,
self.get_template_names()[0], context,
**response_kwargs)
def firefox_accounts(request):
return l10n_utils.render(request, 'firefox/accounts-2019.html')
def process_content_services_form(request, template, success_url_name, template_vars=None, form_kwargs=None):
template_vars = template_vars or {}
form_kwargs = form_kwargs or {}
if request.method == 'POST':
form = ContentServicesForm(data=request.POST, **form_kwargs)
msg = 'Form invalid'
stat = 400
success = False
if form.is_valid():
data = form.cleaned_data.copy()
honeypot = data.pop('office_fax')
if honeypot:
# don't let on there was a problem
msg = 'ok'
stat = 200
else:
# rename custom Salesforce fields to their real GUID name
data['00NU00000053D4G'] = data.pop('interested_countries')
data['00NU00000053D4L'] = data.pop('interested_languages')
data['00NU00000053D4a'] = data.pop('campaign_type')
data['00NU0000004ELEK'] = data.pop('mobile')
data['oid'] = '00DU0000000IrgO'
if data['country'] != 'us':
data['state'] = data.pop('province')
data['lead_source'] = form_kwargs.get(
'lead_source',
'www.mozilla.org/about/partnerships/contentservices/')
# As we're doing the Salesforce POST in the background here,
# `retURL` is never visited/seen by the user. I believe it
# is required by Salesforce though, so it should hang around
# as a placeholder (with a valid URL, just in case).
data['retURL'] = ('http://www.mozilla.org/en-US/'
'about/partnerships/'
'contentservices/start?success=1')
r = requests.post('https://www.salesforce.com/servlet/'
'servlet.WebToLead?encoding=UTF-8', data)
msg = requests.status_codes._codes.get(r.status_code, ['error'])[0]
stat = r.status_code
success = True
if request.is_ajax():
# ensure no unescaped values sent back.
form_errors = {fn: [escape(msg) for msg in msgs] for fn, msgs
in form.errors.iteritems()}
return HttpResponseJSON({'msg': msg, 'errors': form_errors}, status=stat)
# non-AJAX POST
else:
# if form is not valid, render template to retain form data/error messages
if not success:
template_vars.update(csrf(request))
template_vars['form'] = form
template_vars['form_success'] = success
return l10n_utils.render(request, template, template_vars)
# if form is valid, redirect to avoid refresh double post possibility
else:
return HttpResponseRedirect("%s?success" % (reverse(success_url_name)))
# no form POST - build form, add CSRF, & render template
else:
# without auto_id set, all id's get prefixed with 'id_'
form = ContentServicesForm(auto_id='%s', **form_kwargs)
template_vars.update(csrf(request))
template_vars['form'] = form
template_vars['form_success'] = True if ('success' in request.GET) else False
return l10n_utils.render(request, template, template_vars)
def dnt(request):
response = l10n_utils.render(request, 'firefox/dnt.html')
response['Vary'] = 'DNT'
return response
def ad_blocker(request):
return l10n_utils.render(request, 'firefox/features/adblocker.html')
