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 create_action(self, request, serializer):
email = serializer.data['email']
newsletter = serializer.data['newsletter']
basket.subscribe(email, newsletter,
format='H', country=request.REGION.slug,
lang=request.LANG, optin='Y',
trigger_welcome='Y')
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 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 create_action(self, request, serializer):
email = serializer.data['email']
newsletter = serializer.data['newsletter']
lang = serializer.data['lang']
country = self.get_country()
basket.subscribe(email, newsletter, format='H', country=country,
lang=lang, optin='Y', trigger_welcome='Y')
def post_list(self, request, **kwargs):
data = self.deserialize(request, request.raw_post_data,
format='application/json')
basket.subscribe(data['email'], 'marketplace',
format='H', country=request.REGION.slug,
lang=request.LANG, optin='Y',
trigger_welcome='Y')
def landing(request):
"""Developer Hub landing page."""
_refresh_mdn(request)
videos = [
{"name": "airbnb", "path": "FirefoxMarketplace-airbnb-BR-RC-SD1%20640"},
{"name": "evernote", "path": "FirefoxMarketplace-Evernote_BR-RC-SD1%20640"},
{"name": "uken", "path": "FirefoxMarketplace-uken-BR-RC-SD1%20640"},
{"name": "soundcloud", "path": "FirefoxMarketplace-Soundcloud-BR-RC-SD1%20640"},
{"name": "box", "path": "FirefoxMarketplace_box-BR-RC-SD1%20640"},
]
form = DevNewsletterForm(request.POST or None)
if request.method == "POST" and form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(data["email"], "app-dev", source_url=settings.SITE_URL)
messages.success(request, _("Thank you for subscribing!"))
return redirect("ecosystem.landing")
except basket.BasketException:
messages.error(request, _("We apologize, but an error " "occurred in our system. Please try again later."))
return jingo.render(request, "ecosystem/landing.html", {"videos": videos, "newsletter_form": form})
def process_request(self, request):
success = False
form = NewsletterFooterForm(request.locale, request.POST or None)
is_footer_form = (request.method == 'POST' and
'newsletter-footer' in request.POST)
if is_footer_form:
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']
if data[k]))
try:
basket.subscribe(data['email'], data['newsletter'],
**kwargs)
success = True
except basket.BasketException:
msg = _lazy("We are sorry, but there was a problem "
"with our system. Please try again later!")
form.errors['__all__'] = form.error_class([msg])
request.newsletter_form = form
request.newsletter_success = success
def register(request, form):
"""Register a BrowserID-authed user with Affiliates.
Not hooked up to a urlconf; called by other views.
"""
if form.is_valid():
verification = browserid_verify(request)
if not verification:
return None
# Check if user exists (and auth if they do)
user = authenticate(request=request)
if user is None:
email = verification['email']
username = hashlib.sha1(email).hexdigest()[:30]
display_name = form.cleaned_data['display_name']
user = User.objects.create_user(username, email)
user.is_active = True
user.save()
UserProfile.objects.create(user=user, display_name=display_name)
# Subscribe user to mailing lists
if form.cleaned_data['email_subscribe']:
try:
subscribe(email, settings.BASKET_NEWSLETTER,
lang=get_language())
except Exception, err:
log.warning(err)
# New user must be authenticated to log in
user = authenticate(request=request)
login(request, user)
return redirect('my_badges')
def marketplace(request):
submitted = False
error = False
email = ''
if request.method == 'POST':
email = request.POST['email']
format_ = 'T' if request.POST.get('format') == 'text' else 'H'
newsletter = 'app-dev'
if not email_re.match(email):
error = 'email'
if not request.POST.get('privacy', None):
error = 'privacy'
if not error:
basket.subscribe(email, newsletter, format=format_)
submitted = True
return l10n_utils.render(request,
"marketplace/marketplace.html",
{'submitted': submitted,
'error': error,
'email': email})
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 process_request(self, request):
success = False
form = NewsletterForm(request.locale, request.POST or None)
is_footer_form = (request.method == 'POST'
and 'newsletter-footer' in request.POST)
if is_footer_form:
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']
if data[k]))
try:
basket.subscribe(data['email'], data['newsletter'],
**kwargs)
success = True
except basket.BasketException:
msg = _lazy("We are sorry, but there was a problem "
"with our system. Please try again later!")
form.errors['__all__'] = form.error_class([msg])
request.newsletter_form = form
request.newsletter_success = success
def handle_form(request, form):
if form.is_valid():
data = form.cleaned_data
send(request, data)
autorespond(request, data)
if data.get('newsletter', False):
if data.get('interest', False) == 'education':
# custom-1788 is the privacy policy checkbox on this page
payload = {'email': data['email'], 'custom-1788': '1'}
try:
requests.post(
'https://sendto.mozilla.org/page/s/mentor-signup',
data=payload,
timeout=2)
except requests.exceptions.RequestException:
pass
else:
try:
basket.subscribe(data['email'],
'about-mozilla',
source_url=request.build_absolute_uri())
except basket.BasketException:
pass
return True
return False
def contribute(request):
def has_contribute_form():
return request.method == "POST" and "contribute-form" in request.POST
def has_newsletter_form():
return request.method == "POST" and "newsletter-form" in request.POST
locale = getattr(request, "locale", "en-US")
success = False
newsletter_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)
success = handle_contribute_form(request, form)
else:
form = ContributeForm()
if has_newsletter_form():
newsletter_form = NewsletterCountryForm(locale, request.POST, prefix="newsletter")
if newsletter_form.is_valid():
data = newsletter_form.cleaned_data
try:
basket.subscribe(data["email"], "about-mozilla", format=data["fmt"], country=data["country"])
newsletter_success = True
except basket.BasketException, e:
msg = newsletter_form.error_class(
["We apologize, but an error occurred in our system." "Please try again later."]
)
newsletter_form.errors["__all__"] = msg
def contribute(request, template, return_to_form):
has_contribute_form = (request.method == 'POST'
and 'contribute-form' in request.POST)
has_newsletter_form = (request.method == 'POST'
and 'newsletter-form' in request.POST)
locale = getattr(request, 'locale', 'en-US')
contribute_success = False
newsletter_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()
if has_newsletter_form:
newsletter_form = NewsletterFooterForm(locale,
request.POST,
prefix='newsletter')
if newsletter_form.is_valid():
data = newsletter_form.cleaned_data
try:
basket.subscribe(data['email'],
'about-mozilla',
format=data['fmt'],
country=data['country'])
newsletter_success = True
except basket.BasketException:
msg = newsletter_form.error_class([
_('We apologize, but an error occurred in our system. '
'Please try again later.')
])
newsletter_form.errors['__all__'] = msg
else:
newsletter_form = NewsletterFooterForm(locale, prefix='newsletter')
return l10n_utils.render(
request, template, {
'form': form,
'contribute_success': contribute_success,
'newsletter_form': newsletter_form,
'newsletter_success': newsletter_success,
'return_to_form': return_to_form,
'hide_form': hide_contrib_form(request.locale),
'has_moz15': locale in settings.LOCALES_WITH_MOZ15
})
def contribute(request, template, return_to_form):
newsletter_id = 'about-mozilla'
has_contribute_form = (request.method == 'POST' and
'contribute-form' in request.POST)
has_newsletter_form = (request.method == 'POST' and
'newsletter-form' in request.POST)
locale = getattr(request, 'locale', 'en-US')
contribute_success = False
newsletter_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()
if has_newsletter_form:
newsletter_form = NewsletterFooterForm(newsletter_id, locale,
request.POST,
prefix='newsletter')
if newsletter_form.is_valid():
data = newsletter_form.cleaned_data
try:
basket.subscribe(data['email'],
newsletter_id,
format=data['fmt'],
country=data['country'])
newsletter_success = True
except basket.BasketException:
msg = newsletter_form.error_class(
[_('We apologize, but an error occurred in our system. '
'Please try again later.')]
)
newsletter_form.errors['__all__'] = msg
else:
newsletter_form = NewsletterFooterForm(newsletter_id, locale, prefix='newsletter')
return l10n_utils.render(request,
template,
{'form': form,
'contribute_success': contribute_success,
'newsletter_form': newsletter_form,
'newsletter_success': newsletter_success,
'return_to_form': return_to_form,
'hide_form': hide_contrib_form(request.locale),
'has_moz15': locale in settings.LOCALES_WITH_MOZ15})
def create_action(self, request, serializer):
email = serializer.data['email']
basket.subscribe(email,
'marketplace',
format='H',
country=request.REGION.slug,
lang=request.LANG,
optin='Y',
trigger_welcome='Y')
def send_to_device_ajax(request):
locale = l10n_utils.get_locale(request)
phone_or_email = request.POST.get('phone-or-email')
if not phone_or_email:
return HttpResponseJSON({'success': False, 'errors': ['phone-or-email']})
data = {
'platform': request.POST.get('platform'),
}
data_type = 'email' if '@' in phone_or_email else 'number'
data[data_type] = phone_or_email
form = SendToDeviceWidgetForm(data)
if form.is_valid():
phone_or_email = form.cleaned_data.get(data_type)
platform = form.cleaned_data.get('platform')
# check for android & valid send to device test value
# update email/sms message if conditions match
send_to_device_test = request.POST.get('android-send-to-device-test')
if (platform == 'android' and send_to_device_test in
['android-test-modal', 'android-test-embed']):
platform = send_to_device_test
if data_type == 'number':
if platform in SMS_MESSAGES:
try:
basket.send_sms(phone_or_email, SMS_MESSAGES[platform])
except basket.BasketException:
return HttpResponseJSON({'success': False, 'errors': ['system']},
status=400)
else:
# TODO define all platforms in SMS_MESSAGES
return HttpResponseJSON({'success': False, 'errors': ['platform']})
else: # email
if platform in EMAIL_MESSAGES:
try:
basket.subscribe(phone_or_email, EMAIL_MESSAGES[platform],
source_url=request.POST.get('source-url'),
lang=locale)
except basket.BasketException:
return HttpResponseJSON({'success': False, 'errors': ['system']},
status=400)
else:
# TODO define all platforms in EMAIL_MESSAGES
return HttpResponseJSON({'success': False, 'errors': ['platform']})
resp_data = {'success': True}
else:
resp_data = {
'success': False,
'errors': form.errors.keys(),
}
return HttpResponseJSON(resp_data)
def send_to_device_ajax(request):
locale = l10n_utils.get_locale(request)
phone_or_email = request.POST.get('phone-or-email')
if not phone_or_email:
return HttpResponseJSON({'success': False, 'errors': ['phone-or-email']})
data = {
'platform': request.POST.get('platform'),
}
data_type = 'email' if '@' in phone_or_email else 'number'
data[data_type] = phone_or_email
form = SendToDeviceWidgetForm(data)
if form.is_valid():
phone_or_email = form.cleaned_data.get(data_type)
platform = form.cleaned_data.get('platform')
# check for customized widget and update email/sms
# message if conditions match
send_to_device_basket_id = request.POST.get('send-to-device-basket-id')
if (platform == 'android' and
send_to_device_basket_id == 'android-embed'):
platform = 'android-embed'
if data_type == 'number':
if platform in SMS_MESSAGES:
try:
basket.send_sms(phone_or_email, SMS_MESSAGES[platform])
except basket.BasketException:
return HttpResponseJSON({'success': False, 'errors': ['system']},
status=400)
else:
# TODO define all platforms in SMS_MESSAGES
return HttpResponseJSON({'success': False, 'errors': ['platform']})
else: # email
if platform in EMAIL_MESSAGES:
try:
basket.subscribe(phone_or_email, EMAIL_MESSAGES[platform],
source_url=request.POST.get('source-url'),
lang=locale)
except basket.BasketException:
return HttpResponseJSON({'success': False, 'errors': ['system']},
status=400)
else:
# TODO define all platforms in EMAIL_MESSAGES
return HttpResponseJSON({'success': False, 'errors': ['platform']})
resp_data = {'success': True}
else:
resp_data = {
'success': False,
'errors': form.errors.keys(),
}
return HttpResponseJSON(resp_data)
def send_to_device_ajax(request):
locale = l10n_utils.get_locale(request)
email = request.POST.get('s2d-email')
# ensure a value was entered in phone or email field
if not email:
return JsonResponse({'success': False, 'errors': ['s2d-email']})
# pull message set from POST (not part of form, so wont be in cleaned_data)
message_set = request.POST.get('message-set', 'default')
# begin collecting data to pass to form constructor
data = {
'platform': request.POST.get('platform'),
'email': email,
}
# instantiate the form with processed POST data
form = SendToDeviceWidgetForm(data)
if form.is_valid():
email = form.cleaned_data.get('email')
platform = form.cleaned_data.get('platform')
# if no platform specified, default to 'all'
if not platform:
platform = 'all'
# ensure we have a valid message set. if not, fall back to default
if message_set not in SEND_TO_DEVICE_MESSAGE_SETS:
MESSAGES = SEND_TO_DEVICE_MESSAGE_SETS['default']
else:
MESSAGES = SEND_TO_DEVICE_MESSAGE_SETS[message_set]
if platform in MESSAGES['email']:
try:
basket.subscribe(
email,
MESSAGES['email'][platform],
source_url=request.POST.get('source-url'),
lang=locale,
)
except basket.BasketException:
return JsonResponse({
'success': False,
'errors': ['system']
},
status=400)
else:
return JsonResponse({'success': False, 'errors': ['platform']})
resp_data = {'success': True}
else:
resp_data = {'success': False, 'errors': list(form.errors)}
return JsonResponse(resp_data)
def newsletter_subscribe(request):
form = NewsletterSubscriptionForm(request.user, request.POST)
if form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(
data["email"], settings.FACEBOOK_MAILING_LIST, format=data["format"], country=data["country"]
)
except basket.BasketException, e:
log.error("Error subscribing email %s to mailing list: %s" % (data["email"], e))
def newsletter_subscribe(request):
form = NewsletterForm(request.POST)
if form.is_valid():
try:
basket.subscribe(form.cleaned_data['email'],
settings.BASKET_NEWSLETTER,
source_url=request.build_absolute_uri())
except basket.BasketException, e:
log.error('Error subscribing email %s to mailing list: %s' %
(form.cleaned_data['email'], e))
def newsletter_subscribe(request):
form = NewsletterForm(request.POST)
if form.is_valid():
try:
basket.subscribe(form.cleaned_data['email'],
settings.BASKET_NEWSLETTER,
source_url=request.build_absolute_uri())
except basket.BasketException, e:
log.error('Error subscribing email %s to mailing list: %s' %
(form.cleaned_data['email'], e))
def contribute(request):
def has_contribute_form():
return (request.method == 'POST' and
'contribute-form' in request.POST)
def has_newsletter_form():
return (request.method == 'POST' and
'newsletter-form' in request.POST)
locale = getattr(request, 'locale', 'en-US')
success = False
newsletter_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)
if form.is_valid():
data = form.cleaned_data
contribute_send(data)
contribute_autorespond(request, data)
if data['newsletter']:
try:
basket.subscribe(data['email'], 'about-mozilla')
except basket.BasketException, e: pass
success = True
else:
form = ContributeForm()
if has_newsletter_form():
newsletter_form = NewsletterCountryForm(locale,
request.POST,
prefix='newsletter')
if newsletter_form.is_valid():
data = newsletter_form.cleaned_data
try:
basket.subscribe(data['email'],
'about-mozilla',
format=data['fmt'],
country=data['country'])
newsletter_success = True
except basket.BasketException, e:
msg = newsletter_form.error_class(
['We apologize, but an error occurred in our system.'
'Please try again later.']
)
newsletter_form.errors['__all__'] = msg
def create_action(self, request, serializer):
email = serializer.data["email"]
basket.subscribe(
email,
"marketplace",
format="H",
country=request.REGION.slug,
lang=request.LANG,
optin="Y",
trigger_welcome="Y",
)
def newsletter_subscribe(request):
form = NewsletterSubscriptionForm(request.user, request.POST)
if form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(data['email'], settings.FACEBOOK_MAILING_LIST,
format=data['format'], country=data['country'],
source_url=request.build_absolute_uri())
except basket.BasketException, e:
log.error('Error subscribing email %s to mailing list: %s' %
(data['email'], e))
def post_list(self, request, **kwargs):
data = self.deserialize(request,
request.raw_post_data,
format='application/json')
basket.subscribe(data['email'],
'marketplace',
format='H',
country=request.REGION.slug,
lang=request.LANG,
optin='Y',
trigger_welcome='Y')
def save(self):
self.instance.read_dev_agreement = datetime.datetime.now()
self.instance.save()
if self.cleaned_data.get('newsletter'):
UserNotification.update_or_create(user=self.instance,
notification_id=app_surveys.id, update={'enabled': True})
basket.subscribe(self.instance.email,
'app-dev',
format='H',
source_url=os.path.join(settings.SITE_URL,
'developers/submit'))
def save(self):
self.instance.read_dev_agreement = datetime.datetime.now()
self.instance.save()
if self.cleaned_data.get('newsletter'):
UserNotification.update_or_create(user=self.instance,
notification_id=app_surveys.id,
update={'enabled': True})
basket.subscribe(self.instance.email,
'app-dev',
format='H',
source_url=os.path.join(settings.SITE_URL,
'developers/submit'))
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()
context.update(
dict(
id=newsletters,
title=title,
include_country=include_country,
include_language=include_language,
use_thankyou=use_thankyou,
footer=footer,
))
success = False
form = NewsletterFooterForm(newsletters, get_locale(request), request.POST
or None)
if process_form and request.method == 'POST':
if form.is_valid():
data = form.cleaned_data
# If data['lang'] is set, pass it to the template.
# If it's None, empty, or nonexistent, pass 'en'.
context['lang'] = data.get('lang', 'en').strip() 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'], form.newsletters, **kwargs)
except basket.BasketException:
log.exception("Error subscribing %s to newsletter %s" %
(data['email'], newsletters))
msg = _lazy("We are sorry, but there was a problem "
"with our system. Please try again later!")
form.errors['__all__'] = form.error_class([msg])
else:
success = True
request.newsletter_success = success
context.update(dict(form=form, success=success))
html = jingo.render_to_string(request, 'newsletter/includes/form.html',
context)
if not (success and not use_thankyou):
return jinja2.Markup(html)
def post_list(self, request, **kwargs):
data = self.deserialize(request, request.raw_post_data,
format='application/json')
email = data['email']
try:
validate_email(email)
except ValidationError:
raise http_error(http.HttpBadRequest, 'Invalid email address')
basket.subscribe(data['email'], 'marketplace',
format='H', country=request.REGION.slug,
lang=request.LANG, optin='Y',
trigger_welcome='Y')
def post_list(self, request, **kwargs):
data = self.deserialize(request, request.raw_post_data,
format='application/json')
email = data['email']
try:
validate_email(email)
except ValidationError:
raise http_error(http.HttpBadRequest, 'Invalid email address')
basket.subscribe(data['email'], 'marketplace',
format='H', country=request.REGION.slug,
lang=request.LANG, optin='Y',
trigger_welcome='Y')
def handle_contribute_form(request, form):
if form.is_valid():
data = form.cleaned_data
contribute_send(data)
contribute_autorespond(request, data)
if data['newsletter']:
try:
basket.subscribe(data['email'], 'about-mozilla')
except basket.BasketException, e:
pass
return True
def handle_contribute_form(request, form):
if form.is_valid():
data = form.cleaned_data
contribute_send(data)
contribute_autorespond(request, data)
if data["newsletter"]:
try:
basket.subscribe(data["email"], "about-mozilla")
except basket.BasketException, e:
pass
return True
def newsletter_subscribe(request):
form = NewsletterSubscriptionForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(data['email'], 'affiliates',
format=data['format'], country=data['country'],
source_url=request.build_absolute_uri())
except basket.BasketException as e:
log.error('Error subscribing email {0} to mailing list: {1}'.format(data['email'], e))
return JSONResponse({'error': 'basket_error'}, status=500)
return JSONResponse({'success': 'success'})
def newsletter_subscribe(request):
form = NewsletterSubscriptionForm(request.user, request.POST)
if form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(data['email'],
settings.FACEBOOK_MAILING_LIST,
format=data['format'],
country=data['country'],
source_url=request.build_absolute_uri())
except basket.BasketException, e:
log.error('Error subscribing email %s to mailing list: %s' %
(data['email'], e))
def partners(request):
success = False
form = NewsletterForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
data = form.cleaned_data
basket.subscribe(data['email'], 'app-dev', format=data['fmt'])
success = True
return l10n_utils.render(request, "marketplace/partners.html", {
'form': form,
'success': success
})
def handle_contribute_form(request, form):
if form.is_valid():
data = form.cleaned_data
locale = getattr(request, 'locale', 'en-US')
contribute_send(data, locale)
contribute_autorespond(request, data, locale)
if data['newsletter']:
try:
basket.subscribe(data['email'], 'about-mozilla')
except basket.BasketException, e: pass
return True
return False
def marketplace(request):
success = False
form = NewsletterForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
data = form.cleaned_data
basket.subscribe(data['email'], 'app-dev', format=data['fmt'])
success = True
return l10n_utils.render(request,
"marketplace/marketplace.html",
{'form': form,
'success': success})
def handle_form(request, form):
if form.is_valid():
data = form.cleaned_data
send(request, data)
autorespond(request, data)
if data['newsletter']:
try:
basket.subscribe(data['email'], 'about-mozilla')
except basket.BasketException:
pass
return True
return False
def send_to_device_ajax(request):
locale = l10n_utils.get_locale(request)
phone_or_email = request.POST.get("phone-or-email")
if not phone_or_email:
return HttpResponseJSON({"success": False, "errors": ["phone-or-email"]})
data = {"platform": request.POST.get("platform")}
data_type = "email" if "@" in phone_or_email else "number"
data[data_type] = phone_or_email
form = SendToDeviceWidgetForm(data)
if form.is_valid():
phone_or_email = form.cleaned_data.get(data_type)
platform = form.cleaned_data.get("platform")
# check for customized widget and update email/sms
# message if conditions match
send_to_device_basket_id = request.POST.get("send-to-device-basket-id")
if platform == "android" and send_to_device_basket_id == "android-embed":
platform = "android-embed"
if data_type == "number":
if platform in SMS_MESSAGES:
try:
basket.send_sms(phone_or_email, SMS_MESSAGES[platform])
except basket.BasketException:
return HttpResponseJSON({"success": False, "errors": ["system"]}, status=400)
else:
# TODO define all platforms in SMS_MESSAGES
return HttpResponseJSON({"success": False, "errors": ["platform"]})
else: # email
if platform in EMAIL_MESSAGES:
try:
basket.subscribe(
phone_or_email, EMAIL_MESSAGES[platform], source_url=request.POST.get("source-url"), lang=locale
)
except basket.BasketException:
return HttpResponseJSON({"success": False, "errors": ["system"]}, status=400)
else:
# TODO define all platforms in EMAIL_MESSAGES
return HttpResponseJSON({"success": False, "errors": ["platform"]})
resp_data = {"success": True}
else:
resp_data = {"success": False, "errors": form.errors.keys()}
return HttpResponseJSON(resp_data)
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()
context.update(dict(
id=newsletters,
title=title,
include_country=include_country,
include_language=include_language,
use_thankyou=use_thankyou,
footer=footer,
))
success = False
form = NewsletterFooterForm(newsletters, get_locale(request),
request.POST or None)
if process_form and request.method == 'POST':
if form.is_valid():
data = form.cleaned_data
# If data['lang'] is set, pass it to the template.
# If it's None, empty, or nonexistent, pass 'en'.
context['lang'] = data.get('lang', 'en').strip() 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'], form.newsletters,
**kwargs)
except basket.BasketException as e:
if e.code == basket.errors.BASKET_INVALID_EMAIL:
form.errors['email'] = form.error_class([invalid_email_address])
else:
log.exception("Error subscribing %s to newsletter %s" %
(data['email'], form.newsletters))
form.errors['__all__'] = form.error_class([general_error])
else:
success = True
request.newsletter_success = success
context.update(dict(form=form, success=success))
html = jingo.render_to_string(request, 'newsletter/includes/form.html', context)
if not (success and not use_thankyou):
return jinja2.Markup(html)
def save(self):
self.instance.read_dev_agreement = datetime.datetime.now()
self.instance.save()
if self.cleaned_data.get("newsletter"):
UserNotification.update_or_create(
user=self.instance, notification_id=app_surveys.id, update={"enabled": True}
)
basket.subscribe(
self.instance.email,
"app-dev",
format="H",
country=self.request.REGION.slug,
lang=self.request.LANG,
source_url=os.path.join(settings.SITE_URL, "developers/submit"),
)
def test_subscribe_sync_y_api_key_not_in_args(self):
"""
subscribe calls request with the expected parms and returns the result
when sync='Y', adds the API key from the settings to the headers
"""
api_key = 'foo_bar'
email = "*****@*****.**"
newsletters = ['news1', 'news2']
kwargs = {
'arg1': 100,
'arg2': 200,
'sync': 'Y',
}
expected_kwargs = kwargs.copy()
expected_kwargs['email'] = email
expected_kwargs['newsletters'] = newsletters
with nested(patch('basket.base.request', autospec=True),
patch('basket.base.BASKET_API_KEY', api_key)) \
as (request_call, API_KEY):
result = subscribe(email, newsletters, **kwargs)
request_call.assert_called_with('post',
'subscribe',
data=expected_kwargs,
headers={'x-api-key': api_key})
self.assertEqual(request_call.return_value, result)
def apps_newsletter(request):
if request.method == 'POST':
form = SubscriptionForm(request.locale, data=request.POST)
context = {'form': form}
if form.is_valid():
optin = 'N'
if request.locale == 'en-US':
optin = 'Y'
for i in range(constance.config.BASKET_RETRIES):
try:
result = basket.subscribe(email=form.cleaned_data['email'],
newsletters=settings.BASKET_APPS_NEWSLETTER,
country=form.cleaned_data['country'],
format=form.cleaned_data['format'],
lang=request.locale,
optin=optin)
if result.get('status') != 'error':
break
except BasketException:
if i == constance.config.BASKET_RETRIES:
return HttpResponseServerError()
else:
time.sleep(constance.config.BASKET_RETRY_WAIT * i)
del context['form']
else:
context = {'form': SubscriptionForm(request.locale)}
return render(request, 'landing/apps_newsletter.html', context)
def newsletter_subscribe(request, email, cleaned_data):
subscription_details = get_subscription_details(email)
subscribed = subscribed_to_newsletter(subscription_details)
if cleaned_data['newsletter'] and not subscribed:
if not cleaned_data['agree']:
raise forms.ValidationError(PRIVACY_REQUIRED)
optin = 'N'
if request.locale == 'en-US':
optin = 'Y'
for i in range(constance.config.BASKET_RETRIES):
try:
result = basket.subscribe(
email=email,
newsletters=settings.BASKET_APPS_NEWSLETTER,
country=cleaned_data['country'],
format=cleaned_data['format'],
lang=request.locale,
optin=optin,
source_url=request.build_absolute_uri())
if result.get('status') != 'error':
break
except BasketException:
if i == constance.config.BASKET_RETRIES:
return HttpResponseServerError()
else:
time.sleep(constance.config.BASKET_RETRY_WAIT * i)
elif subscription_details:
basket.unsubscribe(subscription_details['token'],
email,
newsletters=settings.BASKET_APPS_NEWSLETTER)
def apps_newsletter(request):
if request.method == 'POST':
form = SubscriptionForm(request.locale, data=request.POST)
context = {'form': form}
if form.is_valid():
optin = 'N'
if request.locale == 'en-US':
optin = 'Y'
for i in range(constance.config.BASKET_RETRIES):
try:
result = basket.subscribe(
email=form.cleaned_data['email'],
newsletters=settings.BASKET_APPS_NEWSLETTER,
country=form.cleaned_data['country'],
format=form.cleaned_data['format'],
lang=request.locale,
optin=optin)
if result.get('status') != 'error':
break
except BasketException:
if i == constance.config.BASKET_RETRIES:
return HttpResponseServerError()
else:
time.sleep(constance.config.BASKET_RETRY_WAIT * i)
del context['form']
else:
context = {'form': SubscriptionForm(request.locale)}
return render(request, 'landing/apps_newsletter.html', context)
def subscribe(self, request, email):
subscription_details = self.get_subscription_details(email)
if 'subscribe_needed' in self.cleaned_data:
optin = 'N'
if request.locale == 'en-US':
optin = 'Y'
basket_data = {
'email': email,
'newsletters': settings.BASKET_APPS_NEWSLETTER,
'country': self.cleaned_data['country'],
'format': self.cleaned_data['format'],
'lang': request.locale,
'optin': optin,
'source_url': request.build_absolute_uri()
}
for retry in range(config.BASKET_RETRIES):
try:
result = basket.subscribe(**basket_data)
if result.get('status') != 'error':
break
except BasketException:
if retry == config.BASKET_RETRIES:
return HttpResponseServerError()
else:
time.sleep(config.BASKET_RETRY_WAIT * retry)
elif subscription_details:
basket.unsubscribe(subscription_details['token'],
email,
newsletters=settings.BASKET_APPS_NEWSLETTER)
def test_subscribe_sync_y_api_key_not_in_args(self):
"""
subscribe calls request with the expected parms and returns the result
when sync='Y', adds the API key from the settings to the headers
"""
api_key = 'foo_bar'
email = "*****@*****.**"
newsletters = ['news1', 'news2']
kwargs = {
'arg1': 100,
'arg2': 200,
'sync': 'Y',
}
expected_kwargs = kwargs.copy()
expected_kwargs['email'] = email
expected_kwargs['newsletters'] = newsletters
with nested(patch('basket.base.request', autospec=True),
patch('basket.base.BASKET_API_KEY', api_key)) \
as (request_call, API_KEY):
result = subscribe(email, newsletters, **kwargs)
request_call.assert_called_with('post', 'subscribe',
data=expected_kwargs,
headers={'x-api-key': api_key})
self.assertEqual(request_call.return_value, result)
def subscribe(self, request, email):
subscription_details = self.get_subscription_details(email)
if 'subscribe_needed' in self.cleaned_data:
optin = 'N'
if request.locale == 'en-US':
optin = 'Y'
basket_data = {
'email': email,
'newsletters': settings.BASKET_APPS_NEWSLETTER,
'country': self.cleaned_data['country'],
'format': self.cleaned_data['format'],
'lang': request.locale,
'optin': optin,
'source_url': request.build_absolute_uri()
}
for retry in range(config.BASKET_RETRIES):
try:
result = basket.subscribe(**basket_data)
if result.get('status') != 'error':
break
except BasketException:
if retry == config.BASKET_RETRIES:
return HttpResponseServerError()
else:
time.sleep(config.BASKET_RETRY_WAIT * retry)
elif subscription_details:
basket.unsubscribe(subscription_details['token'], email,
newsletters=settings.BASKET_APPS_NEWSLETTER)
def save(self):
data = self.cleaned_data
result = basket.subscribe(
data['email'],
self.newsletters(),
format=data['fmt'],
country=data['country'],
welcome_message='Student_Ambassadors_Welcome',
source_url=data['source_url'],
sync='Y')
data = {
'FIRST_NAME': data['first_name'],
'LAST_NAME': data['last_name'],
'STUDENTS_CURRENT_STATUS': data['status'],
'STUDENTS_SCHOOL': data['school'],
'STUDENTS_GRAD_YEAR': data['grad_year'],
'STUDENTS_MAJOR': data['major'],
'COUNTRY_': data['country'],
'STUDENTS_CITY': data['city'],
'STUDENTS_ALLOW_SHARE': data['share_information'],
}
request('post',
'custom_update_student_ambassadors',
token=result['token'],
data=data)
def vpn_invite_waitlist(request):
errors = []
locale = l10n_utils.get_locale(request)
form = VPNWaitlistForm(locale, request.POST)
if form.is_valid():
data = form.cleaned_data
kwargs = {
"email": data["email"],
"fpn_platform": ",".join(data["platforms"]),
"fpn_country": data["country"],
"lang": data["lang"],
"newsletters": "guardian-vpn-waitlist",
}
if settings.BASKET_API_KEY:
kwargs["api_key"] = settings.BASKET_API_KEY
# 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(**kwargs)
except basket.BasketException as e:
if e.code == basket.errors.BASKET_INVALID_EMAIL:
errors.append(str(invalid_email_address))
else:
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])
if errors:
errors = [escape(e) for e in errors]
resp = {
"success": False,
"errors": errors,
}
else:
resp = {"success": True}
return JsonResponse(resp)
def vpn_invite_waitlist(request):
errors = []
locale = l10n_utils.get_locale(request)
form = VPNWaitlistForm(locale, request.POST)
if form.is_valid():
data = form.cleaned_data
kwargs = {
'email': data['email'],
'fpn_platform': ','.join(data['platforms']),
'fpn_country': data['country'],
'lang': data['lang'],
'newsletters': 'guardian-vpn-waitlist',
}
if settings.BASKET_API_KEY:
kwargs['api_key'] = settings.BASKET_API_KEY
# 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(**kwargs)
except basket.BasketException as e:
if e.code == basket.errors.BASKET_INVALID_EMAIL:
errors.append(str(invalid_email_address))
else:
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])
if errors:
errors = [escape(e) for e in errors]
resp = {
'success': False,
'errors': errors,
}
else:
resp = {'success': True}
return JsonResponse(resp)
def send_to_device_ajax(request):
locale = l10n_utils.get_locale(request)
phone_or_email = request.POST.get('phone-or-email')
if not phone_or_email:
return HttpResponseJSON({'success': False, 'errors': ['phone-or-email']})
data = {
'platform': request.POST.get('platform'),
}
data_type = 'email' if '@' in phone_or_email else 'number'
data[data_type] = phone_or_email
form = SendToDeviceWidgetForm(data)
if form.is_valid():
phone_or_email = form.cleaned_data.get(data_type)
platform = form.cleaned_data.get('platform')
if data_type == 'number':
if platform in SMS_MESSAGES:
try:
basket.send_sms(phone_or_email, SMS_MESSAGES[platform])
except basket.BasketException:
return HttpResponseJSON({'success': False, 'errors': ['system']},
status=400)
else:
# TODO define all platforms in SMS_MESSAGES
return HttpResponseJSON({'success': False, 'errors': ['platform']})
else: # email
if platform in EMAIL_MESSAGES:
try:
basket.subscribe(phone_or_email, EMAIL_MESSAGES[platform],
source_url=request.POST.get('source-url'),
lang=locale)
except basket.BasketException:
return HttpResponseJSON({'success': False, 'errors': ['system']},
status=400)
else:
# TODO define all platforms in EMAIL_MESSAGES
return HttpResponseJSON({'success': False, 'errors': ['platform']})
resp_data = {'success': True}
else:
resp_data = {
'success': False,
'errors': form.errors.keys(),
}
return HttpResponseJSON(resp_data)
def landing(request):
"""Developer Hub landing page."""
videos = [
{
'name': 'airbnb',
'path': 'FirefoxMarketplace-airbnb-BR-RC-SD1%20640'
},
{
'name': 'evernote',
'path': 'FirefoxMarketplace-Evernote_BR-RC-SD1%20640'
},
{
'name': 'uken',
'path': 'FirefoxMarketplace-uken-BR-RC-SD1%20640'
},
{
'name': 'soundcloud',
'path': 'FirefoxMarketplace-Soundcloud-BR-RC-SD1%20640'
},
{
'name': 'box',
'path': 'FirefoxMarketplace_box-BR-RC-SD1%20640'
}
]
form = DevNewsletterForm(request.LANG, request.POST or None)
if request.method == 'POST' and form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(data['email'],
'app-dev',
format=data['email_format'],
source_url=settings.SITE_URL)
messages.success(request, _('Thank you for subscribing!'))
return redirect('ecosystem.landing')
except basket.BasketException as e:
log.error(
'Basket exception in ecosystem newsletter: %s' % e)
messages.error(
request, _('We apologize, but an error occurred in our '
'system. Please try again later.'))
return jingo.render(request, 'ecosystem/landing.html',
{'videos': videos, 'newsletter_form': form})
def save(self):
data = self.cleaned_data
basket.subscribe(
data['email'],
self.newsletters(),
format=data['fmt'],
country=data['country'],
source_url=data['source_url'],
first_name=data['first_name'],
last_name=data['last_name'],
fsa_current_status=data['status'],
fsa_school=data['school'],
fsa_grad_year=data['grad_year'],
fsa_major=data['major_free_text'] or data['major'],
fsa_city=data['city'],
fsa_allow_share=data['share_information'],
)
def newsletter_subscribe(request):
form = NewsletterSubscriptionForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
basket.subscribe(data['email'],
'affiliates',
format=data['format'],
country=data['country'],
source_url=request.build_absolute_uri())
except basket.BasketException as e:
log.error(
'Error subscribing email {0} to mailing list: {1}'.format(
data['email'], e))
return JSONResponse({'error': 'basket_error'}, status=500)
return JSONResponse({'success': 'success'})
def subscribe_newsletter(user_profile, basket_id, request=None):
response = basket.subscribe(
user_profile.email,
basket_id,
sync='Y',
source_url=request.build_absolute_uri() if request else None,
optin='Y')
return response['status'] == 'ok'
def contribute(request, template, return_to_form):
def has_contribute_form():
return (request.method == 'POST' and 'contribute-form' in request.POST)
def has_newsletter_form():
return (request.method == 'POST' and 'newsletter-form' in request.POST)
locale = getattr(request, 'locale', 'en-US')
success = False
newsletter_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)
success = handle_contribute_form(request, form)
if success:
# If form was submitted successfully, return a new, empty
# one.
form = ContributeForm()
else:
form = ContributeForm()
if has_newsletter_form():
newsletter_form = NewsletterCountryForm(locale,
request.POST,
prefix='newsletter')
if newsletter_form.is_valid():
data = newsletter_form.cleaned_data
try:
basket.subscribe(data['email'],
'about-mozilla',
format=data['fmt'],
country=data['country'])
newsletter_success = True
except basket.BasketException, e:
msg = newsletter_form.error_class([
'We apologize, but an error occurred in our system.'
'Please try again later.'
])
newsletter_form.errors['__all__'] = msg
