def test_subscribe_create(self):
"""Test create a subscription."""
plans.sync_plans()
self.client.credentials(HTTP_AUTHORIZATION='Token ' +
self.normal_user_token.key)
data = {
'plan_id': "MF-MONTHLY",
}
data.update(self.card)
url = reverse('stripe-api:subscription-create')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Check that the customer was created and has a subscription
customer = Customer.objects.get(user=self.normal_user)
self.assertTrue(subscriptions.has_active_subscription(customer))
if self.display_doc:
# Generate documentation
content = {
'title': "Subscribe",
'http_method': 'POST',
'url': url,
'payload': self.jsonify(data),
'response': self.jsonify(response.data),
'response_status': response.status_code,
'description': ("Subscribe to a give plan with card details.")
}
self.doc.display_section(content)
def check_valid_subscription(user):
products = Product.objects.filter(user=user).count()
if (products < 5):
return True
customer = Customer.objects.filter(user_id=user).first()
valid_subscription = False
if customer != None:
valid_subscription = subscriptions.has_active_subscription(
customer=customer)
return valid_subscription
def cancel_subscription(request, uuid):
if request.method == 'GET':
customer = Customer.objects.filter(user_id=request.user).first()
valid_subscription = False
if (customer != None):
valid_subscription = subscriptions.has_active_subscription(
customer=customer)
if (valid_subscription == True):
subscription = Subscription.objects.get(
id=urlsafe_base64_decode(force_text(uuid)))
cancel(subscription=subscription, at_period_end=False)
return redirect('dashboard_settings')
def dashboard(request):
key = settings.PINAX_STRIPE_PUBLIC_KEY
products = Product.objects.filter(user=request.user)
customer = Customer.objects.filter(user_id=request.user).first()
valid_subscription = False
if customer != None:
valid_subscription = subscriptions.has_active_subscription(customer=customer)
form = PlanForm()
data = { 'products': products,
'product_count': len(products),
'valid': valid_subscription,
'form': form,
'key': key
}
return render(request, 'dashboard.html', data)
def stripe_sub_status(store):
stripe_customer = get_customer_for_user(store)
active = has_active_subscription(customer=stripe_customer)
subscription = Subscription.objects.filter(customer=stripe_customer).order_by('-start').first()
if not subscription:
plan = "No plan"
else:
plan = subscription.plan.name
if active:
return "<span class='label label-success'>Stripe: Active - " + str(plan)+ "</span>"
else:
return "<span class='label label-default'>Stripe: Inactive - " + str(plan)+ "</span>"
def process_request(self, request):
# TODO Add messages limit check.
is_authenticated = request.user.is_authenticated
if django.VERSION < (1, 10):
is_authenticated = is_authenticated()
if is_authenticated and not request.user.is_staff:
url_name = resolve(request.path).url_name
if url_name in settings.PINAX_STRIPE_SUBSCRIPTION_REQUIRED_URLS:
customer = customers.get_customer_for_user(request.user)
user_plan = UserPlan.objects.filter(user=request.user)[0]
if not subscriptions.has_active_subscription(
customer) and user_plan.exceeded_limit(
) or user_plan.exceeded_limit():
return redirect(
settings.PINAX_STRIPE_SUBSCRIPTION_REQUIRED_REDIRECT)
def dashboard_settings(request):
if request.method == 'GET':
profile = Profile.objects.get(user_id=request.user)
referral = Referral.objects.filter(user_id=request.user).first()
if (referral != None):
responses = ReferralResponse.objects.filter(referral_id=referral)
else:
responses = []
cant_referrals = 0
for response in responses:
if (response.action == 'SIGN_UP'):
cant_referrals += 1
initial_dict = dict()
c = Customer.objects.filter(user_id=request.user).first()
if c == None:
card = []
valid_subscription = False
else:
card = Card.objects.filter(customer_id=c.id)
valid_subscription = subscriptions.has_active_subscription(customer=c)
data = { 'user': request.user, 'referrals': cant_referrals}
if (valid_subscription == True):
subs = Subscription.objects.filter(customer_id=c)
data['subs'] = subs
form = SettingsForm(initial=initial_dict, instance=request.user)
data['form'] = form
return render(request, 'settings.html', data)
elif request.method == 'POST':
form = SettingsForm(request.POST, instance=request.user)
if form.is_valid():
try:
form.save()
data = { 'form': form }
messages.success(request, 'Saved Successfully!')
return render(request, 'settings.html', data)
except:
data = { 'form': form }
messages.error(request, 'invalid update')
return render(request, 'settings.html', data)
data = { 'form': form }
messages.error(request, 'Invalid data submitted')
return render(request, 'settings.html', data)
raise ValueError('Invalid request type at dashboad settings')
def create_stripe_user_subscription(store, stripe_customer=None):
if not stripe_customer:
stripe_customer = get_customer_for_user(store)
if subscriptions.has_active_subscription(stripe_customer):
return True
plan, reason = estimate_donation_volume(store)
subscription = subscriptions.create(stripe_customer, plan)
StripeCustomerSubReason.objects.update_or_create(store=store,
defaults={
"subscription":
subscription,
'reason': reason
})
return True
def app_uninstall_task(data, **kwargs):
try:
user = models.AuthAppShopUser.objects.get(
myshopify_domain=kwargs['domain'])
user.token = '00000000000000000000000000000000'
user.save()
# Cancel any Stripe subscriptions
try:
stripe_customer = get_customer_for_user(user)
if subscriptions.has_active_subscription(stripe_customer):
user_subscriptions = models.Subscription.objects.filter(
customer=stripe_customer).filter(
Q(ended_at__isnull=True)
| Q(ended_at__gt=timezone.now()))
for subscription in user_subscriptions:
subscriptions.cancel(subscription, at_period_end=False)
# Clear subscription reason
models.StripeCustomerSubReason.objects.update_or_create(
store=user,
defaults={
"subscription": None,
'reason': None
})
# Clear stripe cards
user_cards = Card.objects.filter(
customer=stripe_customer).order_by("created_at")
for card in user_cards:
delete_card(stripe_customer, card.stripe_id)
except StripeError as e:
logging.error(str(e.message))
# Send an email to the user to welcome them
try:
ctx = {
"myshopify_domain": user.myshopify_domain,
}
subject = render_to_string("main_app/email/uninstall_subject.txt",
ctx)
subject = subject.strip()
message = render_to_string("main_app/email/uninstall_body.txt",
ctx)
email = user.userprofile.shop_contact_email
num_sent = EmailMessage(
subject,
message,
to=[email],
from_email=settings.PINAX_STRIPE_INVOICE_FROM_EMAIL).send()
except Exception:
pass
# Invalidate any existing user sessions.
user.clear_user_sessions()
connection.close()
except ObjectDoesNotExist:
if kwargs['domain']:
logging.warning("App-Uninstall-Webhook-No-User-Found: " +
str(kwargs['domain']))
return
except Exception as e:
logging.error("App-Uninstall-Webhook-Unknown-Exception: " +
str(e.message))
raise e
