def handlerequest(request): #paytm will send POST request herre
if request.method == 'POST':
form = request.POST
response_dict = {}
for i in form.keys():
response_dict[i] = form[i]
if i == 'CHECKSUMHASH':
checksum = form[i]
verify = Checksum.verify_checksum(response_dict, MKEY, checksum)
print(response_dict)
if verify:
if response_dict['RESPCODE'] == '01':
print('order successful')
idlist = response_dict['ORDERID'].split('-')
for i in idlist:
ord = Orders.objects.get(id=i)
ord.payment_status = 'Paid'
ord.transaction_id = response_dict['TXNID']
ord.save()
else:
print('order was not successful because' +
response_dict['RESPMSG'])
return render(request, 'app/payment_status.html',
{'response': response_dict})
else:
return redirect(menu)
def VerifyPaytmResponse(response):
response_dict = {}
if response.method == "POST":
data_dict = {}
for key in response.POST:
data_dict[key] = response.POST[key]
MID = data_dict['MID']
ORDERID = data_dict['ORDERID']
verify = Checksum.verify_checksum(data_dict,
settings.PAYTM_MERCHANT_KEY,
data_dict['CHECKSUMHASH'])
if verify:
STATUS_URL = settings.PAYTM_TRANSACTION_STATUS_URL
headers = {
'Content-Type': 'application/json',
}
data = '{"MID":"%s","ORDERID":"%s"}' % (MID, ORDERID)
check_resp = requests.post(STATUS_URL, data=data,
headers=headers).json()
if check_resp['STATUS'] == 'TXN_SUCCESS':
response_dict['verified'] = True
response_dict['paytm'] = check_resp
return (response_dict)
else:
response_dict['verified'] = False
response_dict['paytm'] = check_resp
return (response_dict)
else:
response_dict['verified'] = False
return (response_dict)
response_dict['verified'] = False
return response_dict
def hendlerequest(request):
#paytm will send payment reques
#paytm will send payment reques
form = request.POST
response_dict = {}
for i in form.keys():
response_dict[i] = form[i]
if i == 'CHECKSUMHASH':
checksum = form[i]
print("res:====", response_dict)
verify = Checksum.verify_checksum(response_dict, MERCHANT_KEY, checksum)
if verify:
if response_dict['RESPCODE'] == '01':
response_dict['thank'] = True
print('order successful')
else:
Order = order.objects.filter(
order_id=(int(response_dict['ORDERID']) - 478997))
print(Order)
update = OrderUpdate.objects.filter(
order_id=(int(response_dict['ORDERID']) - 478997))
Order.delete()
update.delete()
print('order unsuccessfull because', response_dict['RESPMSG'])
else:
print("order unsuccessful because not verify_checksum",
response_dict['RESPMSG'])
return render(request, 'shop/paymentstatus.html',
{'response': response_dict})
def payment(request):
destination = request.POST.get('dest')
uname = request.POST.get('username')
quantity = int(request.POST.get('qtyTicket'))
price = int(request.POST.get('priceTicket'))
if request.method == 'POST':
payments = Payments()
payments.DestinationName = destination
payments.Name = uname
payments.Quantity = quantity
payments.Price = quantity * price
payments.save()
MERCHANT_KEY = 'bQfzzkKzeCbR7jOl'
param_dict = {
'MID': 'amitgo59443067266036',
'ORDER_ID': randomStringDigits(), # order id
'TXN_AMOUNT': str(price * quantity), # amount demanded for.
'CUST_ID': "*****@*****.**",
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'STAGING', # for demo purpose only.
'CHANNEL_ID': 'WEB',
'CALLBACK_URL':
'http://127.0.0.1:8000/notification/' # on this url paytm will send you the status of request
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'pay/makepay.html', {'data': param_dict})
def payment(request):
amount = request.POST.get('amount')
order=request.POST.get('order')
user = User.objects.get(username = request.session["username"])
b = user.coins
(b)=(b)+ int(amount)
user.coins=int(b)
user.save()
id = order
param_dict={
'MID':'WorldP64425807474247',
'ORDER_ID':str(id),
'TXN_AMOUNT':str(amount),
'CUST_ID':'*****@*****.**',
'INDUSTRY_TYPE_ID':'Retail',
'WEBSITE':'WEBSTAGING',
'CHANNEL_ID':'WEB',
'CALLBACK_URL':'http://127.0.0.1:8000/paytm/handlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(param_dict,MERCHANT_KEY)
context = {
'payment_url': settings.PAYTM_PAYMENT_GATEWAY_URL,
'comany_name': settings.PAYTM_COMPANY_NAME,
'param_dict': param_dict
}
return render(request,'paytm/paytm.html',context)
def order_create(request):
cart = Cart(request)
data_dict = {}
if request.method == 'POST':
data_dict = {}
for key in request.POST:
data_dict[key] = request.POST[key]
OrderFormSet = formset_factory(OrderCreateForm,
extra=data_dict['form-TOTAL_FORMS'])
formset = OrderFormSet(request.POST)
# form = OrderCreateForm(request.POST)
if formset.is_valid():
# order=Order.objects.create(customer=request.user, hostel=data_dict['hostel'], wing=data_dict['wing'], room_no=data_dict['room_no'], phone_no=data_dict['phone_no'], delivery_time=data_dict['delivery_time'])
# orders = formset.save(commit=False)
orders_id = []
for order in formset:
order_ID = Checksum.__id_generator__()
order.instance.order_id = order_ID
order.instance.customer = request.user
order.instance.save()
# order.customer=request.user
# order.save()
for item in cart:
OrderItem.objects.create(order=order.instance,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
orders_id.append(order.instance.id)
cart.clear()
order = Order.objects.get(order_id=order_ID)
bill_amount = order.get_total_cost()
return payment(request, order_ID, bill_amount)
# return render(request, 'orders/order/created.html', {'orders': orders_id})
else:
OrderFormSet = formset_factory(OrderCreateForm, extra=1)
formset = OrderFormSet()
return render(request, 'orders/order/create.html', {'formset': formset})
# def create(request):
# AddressInlineFormSet = inlineformset_factory(Address, Store, form=AddressForm)
# if request.method == 'POST':
# storeForm = StoreForm(request.POST)
# if storeForm.is_valid():
# new_store = storeForm.save()
# addressInlineFormSet = AddressInlineFormSet(request.POST, request.FILES, instance=new_store)
# if addressInlineFormSet.is_valid():
# addressInlineFormSet.save()
# return HttpResponseRedirect(reverse('some_happy_customer_url'))
# else:
# classificationformset = ClassificationInlineFormSet(request.POST, request.FILES, instance=new_store)
# else:
# addressInlineFormSet = AddressInlineFormSet()
# storeForm = StoreForm()
# return render(request, 'create.html', locals())
def order(request):
if request.method == "POST":
name = request.POST.get('name', '')
amount = request.POST.get('amount', '')
phone = request.POST.get('phone', '')
timeval = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
strdata = str(name) + str(amount) + str(phone) + str(timeval)
string = json.dumps(strdata).encode('utf-8')
order_id = hashlib.sha256(string).hexdigest()
order = Order(name=name, amount=amount, phone=phone)
order.save()
param_dict = {
'MID': 'kaKgCA19293434392137',
'ORDER_ID': str(order_id),
'TXN_AMOUNT': str(amount),
'CUST_ID': '*****@*****.**',
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/mapnav/handlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'mapnav/paytm.html', {'param_dict': param_dict})
return render(request, 'mapnav/order.html')
def addcustomer(request):
form = CheckoutForms(request.POST)
cart = Cart.objects.all()
m = len(Checkout.objects.all())
l = len(cart)
cart = cart[l - 1]
if form.is_valid():
register = Checkout(name=form.cleaned_data['name'],
email=form.cleaned_data['email'],
phone=form.cleaned_data['phone'],
adress=form.cleaned_data['adress'],
zipcode=form.cleaned_data['zipcode'],
city=form.cleaned_data['city'],
state=form.cleaned_data['state'],
amount=cart.total,
order_id=m)
register.save()
id = register.order_id
param_dict = {
'MID': 'kIDPCg37721409585673',
'ORDER_ID': str(id),
'TXN_AMOUNT': str(register.amount),
'CUST_ID': register.email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://localhost:8000/accounts/handlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'paytm.html', {'param_dict': param_dict})
def payment(request):
# Generating unique order id
order_id = Checksum.__id_generator__()
bill_amount = "100"
data_dict = {
'ORDER_ID': order_id,
'TXN_AMOUNT': bill_amount,
}
return PaytmPaymentPage(data_dict)
def checkout(request,total):
# dest = Destination.get_all_item()
if request.method=="POST":
firstname = request.POST.get('firstname', '')
lastname = request.POST.get('lastname', '')
amount = total
email = request.POST.get('email', '')
address = request.POST.get('address', '') + " " + request.POST.get('address2', '')
# city = request.POST.get('city', '')
state = request.POST.get('state', '')
zip_code = request.POST.get('zip', '')
country = request.POST.get('country', '')
order = Orders(firstname=firstname,lastname=lastname, email=email, address= address, state=state, zip_code=zip_code, country=country, amount=amount)
order.save()
update = OrderUpdate(order_id=order.order_id, update_desc="The order has been placed")
update.save()
thank=True
request.session['oid'] = str(order.order_id)
request.session.set_expiry(3000)
id = order.order_id
# return render(request, 'checkout.html', {'thank':thank, 'id':id})
#request paytm to transfer the amount to your account after payment by user
param_dict={
'MID': 'CokjuX79375453320495',
'ORDER_ID': str(order.order_id),
'TXN_AMOUNT': amount,
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL':'http://127.0.0.1:8000/handlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(param_dict, MERCHANT_KEY)
return render(request, 'payment.html', {'param_dict': param_dict})
# return render(request, 'checkout.html')
user = int(request.session['uid'])
cart = Carts.objects.filter(user = user)
items = {}
if cart:
for c in cart:
print("cart:",c)
product_id = c.product_id
Items = Item.objects.get(id=product_id)
items[c]=Items
print(cart,items)
context={'item':items,'total':total}
return render(request, 'checkout.html',context)
def confirm(request):
username = functions.get_username(request)
if username is not None:
user = User.objects.get(username=username)
email = user.email
product = []
cart = Cart.objects.filter(username=username)
cart_count = functions.cart_count(username)
for item in cart:
prod = Product.objects.get(id=item.product_id)
product.append(prod)
total = 0
for i in product:
price = i.price
total = total + price
prod_id = " "
prod_id = str(prod_id)
for item in cart:
prod = Product.objects.get(id=item.product_id)
produ = str(prod.id)
prod_id = prod_id + produ
prod_id = prod_id + ","
user_id = str(user.id)
today = date.today()
year = str(today.year)
month = str(today.month)
day = str(today.day)
t = time.localtime()
current_time = time.strftime("%H%M%S", t)
pay_id = day + month + year + current_time + "_" + user_id
# for payement table
pay = Payement()
pay.id = pay_id
pay.user_id = user.id
pay.products = prod_id
pay.amount = total
pay.save()
payeeee=Payement.objects.get(id=pay_id)
print(payeeee)
param_dict = {
"MID": "",
"ORDER_ID": str(pay_id),
"TXN_AMOUNT": str(total),
"CUST_ID": email,
"INDUSTRY_TYPE_ID": "Retail",
"WEBSITE": "WEBSTAGING",
"CHANNEL_ID": "WEB",
"CALLBACK_URL": "http://127.0.0.1:8000/handlerequest/",
}
param_dict["CHECKSUMHASH"] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY
)
return render(request, "paytm.html", {"param_dict": param_dict})
return render(request, "shop/checkout.html")
def PaytmPaymentPage(paytmParams):
paytmParams['MID'] = MERCHANT_ID
paytmParams['WEBSITE'] = PAYTM_WEBSITE
paytmParams['INDUSTRY_TYPE_ID'] = PAYTM_INDUSTRY_TYPE_ID
paytmParams['CHANNEL_ID'] = PAYTM_CHANNEL_ID
paytmParams['MOBILE_NO'] = PAYTM_MOBILE
paytmParams['EMAIL'] = PAYTM_EMAIL
paytmParams['CALLBACK_URL'] = CALLBACK_URL
paytmParams['CHECKSUMHASH'] = Checksum.generate_checksum(
paytmParams, MERCHANT_KEY)
return GeneratePaymentPage(paytmParams)
def payment(request):
# provide your unique order id
# if you don't have your unique order id then
order_id = Checksum.__id_generator__()
bill_amount = "100"
cust_id = "*****@*****.**"
data_dict = {
'ORDER_ID': order_id,
'TXN_AMOUNT': bill_amount,
'CUST_ID': cust_id
}
return PaytmPaymentPage(data_dict)
def checkout(request):
if request.method == "POST":
items_json = request.POST.get('itemsjson')
amount = int(request.POST.get('amount'))
name = request.POST.get('iname')
email = request.POST.get('email')
phone = request.POST.get('phone')
address = request.POST.get('address1', '') + " " + request.POST.get(
'address1', '')
city = request.POST.get('city')
state = request.POST.get('state')
zip_code = request.POST.get('zip_code')
order = Orders(items_json=items_json,
amount=amount,
name=name,
email=email,
phone=phone,
address=address,
city=city,
state=state,
zip_code=zip_code,
date=datetime.now())
order.save()
update = OrderUpdate(order_id=order.order_id,
update_desc="The order has been placed")
update.save()
pay_type = request.POST.get('pay_type')
thankyou = True
id = order.order_id
if pay_type:
return render(request, 'shop/checkout.html', {
'thank': thankyou,
'id': id
})
else:
#Request paytm to transfer the amount to your account after payment by user
param_dict = {
'MID': 'WorldP64425807474247',
'ORDER_ID': str(order.order_id),
'TXN_AMOUNT': str(amount),
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/shop/handlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'shop/paytm.html',
{'param_dict': param_dict})
return render(request, 'shop/checkout.html')
def checkout(request):
logger.info("Checking Out.....")
active_user = request.user
address , created = Address.objects.get_or_create(user = active_user)
addressform = AddressForm(request.POST,instance=address)
logger.error(addressform.errors)
if addressform.is_valid():
# address = addressform.save(commit=False)
address.name = str(request.POST['firstname']) + " " + str(request.POST['lastname'])
address.save()
else:
address.delete()
logger.debug("Form is not valid...")
return redirect('homepage')
order = Order.objects.create(user = active_user, amount = str(request.cart.total()) )
order.billing_address = str(address)
order.save()
paytmParams = {
"MID" : MERCHANT_ID,
"WEBSITE" : "WEBSTAGING",
"INDUSTRY_TYPE_ID" : "Retail",
"CHANNEL_ID" : "WEB",
"ORDER_ID" : str(order.order_id),
"CUST_ID" : active_user.email,
"EMAIL" : active_user.email,
"TXN_AMOUNT" : "{0:.2f}".format(float(order.amount)),
"CALLBACK_URL" : "http://localhost:8000/orderdone/",
}
if active_user.mobile_number :
paytmParams['MOBILE_NO'] = str( active_user.mobile_number )
checksum = Checksum.generate_checksum(paytmParams, MERCHANT_KEY)
paytmParams["CHECKSUMHASH"] = checksum
logger.debug("Payment request Sent (cart cleared) ...... ")
# Booking Order
for cartitem in request.cart.cartitem.all():
orderitem = OrderItem.objects.create(
order = order,
item = cartitem.item,
quantity = cartitem.quantity,
)
# empty the cart
del request.session['cart_id']
request.cart.delete()
return render(request , 'pizza/paytm.html', {'paytmParams':paytmParams})
def payment(request):
payment_holder = PaymentHolder.objects.get(payment_id=24)
order_id = Checksum.__id_generator__()
payment_holder.paytm_order_id = order_id
payment_holder.save()
bill_amount = str(payment_holder.amount_owed)
cust_id = payment_holder.user.contact
data_dict = {
'ORDER_ID': order_id,
'TXN_AMOUNT': bill_amount,
'CUST_ID': cust_id,
}
return PaytmPaymentPage(data_dict)
def response(request):
if request.method == "POST":
MERCHANT_KEY = settings.PAYTM_MERCHANT_KEY
data_dict = {}
for key in request.POST:
data_dict[key] = request.POST[key]
verify = Checksum.verify_checksum(data_dict, MERCHANT_KEY, data_dict['CHECKSUMHASH'])
if verify:
PaytmHistory.objects.create(user=request.user, **data_dict)
return render(request,"response.html",{"paytm":data_dict})
else:
return HttpResponse("checksum verify failed")
return HttpResponse(status=200)
def perform_create(self, serializer):
order_id = Checksum.__id_generator__()
bill_amount = serializer["payment_amount"]
cust = Customer.objects.get(pk=1)
cust_id = cust.customer_id
data_dict = {
'ORDER_ID': order_id,
'TXN_AMOUNT': bill_amount,
'CUST_ID': cust_id
}
print(data_dict)
print(PaytmPaymentPage(data_dict))
return PaytmPaymentPage(data_dict)
def homepage(request):
form = TicketForm()
amount = 0
if request.method == "POST":
form = TicketForm(request.POST)
if form.is_valid():
ticket = form.save(commit=False)
ticket.user = request.user
active_user = User.objects.get(email=request.user.email)
amount = int(
request.POST['no_of_tickets']) * 100 # for now price is fixed
ticket.save()
cust_id = 'apneaap' + str(time()) + str(ticket.ticket_id)
print(" ticket id : ", ticket.ticket_id)
print("customer id :", cust_id)
print("mobile number : ", active_user.mobile_number)
print(" Email : ", active_user.email)
paytmParams = {
"MID": MERCHANT_ID,
"WEBSITE": "WEBSTAGING",
"INDUSTRY_TYPE_ID": "Retail",
"CHANNEL_ID": "WEB",
"ORDER_ID": str(ticket.ticket_id),
"CUST_ID": cust_id,
"EMAIL": request.user.email,
"TXN_AMOUNT": "{0:.2f}".format(amount),
"CALLBACK_URL": "http://localhost:8000/qrcode/",
}
if active_user.mobile_number:
paytmParams["MOBILE_NO"] = str(active_user.mobile_number)
checksum = Checksum.generate_checksum(paytmParams, MERCHANT_KEY)
print("Checksum Generated ....... " + checksum + '\n')
paytmParams["CHECKSUMHASH"] = checksum
pprint(dict(paytmParams))
return render(request, 'booking/paytm.html',
{'param_dict': paytmParams})
return render(request, 'booking/homepage.html', {
'form': form,
'amount': amount
})
def payment(request):
MERCHANT_KEY = settings.PAYTM_MERCHANT_KEY
MERCHANT_ID = settings.PAYTM_MERCHANT_ID
CALLBACK_URL = settings.HOST_URL+ settings.PAYTM_CALLBACK_URL
# Generating unique temporary ids
order_id = Checksum.__id_generator__()
bill_amount = 10
if bill_amount:
data_dict = {
'MID':MERCHANT_ID,
'ORDER_ID':str(order_id),
'TXN_AMOUNT': str(bill_amount),
'CUST_ID':'*****@*****.**',
'INDUSTRY_TYPE_ID':'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID':'WEB',
'CALLBACK_URL': CALLBACK_URL,
}
param_dict = data_dict
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(data_dict, MERCHANT_KEY)
return render(request,"payment.html",{'paytmdict':param_dict})
return HttpResponse("Bill Amount Could not find. ?bill_amount=10")
def get_paytm_payment_transactions_details(paytm_order_id):
paytmParams = dict()
paytmParams["MID"] = MERCHANT_ID
paytmParams["ORDERID"] = paytm_order_id
checksum = Checksum.generate_checksum(paytmParams, MERCHANT_KEY)
paytmParams["CHECKSUMHASH"] = checksum
post_data = json.dumps(paytmParams)
response = requests.post(URL,
data=post_data,
headers={
"Content-type": "application/json"
}).json()
return response
def my_order(request):
cart = Cart.objects.filter(customer=request.user)
canteen = Cart.objects.filter(
customer=request.user).values('canteen').distinct()
print(canteen)
datetime = request.POST.get('date_time')
total = 0
orderid = ''
for i in canteen:
price = Cart.objects.filter(customer=request.user,
canteen=i['canteen']).aggregate(
Sum('price'))
cant = User.objects.get(id=i['canteen'])
ord = Orders.objects.create(total_price=price['price__sum'],
ordered_by=request.user,
time=datetime,
ordered_to=cant)
total += int(price['price__sum'])
if len(orderid) == 0:
orderid += str(ord.id)
else:
orderid = orderid + '-' + str(ord.id)
print(orderid)
cart = Cart.objects.filter(customer=request.user, canteen=i['canteen'])
for i in cart:
Myorder.objects.create(canteen_id=cant,
menu=i.food,
quant=i.quantity,
order_id=ord)
i.delete()
param_dict = {
'MID': MID, #merchant id
'ORDER_ID': orderid,
'TXN_AMOUNT': str(total),
'CUST_ID': str(request.user.id),
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING', #for testing
'CHANNEL_ID': 'WEB',
'MOBILE_NO': str(request.user.phone),
'EMAIL': str(request.user.email),
'CALLBACK_URL': 'http://127.0.0.1:8000/handlerequest/'
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(param_dict, MKEY)
return render(request, 'app/checkout.html', {'param_dict': param_dict})
def verify_order(self, request):
self.request = request
self.paytm_dict = request.POST
checksumhash, self.paytm_params = self.get_checksumhash()
is_checksum_valid = Checksum.verify_checksum(self.paytm_params,
self.PAYTM_MERCHANT_KEY,
checksumhash)
self.order = self.get_order()
self.update_order()
if not is_checksum_valid:
self.order.status = self.order.Status.FRAUD
self.order.save()
return is_checksum_valid
def payment(request):
MERCHANT_KEY = settings.PAYTM_MERCHANT_KEY
MERCHANT_ID = settings.PAYTM_MERCHANT_ID
get_lang = "/" + get_language() if get_language() else ''
CALLBACK_URL = settings.HOST_URL + get_lang + settings.PAYTM_CALLBACK_URL
# Generating unique temporary ids
order_id = Checksum.__id_generator__()
bill_amount = 100
if bill_amount:
data_dict = {
'MID':MERCHANT_ID,
'ORDER_ID':str('1'),
'TXN_AMOUNT': str(bill_amount),
'CUST_ID':'*****@*****.**',
'INDUSTRY_TYPE_ID':'Retail',
'WEBSITE': settings.PAYTM_WEBSITE,
'CHANNEL_ID':'WEB',
#'CALLBACK_URL':CALLBACK_URL,
}
param_dict = data_dict
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(data_dict, MERCHANT_KEY)
return render(request,"payment.html",{'paytmdict':param_dict})
return HttpResponse("Bill Amount Could not find. ?bill_amount=10")
def generate(order):
dic = {
"mid": "WqmatC77859343122059",
"order_id": str(order.order_id),
"customer_id": str(order.user.user_id),
"txn_amount": str(order.price),
"channel_id": "WEB",
"website": "WEBSTAGING",
"mobile_no": str(order.user.phone_no),
"industry_type_id": "Retail",
"callback_url": "http://127.0.0.1:8000/payments/verify"
}
checksum = Checksum.generate_checksum(dic, "2aqz4AwRzEM#8Wl@")
dic["checksum"] = checksum
return dic
def handlepaymentmode(request):
if (request.method == "POST"):
goods_name = request.POST.get("goods_name")
goods_amount = request.POST.get("goods_amount")
goods_count = request.POST.get("goods_count")
price = request.POST.get("price")
first_name = request.POST.get("first_name")
last_name = request.POST.get("last_name")
phone_number = request.POST.get("phone_number")
email = request.POST.get("email")
state = request.POST.get("state")
city = request.POST.get("city")
code = request.POST.get("code")
local = request.POST.get("local")
w = []
rd = random.randint(1, 4000)
if rd not in w:
w.append(rd)
orderId = w[len(w) - 1]
customeroredered = orderfromwebsite(
goods_name=goods_name,
goods_amount=goods_amount,
goods_count=goods_count,
orderId="LXI" + str(orderId),
price=price,
first_name=first_name,
last_name=last_name,
phone_number=phone_number,
email=email,
state=state,
city=city,
code=code,
local=local,
)
customeroredered.save()
data_dict = {
'MID': 'hoIoYf23662428021793',
'ORDER_ID': "LXI" + str(orderId),
'TXN_AMOUNT': str(price),
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/paytmsentposturl'
}
data_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
data_dict, MERCHANT_KEY)
return render(request, "paytmhit.html", {'params': data_dict})
def handlerequest(request):
form = request.POST
response_dict = {}
for i in form.keys():
response_dict[i] = form[i]
if i == 'CHECKSUMHASH':
checksum = form[i]
verify = Checksum.verify_checksum(response_dict, MERCHANT_KEY, checksum)
if verify:
if response_dict['RESPCODE'] == '01':
print('order successful')
else:
print('order was not successful because' +
response_dict['RESPMSG'])
return render(request, 'shopping.html', {'response': response_dict})
def checkout(request):
if request.method == "POST":
name = request.POST.get('name', '')
amount = request.POST.get('amount', '')
item_list = request.POST.get('items_list', '')
address = request.POST.get('address1', '') + " " + request.POST.get(
'address2', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
city = request.POST.get('city', '')
state = request.POST.get('state', '')
zip_code = request.POST.get('zip_code', '')
order = Order(name=name,
email=email,
phone=phone,
city=city,
state=state,
amount=amount,
Items_list=item_list,
zipcode=zip_code,
address=address)
order.save()
update = OrderUpdate(order_id=order.order_id,
update_disc="The order has been placed")
update.save()
thank = True
id = order.order_id
#return render(request,'shop/checkout.html',{'thank':thank,'id': id})
# Request paytm to transfer amount to my account after payment is done by user
param_dict = {
'MID': 'Paytm Merchant Account Id',
'ORDER_ID': str(order.order_id),
'TXN_AMOUNT': str(amount),
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum_by_str(
param_dict, MERCHANT_KEY, salt=None)
return render(request, 'shop/paytm.html', {
'param_dict': param_dict,
'thank': True
})
return render(request, 'shop/checkout.html')
def handlerequest(request):
# Paytem will send you post request
form = request.POST
response_dict = {}
for i in form.keys():
response_dict[i] = form[i]
if i == 'CHECKSUMHASH':
checksum = form[i]
verify = Checksum.verify_checksum(response_dict, MERCHANT_KEY, checksum)
if verify:
if response_dict['RESPCODE'] == '01':
print('order successful')
else:
print('Order was not successful beacuse ' +
response_dict['RESPMSG'])
return render(request, 'paymentstatus.html', {'response': response_dict})
def VerifyPaytmResponse(response):
response_dict = {}
if response.method == "POST":
data_dict = {}
for key in response.POST:
data_dict[key] = response.POST[key]
verify = Checksum.verify_checksum(data_dict, MERCHANT_KEY,
data_dict['CHECKSUMHASH'])
if verify:
response_dict['verified'] = True
response_dict['paytm'] = data_dict
return response_dict
else:
response_dict['verified'] = False
return response_dict
response_dict['verified'] = False
return response_dict
