def createPayment(request, product_id):
# Create a new Payment Request
user = request.session.get('user')
product = Product.objects.get(id=product_id)
userObject = User.objects.get(id=user.get('id'))
amount = (product.price - (product.price * (product.discount / 100)))
response = API.payment_request_create(
amount=math.floor(amount),
purpose=f'Payment for {product.name}',
send_email=True,
buyer_name=userObject.name,
email=user.get('email'),
redirect_url="http://127.0.0.1:8000/complete-payment"
)
print(response)
payment_request_id = response['payment_request']['id']
# print the long URL of the payment request.
payment = Payment(user=User(id = user.get('id') ) ,
product=product,
payment_request_id=payment_request_id)
payment.save()
url = response['payment_request']['longurl']
print(response)
return redirect(url)
def post(self, *args, **kwargs):
''' what happens when payment view is posted '''
token = self.request.POST.get('stripeToken')
order = Order.objects.get(user=self.request.user, ordered=False)
amount = int(order.get_final_price() * 100)
try:
charge = stripe.Charge.create(
amount=amount, # cents
currency="usd",
source=token)
# create the payment
payment = Payment()
payment.stripe_charge_id = charge['id']
payment.user = self.request.user
payment.amount = int(order.get_final_price())
payment.save()
# assign the payment to the order
order_items = order.items.all()
order_items.update(ordered=True)
for item in order_items:
item.save()
order.ordered = True
order.payment = payment
order.save()
messages.success(self.request, "Your order was successful!")
return redirect("home")
except stripe.error.CardError as e:
body = e.json_body
def post(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
form = PaymentForm(self.request.POST)
# token = stripe.Token.create(card={ "number": "4242424242424242", "exp_month": 8, "exp_year": 2021, "cvc": "314",})
amount = int(order.get_total() * 100)
try:
charge = stripe.Charge.create(
amount=amount, # cents
currency="usd",
source="tok_visa",
)
payment = Payment()
payment.stripe_charge_id = charge['id']
payment.user = self.request.user
payment.amount = order.get_total()
payment.save()
order.ordered = True
order.payment = payment
order.save()
messages.success(self.request, "Your Order Was Successful")
return redirect("shop:shop")
except stripe.error.CardError as e:
# Since it's a decline, stripe.error.CardError will be caught
body = e.json_body
err = body.get('error', {})
messages.warning(self.request, f"{err.get('message')}")
return redirect("shop:shop")
except stripe.error.RateLimitError as e:
# Too many requests made to the API too quickly
messages.warning(self.request, "RateLimitError")
return redirect("shop:shop")
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
messages.warning(self.request, "InvalidRequestError")
return redirect("shop:shop")
except stripe.error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
messages.warning(self.request, "AuthenticationError")
return redirect("shop:shop")
except stripe.error.APIConnectionError as e:
# Network communication with Stripe failed
messages.warning(self.request, "APIConnectionError")
return redirect("shop:shop")
except stripe.error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
messages.warning(self.request, "StripeError")
return redirect("shop:shop")
except Exception as e:
# Something else happened, completely unrelated to Stripe
messages.warning(self.request, "Something Went Wrong Please Try Again")
return redirect("shop:shop")
def payment():
form = SetUpPaymentForm()
username = current_user.username
if form.validate_on_submit():
payment = Payment(username=username,
firstname=form.firstname.data,
lastname=form.lastname.data,
accountno=form.accountno.data,
sortcode=form.sortcode.data)
db.session.add(payment)
db.session.commit()
return redirect("/payment_setup_complete")
return render_template("payment.html", form=form)
def createPayment(request, product_id):
product = Product.objects.get(id=product_id)
amount = (product.price - (product.price * (product.discount / 100)))
user = request.session.get('user')
userObj = User.objects.get(id=user.get('id'))
# Create a new Payment Request
response = api.payment_request_create(
amount=math.floor(amount),
purpose=f'Payment for {product.name}',
send_email=True,
email=user.get('email'),
phone=userObj.phone,
buyer_name=userObj.name,
redirect_url="http://localhost:8000/complete-payment")
url = response['payment_request']['longurl']
payment_request_id = response['payment_request']['id']
#print(response)
payment = Payment(product=product,
user=User(id=user.get('id')),
payment_request_id=payment_request_id)
payment.save()
return redirect(url)
def createPayment(request, product_id):
user = request.session.get('user')
email = user.get('email')
userObj = User.objects.get(id=user.get('id'))
user_name = userObj.name
phone = userObj.phone
product = Products.objects.get(id=product_id)
amount = product.price - (product.price * product.discount / 100)
response = api.payment_request_create(
amount=math.floor(amount),
purpose=f'Payment for {product.name} course',
send_email=True,
buyer_name=user_name,
email=email,
# phone=phone,
redirect_url="http://localhost:8000/complete-payment")
print(response)
# print the long URL of the payment request.
# print(response['payment_request']['longurl'])
url = response['payment_request']['longurl']
# print the unique ID(or payment request ID)
# print(response['payment_request']['id'])
payment_request_id = response['payment_request']['id']
payment = Payment(
product=product,
user=userObj,
payment_request_id=payment_request_id,
)
payment.save()
return redirect(url)
def get(self, request, product_id):
user = request.session.get('user')
product = Product.objects.get(id=product_id)
userObject = User.objects.get(id=user.get('id'))
amount = product.price - (product.price * (product.descount / 100))
response = API.payment_request_create(
amount=math.floor(amount),
purpose=f'Payment for {product.name}',
send_email=True,
phone=userObject.phone,
buyer_name=userObject.name,
email=user.get('email'),
redirect_url="http://localhost:8000/complete-payment")
# print the long URL of the payment request.
payment_request_id = response['payment_request']['id']
payment = Payment(user=User(id=user.get('id')),
name=Product(id=product_id),
payment_request_id=payment_request_id)
payment.save()
url = response['payment_request']['longurl']
# print the unique ID(or payment request ID)
print(response)
return redirect(url)
def post(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
form = PaymentForm(self.request.POST)
userprofile = UserProfile.objects.get(user=self.request.user)
if form.is_valid():
token = form.cleaned_data.get('stripeToken')
save = form.cleaned_data.get('save')
use_default = form.cleaned_data.get('use_default')
if save:
if userprofile.stripe_customer_id != '' and userprofile.stripe_customer_id is not None:
customer = stripe.Customer.retrieve(
userprofile.stripe_customer_id)
customer.sources.create(source=token)
else:
customer = stripe.Customer.create(
email=self.request.user.email, )
customer.sources.create(source=token)
userprofile.stripe_customer_id = customer['id']
userprofile.one_click_purchasing = True
userprofile.save()
amount = int(order.get_total() * 100)
try:
if use_default or save:
charge = stripe.Charge.create(
amount=amount,
currency='usd',
customer=userprofile.stripe_customer_id)
else:
charge = stripe.Charge.create(amount=amount,
currency='usd',
customer=userprofile.token)
payment = Payment()
payment.stripe_charge_id = charge['id']
payment.user = self.request.user
payment.amount = order.get_total()
payment.save()
order_items = order.items.all()
order_items.update(ordered=True)
for item in order_items:
item.save()
order.ordered = True
order.payment = payment
order.ref_code = create_ref_code()
order.save()
messages.success(self.request, 'Your order was successful')
return redirect('/')
except stripe.error.CardError as e:
body = e.json_body
err = body.get('error', {})
messages.warning(self.request, f"{err.get('message')}")
return redirect("/")
except stripe.error.RateLimitError as e:
# Too many requests made to the API too quickly
messages.warning(self.request, "Rate limit error")
return redirect("/")
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
print(e)
messages.warning(self.request, "Invalid parameters")
return redirect("/")
except stripe.error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
messages.warning(self.request, "Not authenticated")
return redirect("/")
except stripe.error.APIConnectionError as e:
# Network communication with Stripe failed
messages.warning(self.request, "Network error")
return redirect("/")
except stripe.error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
messages.warning(
self.request,
"Something went wrong. You were not charged. Please try again."
)
return redirect("/")
except Exception as e:
# send an email to ourselves
messages.warning(
self.request,
"A serious error occurred. We have been notifed.")
return redirect("/")
messages.warning(self.request, "Invalid data received")
return redirect("/payment/stripe/")
def checkout(request):
if request.method == 'GET':
form = CheckForm()
cart = request.session.get('cart')
if cart is None:
cart = []
for c in cart:
size_str = c.get('size')
tshirt_id = c.get('tshirt')
size_obj = SizeVariant.objects.get(size=size_str, tshirt=tshirt_id)
c['size'] = size_obj
c['tshirt'] = size_obj.tshirt
print(cart)
return render(request, 'checkout.html', {
"form": form,
'cart': cart
})
else:
# post request
form = CheckForm(request.POST)
user = None
if request.user.is_authenticated:
user = request.user
if form.is_valid():
# payment
cart = request.session.get('cart')
if cart is None:
cart = []
for c in cart:
size_str = c.get('size')
tshirt_id = c.get('tshirt')
size_obj = SizeVariant.objects.get(size=size_str,
tshirt=tshirt_id)
c['size'] = size_obj
c['tshirt'] = size_obj.tshirt
shipping_address = form.cleaned_data.get('shipping_address')
phone = form.cleaned_data.get('phone')
payment_method = form.cleaned_data.get('payment_method')
total = cal_total_payable_amount(cart)
print(shipping_address, phone, payment_method, total)
order = Order()
order.shipping_address = shipping_address
order.phone = phone
order.payment_method = payment_method
order.total = total
order.order_status = "PENDING"
order.user = user
order.save()
# saving order items
for c in cart:
order_item = OrderItem()
order_item.order = order
size = c.get('size')
tshirt = c.get('tshirt')
order_item.price = floor(size.price -
(size.price *
(tshirt.discount / 100)))
order_item.quantity = c.get('quantity')
order_item.size = size
order_item.tshirt = tshirt
order_item.save()
buyer_name = f'{user.first_name} {user.last_name}'
print(buyer_name)
# crating payment
response = API.payment_request_create(
amount=order.total,
purpose="Payment For Tshirts",
send_email=True,
buyer_name=f'{user.first_name} {user.last_name}',
email=user.email,
redirect_url="http://localhost:8000/validate_payment"
)
payment_request_id = response ['payment_request']['id']
url = response['payment_request']['longurl']
payment = Payment()
payment.order = order
payment.payment_request_id= payment_request_id
payment.save()
return redirect(url)
else:
return redirect('/checkout/')
def post(self, request, *args, **kwargs):
def _get_total_price(ordered_products):
total_price = 0
for ordered_product in ordered_products:
total_price += ordered_product.total
return total_price
if request.user.is_authenticated:
cart = CartAuth(request)
else:
cart = Cart(request)
order_form = OrderForm(request.POST)
if order_form.is_valid():
fullname = order_form.cleaned_data['fullname']
email = order_form.cleaned_data['email']
phone = order_form.cleaned_data['phone']
user = None
if request.user.is_authenticated:
user = request.user
elif User.objects.get(username=email).exists():
return redirect(reverse('account:login'))
else:
password = User.objects.make_random_password()
user = User.objects.create_user(email, email, password)
profile = Profile(user=user, phone=phone)
profile.save()
user.last_name = fullname
postcode = order_form.cleaned_data.get('postcode')
region = order_form.cleaned_data.get('region')
area = order_form.cleaned_data.get('area')
city = order_form.cleaned_data.get('city')
street = order_form.cleaned_data.get('street')
house = order_form.cleaned_data.get('house')
building = order_form.cleaned_data.get('building')
apartment = order_form.cleaned_data.get('apartment')
comment = order_form.cleaned_data.get('comment')
payment_type = order_form.cleaned_data.get('payment_type')
entity_name = order_form.cleaned_data.get('entity_name')
entity_inn = order_form.cleaned_data.get('entity_inn')
entity_kpp = order_form.cleaned_data.get('entity_kpp')
delivery = None
entity = None
if postcode:
delivery = Delivery(postcode=postcode,
region=region,
area=area,
city=city,
street=street,
house=house,
building=building,
apartment=apartment,
comment=comment)
delivery.save()
if entity_name:
entity = Entity(title=entity_name,
inn=entity_inn,
kpp=entity_kpp)
entity.save()
order = Order(delivery=delivery, user=user, entity=entity)
order.save()
products = tuple(cart.get())
print(tuple(products), 'ORDER PRODUCTS FOR CREATE')
ordered_products = OrderedProducts.objects.bulk_create(
OrderedProducts(order=order,
product=product,
count=product.count,
total=product.get_discount_price() *
int(product.count)) for product in products)
if payment_type in ('bank', 'bill', 'receipt'):
payment = Payment(total=_get_total_price(ordered_products),
_type=self.payment_type_crutch[payment_type])
payment.save()
order.payment = payment
order.save()
return redirect(reverse('account:ProfileOrders'))
return redirect(reverse('account:ProfileOrders'))