def verify_payment(request):
paramz = request.GET.get('trxref', 'None')
user = request.user
full_name = request.user.full_name
email = request.user.email
phone = request.user.phone_number
print(paramz)
pay_queryobj = Payment.objects.all().filter(reference=paramz)
pay_instance = Payment.objects.all().filter(reference=paramz).first()
details = Transaction.verify(reference=paramz)
status = details['data']['status']
if status == 'success':
if pay_instance.product_type == '6 months':
expiry_date = pay_instance.date_created + timedelta(days=184)
pay_queryobj.update(paid=True, expiry_date=expiry_date)
email = request.user.email
current_user = Customuser.objects.filter(email=email)
current_user.update(subscribed=True, expiry_date=expiry_date)
elif pay_instance.product_type == '1 Year':
expiry_date = pay_instance.date_created + timedelta(days=367)
pay_queryobj.update(paid=True, expiry_date=expiry_date)
email = request.user.email
current_user = Customuser.objects.filter(email=email)
current_user.update(subscribed=True, expiry_date=expiry_date)
else:
print(' payment not successful')
return redirect('cbtexam')
def verify_transaction(reference):
resp = Transaction.verify(reference=reference)
resp = json.load(resp)
if resp['data']['status'] == "success":
data = {"verify": True, "data": resp['customer']['metadata']['cart']}
return data
return {"verify": False}
def verifyTransaction(request):
status = False
message = ''
ref = request.POST.get('reference')
response = Transaction.verify(reference=ref)
if response['status']==True and response['data']['status'] != 'failed':
auth_code = response['data']['authorization']['authorization_code']
last_digit = response['data']['authorization']['last4']
expiry_month = response['data']['authorization']['exp_month']
card_exp_year = response['data']['authorization']['exp_year']
card_bank = response['data']['authorization']['bank']
card_account_name = response['data']['authorization']['account_name']
card_first_name = response['data']['customer']['first_name']
card_last_name = response['data']['customer']['last_name']
card_email = response['data']['customer']['email']
card_type = response['data']['authorization']['card_type']
package = response['data']['metadata']['custom_fields']['package']
card = Card(user=request.user, card_auth=auth_code, card_last_digit=last_digit, card_exp_month=expiry_month,card_exp_year=card_exp_year,
card_bank=card_bank, card_account_name=card_account_name, card_first_name=card_first_name,
card_last_name=card_last_name, card_email=card_email, card_type=card_type)
card.save()
package = Package.objects.get(id=int(package))
subscription = Subscription(user=request.user, is_active=True, package_subscribed=package, has_expired=False)
subscription.save()
status = True
message = 'Transaction Successful'
else:
status = False
message = response['message']
return JsonResponse({'status':status, 'message': message})
def verify_payment(request):
mm = marketing_member(request)
ref = request.session['ref_no']
response_dict = Transaction.verify(reference=ref)
data = response_dict.get('data')
print 'status', data['status']
if data['status'] == 'success':
status = "Approved"
user = request.session['user']
amount = request.session['amount']
all_cost = CostCalcSettings.objects.get(marketer=mm, country="Nigeria")
dollarNairaRate = all_cost.dollar_exchange_rate
user.useraccount.credit_amount_D += (float(amount) /
float(dollarNairaRate))
user.useraccount.credit_amount_N += amount
user.useraccount.save()
else:
status = data['status']
bank_record = MarketerPayment.objects.get(ref_no=ref)
bank_record.status = status
bank_record.message = data['gateway_response']
bank_record.save()
messages.success(request, "You have sucessfully funded your VEI Wallet.")
del request.session['ref_no']
del request.session['user']
del request.session['amount']
return redirect('wallet:wallet')
def mainPay(request):
print "i got here"
rp = request.POST
print 'rp', rp
email = request.user.email
random_ref = purchase_ref()
request.session['ref_no'] = random_ref
request.session['user'] = request.user
amount = rp.get('paystack_amount')
print amount
request.session['amount'] = amount
url = 'payments:verify_payment'
callback_url = request.build_absolute_uri(reverse(url))
print "callback-url", callback_url
response = Transaction.initialize(reference=random_ref,
amount=(float(amount) * 100.0),
email=request.user.email,
callback_url=callback_url)
# print 'response:', response
data = response.get('data')
# print "data:", data
authorization_code = data['access_code']
print "access_code", authorization_code
url = data['authorization_url']
# print 'url', url
payment = Payments.objects.create(user=request.user,
amount=amount,
status="Pending",
date_created=timezone.now(),
payment_ref=random_ref)
return redirect(url)
def verify_transcation(self, reference):
"""
Verifies transaction
:param reference: unique transaction reference to be verified
:returns: Status of Transation Success
:rtype: bool
"""
return Transaction.verify(reference=reference)['status']
def test_list(self):
with mock.patch('paystackapi.transaction.Transaction.list') as \
mock_list:
mock_list.return_value = {
'status': True
}
response = Transaction.list()
self.assertTrue(response['status'])
def test_totals(self):
with mock.patch('paystackapi.transaction.Transaction.totals') as \
mock_totals:
mock_totals.return_value = {
'status': True
}
response = Transaction.totals()
self.assertTrue(response['status'])
def test_verify(self):
with mock.patch('paystackapi.transaction.Transaction.verify') as \
mock_verify:
mock_verify.return_value = {
'status': True
}
response = Transaction.verify('reference')
self.assertTrue(response['status'])
def verify_payment(request):
ref = request.session['ref_no']
response_dict = Transaction.verify(reference=ref)
data = response_dict.get('data')
print 'status', data['status']
if data['status'] == 'success':
status = "Approved"
user = request.session['user']
amount = request.session['amount']
order_items = OrderItem.objects.filter(
user_obj=request.user.useraccount, ordered=False, deleted=False)
new_package = Packages.objects.create(user=request.user.useraccount)
new_package.tracking_number = randomNumber(8)
new_package.total_amount = request.session['total_amount']
new_package.shipping_destination = request.session['country']
new_package.shippingCost = request.session['shippingCost']
new_package.subTotal = request.session['subTotal']
new_package.payment_status = "Paid"
new_package.save()
for item in order_items:
item.ordered = True
item.status = "Paid"
item.package = new_package
item.save()
stock_item = Item.objects.get(pk=item.item_id)
if stock_item.quantity <= 0:
stock_item.quantity = 0
else:
stock_item.quantity_left -= item.quantity
stock_item.quantity_sold += item.quantity
stock_item.save()
bank_record = Payments.objects.get(payment_ref=ref)
bank_record.status = status
bank_record.packageID = new_package.tracking_number
bank_record.save()
messages.success(request,
"You have sucessfully paid for this package.")
else:
status = data['status']
messages.success(request,
"You have not sucessfully paid for this package.")
del request.session['country']
del request.session['shippingCost']
del request.session['subTotal']
del request.session['ref_no']
del request.session['total_amount']
return redirect('general:homepage')
def payement(request):
if request.method == 'POST':
refrence = request.POST.get('refrence')
email = request.POST.get('email')
amount = int(float(request.POST.get('amount')))
response = Transaction.initialize(reference=refrence,
amount=amount,
email=email)
return JsonResponse(response, status=200, safe=False)
return JsonResponse({'error': 'could not add item to cart'}, status=400)
def test_charge_token(self):
with mock.patch('paystackapi.transaction.Transaction.charge_token') as \
mock_charge_token:
mock_charge_token.return_value = {
'status': True
}
response = Transaction.charge_token(
'getupall', 'token'
'email', 'amount')
self.assertTrue(response['status'])
def test_verify(self):
httpretty.register_uri(
httpretty.GET,
"https://api.paystack.co/transaction/verify/reference",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.verify('reference')
self.assertTrue(response['status'])
def test_charge(self):
with mock.patch('paystackapi.transaction.Transaction.charge') as \
mock_charge:
mock_charge.return_value = {
'status': True
}
response = Transaction.charge(
'getupall', 'authorization_code'
'email', 'amount')
self.assertTrue(response['status'])
def test_totals(self):
httpretty.register_uri(
httpretty.GET,
"https://api.paystack.co/transaction/totals",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.totals()
self.assertTrue(response['status'])
def test_verify(self):
httpretty.register_uri(
httpretty.GET,
"https://api.paystack.co/transaction/verify/reference",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.verify('reference')
self.assertTrue(response['status'])
def test_totals(self):
httpretty.register_uri(
httpretty.GET,
"https://api.paystack.co/transaction/totals",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.totals()
self.assertTrue(response['status'])
def test_totals(self):
httpretty.register_uri(
httpretty.GET,
self.endpoint_url("/transaction/totals"),
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.totals()
self.assertTrue(response['status'])
def check_transaction(self):
if self.transaction_type == False:
response = Transfer.verify(reference=self.code)
if response['status']:
if response['data']['status'] == "success":
return True
elif self.transaction_type == True:
response = Transaction.verify(reference=self.code)
if response['status']:
if response['data']['status'] == "success":
return True
#parse check data to give result, true, false, pending
return False
def test_initialize(self):
httpretty.register_uri(
httpretty.GET,
"https://api.paystack.co/transaction/initialize",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.initialize(reference='getupall',
amount=12000,
email='*****@*****.**')
self.assertTrue(response['status'])
def test_charge_token(self):
httpretty.register_uri(
httpretty.POST,
"https://api.paystack.co/transaction/charge_token",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.charge_token(
reference='getupall', token='token',
email='email', amount=100000)
self.assertTrue(response['status'])
def test_initialize(self):
httpretty.register_uri(
httpretty.GET,
"https://api.paystack.co/transaction/initialize",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.initialize(
reference='getupall', amount=12000,
email='*****@*****.**')
self.assertTrue(response['status'])
def test_initialize(self):
httpretty.register_uri(
httpretty.POST,
self.endpoint_url("/transaction/initialize"),
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.initialize(reference='getupall',
amount=12000,
email='*****@*****.**')
self.assertTrue(response['status'])
def test_charge(self):
httpretty.register_uri(
httpretty.POST,
self.endpoint_url("/transaction/charge_authorization"),
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.charge(reference='getupall',
authorization_code='authorization_code',
email='email',
amount='amount')
self.assertTrue(response['status'])
def test_charge_token(self):
httpretty.register_uri(
httpretty.POST,
"https://api.paystack.co/transaction/charge_token",
content_type='text/json',
body='{"status": true, "contributors": true}',
status=201,
)
response = Transaction.charge_token(reference='getupall',
token='token',
email='email',
amount=100000)
self.assertTrue(response['status'])
def verify_transaction():
reference = request.form.get("reference")
response = Transaction.verify(reference=reference)
if response["status"]:
return jsonify({
"success": True,
"message": response["message"],
"data": response["data"]
}), 200
else:
return jsonify({
"success": False,
"message": response["message"],
}), 400
def get_transactions():
response = Transaction.list()
if response["status"]:
return jsonify({
"success": True,
"total": response["meta"]["total"],
"total_volume": response["meta"]["total_volume"],
"message": response["message"],
"transactions": response["data"]
}), 200
else:
return jsonify({
"success": False,
"message": response["message"],
}), 400
def new_transaction(email, price, cart):
# start transaction and get payment url
# reference = request.args.get("reference")
# gets args from the checkout endpoint
amount = price
response = Transaction.initialize(amount=amount,
email=email,
callback_url="localhost:5000",
metadata=cart)
response = json.load(response)
if response["status"]:
payment_url = response['data']["authorization_url"]
return True, payment_url
else:
return False, ""
def post(self, request, *args, **kwargs):
response = request.data.get('response',None)
userID = request.data.get('userID', None)
reference = response["reference"]
status = response["status"]
if reference is not None and status == "success":
verify_response = Transaction.verify(reference=f"{reference}")
user = User.objects.get(pk=userID)
reference = verify_response["data"]["reference"]
auth_code = verify_response["data"]["authorization"]["authorization_code"]
card_bin = verify_response["data"]["authorization"]["bin"]
last_4 = verify_response["data"]["authorization"]["last4"]
expiry_month = verify_response["data"]["authorization"]["exp_month"]
expiry_year = verify_response["data"]["authorization"]["exp_year"]
card_type = verify_response["data"]["authorization"]["card_type"]
bank = verify_response["data"]["authorization"]["bank"]
first_name = verify_response["data"]["customer"]["first_name"]
last_name = verify_response["data"]["customer"]["last_name"]
email = verify_response["data"]["customer"]["email"]
card = Card(
user = user,
reference = reference,
auth_code = auth_code,
card_bin = card_bin,
last_4 = last_4,
expiry_month = expiry_month,
expiry_year = expiry_year,
card_type = card_type,
bank = bank,
first_name = first_name,
last_name = last_name,
email = email
)
card_qs = Card.objects.filter(user = user)
if card_qs.exists():
return Response({"message": "You already have a registered card"}, status=HTTP_400_BAD_REQUEST)
else:
card.save()
return Response(status=HTTP_201_CREATED)
return Response(status=HTTP_200_OK)
def test_initialize(self):
with mock.patch('paystackapi.transaction.Transaction.initialize') \
as mock_initialize:
mock_initialize.return_value = {
'status': True, 'message': 'Authorization URL created',
'data': {
'authorization_url': 'https://standard.paystackapi.co/pay/xam1uq26de',
'access_code': 'xam1uq26de',
'reference': 'getupall'
}
}
response = Transaction.initialize(
'getupall', 12000,
'*****@*****.**',
'daily')
self.assertTrue(response['status'])
def new_transaction():
reference = request.form.get("reference")
amount = request.form.get("amount")
email = request.form.get("email")
response = Transaction.initialize(reference=reference,
amount=amount,
email=email)
if response["status"]:
return jsonify({
"success": True,
"payment_url": response["data"]["authorization_url"],
"reference": response["data"]["reference"],
"message": response["message"]
}), 200
else:
return jsonify({
"success": False,
"message": response["message"],
}), 400
def verify_payment(request):
try:
ref = request.session['ref_no']
except:
pass
return redirect('wallet:wallet')
response_dict = Transaction.verify(reference=ref)
data = response_dict.get('data')
print 'status', data['status']
if data['status'] == 'success':
status = "Successful"
else:
status = data['status']
bank_record = Bank.objects.get(ref_no=ref)
bank_record.status = status
bank_record.message = data['gateway_response']
bank_record.save()
del request.session['ref_no']
return redirect('wallet:wallet')
def payment_process(request):
order_id = request.session.get("order_id")
order = get_object_or_404(Order, id=order_id)
paystack_key = paystack_public_key
if request.method == "POST":
transaction = Transaction.initialize(
reference=f"ANGALABIRI_REF_ORDER_{order_id}",
email=order.email,
amount="{:.2f}".format(order.get_total_cost()) * 100,
)
if transaction.is_success:
order.paid = True
order.transaction_id = transaction.id
order.save()
return redirect('shop:payment-done')
else:
return redirect('shop:payment-failed')
return render(request, 'shop/billing/payment.html', {'order': order, 'paystack_key': paystack_key})
def subscribe_full(request):
amount = '170000'
user = request.user
full_name = request.user.full_name
email = request.user.email
phone = request.user.phone_number
response = Transaction.initialize(amount=amount, email=email)
ref = response['data']['reference']
print(full_name)
create_pay_instance = Payment.objects.create(customers_name=full_name,
customers_email=email,
customers_phone=phone,
product_type='1 Year',
reference=ref,
amount='1700')
a_url = response['data']['authorization_url']
return redirect(a_url)
def initiate_charge_card(request, **kwargs):
if request.method == "POST":
markup_percentage, markup_min_charge, is_nigerian_card = get_markup_charge(
request)
txn_desc = kwargs['txn_desc']
txn_ref = kwargs['txn_ref']
request.session['txn_ref'] = txn_ref
actual_amount_D = round(kwargs.get('actual_amount', 0), 2)
request.session['actual_amount_D'] = actual_amount_D
print 'markup_percentage, markup_min_charge: ', markup_percentage, markup_min_charge
markup_charge_D = round(
(float(actual_amount_D) * markup_percentage) + markup_min_charge,
2)
if is_nigerian_card:
max_markup_charge_D = 5
if markup_charge_D > max_markup_charge_D:
markup_charge_D = max_markup_charge_D
amount_D = round(actual_amount_D + markup_charge_D, 2)
cost_calc = marketingmember_costcalc(request, 'Nigeria')
amount_N = format(amount_D * float(cost_calc.dollar_exchange_rate),
'.2f')
amountz = amount_D * float(cost_calc.dollar_exchange_rate) * 100
print "going to paystack to charge card"
email = request.user.email
url = 'general:verifyPayment'
callback_url = request.build_absolute_uri(reverse(url))
print "callback-url", callback_url
response = Transaction.initialize(reference=txn_ref,
amount=amountz,
email=email,
callback_url=callback_url)
print 'response:', response
data = response.get('data')
print "data:", data
authorization_code = data['access_code']
print "access_code", authorization_code
url = data['authorization_url']
print 'url', url
return redirect(url)
def verify_payment(request):
print "rG", request.GET
ref = request.session['txn_ref']
response_dict = Transaction.verify(reference=ref)
data = response_dict.get('data')
print "data", data
print "response_dict", response_dict
amount = data['amount']
status = data['status']
response = data['gateway_response']
print amount, status, response
# jejepay = update_jejepay_obj(ref,ref,response)
# jejepay.amount = amount
# jejepay.save()
go_to_url = request.session['dest_namespace_1']
if go_to_url == None:
go_to_url = request.session['dest_namespace_2']
del request.session['dest_namespace_2']
print "go url:", go_to_url
del request.session['dest_namespace_1']
#messages.info(request, response)
return redirect(
request.build_absolute_uri(
reverse(go_to_url) + '?jejepay_ref=' + ref + '&resp=' + status))
def demo_task(message):
users = User.objects.all()
has_subscription = False
for user in users:
#get active subscription
try:
active = Subscription.objects.get(user=user.id,
is_active=True,
has_expired=False)
if active:
start_date = active.start_date
from datetime import datetime
diff = datetime.now().date() - start_date
date_diff = diff.days
if active.package_subscribed is 4:
if date_diff >= 15:
active.has_expired = True
is_active = False
active.save()
else:
has_subscription = True
elif active.package_subscribed is not 4:
if date_diff >= 30:
active.has_expired = True
is_active = False
active.save()
else:
has_subscription = True
except Subscription.DoesNotExist:
pass
if not has_subscription:
latest_plan = Subscription.objects.filter(
user=user.id).order_by('-id')[:1]
package = None
for plan in latest_plan:
package = plan.package_subscribed
#Get users card
users_card = Card.objects.filter(user=user.id)
for card in users_card:
from paystackapi.transaction import Transaction
import uuid
reference = get_random_string(length=20)
print(reference)
response = Transaction.charge(
reference=reference,
authorization_code=card.card_auth,
email=card.card_email,
amount=int(package.amount) * 100)
print(response)
if response['status'] == True and response['data'][
'status'] != 'failed':
subscription = Subscription(user=user,
is_active=True,
package_subscribed=package,
has_expired=False)
subscription.save()
break
def main(request):
try:
useraccount = UserAccount.objects.get(user=request.user)
if not useraccount.profile_updated:
messages.info(request,
'Please Update your profile to top up your wallet')
return redirect('general:profile')
except Exception as e:
print "e", e
messages.info(request,
'Please Update your profile to top up your wallet')
return redirect('general:profile')
if request.method == "POST":
bot_catcher = request.POST.get('bot_catcher')
# print "bot_catcher",bot_catcher
payment_method = request.POST.get('payment-method')
if bot_catcher != "botty":
return redirect(reverse('general:homepage'))
try:
value = int(request.POST.get('amount'))
except:
messages.info(request, 'Invalid amount entered')
return redirect('wallet:wallet')
if payment_method == "bank":
# print a
random_ref = purchase_ref()
bank_record = Bank.objects.create(
user=request.user,
txn_type="Add",
amount=value,
ref_no=random_ref,
created_at=timezone.now,
date_created=timezone.now().date(),
bank="BANK DEPOSIT",
message="Wallet Top up Via Bank Deposit")
bank_record.save()
print bank_record
payment = Bank.objects.filter(user=request.user)
return render(request, 'general_snippets/bank_details.html', {
'ref': random_ref,
'wallet': payment
})
if value > 20000:
messages.info(
request,
'You have exceeded the Top up Limit, Pls enter an amount less than 20,000'
)
return redirect('wallet:wallet')
# print "value", value
amount = value * 100
# print "amount", amount
email = request.user.email
#secret_key = 'sk_test_9fe140b2bf798accdc2aade269cac47bc2de7ecc'
random_ref = purchase_ref()
request.session['ref_no'] = random_ref
url = 'wallet:verify_payment'
callback_url = request.build_absolute_uri(reverse(url))
# print "callback-url", callback_url
response = Transaction.initialize(reference=random_ref,
amount=amount,
email=email,
callback_url=callback_url)
# print 'response:', response
data = response.get('data')
# print "data:", data
authorization_code = data['access_code']
# print "access_code", authorization_code
url = data['authorization_url']
# print 'url', url
bank_record = Bank.objects.create(user=request.user,
txn_type="Add",
amount=value,
ref_no=random_ref,
created_at=timezone.now,
date_created=timezone.now().date())
bank_record.save()
return redirect(url)
# response = Transaction.charge(reference=random_ref,
# authorization_code=authorization_code,
# email=email,
# amount=amount)
# response_dict = Transaction.verify(reference=random_ref)
# print "response_dict", response_dict
#test_email = email
#test_amount = amount
#plan = 'Basic'
# client = TransactionResource(secret_key, random_ref)
# response = client.initialize(amount,email)
# print"response",response
# client.authorize() # Will open a browser window for client to enter card details
# verify = client.verify() # Verify client credentials
# print "verify", verify
# print type(verify)
# ref = verify.get('data')
# print ref
#client.charge(None,amount,email,random_ref)
#print client.charge() # Charge an already exsiting client
return render(request, 'wallet/topup.html')
def mainPay(request):
marketer = marketing_member(request)
print "i got here"
rp = request.POST
print 'rp', rp
if request.method == "POST":
bot_catcher = request.POST.get('bot_catcher')
print "bot_catcher", bot_catcher
payment_method = request.POST.get('payment-method')
if bot_catcher != "botty":
return redirect(reverse('general:homepage'))
try:
value = int(request.POST.get('amount'))
except:
messages.info(request, 'Invalid amount entered')
# return redirect('wallet:wallet')
return redirect
if payment_method == "bank":
# print a
random_ref = purchase_ref()
bank_payment = MarketerPayment.objects.create(
user=request.user.useraccount,
payment_channel="Bank Payment",
purchase_type_2="Add",
created_at=timezone.now(),
message="Vei Wallet Fund",
amount=amount,
ref_no=random_ref,
marketer=marketer,
bank=None,
teller_no=random_ref)
payment = MarketerPayment.objects.filter(
user=request.user.useraccount)
return redirect('wallet:wallet')
# if value > 9999:
# messages.info(request, 'You have exceeded the Top up Limit, Pls enter an amount less than 10,000')
# return redirect('wallet:wallet')
# print "value", value
amount = value
# print "amount", amount
email = request.user.email
#secret_key = 'sk_test_9fe140b2bf798accdc2aade269cac47bc2de7ecc'
random_ref = purchase_ref()
request.session['ref_no'] = random_ref
request.session['user'] = request.user
request.session['amount'] = amount
url = 'wallet:verify_payment'
callback_url = request.build_absolute_uri(reverse(url))
print "callback-url", callback_url
response = Transaction.initialize(reference=random_ref,
amount=float(amount * 100),
email=email,
callback_url=callback_url)
# print 'response:', response
data = response.get('data')
# print "data:", data
authorization_code = data['access_code']
# print "access_code", authorization_code
url = data['authorization_url']
# print 'url', url
payment = MarketerPayment.objects.create(
user=request.user.useraccount,
payment_channel="Card Payment",
purchase_type_2="Add",
created_at=timezone.now(),
message="Paystack Vei Wallet Fund",
purchase_type_3="veiwallet",
amount=amount,
ref_no=random_ref,
marketer=marketer,
bank=None,
teller_no=random_ref)
user_acc = request.user.useraccount
return redirect(url)
return render(request, 'volkmann/vei_wallet.html')