def make_validated_form(self, **kwargs):
data = dict(name='Jeferson Calazans', email='*****@*****.**',
cpf='12345678901', phone_0='21', phone_1='99887766',)
data.update(kwargs)
form = SubscriptionForm(data)
form.is_valid()
return form
def create(request):
form = SubscriptionForm(request.POST)
if not form.is_valid():
return render(request, 'subscriptions/subscription_form.html', {'form': form})
obj = form.save()
return HttpResponseRedirect('/inscricao/%d/' % obj.pk)
def test_must_inform_email_or_phone(self):
form = SubscriptionForm({
'name': 'User',
'cpf': '01234567891',
})
self.assertFalse(form.is_valid())
self.assertTrue(form.errors.get('__all__'))
def test_insert_subscription_with_invalid_email(self):
form = SubscriptionForm({
'name': 'Josemar Davi Luedke',
'cpf': '12345678901',
'email': 'fulano.castro.mail.com',
'phone': '51-00000000'
})
self.assertFalse(form.is_valid())
def test_insert_subscription_with_empty_phone(self):
form = SubscriptionForm({
'name': 'Josemar Davi Luedke',
'cpf': '12345678901',
'email': '*****@*****.**',
'phone': ''
})
self.assertTrue(form.is_valid())
def test_insert_subscription_with_empty_phone(self):
form = SubscriptionForm({
'name': 'Fulano Silva Castro',
'cpf': '39373617311',
'email': '*****@*****.**',
'phone': ''
})
self.assertTrue(form.is_valid())
def test_insert_subscription_with_invalid_email(self):
form = SubscriptionForm({
'name': 'Fulano Silva Castro',
'cpf': '39373617311',
'email': 'fulano.castro.mail.com',
'phone': '(61) 9189-0198'
})
self.assertFalse(form.is_valid())
def test_insert_subscription_with_empty_cpf(self):
form = SubscriptionForm({
'name': 'Josemar Davi Luedke',
'cpf': '',
'email': '*****@*****.**',
'phone': '51-00000000'
})
self.assertFalse(form.is_valid())
def creates_a_subscription_for_the_subscriber_to_the_feed(self):
form = SubscriptionForm({'subscriber': self.subscriber.pk,
'feed_record': self.feed_record.pk})
assert form.is_valid(), 'The form had errors: %r' % (form.errors,)
form.save()
subscription = self.subscriber.subscription(self.feed, self.library)
assert subscription is not None
def make_validated_form(self, **kwargs):
valid = dict(name='Fabio Oliveira',
cpf='12345678901',
email='*****@*****.**',
phone='21-99186180')
data = dict(valid, **kwargs)
form = SubscriptionForm(data)
form.is_valid()
return form
def test_valid_subscription_form_data(self):
form = SubscriptionForm({
'credit_card_number': "4242424242424242",
'cvv': "123",
'expiry_month': '11',
'expiry_year': '2025',
'stripe_id': 'tok_visa'
})
self.assertTrue(form.is_valid())
def creates_a_subscription_for_the_subscriber_to_the_feed(self):
form = SubscriptionForm({'subscriber': self.subscriber.pk,
'feed_record': self.feed_record.pk})
assert form.is_valid(), 'The form had errors: %r' % (form.errors,)
form.save()
subscription = self.subscriber.subscription(self.feed, self.library)
assert subscription is not None
def test_returns_error_if_cpf_is_not_all_digits(self):
form = SubscriptionForm({
'name': 'User',
'cpf': '0123456789a',
'email': '*****@*****.**',
'phone': '555-78376',
})
self.assertFalse(form.is_valid())
#self.assertIn('cpf', form.errors)
self.assertTrue(form.errors.get('cpf'))
def test_returns_error_with_less_than_11_digits_in_cpf(self):
form = SubscriptionForm({
'name': 'User',
'cpf': '123456789',
'email': '*****@*****.**',
'phone': '555-78376',
})
self.assertFalse(form.is_valid())
#self.assertIn('cpf', form.errors)
self.assertTrue(form.errors.get('cpf'))
def make_validated_form(self, **kwargs):
valid = dict(name='Victor',
cpf='11122233344',
email='*****@*****.**',
phone='(21) 2222-3333')
data = dict(valid, **kwargs)
form = SubscriptionForm(data)
form.is_valid()
return form
def subscriptionview(request):
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = SubscriptionForm(request.POST)
# establish initial values
email = ''
phone = ''
gpu_list = None
subscriber = None
# if form is valid then populate values
if form.is_valid():
if form.cleaned_data.__contains__('email'):
email = form.cleaned_data['email']
if form.cleaned_data.__contains__('phone'):
phone = form.cleaned_data['phone']
if form.cleaned_data.__contains__('gpus'):
gpu_list = form.cleaned_data['gpus']
# otherwise return and inform user of invalid form
else:
return render(request, 'suboverview.html', {'form': form})
# scold user if email and phone are both empty
if email == '' and phone == '':
messages.error(
request,
'At least one of email or phone is required for un/re/subscription.'
)
return render(request, 'suboverview.html', {'form': form})
# otherwise query the subscriber with the provided info
else:
subscriber = Subscriber.objects.filter(
Q(email=email) | Q(phone=phone))
# retrieve number of subscribers with this info (should be <= 2)
subcount = subscriber.count()
# process unsubscription request
if 'unsubscribe' in request.POST:
unsubscribe(subcount, request, subscriber)
# process re/subscription request
elif 'subscribe' in request.POST:
subscribe(subcount, request, subscriber, gpu_list, form, email,
phone)
# if a GET (or any other method) we'll create a blank form
else:
form = SubscriptionForm()
return render(request, 'suboverview.html', {'form': form})
def create(request):
form = SubscriptionForm(request.POST) # receive the data of form.
if not form.is_valid():
return render(request, 'subscriptions/subscription_form.html',
{'form': form})
subscription = form.save()
_send_mail('Confirmação de inscrição', settings.DEFAULT_FROM_EMAIL,
subscription.email, 'subscriptions/subscription_email.txt',
{'subscription': subscription})
return HttpResponseRedirect(r('subscriptions:detail', subscription.pk))
def create(request):
form = SubscriptionForm(request.POST or None)
if form.is_valid():
form.save()
send_mail(u'[EventeX] Inscrição efetuada com sucesso',
u"""Parabéns! A sua inscrição foi feita com sucesso!""",
settings.DEFAULT_FROM_EMAIL,
[form.data.get('email'), ])
return redirect(reverse('subscription:success'))
context = RequestContext(request, {'form': form})
return render_to_response('subscriptions/subscriptions_form.html', context)
def make_validated_form(self, **kwargs):
data = dict(
name='Test Testing Name',
cpf='12345678901',
email='*****@*****.**',
phone_0='12',
phone_1='123456789'
)
data.update(kwargs)
form = SubscriptionForm(data)
form.is_valid()
return form
def create(request):
form = SubscriptionForm(request.POST)
if not form.is_valid():
context = RequestContext(request, {'form': form})
return render_to_response('subscriptions/new.html', context)
subscription = form.save()
send_mail(subject=u'Cadastrado com Sucesso',
message=u'Obrigado pela sua inscrição!',
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[subscription.email])
return HttpResponseRedirect(
reverse('subscriptions:success', args=[ subscription.pk ]))
def create(request):
form = SubscriptionForm(request.POST)
if not form.is_valid():
context = RequestContext(request, {'form': form})
return render_to_response('subscriptions/new.html', context)
s = Subscription()
s.name = form.cleaned_data['name']
s.cpf = form.cleaned_data['cpf']
s.email = form.cleaned_data['email']
s.phone = form.cleaned_data['phone']
s.save()
# notifica o cadastro
send_subscription_email(s)
return HttpResponseRedirect(reverse('subscriptions:success', args=[ s.pk ]))
def make_validated_form(self, **kwargs):
'''
Create and update a SubscriptionForm with kwargs
'''
data = dict(
name = 'LRezende',
email = '*****@*****.**',
cpf = '12345678901',
phone_0 = '82',
phone_1 = '123456789'
)
data.update(kwargs)
form = SubscriptionForm(data)
form.is_valid()
return form
def new(request):
form = SubscriptionForm(initial={
'name': 'Entre o seu nome',
'cpf': 'Digite o seu CPF sem pontos',
'email': 'Informe o seu email',
'phone': '21-96186180',
})
context = RequestContext(request, {'form': form})
return render_to_response('subscriptions/new.html', context)
def signup(request, template="customers/account_signup.html"):
stripe_key = settings.STRIPE_PUBLIC_KEY
subscription_form = SubscriptionForm(request.POST or None)
customer_form = CustomerForm(request.POST or None)
if request.method == "POST" and subscription_form.is_valid() and \
customer_form.is_valid():
with transaction.commit_on_success():
save = transaction.savepoint()
try:
customer = customer_form.save(commit=False)
customer.update_card(request.POST['stripeToken'])
subscription = subscription_form.save(commit=False)
subscription.customer = customer
customer.save()
subscription.save()
transaction.savepoint_commit(save)
if not customer.user.is_active:
send_verification_mail(request, customer.user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, customer.user)
return login_redirect(request)
except Exception as e:
error(request, e)
transaction.savepoint_rollback(save)
context = {
'customer_form': customer_form,
'subscription_form': subscription_form,
'stripe_key': stripe_key,
}
return render(request, template, context)
def create(request):
form = SubscriptionForm(request.POST)
if form.is_valid():
obj = form.save()
return HttpResponseRedirect('/inscricao/%d/' % obj.pk)
return new(request)
def test_form_has_fields(self):
"""Form must have 4 fields. """
form = SubscriptionForm()
expected = ['name', 'cpf', 'email', 'phone']
self.assertSequenceEqual(expected, list(form.fields))
def signup(request):
# Necessary data for page
stripe_key = settings.STRIPE_PUBLIC_KEY
subscription_form = SubscriptionForm(request.POST or None)
customer_form = CustomerForm(request.POST or None)
gift_form = GiftSubscriptionForm(request.POST or None)
plans = Plan.objects.jsonify_for_form()
code_check_url = reverse("gifts_check_code")
invite_code = request.GET.get("invite_code", "")
reward_code_form = RewardCodeForm(request.POST or None, initial={"invite_code": invite_code})
context = {
"customer_form": customer_form,
"subscription_form": subscription_form,
"gift_form": gift_form,
"reward_code_form": reward_code_form,
"stripe_key": stripe_key,
"plans": plans,
"gift_purchase": request.POST.get("gift_purchase"),
"code_check_url": code_check_url,
"gift_code": request.POST.get("code"),
}
# Shortcut for initial page load
if request.method != "POST":
return context
# Validate forms, handle gift if necessary
if subscription_form.is_valid():
if subscription_form.cleaned_data["amount"] == "0.125":
plan = Plan.objects.get(trial=True)
else:
plan = Plan.objects.get(
amount=subscription_form.cleaned_data["amount"], interval=subscription_form.cleaned_data["interval"]
)
context["plan"] = plan
else:
return context
if context.get("gift_purchase") and gift_form.is_valid():
return gift_purchase(request, context)
if context.get("gift_code") and customer_form.is_valid():
return gift_redeem(request, context)
if not customer_form.is_valid():
return context
if not reward_code_form.is_valid():
return context
# Attempt normal subscription signup
with transaction.commit_on_success():
save = transaction.savepoint()
try:
customer = customer_form.save(commit=False).customer
customer.update_card(request.POST["stripeToken"])
customer.save()
subscription = Subscription(customer=customer, plan=plan)
subscription.save()
transaction.savepoint_commit(save)
form_invite_code = reward_code_form.cleaned_data["invite_code"]
if form_invite_code != "" and form_invite_code != None:
inv_code_instance = InviteCode.objects.filter(code=form_invite_code)
if inv_code_instance.exists():
inv = inv_code_instance.get()
inv.customer.grant_reward(customer)
if not customer.user.is_active:
send_verification_mail(request, customer.user, "signup_verify")
info(request, _("A verification email has been sent with " "a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, customer.user)
return redirect(reverse("customers_home"))
except Exception as e:
transaction.savepoint_rollback(save)
error(request, e)
return context
def setUp(self):
self.form = SubscriptionForm()
def make_validated_form(self, **kwargs):
data = dict(name='Rafael Vidal', email="*****@*****.**", cpf='134.176.861-99', phone="05163201254")
data.update(kwargs)
form = SubscriptionForm(data)
form.is_valid()
return form
def get_context_data(self, **kwargs):
context = super(IndexView, self).get_context_data()
config = SiteConfiguration.get_solo()
if config.show_site:
context['subscribe_form'] = SubscriptionForm()
return context
def test_if_form_has_no_paid_field(self):
form = SubscriptionForm()
self.assertFalse(form.fields.get('paid'))
def empty_form(request):
return render(request, 'subscriptions/subscription_form.html',
{'form': SubscriptionForm()})
