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 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 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 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 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 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 checkoutdetails(request):
cid = request.user.id
if request.method == "POST":
c = customerbillingaddress()
listingid = request.POST.get("listingid")
c.cid = request.user
c.fname = request.POST.get("fname")
name = request.POST.get("fname")
c.lname = request.POST.get("lname")
c.address = request.POST.get("address")
c.city = request.POST.get("city")
c.state = request.POST.get("state")
c.country = request.POST.get("country")
c.zipcode = request.POST.get("zipcode")
c.contact = request.POST.get("contact")
c.quantity = request.POST.get("quantity")
amount = request.POST.get("amount")
c.amount = request.POST.get("amount")
cartidd = pendingorder.objects.filter(cid_id=cid).values("id")[:1]
c.cartid = pendingorder.objects.get(id=cartidd)
c.save()
order_id = c.id
print(order_id)
messages.success(request, "address saved")
param_dict = {
'MID': 'yDZuTr04800090412050',
'ORDER_ID': str(order_id),
'TXN_AMOUNT': str(amount),
'CUST_ID': str(cid),
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/handlerrequest',
}
param_dict["CHECKSUMHASH"] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, "cart/paytm.html", {'param_dict': param_dict})
# return render(request,"productlist/index.html")
else:
messages.error(request, "error in address")
return render(request, "cart/checkout.html")
def checkout(request):
if request.method == "POST":
items_json = request.POST.get('itemsJson', '')
name = request.POST.get('name', '')
amount = request.POST.get('amount', '')
email = request.POST.get('email', '')
address = request.POST.get('address1', '') + " " + request.POST.get(
'address2', '')
city = request.POST.get('city', '')
state = request.POST.get('state', '')
zip_code = request.POST.get('zip_code', '')
phone = request.POST.get('phone', '')
order = Orders(items_json=items_json,
name=name,
email=email,
address=address,
city=city,
state=state,
zip_code=zip_code,
phone=phone,
amount=amount)
order.save()
update = orderUpdate(order_id=order.order_id,
update_desc="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 the amount to your account after payment by user
param_dict = {
'MID': 'xWmblH35395467167516',
'ORDER_ID': str(order.order_id),
'TXN_AMOUNT': str(amount),
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'https://dp.harshblog.xyz/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 success(mid, order_id):
para = {}
para["MID"] = mid
para["ORDERID"] = order_id
checksum = Checksum.generate_checksum(para, '2aqz4AwRzEM#8Wl@')
para['CHECKSUMHASH'] = checksum
post_data = json.dumps(para)
url = "https://securegw-stage.paytm.in/order/status"
response = requests.post(url,
data=post_data,
headers={
"Content-type": "application/json"
}).json()
order = Order.objects.get(order_id=order_id)
if response['ORDERID'] != order_id:
return False
if response['TXNAMOUNT'] != order.price:
return False
return True
def paytm(request):
obj1 = request.POST.get('id')
obj2 = request.POST.get('total')
obj3 = request.POST.get('email')
print(obj1, obj2, obj3)
param_dict = {
'MID': 'ZdehqP52015247605360',
'ORDER_ID': str(obj1),
'TXN_AMOUNT': str(obj2),
'CUST_ID': str(obj3),
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/cart/handlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'payment/paym.html', {'param_dict': param_dict})
def checkout(request):
if request.method == 'POST':
items_json = request.POST.get('itemsJson', '')
name = request.POST.get('name', '')
amount = request.POST.get('amount', '')
email = request.POST.get('email', '')
address = request.POST.get('address1', '') + " " + request.POST.get(
'address2', '')
city = request.POST.get('city', '')
state = request.POST.get('state', '')
zip_code = request.POST.get('zip_code', '')
phone = request.POST.get('phone', '')
order = Order(items_json=items_json,
name=name,
email=email,
address=address,
city=city,
state=state,
zip_code=zip_code,
phone=phone,
amount=amount)
order.save()
update = Orderupdate(orderid=orderid,
update_desc="The order has been placed")
update.save()
thank = True
id = order.orderid
#return render(request,'shop/checkout.html',{'thank':thank ,'id':id})
param_dict = {
'MID': 'WorldP64425807474247',
'ORDER_ID': str(order.orderid),
'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 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 checkout(request):
if request.method == "POST":
items_json = request.POST.get('itemsJson', '')
amount = request.POST.get('amount', '')
firstName = request.POST.get('firstName', '')
lastName = request.POST.get('lastName', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
country = request.POST.get('country', '')
state = request.POST.get('state', '')
city = request.POST.get('city', '')
zip_code = request.POST.get('zip_code', '')
address1 = request.POST.get('address1', '')
address2 = request.POST.get('address2', '')
order = Orders(items_json=items_json, firstName=firstName, lastName=lastName,
email=email, phone=phone, country=country,
state=state, city=city, zip_code=zip_code,
address1=address1, address2=address2, amount=amount)
order.save()
thank = True
id = order.order_id
param_dict = {
'MID': os.getenv("DJANGO_MERCHANT_ID"),
'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/paymentstatus/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'paytm.html', {'param_dict': param_dict})
return render(request, 'checkout.html')
def paytm(request):
obj1 = request.POST.get('id')
obj2 = request.POST.get('total')
obj3 = request.POST.get('email')
print(obj1, obj2, obj3)
param_dict = {
# 'MID': 'IziPPU18604609740449',
'MID': 'ZdehqP52015247605360',
'ORDER_ID': str(obj1),
'TXN_AMOUNT': str(obj2),
'CUST_ID': str(obj3),
'INDUSTRY_TYPE_ID': 'Retail',
'PAYMENT_MODE_ONLY': 'yes',
'PAYMENT_TYPE_ID': ['DC', 'CC'],
'AUTH_MODE': '3D',
'WEBSITE': 'DEFAULT',
'CHANNEL_ID': 'WEB',
# 'CALLBACK_URL': 'https://customauctions.in/handlerequest/',
'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})
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 payment(request):
if request.user.is_authenticated and request.user.is_customer:
if request.method == 'POST':
pay = request.POST.get('paymentMethod')
if pay == "paydel":
order = Order.objects.filter(user_id=request.user,
completed=False)[0]
order.completed = True
order.trans_mode = "D"
order.save()
response_dict = {
'ORDERID': str(order.order_id),
'STATUS': 'TXN_SUCCESS'
}
return render(request, 'shop/complete.html',
{'response': response_dict})
else:
order = Order.objects.filter(user_id=request.user,
completed=False)[0]
param_dict = {
'MID': 'WorldP64425807474247',
'ORDER_ID': str(order.order_id),
'TXN_AMOUNT': str(order.totalamt),
'CUST_ID': request.user.email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://localhost:8000/handlepayment/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'shop/paytm.html',
{'param_dict': param_dict})
return redirect('checkout')
else:
return redirect('login')
def checkout(request):
if request.method == "POST":
jsonitem = request.POST['jsonitem']
fname = request.POST['fname']
lname = request.POST['lname']
email = request.POST['email']
address1 = request.POST['address1']
address2 = request.POST['address2']
city = request.POST['city']
state = request.POST['state']
zip_code = request.POST['zip_code']
prod = json.loads(jsonitem)
sum = 0
for item in prod:
print("product: ", item, "qty:-", prod[item][0])
item = item[2:]
print("product: ", item)
prize = Product.objects.filter(id=item)
p = int(prize[0].price) * int(prod['pr' + item][0])
sum = sum + p
ammount1 = sum
Order = order(json_item=jsonitem,
fname=fname,
ammount=ammount1,
lname=lname,
email=email,
address1=address1,
address2=address2,
city=city,
state=state,
zipcode=zip_code)
Order.save()
update = OrderUpdate(order_id=Order.order_id,
update_desc="The order has been placed")
update.save()
thank = True
#id=Order.order_id
#return render(request, 'shop/checkout.html',{'thank':thank,'orderid':id})
param_dict = {
'MID': 'bEtzWe72963291709602',
'ORDER_ID': str(478997 + Order.order_id),
'TXN_AMOUNT': str(ammount1),
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/shop/hendlerequest/',
}
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
param_dict, MERCHANT_KEY)
return render(request, 'shop/paytm.html', {'param_dict': param_dict})
# jsonitem=request.GET.get('jsonitem')
# prod=json.loads(jsonitem)
# plist=[]
# for p in prod:
# a=int(p[1])
# q=int(p[0])
# b=Product.objects.filter(id=a)
# plist.append(b)
# print("plist",plist)
# params={'prizes':plist}
##requset to paytm to transvet=r the ammount to your account by user
return render(request, 'shop/checkout.html', {})
def get_checksumhash(self):
return Checksum.generate_checksum(self._payload, self.conf.KEY)
def all_available_spaces(request, id):
'''
booking spaces by user and calculating bills
'''
print("email----", request.user.email)
all_data = SpaceDetails.objects.get(id=id)
booked_data = BookedSeats.objects.filter(space__id=id)
time_in_hrs = int((all_data.time)[:-3])
price_per_hour = all_data.price / time_in_hrs
if request.method == "POST":
book_space = BookedSeats(space=all_data,
user=request.user,
start_date=request.POST.get("start_date"),
end_date=request.POST.get("end_date"),
start_time=request.POST.get("start_time"),
end_time=request.POST.get("end_time"))
start_date = request.POST.get("start_date")
end_date = request.POST.get("end_date")
start_time = request.POST.get("start_time")
end_time = request.POST.get("end_time")
val = check_spaces(booked_data, start_date, end_date, start_time,
end_time)
'''
calculating price
'''
days = 1
if datetime.strptime(end_date, '%Y-%m-%d').date() != datetime.strptime(
start_date, '%Y-%m-%d').date():
diff_date = datetime.strptime(
end_date, '%Y-%m-%d').date() - datetime.strptime(
start_date, '%Y-%m-%d').date()
print(diff_date)
print(str(diff_date).split(" "))
days = int(str(diff_date).split(" ")[0])
# calculating time
start_time = datetime.strptime(start_time, "%H:%M")
end_time = datetime.strptime(end_time, "%H:%M")
diff_time = end_time - start_time
diff = str(diff_time).split(":")
diff_time_hrs = int(diff[0])
diff_time_min = int(diff[1])
total_price = (price_per_hour +
diff_time_min / 60) * price_per_hour * days
print(total_price)
if val == False:
book_space.save()
total_cost = total_price
order_id = Checksum.__id_generator__()
print(order_id)
param_dict = {
'MID': Test_Merchant_ID,
'ORDER_ID': order_id,
'TXN_AMOUNT': str(total_cost),
'CUST_ID': '*****@*****.**',
'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, Test_Merchant_Key)
return render(request, 'lookspace_app/paytm.html',
{'param_dict': param_dict})
else:
print("space is not available")
messages.error(request, 'Space is not available.')
return render(request, 'lookspace_app/book_space.html',
{'all_data': all_data})
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
print(request.POST)
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 + settings.PAYTM_CALLBACK_URL
order_id = Checksum.__id_generator__()
bill_amount = 0
form = OrderCreate(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
address = form.cleaned_data['address']
email = form.cleaned_data['email']
mobno = form.cleaned_data['mobno']
order = Order(username=request.user,
name=name,
address=address,
email=email,
mobno=mobno,
order_id=order_id)
order.save()
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
bill_amount = cart.get_total_price()
cart.clear()
if bill_amount:
data_dict = {
'MID': MERCHANT_ID,
'ORDER_ID': order_id,
'TXN_AMOUNT': bill_amount,
'CUST_ID': email,
'MOBILE_NO': mobno,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': settings.PAYTM_WEBSITE,
'CHANNEL_ID': 'WEB',
'CALLBACK_URL':
CALLBACK_URL, #"http://127.0.0.1:8000/paytm/response"
}
param_dict = data_dict
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
data_dict, MERCHANT_KEY)
print(param_dict)
return render(request, "paytm/payment.html",
{'paytmdict': param_dict})
else:
return HttpResponse("Bill Amount Could not find. ?bill_amount=10")
else:
form = OrderCreate()
return render(request, 'orders/order/create.html', {
'form': form,
'username': request.user
})
def successful(request):
if request.method != "POST":
return render(request, "book/apology.html",
{"message": "Error occured"})
id = int(request.POST["id"])
hotel = Hotel.objects.get(id=id)
checkin = request.POST["checkin"]
checkout = request.POST["checkout"]
first_name = request.POST["first_name"]
last_name = request.POST["last_name"]
phone = request.POST["phone"]
email = request.POST["email"]
room = int(request.POST["room"])
adult = int(request.POST["adult"])
child = int(request.POST["child"])
days = int(request.POST["days"])
price = str(create_price(id, room, adult, child, days))
tracking_id = first_name[0] + last_name[0] + str(int(time.time()))
print(tracking_id)
b = Booking(hotel=hotel,
checkin_date=checkin,
checkout_date=checkout,
room=room,
adult=adult,
child=child,
first_name=first_name,
last_name=last_name,
phone=phone,
email=email,
tracking_id=tracking_id,
price=price)
try:
b.save()
except:
print("Error Occured")
return render(request, "book/apology.html",
{"message": "Internal Server Error"})
MERCHANT_KEY = 'your merchant key'
data_dict = {
'MID': 'your merchant id',
'ORDER_ID': tracking_id,
'TXN_AMOUNT': price,
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'webstaging',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/callback',
}
param_dict = data_dict
param_dict['CHECKSUMHASH'] = Checksum.generate_checksum(
data_dict, MERCHANT_KEY)
return render(request, "book/paytm.html", {"param_dict": param_dict})