def period_boundary_test(self, period_start, period_end):
# For a given period start, test the period_end is equal to the given period_end
s = Subscription(location=self.location,
user=self.user1,
start_date=period_start)
ps, pe = s.get_period(target_date=period_start)
self.assertEquals(pe, period_end)
def test_is_period_boundary(self): s = Subscription(location=self.location, user=self.user1, start_date=date(2016,1,1), end_date=date(2016,5,31)) self.assertFalse(s.is_period_boundary(target_date=date(2016, 2, 15))) self.assertFalse(s.is_period_boundary(target_date=date(2016, 2, 29))) self.assertFalse(s.is_period_boundary(target_date=date(2016, 3, 15))) self.assertFalse(s.is_period_boundary(target_date=date(2016, 3, 31)))
def home():
if current_user.is_authenticated:
return redirect(url_for("users.account_home"))
form = SubscriptionForm()
if form.validate_on_submit():
sub = Subscription(email=form.email.data)
db.session.add(sub)
db.session.commit()
flash("Your email has been successfully registered!", "success")
return render_template("homepage.html", form=form)
def create_subscription(contact, subscription_type='N', payment_type='C'):
# subscription_type is ('P', 'R', 'N', 'F')
# F is Free
subscription = Subscription(contact=contact)
subscription.type = subscription_type
subscription.payment_type = payment_type
subscription.save()
return Subscription.objects.get(pk=subscription.id)
def subscriptionsubmit(request):
uid = request.user.id
appuser = AppUser.objects.get(user_id=uid)
post_data = request.POST
if appuser.subscription is None:
print("not subsribed yet")
subscription = Subscription(
first_name = post_data['first_name'],
last_name = post_data['last_name'],
phone = post_data['phone'],
email = post_data['email'],
address = post_data['address'],
subscription_type = post_data['subscription_type'],
charge = post_data['subscription_type'],
)
subscription.save()
appuser.subscription = subscription
appuser.subscription_type = post_data['subscription_type']
appuser.save()
return redirect("profile")
else:
print(post_data)
print("subscript exists")
appuser.subscription.first_name = post_data['first_name'],
appuser.subscription.last_name = post_data['last_name'],
appuser.subscription.phone = post_data['phone'],
appuser.subscription.email = post_data['email'],
appuser.subscription.address = post_data['address'],
appuser.subscription.subscription_type = post_data['subscription_type'],
appuser.subscription.charge = post_data['subscription_type'],
appuser.subscription.save()
appuser.subscription_type = post_data['subscription_type']
appuser.save()
return redirect("profile")
def add_subscription(request):
if request.method == "POST":
form = NewSubscriptionForm(request.POST)
if form.is_valid():
# if customer does not have a stripe_id
# create a customer from token
# if customer does have a stripe_id
# update source with token?
# create a subscription with customer, plan, and token
# on failure, let customer know
plan_stripe_id = form.cleaned_data['plan']
token = form.cleaned_data['token']
plan = Plan.objects.get(stripe_id=plan_stripe_id)
# TODO handle no plan
user = request.user
if not user.stripe_id:
user.create_stripe_customer(form.cleaned_data['token'])
try:
stripe_subscription = stripe.Subscription.create(
customer=user.stripe_id, source=token, items=[{
"plan": plan_stripe_id
}]
)
subscription = Subscription.create_from_stripe_sub(
user=user,
plan=plan,
stripe_subscription=stripe_subscription,
)
return redirect(reverse('subscriptions'))
except stripe.error.CardError as ex:
error = ex.json_body.get('error')
messages.error(
request, "We had a problem processing your card. {}".format(error['message'])
)
else:
form = NewSubscriptionForm()
return render(
request, "core/add_subscription.html", {
"form": form,
"plans": Plan.objects.available().as_dicts(),
"email": request.user.email,
"stripe_key": settings.STRIPE_PUBLISHABLE_KEY
}
)
def subscription_toggle(request, sub_type, sub_id):
if sub_type not in ['party', 'committee', 'person', 'category']:
raise Http404
lookup = {
'user': request.user,
'%s_id' % sub_type: sub_id,
}
subscribed = None
try:
Subscription.objects.get(**lookup).delete()
subscribed = False
except Subscription.DoesNotExist:
Subscription(**lookup).save()
subscribed = True
ctx = {
'subscribed': subscribed,
}
return ctx
def period_boundary_test(self, period_start, period_end): # For a given period start, test the period_end is equal to the given period_end s = Subscription(location=self.location, user=self.user1, start_date=period_start) ps, pe = s.get_period(target_date=period_start) self.assertEquals(pe, period_end)
def add_subscription(request, *args, **kwargs):
corporate_code = None
if 'code' in kwargs:
corporate_code = get_object_or_404(CorporateCode, code=kwargs['code'])
if request.method == "POST":
form = NewSubscriptionForm(request.POST)
if form.is_valid():
# if customer does not have a stripe_id
# create a customer from token
# if customer does have a stripe_id
# update source with token?
# create a subscription with customer, plan, and token
# on failure, let customer know
plan_stripe_id = form.cleaned_data['plan']
token = form.cleaned_data['token']
plan = Plan.objects.get(stripe_id=plan_stripe_id)
# TODO handle no plan
user = request.user
if not user.stripe_id:
user.create_stripe_customer()
sub_kwargs = {
"customer": user.stripe_id,
"source": token,
"items": [{
"plan": plan_stripe_id
}]
}
if corporate_code:
sub_kwargs['coupon'] = corporate_code.code
try:
stripe_subscription = stripe.Subscription.create(**sub_kwargs)
subscription = Subscription.create_from_stripe_sub(
user=user,
plan=plan,
stripe_subscription=stripe_subscription,
corporate_code=corporate_code)
return redirect(reverse('subscriptions'))
except stripe.error.CardError as ex:
error = ex.json_body.get('error')
messages.error(
request,
"We had a problem processing your card. {}".format(
error['message']))
rollbar.report_exc_info(sys.exc_info(), request)
except Exception as ex:
messages.error(request, (
"We had a problem on our end processing your order. "
"You have not been charged. Our administrators have been notified."
))
rollbar.report_exc_info(sys.exc_info(), request)
plans = [{
'stripe_id': plan.stripe_id,
'amount': plan.amount,
'display_price': plan.display_price(corporate_code),
'name': plan.name,
} for plan in Plan.objects.available()]
plandict = {plan['stripe_id']: plan for plan in plans}
return render(
request, "core/add_subscription.html", {
"form": NewSubscriptionForm(),
"corporate_code": corporate_code,
"plans": plans,
"plandict_json": json.dumps(plandict, cls=DjangoJSONEncoder),
"email": request.user.email,
"stripe_key": settings.STRIPE_PUBLISHABLE_KEY
})
def worker_subscription_form(request,
template_name='worker/subscription.html'):
u"""
Worker subscription.
View para entrada de informações detalhadas e upload de documentos do
trabalhador
"""
if request.user.account_state == Account_States.approved:
return redirect('core:settings')
form = WorkerSubscriptionForm(request.POST or None, request.FILES)
formPhone = PhoneForm(request.POST or None)
if form.is_valid():
# Now we have all necessary data, let's create the subscription
user = request.user
user.account_state = Account_States.waiting
documents = UserDocuments()
documents.person_id = zip_image(request.FILES['id_doc'])
documents.residence_proof = zip_image(request.FILES['address_proof'])
documents.cpf = zip_image(request.FILES['cpf_doc'])
documents.save()
user.documents = documents
#for skill in form.cleaned_data['skills']:
# user.skills.add(skill)
#user.phone_number = form.cleaned_data['phone']
phone = formPhone.save(commit=False)
phone.indico_user = request.user
phone.number = request.POST['number']
phone.save()
user.categories.add(form.cleaned_data['category'])
user.resume = form.cleaned_data['resume']
user.is_terms_accepted = form.cleaned_data['accept_tc']
user.is_application_form_filled = True
user.account_type = 2
user.save()
subscription = Subscription(candidate=user)
subscription.save()
subject = get_new_subscription_title(user)
message = get_new_subscription_body(user, subscription)
# Send mail to admins
mail_admins(subject, message, fail_silently=True)
# Send mail to worker
send_mail("Peça recomendações",
alert_subscription_message(request, user),
'*****@*****.**', [user.email],
fail_silently=True)
messages.add_message(
request, messages.INFO,
"Seu perfil foi enviado com sucesso, em breve um de nossos representantes estará avaliando o seu processo."
)
return redirect('worker:home')
return render(request, template_name, {
'formPhone': formPhone,
'form': form
})
def add_subscription(request, code=False, *args, **kwargs):
user = request.user
if not user.stripe_id:
user.create_stripe_customer()
corporate_code = None
coupon_code = None
if code:
try:
coupon_code = CouponCode.objects.get(code=code)
if coupon_code.redeem_by < datetime.now().date():
messages.error(request, "That coupon has expired")
return redirect('/subscriptions/new/')
except CouponCode.DoesNotExist:
coupon_code = None
try:
corporate_code = CorporateCode.objects.get(code=code)
if corporate_code.redeem_by < datetime.now().date():
messages.error(request, "That corporate code has expired")
return redirect('/subscriptions/new/')
except CorporateCode.DoesNotExist:
corporate_code = None
if 'code' in kwargs and 'coupon_type' in kwargs:
if kwargs['coupon_type'] == 'corporate':
corporate_code = get_object_or_404(CorporateCode,
code=kwargs['code'])
else:
coupon_code = get_object_or_404(CouponCode, code=kwargs['code'])
if request.method == "POST":
if 'couponCode' in request.POST:
try:
coupon = CouponCode.objects.get(code=request.POST['code'])
#fail if the users email is not allowed by the coupon
if coupon.emails and request.user.email not in coupon.emails:
raise Exception
#fail if none of the coupons plans are available
if coupon.plans.count() > 0 and not any(
[p.available for p in coupon.plans.all()]):
raise Exception
#fail if there is a subscription with this coupon already attached
#to the user
if request.user.subscriptions.filter(
coupon_code=coupon).count() == 0:
redirURL = "/subscriptions/new/{}/".format(coupon.code)
return redirect(redirURL)
else:
messages.error(request,
"You have already used that coupon.")
except CouponCode.DoesNotExist:
messages.error(request, "That is not a valid coupon.")
except Exception as ex:
messages.error(request, "Error: That is not a valid coupon.")
rollbar.report_exc_info(sys.exc_info(), request)
else:
form = NewSubscriptionForm(request.POST)
if form.is_valid():
plan_stripe_id = form.cleaned_data['plan']
token = form.cleaned_data['token']
plan = Plan.objects.get(stripe_id=plan_stripe_id)
# TODO handle no plan
user = request.user
if not user.stripe_id:
user.create_stripe_customer()
sub_kwargs = {
"customer": user.stripe_id,
"source": token,
"items": [{
"plan": plan_stripe_id
}]
}
if corporate_code:
sub_kwargs['coupon'] = corporate_code.code
elif coupon_code:
sub_kwargs['coupon'] = coupon_code.code
try:
if corporate_code:
sub_kwargs['billing'] = 'send_invoice'
sub_kwargs['days_until_due'] = 30
# sub_kwargs
# {'customer': 'cus_Ck3yEqbljkn0Zp', 'source': 'tok_1CszGPDR4unvi416aLuq8bR5', 'items': [{'plan': '4-boxesC9MB77'}]}
stripe_subscription = stripe.Subscription.create(
**sub_kwargs)
subscription = Subscription.create_from_stripe_sub(
user=user,
plan=plan,
stripe_subscription=stripe_subscription,
corporate_code=corporate_code,
coupon_code=coupon_code)
#'cancel' the subscription, so that the corporate plans do not auto renew
# if corporate_code:
# stripe_sub = subscription.get_stripe_subscription()
# stripe_sub.delete(at_period_end = True)
# subscription.cancelled = True
# subscription.save()
return redirect('/subscriptions/')
except stripe.error.CardError as ex:
print(ex)
error = ex.json_body.get('error')
messages.error(
request,
"We had a problem processing your card. {}".format(
error['message']))
rollbar.report_exc_info(sys.exc_info(), request)
except Exception as ex:
print(ex)
messages.error(request, (
"We had a problem on our end processing your order. "
"You have not been charged. Our administrators have been notified."
))
rollbar.report_exc_info(sys.exc_info(), request)
available_plans = Plan.objects.available().order_by('name')
if coupon_code and coupon_code.plans.count() > 0:
available_plans = coupon_code.plans.all()
plans = [{
'stripe_id':
plan.stripe_id,
'amount':
plan.amount,
'display_price':
plan.display_price(corporate_code=corporate_code,
coupon_code=coupon_code),
'name':
plan.name,
} for plan in available_plans]
plandict = {plan['stripe_id']: plan for plan in plans}
return render(
request, "core/add_subscription.html", {
"form": NewSubscriptionForm(),
"corporate_code": corporate_code,
"coupon_code": coupon_code,
"plans": plans,
"plandict_json": json.dumps(plandict, cls=DjangoJSONEncoder),
"email": request.user.email,
"stripe_key": settings.STRIPE_PUBLISHABLE_KEY
})