def test_rereview(self):
form = forms_payments.AccountListForm(
data={'accounts': self.account.pk}, **self.kwargs)
assert form.is_valid(), form.errors
form.save()
eq_(self.addon.status, amo.STATUS_PUBLIC)
eq_(RereviewQueue.objects.count(), 1)
form = forms_payments.AccountListForm(None, **self.kwargs)
eq_(form.fields['accounts'].empty_label, None)
def test_with_owner_account(self):
user = self.user
account = self.create_user_account(user)
assert self.is_owner(user)
form = forms_payments.AccountListForm(
data={'accounts': account.pk}, user=user, **self.kwargs)
eq_(form.current_payment_account, None)
assert form.is_valid(), form.errors
form.save()
form = forms_payments.AccountListForm(None, user=user,
**self.kwargs)
eq_(form.fields['accounts'].widget.attrs.get('disabled'), None)
eq_(form.fields['accounts'].empty_label, None)
eq_(form.initial['accounts'], account)
def test_with_other_owner_account_existing_account(self):
owner_account = self.associate_owner_account()
user = self.other
account = self.create_user_account(user)
self.make_owner(user)
assert self.is_owner(user)
form = forms_payments.AccountListForm(
data={'accounts': account.pk}, user=user, **self.kwargs)
eq_(form.current_payment_account, owner_account)
assert form.is_valid(), form.errors
form.save()
form = forms_payments.AccountListForm(None, user=user,
**self.kwargs)
eq_(form.fields['accounts'].empty_label, None)
eq_(form.initial['accounts'], account)
assert form.current_payment_account is None
def test_with_shared_account(self):
account = self.create_user_account(self.user)
shared = self.create_user_account(self.other, shared=True)
form = forms_payments.AccountListForm(user=self.user,
**self.kwargs)
self.assertSetEqual(form.fields['accounts'].queryset,
(account, shared))
def associate_owner_account(self):
owner_account = self.create_user_account(self.user)
form = forms_payments.AccountListForm(
data={'accounts': owner_account.pk}, user=self.user, **self.kwargs)
assert form.is_valid(), form.errors
form.save()
return owner_account
def test_set_shared_account(self):
shared = self.create_user_account(self.other, shared=True)
form = forms_payments.AccountListForm(
data={'accounts': shared.pk}, user=self.user, **self.kwargs)
assert form.is_valid()
form.save()
eq_(self.addon.app_payment_account.payment_account.pk, shared.pk)
def test_norereview(self):
self.addon.update(highest_status=amo.STATUS_PENDING)
form = forms_payments.AccountListForm(
data={'accounts': self.account.pk}, **self.kwargs)
assert form.is_valid(), form.errors
form.save()
eq_(self.addon.status, amo.STATUS_PENDING)
eq_(RereviewQueue.objects.count(), 0)
def test_disagreed_tos_rereview(self):
self.account.update(agreed_tos=False)
form = forms_payments.AccountListForm(
data={'accounts': self.account.pk}, **self.kwargs)
assert not form.is_valid()
eq_(form.errors['accounts'],
['Select a valid choice. That choice is not one of the available '
'choices.'])
def test_admin_account_empty_string(self):
self.associate_owner_account()
user = self.admin
assert not self.is_owner(user)
form = forms_payments.AccountListForm(
data={'accounts': ''}, user=user, **self.kwargs)
assert form.fields['accounts'].widget.attrs['disabled'] is not None
assert not form.is_valid(), form.errors
def test_with_non_owner_admin_account(self):
user = self.admin
account = self.create_user_account(user)
assert not self.is_owner(user)
form = forms_payments.AccountListForm(
data={'accounts': account.pk}, user=user, **self.kwargs)
eq_(form.current_payment_account, None)
assert form.fields['accounts'].widget.attrs['disabled'] is not None
assert not form.is_valid(), form.errors
def test_set_shared_account(self):
shared = self.create_user_account(self.other, shared=True)
form = forms_payments.AccountListForm(
data={'accounts': shared.pk}, user=self.user, **self.kwargs)
assert form.is_valid()
form.save()
accts = set(a.payment_account.pk for a in
self.addon.all_payment_accounts())
assert shared.pk in accts, 'Unexpected: {a}'.format(a=accts)
def test_with_non_owner_account_existing_account(self):
owner_account = self.associate_owner_account()
user = self.other
account = self.create_user_account(user)
assert not self.is_owner(user)
form = forms_payments.AccountListForm(
data={'accounts': account.pk}, user=user, **self.kwargs)
assert form.fields['accounts'].widget.attrs['disabled'] is not None
eq_(form.current_payment_account, owner_account)
assert not form.is_valid(), form.errors
def payments(request, addon_id, addon, webapp=False):
premium_form = forms_payments.PremiumForm(
request.POST or None, request=request, addon=addon,
user=request.amo_user)
region_form = forms.RegionForm(
request.POST or None, product=addon, request=request)
upsell_form = forms_payments.UpsellForm(
request.POST or None, addon=addon, user=request.amo_user)
account_list_form = forms_payments.AccountListForm(
request.POST or None, addon=addon, user=request.amo_user)
if request.method == 'POST':
success = all(form.is_valid() for form in
[premium_form, region_form, upsell_form,
account_list_form])
if success:
region_form.save()
try:
premium_form.save()
except client.Error as err:
success = False
log.error('Error setting payment information (%s)' % err)
messages.error(
request, _(u'We encountered a problem connecting to the '
u'payment server.'))
raise # We want to see these exceptions!
is_free_inapp = addon.premium_type == amo.ADDON_FREE_INAPP
is_now_paid = (addon.premium_type in amo.ADDON_PREMIUMS
or is_free_inapp)
# If we haven't changed to a free app, check the upsell.
if is_now_paid and success:
try:
if not is_free_inapp:
upsell_form.save()
account_list_form.save()
except client.Error as err:
log.error('Error saving payment information (%s)' % err)
messages.error(
request, _(u'We encountered a problem connecting to '
u'the payment server.'))
success = False
raise # We want to see all the solitude errors now.
# If everything happened successfully, give the user a pat on the back.
if success:
messages.success(request, _('Changes successfully saved.'))
return redirect(addon.get_dev_url('payments'))
# TODO: refactor this (bug 945267)
is_packaged = addon.is_packaged
android_payments_enabled = waffle.flag_is_active(request,
'android-payments')
android_packaged_enabled = waffle.flag_is_active(request,
'android-packaged')
desktop_packaged_enabled = waffle.flag_is_active(request,
'desktop-packaged')
# If android payments is not allowed then firefox os must
# be 'checked' and android-mobile and android-tablet should not be.
invalid_paid_platform_state = []
# If isn't packaged or it is packaged and the android-packaged flag is on
# then we should check that desktop isn't set to True.
if not is_packaged or (is_packaged and desktop_packaged_enabled):
invalid_paid_platform_state.append(('desktop', True))
if not android_payments_enabled:
# When android-payments is off...
# If isn't packaged or it is packaged and the android-packaged flag is on
# then we should check for the state of android-mobile and android-tablet.
if not is_packaged or (is_packaged and android_packaged_enabled):
invalid_paid_platform_state += [('android-mobile', True),
('android-tablet', True)]
invalid_paid_platform_state.append(('firefoxos', False))
cannot_be_paid = (
addon.premium_type == amo.ADDON_FREE and
any(premium_form.device_data['free-%s' % x] == y
for x, y in invalid_paid_platform_state))
try:
tier_zero = Price.objects.get(price='0.00', active=True)
tier_zero_id = tier_zero.pk
except Price.DoesNotExist:
tier_zero = None
tier_zero_id = ''
# Get the regions based on tier zero. This should be all the
# regions with payments enabled.
paid_region_ids_by_slug = []
if tier_zero:
paid_region_ids_by_slug = tier_zero.region_ids_by_slug()
provider = get_provider()
paid_platform_names = [unicode(platform[1])
for platform in PAID_PLATFORMS(request, is_packaged)]
return render(request, 'developers/payments/premium.html',
{'addon': addon, 'webapp': webapp, 'premium': addon.premium,
'form': premium_form, 'upsell_form': upsell_form,
'tier_zero_id': tier_zero_id, 'region_form': region_form,
'DEVICE_LOOKUP': DEVICE_LOOKUP,
'is_paid': (addon.premium_type in amo.ADDON_PREMIUMS
or addon.premium_type == amo.ADDON_FREE_INAPP),
'cannot_be_paid': cannot_be_paid,
'paid_platform_names': paid_platform_names,
'has_incomplete_status': addon.status == amo.STATUS_NULL,
'is_packaged': addon.is_packaged,
# Bango values
'account_form': provider.forms['account'](),
'account_list_form': account_list_form,
# Waffles
'api_pricelist_url': reverse('price-list'),
'payment_methods': {
PAYMENT_METHOD_ALL: _('All'),
PAYMENT_METHOD_CARD: _('Credit card'),
PAYMENT_METHOD_OPERATOR: _('Carrier'),
},
'all_paid_region_ids_by_slug': paid_region_ids_by_slug,
'provider': provider})
def payment_accounts_form(request):
bango_account_form = forms_payments.AccountListForm(
user=request.amo_user, addon=None)
return render(request,
'developers/payments/includes/bango_accounts_form.html',
{'account_list_form': bango_account_form})
