def test_subscribe_customer_to_plan_failed_payment(self): stripe_plan = self.stripe_utils.get_or_create_stripe_plan( 2000, "test plan 1", stripe_plan_id='test-plan-1') stripe_customer = StripeCustomer.get_or_create( email=self.customer_email, token=self.failed_token) result = self.stripe_utils.subscribe_customer_to_plan( stripe_customer.stripe_id, [{ "plan": stripe_plan.get('response_object').stripe_plan_id }]) self.assertIsNone(result.get('response_object'), None) self.assertIsNotNone(result.get('error'))
def test_subscribe_customer_to_plan(self): stripe_plan = self.stripe_utils.get_or_create_stripe_plan( 2000, "test plan 1", stripe_plan_id='test-plan-1') stripe_customer = StripeCustomer.get_or_create( email=self.customer_email, token=self.token) result = self.stripe_utils.subscribe_customer_to_plan( stripe_customer.stripe_id, [{ "plan": stripe_plan.get('response_object').stripe_plan_id }]) self.assertIsInstance(result.get('response_object'), stripe.Subscription) self.assertIsNone(result.get('error')) self.assertEqual(result.get('response_object').get('status'), 'active')
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): # Get billing address data billing_address_data = form.cleaned_data token = form.cleaned_data.get('token') user = request.session.get('user') try: CustomUser.objects.get(email=user.get('email')) except CustomUser.DoesNotExist: password = CustomUser.get_random_password() # Register the user, and do not send emails CustomUser.register(user.get('name'), password, user.get('email'), app='dcl', base_url=None, send_email=False) # Get or create stripe customer customer = StripeCustomer.get_or_create(email=user.get('email'), token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response( self.get_context_data(form=form)) # Create Billing Address billing_address = form.save() request.session['billing_address_data'] = billing_address_data request.session['billing_address'] = billing_address.id request.session['token'] = token request.session['customer'] = customer.id return HttpResponseRedirect( reverse('datacenterlight:order_confirmation')) else: return self.form_invalid(form)
def test_create_vm_task(self): """Tests the create vm task for monthly subscription This test is supposed to validate the proper execution of celery create_vm_task on production, as we have no other way to do this. """ # We create a VM from the first template available to DCL vm_template = VMTemplate.objects.all().first() template_data = VMTemplateSerializer(vm_template).data # The specs of VM that we want to create specs = {'cpu': 1, 'memory': 2, 'disk_size': 10, 'price': 15} stripe_customer = StripeCustomer.get_or_create( email=self.customer_email, token=self.token) card_details = self.stripe_utils.get_card_details( stripe_customer.stripe_id) card_details_dict = card_details.get('error') self.assertEquals(card_details_dict, None) billing_address_data = { 'cardholder_name': self.customer_name, 'postal_code': '1231', 'country': 'CH', 'token': self.token, 'street_address': 'Monty\'s Street', 'city': 'Hollywood' } vm_template_id = template_data.get('id', 1) cpu = specs.get('cpu') memory = specs.get('memory') disk_size = specs.get('disk_size') amount_to_be_charged = get_vm_price(cpu=cpu, memory=memory, disk_size=disk_size) plan_name = StripeUtils.get_stripe_plan_name(cpu=cpu, memory=memory, disk_size=disk_size) stripe_plan_id = StripeUtils.get_stripe_plan_id(cpu=cpu, ram=memory, ssd=disk_size, version=1, app='dcl') stripe_plan = self.stripe_utils.get_or_create_stripe_plan( amount=amount_to_be_charged, name=plan_name, stripe_plan_id=stripe_plan_id) subscription_result = self.stripe_utils.subscribe_customer_to_plan( stripe_customer.stripe_id, [{ "plan": stripe_plan.get('response_object').stripe_plan_id }]) stripe_subscription_obj = subscription_result.get('response_object') # Check if the subscription was approved and is active if stripe_subscription_obj is None \ or stripe_subscription_obj.status != 'active': msg = subscription_result.get('error') raise Exception("Creating subscription failed: {}".format(msg)) billing_address = BillingAddress( cardholder_name=billing_address_data['cardholder_name'], street_address=billing_address_data['street_address'], city=billing_address_data['city'], postal_code=billing_address_data['postal_code'], country=billing_address_data['country']) billing_address.save() order = HostingOrder.create(price=specs['price'], vm_id=0, customer=stripe_customer, billing_address=billing_address) async_task = create_vm_task.delay(vm_template_id, self.user, specs, template_data, order.id) new_vm_id = 0 res = None for i in range(0, 10): sleep(5) res = AsyncResult(async_task.task_id) if res.result is not None and res.result > 0: new_vm_id = res.result break # We expect a VM to be created within 50 seconds self.assertGreater( new_vm_id, 0, "VM could not be created. res._get_task_meta() = {}".format( res._get_task_meta()))
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): context = self.get_context_data() token = form.cleaned_data.get("token") donation_amount = form.cleaned_data.get("donation_amount") # Get or create stripe customer customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # Create Billing Address billing_address = form.save() # Make stripe charge to a customer stripe_utils = StripeUtils() stripe_utils.CURRENCY = "usd" charge_response = stripe_utils.make_charge(amount=donation_amount, customer=customer.stripe_id) charge = charge_response.get("response_object") # Check if the payment was approved if not charge: context.update({"paymentError": charge_response.get("error"), "form": form}) return render(request, self.template_name, context) # Create a donation charge = charge_response.get("response_object") donation_data = request.POST.copy() donation_data.update( { "cc_brand": charge.source.brand, "stripe_charge_id": charge.id, "last4": charge.source.last4, "billing_address": billing_address.id, "donator": customer.id, "donation": donation_amount, } ) donation_form = DonationForm(donation_data) if donation_form.is_valid(): # reactivate donation status donation = donation_form.save() try: donator_status = DonatorStatus.objects.get(user=self.request.user) donator_status.set_active() except DonatorStatus.DoesNotExist: pass donation = donation_form.save() context = {"donation": donation, "base_url": "{0}://{1}".format(request.scheme, request.get_host())} email_data = { "subject": "Your donation have been charged", "to": request.user.email, "context": context, "template_name": "donation_charge", "template_path": "nosystemd/emails/", } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect(reverse("nosystemd:donations", kwargs={"pk": donation.id})) else: self.form_invalid(donation_form) else: return self.form_invalid(form)
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): # Get billing address data billing_address_data = form.cleaned_data context = self.get_context_data() template = request.session.get('template') specs = request.session.get('specs') vm_template_id = template.get('id', 1) final_price = specs.get('price') token = form.cleaned_data.get('token') owner = self.request.user # Get or create stripe customer customer = StripeCustomer.get_or_create(email=owner.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # Create Billing Address billing_address = form.save() # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge(amount=final_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(request, self.template_name, context) charge = charge_response.get('response_object') # Create OpenNebulaManager manager = OpenNebulaManager(email=owner.email, password=owner.password) # Get user ssh key if not UserHostingKey.objects.filter( user=self.request.user).exists(): context.update({ 'sshError': 'error', 'form': form }) return render(request, self.template_name, context) # For now just get first one user_key = UserHostingKey.objects.filter( user=self.request.user).first() # Create a vm using logged user vm_id = manager.create_vm( template_id=vm_template_id, # XXX: Confi specs=specs, ssh_key=user_key.public_key, ) # Create a Hosting Order order = HostingOrder.create( price=final_price, vm_id=vm_id, customer=customer, billing_address=billing_address ) # Create a Hosting Bill bill = HostingBill.create( customer=customer, billing_address=billing_address) # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): billing_address_data.update({ 'user': customer.user.id }) billing_address_user_form = UserBillingAddressForm( billing_address_data) billing_address_user_form.is_valid() billing_address_user_form.save() # Associate an order with a stripe payment order.set_stripe_charge(charge) # If the Stripe payment was successed, set order status approved order.set_approved() vm = VirtualMachineSerializer(manager.get_vm(vm_id)).data # Send notification to ungleich as soon as VM has been booked context = { 'vm': vm, 'order': order, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'New VM request', 'to': request.user.email, 'context': context, 'template_name': 'new_booked_vm', 'template_path': 'hosting/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect(reverse('hosting:orders', kwargs={'pk': order.id})) else: return self.form_invalid(form)
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): data = form.cleaned_data context = self.get_context_data() token = data.get('token') membership_type = data.get('membership_type') # Get or create stripe customer customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge(amount=membership_type.first_month_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(request, self.template_name, context) charge = charge_response.get('response_object') # Create Billing Address billing_address = form.save() # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): data.update({ 'user': customer.user.id }) billing_address_user_form = UserBillingAddressForm(data) billing_address_user_form.is_valid() billing_address_user_form.save() # Get membership dates membership_start_date, membership_end_date = membership_type.first_month_range # Create membership plan membership_data = { 'type': membership_type, 'start_date': membership_start_date, 'end_date': membership_end_date } membership = Membership.create(membership_data) # Create membership order order_data = { 'membership': membership, 'customer': customer, 'billing_address': billing_address, 'stripe_charge': charge, 'amount': membership_type.first_month_price, 'start_date': membership_start_date, 'end_date': membership_end_date } membership_order = MembershipOrder.create(order_data) request.session.update({ 'membership_price': membership.type.first_month_price, 'membership_dates': membership.type.first_month_formated_range }) context = { 'membership': membership, 'order': membership_order, 'membership_start_date': membership_start_date, 'membership_end_date': membership_end_date, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'Your membership has been charged', 'to': request.user.email, 'context': context, 'template_name': 'membership_charge', 'template_path': 'digitalglarus/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect(reverse('digitalglarus:membership_activated')) else: return self.form_invalid(form)
def form_valid(self, form): data = form.cleaned_data context = self.get_context_data() token = data.get('token') start_date = data.get('start_date') end_date = data.get('end_date') is_free = context.get('is_free') normal_price, final_price, free_days = Booking.\ booking_price(self.request.user, start_date, end_date) charge = None # if not credit_card_needed: # Get or create stripe customer customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # If booking is not free, make the stripe charge if not is_free: # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge(amount=final_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(self.request, self.template_name, context) charge = charge_response.get('response_object') # Create Billing Address for Membership Order billing_address = form.save() # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): data.update({ 'user': customer.user.id }) billing_address_user_form = UserBillingAddressForm(data) billing_address_user_form.is_valid() billing_address_user_form.save() # Create Booking booking_data = { 'start_date': start_date, 'end_date': end_date, 'start_date': start_date, 'free_days': free_days, 'price': normal_price, 'final_price': final_price, } booking = Booking.create(booking_data) # Create Booking order order_data = { 'booking': booking, 'customer': customer, 'billing_address': billing_address, 'stripe_charge': charge, 'amount': final_price, 'original_price': normal_price, 'special_month_price': BookingPrice.objects.last().special_month_price, } order = BookingOrder.create(order_data) return HttpResponseRedirect(self.get_success_url(order.id))
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): # Get billing address data billing_address_data = form.cleaned_data context = self.get_context_data() template = request.session.get('template') specs = request.session.get('specs') vm_template_id = template.get('id', 1) final_price = specs.get('price') token = form.cleaned_data.get('token') owner = self.request.user # Get or create stripe customer customer = StripeCustomer.get_or_create(email=owner.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response( self.get_context_data(form=form)) # Create Billing Address billing_address = form.save() # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge( amount=final_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(request, self.template_name, context) charge = charge_response.get('response_object') # Create OpenNebulaManager manager = OpenNebulaManager(email=owner.email, password=owner.password) # Get user ssh key if not UserHostingKey.objects.filter( user=self.request.user).exists(): context.update({'sshError': 'error', 'form': form}) return render(request, self.template_name, context) # For now just get first one user_key = UserHostingKey.objects.filter( user=self.request.user).first() # Create a vm using logged user vm_id = manager.create_vm( template_id=vm_template_id, # XXX: Confi specs=specs, ssh_key=user_key.public_key, ) # Create a Hosting Order order = HostingOrder.create(price=final_price, vm_id=vm_id, customer=customer, billing_address=billing_address) # Create a Hosting Bill bill = HostingBill.create(customer=customer, billing_address=billing_address) # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): billing_address_data.update({'user': customer.user.id}) billing_address_user_form = UserBillingAddressForm( billing_address_data) billing_address_user_form.is_valid() billing_address_user_form.save() # Associate an order with a stripe payment order.set_stripe_charge(charge) # If the Stripe payment was successed, set order status approved order.set_approved() vm = VirtualMachineSerializer(manager.get_vm(vm_id)).data # Send notification to ungleich as soon as VM has been booked context = { 'vm': vm, 'order': order, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'New VM request', 'to': request.user.email, 'context': context, 'template_name': 'new_booked_vm', 'template_path': 'hosting/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect( reverse('hosting:orders', kwargs={'pk': order.id})) else: return self.form_invalid(form)
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): context = self.get_context_data() specifications = request.session.get('vm_specs') vm_type = specifications.get('hosting_company') vm = VirtualMachineType.objects.get(hosting_company=vm_type) final_price = vm.calculate_price(specifications) plan_data = { 'vm_type': vm, 'cores': specifications.get('cores'), 'memory': specifications.get('memory'), 'disk_size': specifications.get('disk_size'), 'configuration': specifications.get('configuration'), 'price': final_price } token = form.cleaned_data.get('token') # Get or create stripe customer customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # Create Virtual Machine Plan plan = VirtualMachinePlan.create(plan_data, request.user) # Create Billing Address billing_address = form.save() # Create a Hosting Order order = HostingOrder.create(vm_plan=plan, customer=customer, billing_address=billing_address) # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge(amount=final_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(request, self.template_name, context) charge = charge_response.get('response_object') # Associate an order with a stripe payment order.set_stripe_charge(charge) # If the Stripe payment was successed, set order status approved order.set_approved() # Send notification to ungleich as soon as VM has been booked context = { 'vm': plan, 'order': order, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'New VM request', 'to': request.user.email, 'context': context, 'template_name': 'new_booked_vm', 'template_path': 'hosting/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect(reverse('hosting:orders', kwargs={'pk': order.id})) else: return self.form_invalid(form)
def post(self, request, *args, **kwargs): if 'product' in request.POST: # query for the supplied product product = None try: product = GenericProduct.objects.get( id=request.POST['generic_payment_form-product_name']) except GenericProduct.DoesNotExist as dne: logger.error( "The requested product '{}' does not exist".format( request.POST['generic_payment_form-product_name'])) except GenericProduct.MultipleObjectsReturned as mpe: logger.error( "There seem to be more than one product with " "the name {}".format( request.POST['generic_payment_form-product_name'])) product = GenericProduct.objects.all( product_name=request. POST['generic_payment_form-product_name']).first() if product is None: return JsonResponse({}) else: return JsonResponse({ 'amount': product.get_actual_price(), 'isSubscription': product.product_is_subscription }) if 'login_form' in request.POST: login_form = HostingUserLoginForm(data=request.POST, prefix='login_form') if login_form.is_valid(): email = login_form.cleaned_data.get('email') password = login_form.cleaned_data.get('password') auth_user = authenticate(email=email, password=password) if auth_user: login(self.request, auth_user) if 'product_slug' in kwargs: return HttpResponseRedirect( reverse('show_product', kwargs={ 'product_slug': kwargs['product_slug'] })) return HttpResponseRedirect( reverse('datacenterlight:payment')) else: context = self.get_context_data() context['login_form'] = login_form return self.render_to_response(context) if request.user.is_authenticated(): address_form = BillingAddressForm(data=request.POST, ) else: address_form = BillingAddressFormSignup(data=request.POST, ) if address_form.is_valid(): # Check if we are in a generic payment case and handle the generic # payment details form before we go on to verify payment if ('generic_payment_type' in request.session and self.request.session['generic_payment_type'] == 'generic'): if 'product_id' in request.session: generic_payment_form = ProductPaymentForm( data=request.POST, prefix='generic_payment_form', product_id=request.session['product_id']) else: generic_payment_form = GenericPaymentForm( data=request.POST, prefix='generic_payment_form') if generic_payment_form.is_valid(): logger.debug("Generic payment form is valid.") if 'product_id' in request.session: product = generic_payment_form.product else: product = generic_payment_form.cleaned_data.get( 'product_name') gp_details = { "product_name": product.product_name, "amount": generic_payment_form.cleaned_data.get('amount'), "recurring": generic_payment_form.cleaned_data.get('recurring'), "description": generic_payment_form.cleaned_data.get('description'), "product_id": product.id, "product_slug": product.product_slug } request.session["generic_payment_details"] = (gp_details) else: logger.debug("Generic payment form invalid") context = self.get_context_data() context['generic_payment_form'] = generic_payment_form context['billing_address_form'] = address_form return self.render_to_response(context) token = address_form.cleaned_data.get('token') if token is '': card_id = address_form.cleaned_data.get('card') try: user_card_detail = UserCardDetail.objects.get(id=card_id) if not request.user.has_perm('view_usercarddetail', user_card_detail): raise UserCardDetail.DoesNotExist( _("{user} does not have permission to access the " "card").format(user=request.user.email)) except UserCardDetail.DoesNotExist as e: ex = str(e) logger.error("Card Id: {card_id}, Exception: {ex}".format( card_id=card_id, ex=ex)) msg = _("An error occurred. Details: {}".format(ex)) messages.add_message(self.request, messages.ERROR, msg, extra_tags='make_charge_error') return HttpResponseRedirect( reverse('datacenterlight:payment') + '#payment_error') request.session['card_id'] = user_card_detail.id else: request.session['token'] = token if request.user.is_authenticated(): this_user = { 'email': request.user.email, 'name': request.user.name } customer = StripeCustomer.get_or_create( email=this_user.get('email'), token=token) else: user_email = address_form.cleaned_data.get('email') user_name = address_form.cleaned_data.get('name') this_user = {'email': user_email, 'name': user_name} try: custom_user = CustomUser.objects.get(email=user_email) customer = StripeCustomer.objects.filter( user_id=custom_user.id).first() if customer is None: logger.debug( ("User {email} is already registered with us." "But, StripeCustomer does not exist for {email}." "Hence, creating a new StripeCustomer.").format( email=user_email)) customer = StripeCustomer.create_stripe_api_customer( email=user_email, token=token, customer_name=user_name) except CustomUser.DoesNotExist: logger.debug( ("StripeCustomer does not exist for {email}." "Hence, creating a new StripeCustomer.").format( email=user_email)) customer = StripeCustomer.create_stripe_api_customer( email=user_email, token=token, customer_name=user_name) request.session['billing_address_data'] = address_form.cleaned_data request.session['user'] = this_user # Get or create stripe customer if not customer: address_form.add_error("__all__", "Invalid credit card") return self.render_to_response( self.get_context_data(billing_address_form=address_form)) if type(customer) is StripeCustomer: request.session['customer'] = customer.stripe_id else: request.session['customer'] = customer return HttpResponseRedirect( reverse('datacenterlight:order_confirmation')) else: context = self.get_context_data() context['billing_address_form'] = address_form return self.render_to_response(context)
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): data = form.cleaned_data context = self.get_context_data() token = data.get('token') membership_type = data.get('membership_type') # Get or create stripe customer customer = StripeCustomer.get_or_create( email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response( self.get_context_data(form=form)) # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge( amount=membership_type.first_month_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(request, self.template_name, context) charge = charge_response.get('response_object') # Create Billing Address billing_address = form.save() # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): data.update({'user': customer.user.id}) billing_address_user_form = UserBillingAddressForm(data) billing_address_user_form.is_valid() billing_address_user_form.save() # Get membership dates membership_start_date, membership_end_date = membership_type.first_month_range # Create or update membership plan membership_data = { 'type': membership_type, 'active': True, 'start_date': membership_start_date, 'end_date': membership_end_date } membership = Membership.activate_or_crete(membership_data, self.request.user) # Create membership order order_data = { 'membership': membership, 'customer': customer, 'billing_address': billing_address, 'stripe_charge': charge, 'amount': membership_type.first_month_price, 'start_date': membership_start_date, 'end_date': membership_end_date } membership_order = MembershipOrder.create(order_data) request.session.update({ 'membership_price': membership.type.first_month_price, 'membership_dates': membership.type.first_month_formated_range }) context = { 'membership': membership, 'order': membership_order, 'membership_start_date': membership_start_date, 'membership_end_date': membership_end_date, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'Your membership has been charged', 'to': request.user.email, 'context': context, 'template_name': 'membership_charge', 'template_path': 'digitalglarus/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect( reverse('digitalglarus:membership_activated')) else: return self.form_invalid(form)
def form_valid(self, form): data = form.cleaned_data context = self.get_context_data() token = data.get('token') start_date = data.get('start_date') end_date = data.get('end_date') is_free = context.get('is_free') normal_price, final_price, free_days = Booking.\ booking_price(self.request.user, start_date, end_date) charge = None # if not credit_card_needed: # Get or create stripe customer customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # If booking is not free, make the stripe charge if not is_free: # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge( amount=final_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(self.request, self.template_name, context) charge = charge_response.get('response_object') # Create Billing Address for Membership Order billing_address = form.save() # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): data.update({'user': customer.user.id}) billing_address_user_form = UserBillingAddressForm(data) billing_address_user_form.is_valid() billing_address_user_form.save() # Create Booking booking_data = { 'start_date': start_date, 'end_date': end_date, 'start_date': start_date, 'free_days': free_days, 'price': normal_price, 'final_price': final_price, } booking = Booking.create(booking_data) # Create Booking order order_data = { 'booking': booking, 'customer': customer, 'billing_address': billing_address, 'stripe_charge': charge, 'amount': final_price, 'original_price': normal_price, 'special_month_price': BookingPrice.objects.last().special_month_price, } order = BookingOrder.create(order_data) context = { 'booking': booking, 'order': order, 'base_url': "{0}://{1}".format(self.request.scheme, self.request.get_host()) } email_data = { 'subject': 'Your booking order has been placed', 'to': self.request.user.email, 'context': context, 'template_name': 'booking_order_email', 'template_path': 'digitalglarus/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect(self.get_success_url(order.id))
def post(self, request, *args, **kwargs): if 'login_form' in request.POST: login_form = HostingUserLoginForm( data=request.POST, prefix='login_form' ) if login_form.is_valid(): email = login_form.cleaned_data.get('email') password = login_form.cleaned_data.get('password') auth_user = authenticate(email=email, password=password) if auth_user: login(self.request, auth_user) return HttpResponseRedirect( reverse('datacenterlight:payment') ) else: context = self.get_context_data() context['login_form'] = login_form return self.render_to_response(context) if request.user.is_authenticated(): address_form = BillingAddressForm( data=request.POST, ) else: address_form = BillingAddressFormSignup( data=request.POST, ) if address_form.is_valid(): token = address_form.cleaned_data.get('token') if token is '': card_id = address_form.cleaned_data.get('card') try: user_card_detail = UserCardDetail.objects.get(id=card_id) if not request.user.has_perm( 'view_usercarddetail', user_card_detail ): raise UserCardDetail.DoesNotExist( _("{user} does not have permission to access the " "card").format(user=request.user.email) ) except UserCardDetail.DoesNotExist as e: ex = str(e) logger.error("Card Id: {card_id}, Exception: {ex}".format( card_id=card_id, ex=ex ) ) msg = _("An error occurred. Details: {}".format(ex)) messages.add_message( self.request, messages.ERROR, msg, extra_tags='make_charge_error' ) return HttpResponseRedirect( reverse('datacenterlight:payment') + '#payment_error' ) request.session['card_id'] = user_card_detail.id else: request.session['token'] = token if request.user.is_authenticated(): this_user = { 'email': request.user.email, 'name': request.user.name } customer = StripeCustomer.get_or_create( email=this_user.get('email'), token=token ) else: user_email = address_form.cleaned_data.get('email') user_name = address_form.cleaned_data.get('name') this_user = { 'email': user_email, 'name': user_name } try: custom_user = CustomUser.objects.get(email=user_email) customer = StripeCustomer.objects.filter( user_id=custom_user.id).first() if customer is None: logger.debug( ("User {email} is already registered with us." "But, StripeCustomer does not exist for {email}." "Hence, creating a new StripeCustomer.").format( email=user_email ) ) customer = StripeCustomer.create_stripe_api_customer( email=user_email, token=token, customer_name=user_name) except CustomUser.DoesNotExist: logger.debug( ("StripeCustomer does not exist for {email}." "Hence, creating a new StripeCustomer.").format( email=user_email ) ) customer = StripeCustomer.create_stripe_api_customer( email=user_email, token=token, customer_name=user_name) request.session['billing_address_data'] = address_form.cleaned_data request.session['user'] = this_user # Get or create stripe customer if not customer: address_form.add_error( "__all__", "Invalid credit card" ) return self.render_to_response( self.get_context_data( billing_address_form=address_form ) ) if type(customer) is StripeCustomer: request.session['customer'] = customer.stripe_id else: request.session['customer'] = customer return HttpResponseRedirect( reverse('datacenterlight:order_confirmation')) else: context = self.get_context_data() context['billing_address_form'] = address_form return self.render_to_response(context)
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): context = self.get_context_data() token = form.cleaned_data.get('token') donation_amount = form.cleaned_data.get('donation_amount') # Get or create stripe customer customer = StripeCustomer.get_or_create(email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response(self.get_context_data(form=form)) # Create Billing Address billing_address = form.save() # Make stripe charge to a customer stripe_utils = StripeUtils() stripe_utils.CURRENCY = 'usd' charge_response = stripe_utils.make_charge(amount=donation_amount, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) return render(request, self.template_name, context) # Create a donation charge = charge_response.get('response_object') donation_data = request.POST.copy() donation_data.update({ 'cc_brand': charge.source.brand, 'stripe_charge_id': charge.id, 'last4': charge.source.last4, 'billing_address': billing_address.id, 'donator': customer.id, 'donation': donation_amount }) donation_form = DonationForm(donation_data) if donation_form.is_valid(): # reactivate donation status donation = donation_form.save() try: donator_status = DonatorStatus.objects.get(user=self.request.user) donator_status.set_active() except DonatorStatus.DoesNotExist: pass donation = donation_form.save() context = { 'donation': donation, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'Your donation have been charged', 'to': request.user.email, 'context': context, 'template_name': 'donation_charge', 'template_path': 'nosystemd/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect(reverse('nosystemd:donations', kwargs={'pk': donation.id})) else: self.form_invalid(donation_form) else: return self.form_invalid(form)
def post(self, request, *args, **kwargs): form = self.get_form() if form.is_valid(): data = form.cleaned_data context = self.get_context_data() token = data.get('token') membership_type = data.get('membership_type') # Get or create stripe customer customer = StripeCustomer.get_or_create( email=self.request.user.email, token=token) if not customer: form.add_error("__all__", "Invalid credit card") return self.render_to_response( self.get_context_data(form=form)) # Make stripe charge to a customer stripe_utils = StripeUtils() charge_response = stripe_utils.make_charge( amount=membership_type.first_month_price, customer=customer.stripe_id) charge = charge_response.get('response_object') # Check if the payment was approved if not charge: context.update({ 'paymentError': charge_response.get('error'), 'form': form }) email_to_admin_data = { 'subject': "Could not create charge for Digital Glarus " "user: {user}".format(user=self.request.user.email), 'from_email': '*****@*****.**', 'to': ['*****@*****.**'], 'body': "\n".join([ "%s=%s" % (k, v) for (k, v) in charge_response.items() ]), } send_plain_email_task.delay(email_to_admin_data) return render(request, self.template_name, context) # Subscribe the customer to dg plan from the next month onwards stripe_plan = stripe_utils.get_or_create_stripe_plan( amount=membership_type.price, name='Digital Glarus {sub_type_name} Subscription'.format( sub_type_name=membership_type.name), stripe_plan_id='dg-{sub_type_name}'.format( sub_type_name=membership_type.name)) subscription_result = stripe_utils.subscribe_customer_to_plan( customer.stripe_id, [{ "plan": stripe_plan.get('response_object').stripe_plan_id }], trial_end=membership_type.next_month_in_sec_since_epoch) stripe_subscription_obj = subscription_result.get( 'response_object') # Check if call to create subscription was ok if (stripe_subscription_obj is None or (stripe_subscription_obj.status != 'active' and stripe_subscription_obj.status != 'trialing')): context.update({ 'paymentError': subscription_result.get('error'), 'form': form }) email_to_admin_data = { 'subject': "Could not create Stripe subscription for " "Digital Glarus user: {user}".format( user=self.request.user.email), 'from_email': '*****@*****.**', 'to': ['*****@*****.**'], 'body': "\n".join([ "%s=%s" % (k, v) for (k, v) in subscription_result.items() ]), } send_plain_email_task.delay(email_to_admin_data) return render(request, self.template_name, context) charge = charge_response.get('response_object') if 'source' in charge: cardholder_name = charge['source']['name'] else: cardholder_name = customer.user.name # Create Billing Address billing_address = form.save() # Create Billing Address for User if he does not have one if not customer.user.billing_addresses.count(): data.update({ 'user': customer.user.id, 'cardholder_name': cardholder_name }) billing_address_user_form = UserBillingAddressForm(data) billing_address_user_form.is_valid() billing_address_user_form.save() # Get membership dates membership_start_date, membership_end_date = membership_type.first_month_range # Create or update membership plan membership_data = { 'type': membership_type, 'active': True, 'start_date': membership_start_date, 'end_date': membership_end_date } membership = Membership.activate_or_crete(membership_data, self.request.user) # Create membership order order_data = { 'membership': membership, 'customer': customer, 'billing_address': billing_address, 'stripe_charge': charge, 'stripe_subscription_id': stripe_subscription_obj.id, 'amount': membership_type.first_month_price, 'start_date': membership_start_date, 'end_date': membership_end_date } membership_order = MembershipOrder.create(order_data) request.session.update({ 'membership_price': membership.type.first_month_price, 'membership_dates': membership.type.first_month_formated_range }) email_to_admin_data = { 'subject': "New Digital Glarus subscription: {user}".format( user=self.request.user.email), 'from_email': '*****@*****.**', 'to': ['*****@*****.**'], 'body': "\n".join(["%s=%s" % (k, v) for (k, v) in order_data.items()]), } send_plain_email_task.delay(email_to_admin_data) context = { 'membership': membership, 'order': membership_order, 'membership_start_date': membership_start_date, 'membership_end_date': membership_end_date, 'base_url': "{0}://{1}".format(request.scheme, request.get_host()) } email_data = { 'subject': 'Your membership has been charged', 'to': request.user.email, 'context': context, 'template_name': 'membership_charge', 'template_path': 'digitalglarus/emails/' } email = BaseEmail(**email_data) email.send() return HttpResponseRedirect( reverse('digitalglarus:membership_activated')) else: return self.form_invalid(form)