def checkout(request):
url = "https://restcountries-v1.p.rapidapi.com/all"
headers = {
'x-rapidapi-host': "restcountries-v1.p.rapidapi.com",
'x-rapidapi-key': "3b2ed275fbmsh21f27fe96f38688p182fedjsna34ff216cf39"
}
response = requests.request("GET", url, headers=headers)
countries = json.loads(response.text)
print(countries[8]['name'])
print(countries[8]["callingCodes"])
client = razorpay.Client(auth=("rzp_test_aVR1IKDghGVJcq",
"MIdgCBvppW3DYwzXqIgRNjcd"))
Data = cartData(request)
cartItems = Data['cartItems']
order = Data['order']
items = Data['items']
print('order:', order)
if request.user.is_authenticated:
total = int(order.get_cart_total * 100)
else:
total = int(order['get_cart_total'] * 100)
order_amount = total
order_currency = 'USD'
order_receipt = 'order_rcptid_11'
if order_amount == 0:
return redirect('cart')
else:
response = client.order.create(
dict(amount=order_amount,
currency=order_currency,
receipt=order_receipt,
payment_capture=0))
print(response)
order_id = response['id']
order_status = response['status']
context = {
'items': items,
'order': order,
'cartItems': cartItems,
'order_id': order_id,
'c': countries
}
return render(request, 'store/checkout.html', context)
def razorpay1(request):
amount = request.session['amount']
paisa = float(amount) * 100
if request.method == 'POST':
order_currency = 'INR'
client = razorpay.Client(auth=('rzp_test_BxzCGCso9MsXoi',
'rp5tFJd7Y8iEYuzHoieESrjg'))
payment = client.order.create({
'amount': paisa,
'currency': 'INR',
'payment_capture': '1'
})
context = {'amount': amount, 'paisa': paisa}
return render(request, 'user_side/payment/razorpay.html', context)
def OrderSuccess(request):
if request.method == "POST":
razorpay_payment_id = request.POST.get('razorpay_payment_id')
razorpay_order_id = request.POST.get('razorpay_order_id')
razorpay_signature = request.POST.get('razorpay_signature')
razorData = {'razorpay_payment_id':razorpay_payment_id, 'razorpay_order_id':razorpay_order_id, 'razorpay_signature':razorpay_signature}
client = razorpay.Client(auth=("YOUR_RAZORPAY_KEY", "YOUR_RAZORPAY_SECRET"))
client.utility.verify_payment_signature(razorData)
currOrder = Order.objects.get(razorpay_order_id=razorpay_order_id)
currOrder.razorpay_payment_id = razorpay_payment_id
currOrder.razorpay_signature = razorpay_signature
currOrder.paymentStatus = "Paid Successfully"
currOrder.save()
return render(request, 'paymentSuccess.html')
def userInfoForOrderPayment(request):
if request.method == 'POST':
user = request.user
userProfile, created = UserProfile.objects.get_or_create(user=user)
basket = request.basket
if not request.basket.id:
raise Http404('Unauthorised')
p = PaymentDetailsView()
order_number = p.generate_order_number(basket)
client = razorpay.Client(auth=(RZP_KEY, RZP_SECRET))
amount = int(basket.total_incl_tax) * 100
receipt = str(order_number)
print amount
d = {
'amount': amount,
'currency':'INR',
'receipt':receipt,
'notes':{}
}
order = client.order.create(data=d)
data = {
'name' : user.first_name + " " + user.last_name,
'phone' : userProfile.phone,
'email' : user.email,
'amount' : amount,
'receipt': order_number,
'order_id': order["id"]
}
shippingAddress = request.session['checkout_data']['shipping']
if 'new_address_fields' in shippingAddress:
phone = shippingAddress['new_address_fields']['phone_number'].replace(' ','')
# print phone
else:
user_address_id = shippingAddress['user_address_id']
# print 'user_address_id : ', user_address_id
userAdd = UserAddress.objects.get(id=user_address_id)
phone = '+' + str(userAdd.phone_number.country_code) + str(userAdd.phone_number.national_number).replace(' ', '')
# print phone
if not data['phone']:
data['phone'] = phone
data = json.dumps(data)
return HttpResponse(data)
else:
raise Http404('Unauthorised')
def home(request):
if request.method == "POST":
name = request.POST.get('name')
amount = 50000
client = razorpay.Client(auth=("rzp_test_9nmrK825fjo0Ym",
"1f1icPZDRCKvac3lzpOmLSl1"))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'index.html')
def home(request):
if request.method == "POST":
name = request.POST.get('name')
amount = 10000
client = razorpay.Client(auth=("rzp_test_VNYJvfzZMCpg4x",
"ZeS7HXZDIjfYNfcPVfn4C3XU"))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'index.html')
def pay(request):
if request.method == "POST":
name = request.POST.get('name')
amount = 10
client = razorpay.Client(auth=("rzp_test_F6XHUzkD9qre7E",
"q8qMjqYfgMo699AVMWHlGV8D"))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'store/pay.html')
def getOrderId(booking_info):
booking_data = {
"amount": int(booking_info['price']) * int(booking_info['days']) * 100,
"currency": "INR",
"receipt": uuid.uuid1().hex,
"payment_capture": "1"
}
client = razorpay.Client(auth=("rzp_test_lskMJcJY6Yjp9c",
"mhBmpOTiVYb0oyARYw36nF86"))
response = client.order.create(data=booking_data)
return json.dumps(response)
def home(request):
if request.method == "POST":
name = request.POST.get('name')
amount = 50000
client = razorpay.Client(auth=("rzp_test_a5ge0Nc4hINHRN",
"gi7G1LIhCC1G7kYrnS1Tf9kh"))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'index.html')
def order(request):
request = json.loads(request.body.decode('utf-8'))
try:
client = razorpay.Client(auth=("rzp_test_RWzCot8F1JlWH4",
"MjrfFw4GQ0H7J2ICsfKuZqpn"))
payment = client.order.create({
'amount': int(request["amount"]) * 100,
'currency': 'INR'
})
print(payment)
except Exception as e:
print(e)
return JsonResponse({"payment_details": payment})
def paymentGateway(request):
order_amount = 50000
order_currency = 'INR'
order_receipt = '10'
notes = {'Shipping address': 'Bommanahalli, Bangalore'} # OPTIONAL
DATA = {
"amount": order_amount,
"currency": "INR",
}
client = razorpay.Client(auth=(<your razorpay api key>, <you razorpay secret key>))
order_id=client.order.create(data = DATA)
context = {"orderid":order_id}
return render(request,"payu.html",context)
def handle_payment_success(request):
# request.data is coming from frontend
res = json.loads(request.data["response"])
"""res will be:
{'razorpay_payment_id': 'pay_G3NivgSZLx7I9e',
'razorpay_order_id': 'order_G3NhfSWWh5UfjQ',
'razorpay_signature': '76b2accbefde6cd2392b5fbf098ebcbd4cb4ef8b78d62aa5cce553b2014993c0'}
"""
ord_id = ""
raz_pay_id = ""
raz_signature = ""
# res.keys() will give us list of keys in res
for key in res.keys():
if key == 'razorpay_order_id':
ord_id = res[key]
elif key == 'razorpay_payment_id':
raz_pay_id = res[key]
elif key == 'razorpay_signature':
raz_signature = res[key]
# get order by payment_id which we've created earlier with isPaid=False
order = Order.objects.get(order_payment_id=ord_id)
data = {
'razorpay_order_id': ord_id,
'razorpay_payment_id': raz_pay_id,
'razorpay_signature': raz_signature
}
client = razorpay.Client(auth=(env('PUBLIC_KEY'), env('SECRET_KEY')))
# checking if the transaction is valid or not if it is "valid" then check will return None
check = client.utility.verify_payment_signature(data)
if check is not None:
print("Redirect to error url or error page")
return Response({'error': 'Something went wrong'})
# if payment is successful that means check is None then we will turn isPaid=True
order.isPaid = True
order.save()
res_data = {
'message': 'payment successfully received!'
}
return Response(res_data)
def post(self, request):
rz_client = razorpay.Client(auth=(settings.RZ_KEY_ID,
settings.RZ_KEY_SECRET))
rz_client.set_app_details({
"title": "ArtistSchool_Django",
"version": "0.1-alpha"
})
order_amount = 49900 # Razorpay API wants Rs. 499.00 to be written as 49900
from random import randint
order_receipt = f'reciept_{randint(0,10**6)}'
# TODO: Add proper details in notes
# TODO: Take course slug through query string
notes = {'studentEmail': '*****@*****.**'}
response = rz_client.order.create({
'amount': int(order_amount),
'currency': 'INR',
'payment_capture': '0',
"notes": notes
})
student = Student.objects.first() # TODO
course = Course.objects.first() # TODO
order_id = response['id']
order_status = response['status']
context = {
'key': settings.RZ_KEY_ID,
"order_id": order_id,
"prod_name": course.name,
"callback_url": "http://localhost:8000/v1/payment/callback/",
"currency": "INR",
"amount": str(order_amount),
}
try:
enrollment = CourseEnrollment.objects.get(student=student,
course=course)
except:
enrollment = CourseEnrollment(student=student, course=course)
enrollment.save()
transaction = EnrollmentTransaction(enrollment=enrollment,
razorpay_order_id=order_id)
transaction.save()
if order_status == 'created':
# return render(request, 'pay.html', context)
return JsonResponse(context)
else:
return HttpResponse("ERROR")
def handle_payment_success(request):
res = json.loads(request.data["response"])
client = razorpay.Client(("<YOUR_API_KEY>", "<YOUR_API_SECRET>"))
check = client.utility.verify_payment_signature(data)
if check is not None:
print("Redirect to error url or error page")
return Response({'error': 'Something went wrong'})
order.isPaid = True
order.save()
res_data = {'message': 'payment successfully received!'}
return Response(res_data)
def plan(request):
if request.method == "POST":
amount = 5
order_currency = 'INR'
client = razorpay.Client(auth=('rzp_test_c3TFXGS6EeIt7c',
'44lYMuRV7iEihEHGNLKd4PMP'))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'plan.html')
def home(request):
if request.method == 'POST':
name = request.POST.get('name')
amount = 50000
client = razorpay.Client(auth=("rzp_test_tN0wqOxzMhJNzS",
"iLkKtAr6NUMChyq27b7nXyHl"))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'index.html')
def summary(request, pk):
transaction = Transactions.objects.get(pk=pk)
RAZOR_KEY=settings.RAZOR_KEY
RAZOR_SECRET=settings.RAZOR_SECRET
client = razorpay.Client(auth=(RAZOR_KEY, RAZOR_SECRET))
order_id = transaction.Order_id
payment_capture = client.order.payments(order_id)
if payment_capture['items'][0]['captured'] == True:
transaction.Status='1'
transaction.update()
return HttpResponse('success')
else :
transaction.Status='2'
transaction.update()
return HttpResponse('failed')
def validate_payment(request):
data = json.loads(request.body)
razorpay_payment_id = data['razorpay_payment_id']
razorpay_order_id = data['razorpay_order_id']
razorpay_signature = data['razorpay_signature']
client = razorpay.Client(auth=(settings.RAZORPAY_API_KEY_PUBLISHABLE,
settings.RAZORPAY_API_KEY_HIDDEN))
params_dict = {
'razorpay_payment_id': razorpay_payment_id,
'razorpay_order_id': razorpay_order_id,
'razorpay_signature': razorpay_signature
}
res = client.utility.verify_payment_signature(params_dict)
print(res)
if not res:
order = Order.objects.get(payment_intent=razorpay_order_id)
order.paid = True
order.save()
for item in order.items.all():
product = item.product
product.num_available = product.num_available - item.quantity
product.save()
subject = 'Order confirmation'
from_email = '*****@*****.**'
to = ['*****@*****.**', order.email]
text_content = 'Your order is successful!'
html_content = render_to_string('order_confirmation.html',
{'order': order})
pdf = render_to_pdf('order_pdf.html', {'order': order})
msg = EmailMultiAlternatives(subject, text_content, from_email, to)
msg.attach_alternative(html_content, "text/html")
if pdf:
name = 'order_%s.pdf' % order.id
msg.attach(name, pdf, 'application/pdf')
msg.send()
return JsonResponse({'success': True})
def __init__(self,
public_key,
secret_key,
image='',
name='',
prefill=False,
**kwargs):
self.secret_key = secret_key
self.public_key = public_key
self.image = image
self.name = name
self.prefill = prefill
self.razorpay_client = razorpay.Client(auth=(public_key, secret_key))
super(RazorPayProvider, self).__init__(**kwargs)
def payment(request):
obj = Registration.objects.get(user__username=request.user.username)
if obj.paid==False:
client = razorpay.Client(auth = ('rzp_test_iCqL53D2oVdlIL', 'A5bcZDlcdxB6qz5K6O4i5eD1'))
payment = client.order.create({'amount':10000000, 'currency':'INR', 'payment_capture':'1'})
if request.method=="POST":
obj.paid = True
obj.order_id = request.POST["razorpay_order_id"]
obj.save()
return HttpResponseRedirect(reverse('profilepage:profilepage'))
return render(request,"reg_sign_in_out/payment.html",{'payment':payment})
else:
return render(request,"reg_sign_in_out/paid.html")
def app_charge():
key_id = request.form['key_id']
key_secret = request.form['key_secret']
razorpay_client = razorpay.Client(auth=(key_id, key_secret))
payment_id = request.form['razorpay_payment_id']
order_id = request.form['razorpay_order_id']
signature = request.form['razorpay_signature']
parameters = {
"razorpay_order_id": order_id,
"razorpay_payment_id": payment_id,
"razorpay_signature": signature
}
verified_signature = razorpay_client.utility.verify_payment_signature(
parameters) # if verified_signature is None, the result is True
if verified_signature == None:
return render_template('thankyou.html')
def razorPay(request):
print('in razorPay')
if request.method == 'POST':
print('if of razorpay')
amount = 100
order_currency = 'INR'
client = razorpay.Client(auth=('rzp_test_agtBEf4PEspMpI',
'lqytfEwvzRIAkft3FEekzi1B'))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'paymentDone.html')
print('out of if')
return render(request, 'raZorpay.html')
def checkoutcustomer(request):
if request.method == 'POST':
user = request.user
address = request.POST['address']
phone = request.POST['phone']
usercart = CustomerCart.objects.filter(customer = request.user).select_related('product')
totalprice = sum(item.product.price for item in usercart)
receipt = str(uuid.uuid1())
client = razorpay.Client(auth=("rzp_test_bAYqeZhjXN8pf0", "cgw5fGdAZHz9CO1GCGp2UJG6"))
DATA = {
'amount':totalprice*100,
'currency':'INR',
'receipt':'masupreiept',
'payment_capture':1,
'notes':{}
}
order_details = client.order.create(data=DATA)
# return HttpResponse(order_details)
customercheckout_order_instance = CustomerCheckout(customer = request.user,
order_id = order_details.get('id'),
total_amount = totalprice,
reciept_num = receipt,
delivery_address = address,
delivery_phone = phone)
customercheckout_order_instance.save()
customercheckout = CustomerCheckout.objects.get(id = customercheckout_order_instance.id)
for item in usercart:
orderedproduct_instance = customerPayedProducts(customer = request.user,
product_name = item.product.product_name,
price = item.product.price,
product_description = item.product.product_description,
checkout_details = customercheckout)
orderedproduct_instance.save()
context = {'order_id' : order_details.get('id'),
'amount' : totalprice,
'amountscript' : totalprice*100,
'currency' : 'INR',
'companyname' : 'Mashupcommrz',
'username' : request.user.first_name+' '+request.user.last_name,
'useremail' : request.user.email,
'phonenum' : phone,
'rzpkey' : 'rzp_test_bAYqeZhjXN8pf0'
}
return render(request,'customer/checkout.html',context)
else:
return HttpResponseRedirect(reverse('products'))
def get_context_data(self, **kwargs):
#context = super().get_context_data(**kwargs)
context = {}
data = self.request.GET
client = razorpay.Client(auth=('%s' % settings.RAZOR_PAY_KEY,
'%s' % settings.RAZOR_PAY_SECRET))
plans = client.plan.all()
#plan_amount =
plan = data.get('plan', 'Silver')
payment_detail = PaymentDetail.objects.filter(
payment_customer__user__email=self.request.user.email).order_by(
'-id')
if payment_detail.exists():
payment_detail = payment_detail[0]
subscription_res = client.subscription.fetch(
payment_detail.subscription_id)
if 'status' in subscription_res:
status = subscription_res['status']
if status not in ['created', 'authenticated', 'active']:
payment_detail.status = False
payment_detail.save()
context.update(paid=False)
for i in plans['items']:
plan_name = i['item']['name']
if plan_name == plan:
plan_amount = i['item']['amount']
order_data = {
'amount': plan_amount,
'currency': 'INR',
'payment_capture': 1,
'notes': {
'plan': i['id']
}
}
order_id = client.order.create(data=order_data)['id']
context.update(
plan=plan,
plan_id=i['id'],
plan_amount=plan_amount,
order_id=order_id,
customer_name=self.request.user.get_full_name().title(),
#customer_email='*****@*****.**')
customer_email=self.request.user.email)
return context
def bookinstructor(request):
services = Services.objects.all()
if request.method == 'POST':
#order_amount = 29900
#order_currency = 'INR'
order_receipt = orderid.orderid
name = request.POST['name']
noofpeople = request.POST['noofpeople']
date = request.POST['date']
mobile = request.POST['mobile']
email = request.POST['email']
address = request.POST['address']
injury = request.POST['injury']
service = request.POST['item']
msg = request.POST['message']
booking = Booking.objects.create(
payment_id=order_receipt,
name=name,
mobile=mobile,
email=email,
injury=injury,
address=address,
no_of_students=noofpeople,
date_of_event=date,
service=service,
msg=msg,
)
booking.save()
print(orderid.orderid)
# OPTIONALclient.order.create(amount=order_amount, currency=order_currency, receipt=order_receipt, notes=notes)
client = razorpay.Client(auth=('rzp_test_Dr4vACZpQp5l9V',
'EZYzh6OSYgQTIhgsKS3yLv5V'))
payment = client.order.create({
'order_amount': '29900',
'order_currency': 'INR',
'receipt': 'order_receipt',
'payment_capture': '1'
})
print("jhsdkufhsudhfuhsduifgiudg")
return redirect(success)
else:
print('noooooooo')
return render(request, 'yogbookingapp/booknow.html',
{'services': services})
def success_redirect(request):
razorpay_payment_id = request.POST['razorpay_payment_id']
razorpay_order_id = request.POST['razorpay_order_id']
razorpay_signature = request.POST['razorpay_signature']
temp_client = razorpay.Client(auth=("rzp_test_XgSvcOhAnzdFER", "4gwNXfK8dXaeAkkKAKGIByhT"))
params_dict = {
'razorpay_order_id': razorpay_order_id,
'razorpay_payment_id': razorpay_payment_id,
'razorpay_signature': razorpay_signature
}
temp_client.utility.verify_payment_signature(params_dict)
order_obj = Order.objects.get(razorpay_order_id=razorpay_order_id)
order_obj.payment = True
order_obj.payment_id = razorpay_payment_id
order_obj.save()
Cart.objects.filter(customer_id=request.user.id).delete()
return render(request, 'payment_success.html', {'data': request.POST})
def home(request):
if request.method == "POST":
name = request.POST.get('name')
amount = int(request.POST.get('amount')) * 100
client = razorpay.Client(auth=("rzp_test_fIQJWiEsCEUyzS",
"UiKtan5P5LpnMFLNkKvCEw7x"))
payment = client.order.create({
'amount': amount,
'currency': 'INR',
'payment_capture': '1'
})
coffee = Coffee(name=name, amount=amount, order_id=payment['id'])
coffee.save()
return render(request, 'index.html', {'payment': payment})
return render(request, 'index.html')
def payment(request):
empty_list=[]
with open("payment-logs.txt") as f:
empty_list=([line.rstrip() for line in f])
context = {}
client = razorpay.Client(auth=("rzp_test_EXjbUEDybwsOhO", "UlTOik00OQcCXKmKvJU7BROz"))
response = client.order.create(data={"amount": int(empty_list[0])*100, "currency": "INR"})
order_id = response["id"]
order_status = response["status"]
if order_status == "created":
context["order_id"] = order_id
context["insurance_name"] = empty_list[1] # vehicle
context["price"] = empty_list[0] # insurace_basic_pay * bike valued amount
context["username"] = request.user.username # user
obj = orders(orderid=order_id,insurance_name=empty_list[1],price=empty_list[0],username=request.user.username)
obj.save()
return render(request, 'payment.html', context)
def cart_view(request):
existing_order = get_user_pending_order(request)
print(f'{existing_order} = existing order')
if existing_order == 0:
messages.warning(request, 'No items in cart. Add items to view cart.')
return redirect(reverse(products_view))
else:
# print(existing_order[0].cart)
order = existing_order
print(f'{order}, cartview')
total_per = [i.product.price * i.quantity for i in order]
total = sum(total_per)
if total > 1:
client = razorpay.Client(auth=("rzp_test_###########",
"#############"))
client.set_app_details({
"title": "DjangoProject",
"version": "0.1"
})
DATA = {
'amount': float(total * 100),
'currency': 'INR',
'receipt': generate_order_id(),
'payment_capture': 1,
}
returned = client.order.create(data=DATA)
# print(returned['id'])
context = {
'order': order,
'order_id': returned['id'],
'total': total,
'razor_price': total * 100,
}
order = Order.objects.get(owner=request.user,
is_ordered=False,
is_cart=True)
order.ref_code = returned['id']
order.save()
print(order.ref_code)
return render(request, 'products/cart.html', context)
else:
messages.warning(request,
'No items in cart. Add items to view cart.')
return redirect(reverse(products_view))
def pay_now(request):
if request.method == "POST":
amount = request.POST.get('amount')
email = request.POST.get('email')
amount = int(amount)
c = razorpay.Client(auth=('rzp_test_hiic6D1AgJcwTl',
'SEOJWm7zRXO7jpZbczbHUN5T'))
payment = c.order.create({
'amount': amount * 100,
'currency': 'INR',
'payment_capture': '1'
})
return render(request, 'donte_now.html', {
'payment': payment,
'email': email
})
return render(request, 'donte_now.html')
