def handle_successful_order(self, order):
"""
Handle the various steps required after an order has been successfully
placed.
Override this view if you want to perform custom actions when an
order is submitted.
"""
from ledger.payments.utils import update_payments
# Get the return url
return_url = self.checkout_session.return_url()
force_redirect = self.checkout_session.force_redirect()
# Update the payments in the order lines
invoice = Invoice.objects.get(order_number=order.number)
update_payments(invoice.reference)
if self.checkout_session.send_email():
# Send confirmation message (normally an email)
self.send_confirmation_message(order, self.communication_type_code)
# Flush all session data
self.checkout_session.flush()
# Save order and invoice id in session so thank-you page can load it
self.request.session['checkout_order_id'] = order.id
self.request.session['checkout_return_url'] = return_url
if not force_redirect:
response = HttpResponseRedirect(self.get_success_url())
else:
response = HttpResponseRedirect('{}?invoice={}'.format(return_url, Invoice.objects.get(order_number=order.number).reference))
self.send_signal(self.request, response, order)
return response
def make_payment(self):
''' Pay this invoice with the token attached to it.
:return: BpointTransaction
'''
from ledger.payments.facade import bpoint_facade
from ledger.payments.utils import update_payments
try:
if self.token:
card_details = self.token.split('|')
card = TempBankCard(card_details[0], card_details[1])
if len(card_details) == 3:
card.last_digits = card_details[2]
else:
card.last_digits = None
txn = bpoint_facade.pay_with_temptoken(
'payment', 'telephoneorder', 'single', card,
self.order_number, self.reference, self.amount, None)
if txn.approved:
try:
BpointToken.objects.get(DVToken=card_details[0])
self.token = ''
self.save()
except BpointToken.DoesNotExist:
UsedBpointToken.objects.create(DVToken=card_details[0])
self.token = ''
self.save()
update_payments(self.reference)
return txn
else:
raise ValidationError(
'This invoice doesn\'t have any tokens attached to it.')
except Exception as e:
traceback.print_exc()
raise
def create(self,request,format=None):
try:
http_status = status.HTTP_200_OK
#parse and validate data
serializer = CashSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
invoice,txn = None, None
#Check if the invoice being paid for exists
# Check if the invoice exists if action is payment,preauth
try:
invoice = Invoice.objects.get(reference=serializer.validated_data['invoice']['reference'])
serializer.validated_data['invoice'] = invoice
except Invoice.DoesNotExist:
raise serializers.ValidationError("The invoice doesn't exist.")
# Check if the amount was specified otherwise pay the whole amount
if not serializer.validated_data.get('amount'):
serializer.validated_data['amount'] = invoice.amount
with transaction.atomic():
txn = serializer.save()
if txn.type == 'refund':
TrackRefund.objects.create(user=request.user,type=1,refund_id=txn.id,details=serializer.validated_data['details'])
send_refund_email(invoice,'manual',txn.amount)
update_payments(invoice.reference)
http_status = status.HTTP_201_CREATED
serializer = CashSerializer(txn)
return Response(serializer.data,status=http_status)
except serializers.ValidationError:
raise
except ValidationError as e:
raise serializers.ValidationError(str(''.join(e.error_dict.values()[0][0])))
except Exception as e:
raise serializers.ValidationError(str(e[0]))
def handle_successful_order(self, order):
"""
Handle the various steps required after an order has been successfully
placed.
Override this view if you want to perform custom actions when an
order is submitted.
"""
from ledger.payments.utils import update_payments
# Get the return url
return_url = self.checkout_session.return_url()
return_preload_url = self.checkout_session.return_preload_url()
force_redirect = self.checkout_session.force_redirect()
# Update the payments in the order lines
invoice = Invoice.objects.get(order_number=order.number)
update_payments(invoice.reference)
if self.checkout_session.send_email():
# Send confirmation message (normally an email)
self.send_confirmation_message(order, self.communication_type_code)
# Flush all session data
self.checkout_session.flush()
# Save order and invoice id in session so thank-you page can load it
self.request.session['checkout_order_id'] = order.id
self.request.session['checkout_invoice'] = invoice.reference
self.request.session['checkout_return_url'] = return_url
self.request.session.save()
# If preload is enabled, fire off an unmonitored request server-side
# FIXME: replace with basket one-time secret
if return_preload_url:
try:
requests.get('{}?invoice={}'.format(return_preload_url,
invoice.reference),
cookies=self.request.COOKIES,
verify=False)
# bodge for race condition: if preload updates the session, we need to update it
self.request.session._session_cache = self.request.session.load(
)
except requests.exceptions.ConnectionError:
pass
if not force_redirect:
response = HttpResponseRedirect(self.get_success_url())
else:
response = HttpResponseRedirect('{}?invoice={}'.format(
return_url, invoice.reference))
self.send_signal(self.request, response, order)
return response
def move_funds(self, amount, invoice, details):
from ledger.payments.models import CashTransaction
from ledger.payments.utils import update_payments
with transaction.atomic():
try:
# Move all the bpoint transactions to the new invoice
for txn in self.bpoint_transactions:
txn.crn1 = invoice.reference
txn.save()
# Move all the bpay transactions to the new invoice
for txn in self.bpay_transactions:
txn.crn = invoice.reference
txn.save()
# Move the remainder of the amount to the a cash transaction
new_amount = self.__calculate_cash_payments()
if self.transferable_amount < new_amount:
raise ValidationError(
'The amount to be moved is more than the allowed transferable amount'
)
if new_amount > 0:
# Create a moveout transaction for current invoice
CashTransaction.objects.create(
invoice=self,
amount=amount,
type='move_out',
source='cash',
details='Move funds to invoice {}'.format(
invoice.reference),
movement_reference=invoice.reference)
update_payments(self.reference)
# Create a move in transaction for other invoice
CashTransaction.objects.create(
invoice=invoice,
amount=amount,
type='move_in',
source='cash',
details='Move funds from invoice {}'.format(
self.reference),
movement_reference=self.reference)
# set the previous invoice in the new invoice
invoice.previous_invoice = self
invoice.save()
# Update the oracle interface invoices sp as to prevent duplicate sending of amounts to oracle
from ledger.payments.models import OracleParserInvoice
OracleParserInvoice.objects.filter(
reference=self.reference).update(
reference=invoice.reference)
update_payments(invoice.reference)
except:
raise
def create(self, request, format=None):
try:
http_status = status.HTTP_200_OK
#parse and validate data
serializer = CashSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
invoice, txn = None, None
#Check if the invoice being paid for exists
# Check if the invoice exists if action is payment,preauth
try:
invoice = Invoice.objects.get(
reference=serializer.validated_data['invoice']
['reference'])
serializer.validated_data['invoice'] = invoice
except Invoice.DoesNotExist:
raise serializers.ValidationError("The invoice doesn't exist.")
# Check if the amount was specified otherwise pay the whole amount
if not serializer.validated_data.get('amount'):
serializer.validated_data['amount'] = invoice.amount
with transaction.atomic():
txn = serializer.save()
if txn.type == 'refund':
TrackRefund.objects.create(
user=request.user,
type=1,
refund_id=txn.id,
details=serializer.validated_data['details'])
send_refund_email(invoice, 'manual', txn.amount)
update_payments(invoice.reference)
LEDGER_INVOICE_TRANSACTION_CALLBACK_MODULE = env(
'LEDGER_INVOICE_TRANSACTION_CALLBACK_MODULE', '')
if len(LEDGER_INVOICE_TRANSACTION_CALLBACK_MODULE) != 0:
try:
ltc = LEDGER_INVOICE_TRANSACTION_CALLBACK_MODULE.split(":")
exec('import ' + str(ltc[0]))
exec(ltc[1] + "('" + invoice.reference + "')")
except Exception as e:
print(e)
http_status = status.HTTP_201_CREATED
serializer = CashSerializer(txn)
return Response(serializer.data, status=http_status)
except serializers.ValidationError:
raise
except ValidationError as e:
raise serializers.ValidationError(
str(''.join(e.error_dict.values()[0][0])))
except Exception as e:
raise serializers.ValidationError(str(e[0]))
def move_funds(self,amount,invoice,details):
from ledger.payments.models import CashTransaction
from ledger.payments.utils import update_payments
with transaction.atomic():
try:
# Move all the bpoint transactions to the new invoice
for txn in self.bpoint_transactions:
txn.crn1 = invoice.reference
txn.save()
# Move all the bpay transactions to the new invoice
for txn in self.bpay_transactions:
txn.crn = invoice.reference
txn.save()
# Move the remainder of the amount to the a cash transaction
new_amount = self.__calculate_cash_payments()
if self.transferable_amount < new_amount:
raise ValidationError('The amount to be moved is more than the allowed transferable amount')
if new_amount > 0:
# Create a moveout transaction for current invoice
CashTransaction.objects.create(
invoice = self,
amount = amount,
type = 'move_out',
source = 'cash',
details = 'Move funds to invoice {}'.format(invoice.reference),
movement_reference = invoice.reference
)
update_payments(self.reference)
# Create a move in transaction for other invoice
CashTransaction.objects.create(
invoice = invoice,
amount = amount,
type = 'move_in',
source = 'cash',
details = 'Move funds from invoice {}'.format(self.reference),
movement_reference = self.reference
)
# set the previous invoice in the new invoice
invoice.previous_invoice = self
invoice.save()
# Update the oracle interface invoices sp as to prevent duplicate sending of amounts to oracle
from ledger.payments.models import OracleParserInvoice
OracleParserInvoice.objects.filter(reference=self.reference).update(reference=invoice.reference)
update_payments(invoice.reference)
except:
raise
def refund(self, request, *args, **kwargs):
try:
http_status = status.HTTP_200_OK
instance = self.get_object()
serializer = AmountSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
refund = instance.refund(serializer.validated_data, request.user)
invoice = Invoice.objects.get(reference=instance.crn1)
update_payments(invoice.reference)
serializer = BpointTransactionSerializer(refund)
return Response(serializer.data, status=http_status)
except serializers.ValidationError:
traceback.print_exc()
raise
except Exception as e:
traceback.print_exc()
raise serializers.ValidationError(str(e))
def refund(self,request,*args,**kwargs):
try:
http_status = status.HTTP_200_OK
instance = self.get_object()
serializer = AmountSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
refund = instance.refund(serializer.validated_data,request.user)
invoice = Invoice.objects.get(reference=instance.crn1)
update_payments(invoice.reference)
serializer = BpointTransactionSerializer(refund)
return Response(serializer.data,status=http_status)
except serializers.ValidationError:
traceback.print_exc()
raise
except Exception as e:
traceback.print_exc()
raise serializers.ValidationError(str(e))
def make_payment(self):
''' Pay this invoice with the token attached to it.
:return: BpointTransaction
'''
from ledger.payments.facade import bpoint_facade
from ledger.payments.utils import update_payments
try:
if self.token:
card_details = self.token.split('|')
card = TempBankCard(
card_details[0],
card_details[1]
)
if len(card_details) == 3:
card.last_digits = card_details[2]
else:
card.last_digits = None
txn = bpoint_facade.pay_with_temptoken(
'payment',
'telephoneorder',
'single',
card,
self.order_number,
self.reference,
self.amount,
None
)
if txn.approved:
try:
BpointToken.objects.get(DVToken=card_details[0])
self.token = ''
self.save()
except BpointToken.DoesNotExist:
UsedBpointToken.objects.create(DVToken=card_details[0])
self.token = ''
self.save()
update_payments(self.reference)
return txn
else:
raise ValidationError('This invoice doesn\'t have any tokens attached to it.')
except Exception as e:
traceback.print_exc()
raise
def create_temp_bookingupdate(request, arrival, departure, booking_details,
old_booking, total_price):
# delete all the campsites in the old moving so as to transfer them to the new booking
old_booking.campsites.all().delete()
booking = create_booking_by_site(
booking_details['campsites'][0],
start_date=arrival,
end_date=departure,
num_adult=booking_details['num_adult'],
num_concession=booking_details['num_concession'],
num_child=booking_details['num_child'],
num_infant=booking_details['num_infant'],
cost_total=total_price,
customer=old_booking.customer,
updating_booking=True)
# Move all the vehicles to the new booking
for r in old_booking.regos.all():
r.booking = booking
r.save()
lines = price_or_lineitems(request, booking, booking.campsite_id_list)
booking_arrival = booking.arrival.strftime('%d-%m-%Y')
booking_departure = booking.departure.strftime('%d-%m-%Y')
reservation = "Reservation for {} from {} to {} at {}".format(
'{} {}'.format(booking.customer.first_name,
booking.customer.last_name), booking_arrival,
booking_departure, booking.mooringarea.name)
# Proceed to generate invoice
checkout_response = checkout(request,
booking,
lines,
invoice_text=reservation,
internal=True)
internal_create_booking_invoice(booking, checkout_response)
# Get the new invoice
new_invoice = booking.invoices.first()
# Check if the booking is a legacy booking and doesn't have an invoice
if old_booking.legacy_id and old_booking.invoices.count() < 1:
# Create a cash transaction in order to fix the outstnding invoice payment
CashTransaction.objects.create(
invoice=Invoice.objects.get(
reference=new_invoice.invoice_reference),
amount=old_booking.cost_total,
type='move_in',
source='cash',
details='Transfer of funds from migrated booking',
movement_reference='Migrated Booking Funds')
# Update payment details for the new invoice
update_payments(new_invoice.invoice_reference)
# Attach new invoices to old booking
for i in old_booking.invoices.all():
inv = Invoice.objects.get(reference=i.invoice_reference)
inv.voided = True
#transfer to the new invoice
inv.move_funds(
inv.transferable_amount,
Invoice.objects.get(reference=new_invoice.invoice_reference),
'Transfer of funds from {}'.format(inv.reference))
inv.save()
# Change the booking for the selected invoice
new_invoice.booking = old_booking
new_invoice.save()
return booking
def get(self, request, *args, **kwargs):
print (" APPLICATION FEE SUCCESS ")
# for ss in request.session.keys():
# print (ss)
# print (request.session[ss])
proposal = None
submitter = None
invoice = None
try:
print '0a Session: {}'.format(request.session['cols_app_invoice'] if 'cols_app_invoice' in request.session else '')
print '0b Last Session: {}'.format(request.session['cols_last_app_invoice'] if 'cols_last_app_invoice' in request.session else '')
#import ipdb; ipdb.set_trace()
context = template_context(self.request)
basket = None
application_fee = get_session_application_invoice(request.session)
print (" Session (App Fee) {}".format(application_fee))
print (" 1 ")
proposal = application_fee.proposal
print (" 2 ")
#proposal = get_session_application_invoice(request.session)
try:
recipient = proposal.applicant.email
submitter = proposal.applicant
except:
recipient = proposal.submitter.email
submitter = proposal.submitter
print (" 3 ")
if self.request.user.is_authenticated():
basket = Basket.objects.filter(status='Submitted', owner=request.user).order_by('-id')[:1]
#basket_open = Basket.objects.filter(status='Open', owner=request.user).order_by('-id')[:1]
#print '3a - Basket ID: {}, Status: {}'.format(basket_open[0].id, basket_open[0].status)
print (" 3a ")
else:
basket = Basket.objects.filter(status='Submitted', owner=booking.proposal.submitter).order_by('-id')[:1]
print (" 3b ")
print (" 4 ")
order = Order.objects.get(basket=basket[0])
print (" 5 ")
invoice = Invoice.objects.get(order_number=order.number)
print (" 6 ")
invoice_ref = invoice.reference
print (" 7 ")
#book_inv, created = BookingInvoice.objects.get_or_create(booking=booking, invoice_reference=invoice_ref)
fee_inv, created = ApplicationFeeInvoice.objects.get_or_create(application_fee=application_fee, invoice_reference=invoice_ref)
#import ipdb; ipdb.set_trace()
print 'Basket ID: {}, Status: {}, Order: {}, Invoice: {}'.format(basket[0].id, basket[0].status, order, invoice_ref)
if application_fee.payment_type == 3:
try:
inv = Invoice.objects.get(reference=invoice_ref)
order = Order.objects.get(number=inv.order_number)
order.user = submitter
order.save()
print (" 8 ")
except Invoice.DoesNotExist:
print ("INVOICE ERROR")
logger.error('{} tried paying an application fee with an incorrect invoice'.format('User {} with id {}'.format(proposal.submitter.get_full_name(), proposal.submitter.id) if proposal.submitter else 'An anonymous user'))
return redirect('external-proposal-detail', args=(proposal.id,))
#if inv.system not in ['S557']:
print ("INVOICE SYSTEM {}, settings.PS_PAYMENT_SYSTEM_ID {}".format(inv.system, settings.PS_PAYMENT_SYSTEM_ID))
if inv.system not in ['0557']:
print ("SYSTEM ERROR")
logger.error('{} tried paying an application fee with an invoice from another system with reference number {}'.format('User {} with id {}'.format(proposal.submitter.get_full_name(), proposal.submitter.id) if proposal.submitter else 'An anonymous user',inv.reference))
return redirect('external-proposal-detail', args=(proposal.id,))
if fee_inv:
application_fee.payment_type = 1 # internet booking
application_fee.expiry_time = None
update_payments(invoice_ref)
print (" 9 ")
proposal = proposal_submit(proposal, request)
if proposal and (invoice.payment_status == 'paid' or invoice.payment_status == 'over_paid'):
proposal.fee_invoice_reference = invoice_ref
proposal.save()
print (" 10 ")
else:
logger.error('Invoice payment status is {}'.format(invoice.payment_status))
raise
application_fee.save()
print (" 11 ")
request.session['cols_last_app_invoice'] = application_fee.id
delete_session_application_invoice(request.session)
print '11a Session: {}'.format(request.session['cols_app_invoice'] if 'cols_app_invoice' in request.session else '')
print '11b Last Session: {}'.format(request.session['cols_last_app_invoice'] if 'cols_last_app_invoice' in request.session else '')
send_application_fee_invoice_tclass_email_notification(request, proposal, invoice, recipients=[recipient])
send_application_fee_confirmation_tclass_email_notification(request, proposal, invoice, recipients=[recipient])
print (" 12 ")
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': invoice
}
print (" 13 ")
return render(request, self.template_name, context)
except Exception as e:
print 'My Exception: {}'.format(e)
if ('cols_last_app_invoice' in request.session) and ApplicationFee.objects.filter(id=request.session['cols_last_app_invoice']).exists():
application_fee = ApplicationFee.objects.get(id=request.session['cols_last_app_invoice'])
proposal = application_fee.proposal
try:
recipient = proposal.applicant.email
submitter = proposal.applicant
except:
recipient = proposal.submitter.email
submitter = proposal.submitter
if ApplicationFeeInvoice.objects.filter(application_fee=application_fee).count() > 0:
afi = ApplicationFeeInvoice.objects.filter(application_fee=application_fee)
#invoice = afi[0].invoice_reference
invoice = afi[0]
print (" 13a: {} ".format(invoice))
# book_inv = BookingInvoice.objects.get(booking=booking).invoice_reference
else:
#import ipdb; ipdb.set_trace()
print (" 14 ")
return redirect('home')
context = {
#'booking': booking,
#'book_inv': [app_inv]
'proposal': proposal,
'submitter': submitter,
'fee_invoice': invoice
}
print (" 15 ")
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
proposal = None
submitter = None
invoice = None
try:
# Retrieve db processes stored when calculating the fee, and delete the session
db_operations = request.session['db_processes']
del request.session['db_processes']
application_fee = get_session_application_invoice(request.session)
proposal = application_fee.proposal
try:
if proposal.applicant:
recipient = proposal.applicant.email
#submitter = proposal.applicant
elif proposal.proxy_applicant:
recipient = proposal.proxy_applicant.email
#submitter = proposal.proxy_applicant
else:
recipient = proposal.submitter.email
#submitter = proposal.submitter
except:
recipient = proposal.submitter.email
submitter = proposal.submitter
if self.request.user.is_authenticated():
basket = Basket.objects.filter(
status='Submitted', owner=request.user).order_by('-id')[:1]
else:
basket = Basket.objects.filter(
status='Submitted',
owner=booking.proposal.submitter).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
invoice_ref = invoice.reference
fee_inv, created = ApplicationFeeInvoice.objects.get_or_create(
application_fee=application_fee, invoice_reference=invoice_ref)
if application_fee.payment_type == ApplicationFee.PAYMENT_TYPE_TEMPORARY:
try:
inv = Invoice.objects.get(reference=invoice_ref)
order = Order.objects.get(number=inv.order_number)
#order.user = submitter
order.user = request.user
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an application fee with an incorrect invoice'
.format('User {} with id {}'.
format(proposal.submitter.get_full_name(
), proposal.submitter.id) if proposal.
submitter else 'An anonymous user'))
return redirect('external-proposal-detail',
args=(proposal.id, ))
if inv.system not in ['0517']:
logger.error(
'{} tried paying an application fee with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
proposal.submitter.get_full_name(),
proposal.submitter.id) if proposal.submitter
else 'An anonymous user', inv.reference))
return redirect('external-proposal-detail',
args=(proposal.id, ))
if fee_inv:
#application_fee.payment_type = 1 # internet booking
application_fee.payment_type = ApplicationFee.PAYMENT_TYPE_INTERNET
application_fee.expiry_time = None
update_payments(invoice_ref)
#proposal = proposal.submit(request, None)
#proposal.fee_invoice_reference = request.GET['invoice']
# proposal = proposal_submit_apiary(proposal, request)
if proposal and (invoice.payment_status == 'paid'
or invoice.payment_status == 'over_paid'):
proposal.fee_invoice_reference = invoice_ref
proposal.save()
proposal_submit_apiary(proposal, request)
self.adjust_db_operations(db_operations)
else:
logger.error('Invoice payment status is {}'.format(
invoice.payment_status))
raise
application_fee.save()
request.session[
'das_last_app_invoice'] = application_fee.id
delete_session_application_invoice(request.session)
send_application_fee_invoice_apiary_email_notification(
request, proposal, invoice, recipients=[recipient])
#send_application_fee_confirmation_apiary_email_notification(request, application_fee, invoice, recipients=[recipient])
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': invoice
}
return render(request, self.template_name, context)
except Exception as e:
if ('das_last_app_invoice'
in request.session) and ApplicationFee.objects.filter(
id=request.session['das_last_app_invoice']).exists():
application_fee = ApplicationFee.objects.get(
id=request.session['das_last_app_invoice'])
proposal = application_fee.proposal
try:
if proposal.applicant:
recipient = proposal.applicant.email
#submitter = proposal.applicant
elif proposal.proxy_applicant:
recipient = proposal.proxy_applicant.email
#submitter = proposal.proxy_applicant
else:
recipient = proposal.submitter.email
#submitter = proposal.submitter
except:
recipient = proposal.submitter.email
submitter = proposal.submitter
if ApplicationFeeInvoice.objects.filter(
application_fee=application_fee).count() > 0:
afi = ApplicationFeeInvoice.objects.filter(
application_fee=application_fee)
invoice = afi[0]
else:
return redirect('home')
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': invoice
}
return render(request, self.template_name, context)
def handle(self, *args, **options):
print("RUNNING")
user = EmailUser.objects.get(email='*****@*****.**')
#days_back = options['days_back'][0]
file_path = options['file']
print(file_path)
booking_refunds = []
booking_errors = []
refund_success = False
#Booking.objects.filter(arrival__gte='2020-01-01', arrival__lte='2020-01-21')[:2]
f = open(file_path)
for line in f:
line = line.strip('\n')
print(line + ":")
refund_success = False
try:
b = Booking.objects.get(id=line)
print(b)
#fo r b in bookings:
print(b.created)
invoice_string = ""
refund_success = False
booking_refund_success = False
bookinginvoice = BookingInvoice.objects.filter(booking=b)
for bi in bookinginvoice:
print(bi.invoice_reference)
invoices = Invoice.objects.filter(
reference=bi.invoice_reference)
#invoice_string = ""
bp_amount = "0.00"
refund_success = False
for inv in invoices:
#invoice_string = invoice_string + inv.reference+","
if inv.bpoint_transactions.count() == 1:
for bp in inv.bpoint_transactions:
if bp.action == 'payment':
bpoint_id = bp.id
# call ledger refund command (with try catch)
try:
bp_amount = '{:.2f}'.format(
float(bp.amount))
#bpoint_money_to = (Decimal('{:.2f}'.format(float(bp_txn['line-amount']))) - Decimal('{:.2f}'.format(float(bp_txn['line-amount']))) - Decimal('{:.2f}'.format(float(bp_txn['line-amount']))))
#lines.append({'ledger_description':str("Payment Gateway Refund to "+bp_txn['txn_number']),"quantity":1,"price_incl_tax": bpoint_money_to,"oracle_code":str(settings.UNALLOCATED_ORACLE_CODE), 'line_status': 3})
#bpoint = BpointTransaction.objects.get(txn_number=bp_txn['txn_number'])
info = {
'amount':
Decimal('{:.2f}'.format(
float(bp.amount))),
'details':
'Refund via system'
}
refund = bp.refund(info, user)
refund_success = True
booking_refund_success = True
update_payments(bp.crn1)
except Exception as e:
print(e)
refund_success = False
#bpoint_failed_amount = Decimal(bp_txn['line-amount'])
#lines = []
#lines.append({'ledger_description':str("Refund failed for txn "+bp_txn['txn_number']),"quantity":1,"price_incl_tax":bpoint_failed_amount,"oracle_code":str(settings.UNALLOCATED_ORACLE_CODE), 'line_status': 1})
else:
refund_success = False
print("Too many transactions")
invoice_string = invoice_string + inv.reference + "(" + str(
refund_success) + "),"
booking_refunds.append({
'booking_id': b.id,
'amount': bp_amount,
'booking_customer': b.customer.email,
'invoices': invoice_string,
'refund_success': booking_refund_success
})
except Exception as e:
print(e)
booking_errors.append(line)
print("-----")
# Send email with success and failed refunds
#print (days_back)
print(booking_refunds)
context = {
"booking_refunds": booking_refunds,
"booking_errors": booking_errors
}
email_list = []
for email_to in settings.NOTIFICATION_EMAIL.split(","):
email_list.append(email_to)
print("SENDING EMAIL")
print(settings.EMAIL_FROM)
emails.sendHtmlEmail(tuple(email_list),
"[PARKSTAY] Bulk Refund Script",
context,
'ps/email/bulk_refund.html',
None,
None,
settings.EMAIL_FROM,
'system-oim',
attachments=None)
#print ("COMPLETED")
return "Completed"
def parseFile(file_path):
'''Parse the file in order to create the relevant
objects.
'''
from ledger.payments.models import Invoice
f = get_file(file_path)
transaction_list, group_list, account_list = [], [], []
transaction_rows, group_rows, account_rows = [], [], []
accountttrailer_rows, grouptrailer_rows, filetrailer_row = [], [], None
accountttrailer_list, grouptrailer_list = [], []
bpay_file = None
success = True
biller_code = None
try:
# Validate the file first
validate_file(f)
f.seek(0)
reader = csv.reader(f)
# Instanciate a new Bpay File
bpay_file = BpayFile()
for row in reader:
if row:
if checkStepValue(row[0]) == '01':
# Format the time to 24h
bpay_file.created = validate_datetime(row[3],row[4])
bpay_file.file_id = row[5]
elif checkStepValue(row[0]) == '02':
biller_code = row[1]
group_rows.append(row)
elif checkStepValue(row[0]) == '03':
account_rows.append(row)
elif checkStepValue(row[0]) == '30':
if row[11] not in ['APF','LBX']:
#transaction_list.append(record_txn(row,bpay_file))
row.append(biller_code)
transaction_rows.append(row)
elif checkStepValue(row[0]) == '49':
accountttrailer_rows.append(row)
elif checkStepValue(row[0]) == '98':
grouptrailer_rows.append(row)
elif checkStepValue(row[0]) == '99':
filetrailer_row = row
with transaction.atomic():
bpay_file.save()
# Create Group Records
for row in group_rows:
group_list.append(record_grouprec(row,bpay_file))
# Create Account Records
for row in account_rows:
account_list.append(record_accountrec(row,bpay_file))
# Create transactions
for row in transaction_rows:
transaction_list.append(record_txn(row,bpay_file))
# Create Account Trailer Records
for row in accountttrailer_rows:
accountttrailer_list.append(record_accounttrailer(row,bpay_file))
# Create Group Trailer Records
for row in grouptrailer_rows:
grouptrailer_list.append(record_grouptrailer(row,bpay_file))
# Store Records
BpayGroupRecord.objects.bulk_create(group_list)
BpayAccountRecord.objects.bulk_create(account_list)
BpayTransaction.objects.bulk_create(transaction_list)
BpayAccountTrailer.objects.bulk_create(accountttrailer_list)
BpayGroupTrailer.objects.bulk_create(grouptrailer_list)
# Create File Trailer Record
record_filetrailer(filetrailer_row,bpay_file).save()
# Update payments in the new transaction invoices
for t in bpay_file.transactions.all():
try:
inv = Invoice.objects.get(reference=t.crn)
update_payments(inv.reference)
except Invoice.DoesNotExist:
pass
return success,bpay_file,''
except IntegrityError as e:
success = False
return success,None,e.message
except Exception as e:
traceback.print_exc()
success = False
return success,None,e.message
finally:
f.close()
def get(self, request, *args, **kwargs):
print("=== Infringement Penalty SUCCESS ===")
sanction_outcome = None
offender = None
invoice = None
try:
context = template_context(self.request)
basket = None
infringement_penalty = get_session_infringement_invoice(
request.session) # this raises an error when accessed 2nd time
sanction_outcome = infringement_penalty.sanction_outcome
recipient = sanction_outcome.get_offender()[0].email
submitter = sanction_outcome.get_offender()[0]
if self.request.user.is_authenticated():
basket = Basket.objects.filter(
status='Submitted', owner=request.user).order_by('-id')[:1]
else:
# basket = Basket.objects.filter(status='Submitted', owner=booking.proposal.submitter).order_by('-id')[:1]
basket = Basket.objects.filter(status='Submitted',
owner=None).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
print('invoice.reference: ' + invoice.reference)
# Update status of the infringement notice
if sanction_outcome.status not in SanctionOutcome.FINAL_STATUSES:
inv_payment_status = invoice.payment_status
if inv_payment_status == SanctionOutcome.PAYMENT_STATUS_PAID:
sanction_outcome.log_user_action(
SanctionOutcomeUserAction.
ACTION_PAY_INFRINGEMENT_PENALTY.format(
sanction_outcome.lodgement_number,
invoice.payment_amount, invoice.reference),
request)
sanction_outcome.payment_status = SanctionOutcome.PAYMENT_STATUS_PAID
sanction_outcome.close()
elif inv_payment_status == SanctionOutcome.PAYMENT_STATUS_OVER_PAID:
# Should not reach here
logger.warn(
'{} overpaid an infringement penalty: {}'.format(
'User {} with id {}'.format(
request.user.get_full_name(), request.user.id)
if sanction_outcome.offender else
'An anonymous user',
sanction_outcome.lodgement_number))
sanction_outcome.payment_status = SanctionOutcome.PAYMENT_STATUS_OVER_PAID
sanction_outcome.save()
elif inv_payment_status == SanctionOutcome.PAYMENT_STATUS_PARTIALLY_PAID:
# Should not reach here
logger.warn(
'{} partially paid an infringement penalty: {}'.format(
'User {} with id {}'.format(
request.user.get_full_name(), request.user.id)
if sanction_outcome.offender else
'An anonymous user',
sanction_outcome.lodgement_number))
sanction_outcome.payment_status = SanctionOutcome.PAYMENT_STATUS_OVER_PAID
sanction_outcome.save()
# invoice_ref = invoice.reference
fee_inv, created = InfringementPenaltyInvoice.objects.get_or_create(
infringement_penalty=infringement_penalty,
invoice_reference=invoice.reference)
# infringement_penalty.invoice = invoice
# infringement_penalty.save()
if infringement_penalty.payment_type == InfringementPenalty.PAYMENT_TYPE_TEMPORARY:
try:
# inv = Invoice.objects.get(reference=invoice_ref)
order = Order.objects.get(number=invoice.order_number)
order.user = submitter
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an infringement penalty: {} with an incorrect invoice'
.format(
'User {} with id {}'.format(
request.user.get_full_name(), request.user.id)
if request.user else 'An anonymous user',
sanction_outcome.lodgement_number))
#return redirect('external', args=(proposal.id,))
return redirect('external')
if invoice.system not in [
WC_PAYMENT_SYSTEM_ID.replace('S', '0'),
PS_PAYMENT_SYSTEM_ID,
]:
logger.error(
'{} tried paying an infringement penalty with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
request.user.get_full_name(), request.user.id)
if request.user else 'An anonymous user',
invoice.reference))
#return redirect('external-proposal-detail', args=(proposal.id,))
return redirect('external')
# if fee_inv:
infringement_penalty.payment_type = InfringementPenalty.PAYMENT_TYPE_INTERNET
infringement_penalty.expiry_time = None
update_payments(invoice.reference)
infringement_penalty.save()
request.session[
'wc_last_infringement_invoice'] = infringement_penalty.id
delete_session_infringement_invoice(request.session)
print('delete session infringement invoice')
# TODO 1. offender, 2. internal officer
#send_application_fee_invoice_tclass_email_notification(request, proposal, invoice, recipients=[recipient])
#send_application_fee_confirmation_tclass_email_notification(request, application_fee, invoice, recipients=[recipient])
try:
invoice_created_datetime = invoice.created
except Exception as e:
inv = Invoice.objects.get(
reference=invoice.invoice_reference)
invoice_created_datetime = inv.created
context = {
'sanction_outcome': sanction_outcome,
'offender': recipient,
'invoice_created_datetime': invoice_created_datetime
}
return render(request, self.template_name, context)
except Exception as e:
if ('wc_last_infringement_invoice'
in request.session) and InfringementPenalty.objects.filter(
id=request.session['wc_last_infringement_invoice']
).exists():
infringement_penalty = InfringementPenalty.objects.get(
id=request.session['wc_last_infringement_invoice'])
sanction_outcome = infringement_penalty.sanction_outcome
recipient = sanction_outcome.get_offender()[0].email
submitter = sanction_outcome.assigned_to.email if sanction_outcome.assigned_to else None
if InfringementPenaltyInvoice.objects.filter(
infringement_penalty=infringement_penalty).count() > 0:
ip_inv = InfringementPenaltyInvoice.objects.filter(
infringement_penalty=infringement_penalty)
invoice = ip_inv[0]
# if infringement_penalty.infringement_penalty_invoices.all().count():
else:
return redirect('external')
try:
invoice_created_datetime = invoice.created
except Exception as e:
inv = Invoice.objects.get(reference=invoice.invoice_reference)
invoice_created_datetime = inv.created
# invoice_created_datetime = infringement_penalty.created
context = {
'sanction_outcome': sanction_outcome,
'offender': recipient,
'invoice_created_datetime': invoice_created_datetime
}
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
print('in ApplicationFeeSuccessView.get()')
proposal = None
submitter = None
invoice = None
try:
application_fee = get_session_application_invoice(
request.session
) # This raises an exception when accessed 2nd time?
# Retrieve db processes stored when calculating the fee, and delete the session
db_operations = request.session['db_processes']
del request.session['db_processes']
# Retrieve auto_renew stored when calculating the fee, and delete
auto_renew = request.session.get('auto_renew')
if request.session.get('auto_renew'):
del request.session['auto_renew']
proposal = application_fee.proposal
recipient = proposal.applicant_email
submitter = proposal.submitter
if self.request.user.is_authenticated():
basket = Basket.objects.filter(
status='Submitted', owner=request.user).order_by('-id')[:1]
else:
basket = Basket.objects.filter(
status='Submitted',
owner=proposal.submitter).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
invoice_ref = invoice.reference
# Update the application_fee object
# For the AUA and MLA, the application_fee already has relations to fee_item(s) created when creating lines.
# In that case, there are no 'fee_item_id' and/or 'fee_item_additional_id' keys in the db_operations
if 'fee_item_id' in db_operations:
fee_items = FeeItem.objects.filter(
id=db_operations['fee_item_id'])
if fee_items:
application_fee.fee_items.add(fee_items.first())
if 'fee_item_additional_id' in db_operations:
fee_item_additionals = FeeItem.objects.filter(
id=db_operations['fee_item_additional_id'])
if fee_item_additionals:
application_fee.fee_items.add(fee_item_additionals.first())
application_fee.invoice_reference = invoice_ref
application_fee.save()
if application_fee.payment_type == ApplicationFee.PAYMENT_TYPE_TEMPORARY:
try:
inv = Invoice.objects.get(reference=invoice_ref)
order = Order.objects.get(number=inv.order_number)
order.user = request.user
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an application fee with an incorrect invoice'
.format('User {} with id {}'.
format(proposal.submitter.get_full_name(
), proposal.submitter.id) if proposal.
submitter else 'An anonymous user'))
return redirect('external-proposal-detail',
args=(proposal.id, ))
if inv.system not in [
PAYMENT_SYSTEM_PREFIX,
]:
logger.error(
'{} tried paying an application fee with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
proposal.submitter.get_full_name(),
proposal.submitter.id) if proposal.submitter
else 'An anonymous user', inv.reference))
return redirect('external-proposal-detail',
args=(proposal.id, ))
# if fee_inv:
application_fee.payment_type = ApplicationFee.PAYMENT_TYPE_INTERNET
application_fee.expiry_time = None
update_payments(invoice_ref)
if proposal and invoice.payment_status in (
'paid',
'over_paid',
):
logger.info(
'The fee for the proposal: {} has been fully paid'.
format(proposal.lodgement_number))
# proposal.child_obj.process_after_payment_success(request)
if proposal.application_type.code in (
AuthorisedUserApplication.code,
MooringLicenceApplication.code):
# For AUA or MLA, as payment has been done, create approval
approval, created = proposal.child_obj.update_or_create_approval(
datetime.datetime.now(pytz.timezone(TIME_ZONE)),
request, auto_renew)
else:
# When WLA / AAA
if proposal.application_type.code in [
WaitingListApplication.code,
AnnualAdmissionApplication.code
]:
proposal.lodgement_date = datetime.datetime.now(
pytz.timezone(TIME_ZONE))
proposal.log_user_action(
ProposalUserAction.ACTION_LODGE_APPLICATION.
format(proposal.id), request)
ret1 = proposal.child_obj.send_emails_after_payment_success(
request)
if not ret1:
raise ValidationError(
'An error occurred while submitting proposal (Submit email notifications failed)'
)
proposal.save()
proposal.processing_status = Proposal.PROCESSING_STATUS_WITH_ASSESSOR
proposal.customer_status = Proposal.CUSTOMER_STATUS_WITH_ASSESSOR
proposal.save()
else:
msg = 'Invoice: {} payment status is {}. It should be either paid or over_paid'.format(
invoice.reference, invoice.payment_status)
logger.error(msg)
raise Exception(msg)
application_fee.save()
request.session[
self.LAST_APPLICATION_FEE_ID] = application_fee.id
delete_session_application_invoice(request.session)
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': application_fee,
}
return render(request, self.template_name, context)
except ItemNotSetInSessionException as e:
if self.LAST_APPLICATION_FEE_ID in request.session:
if ApplicationFee.objects.filter(id=request.session[
self.LAST_APPLICATION_FEE_ID]).exists():
application_fee = ApplicationFee.objects.get(
id=request.session[self.LAST_APPLICATION_FEE_ID])
proposal = application_fee.proposal
submitter = proposal.submitter
if type(proposal.child_obj) in [
WaitingListApplication, AnnualAdmissionApplication
]:
proposal.auto_approve(request)
else:
msg = 'ApplicationFee with id: {} does not exist in the database'.format(
str(request.session[self.LAST_APPLICATION_FEE_ID]))
logger.error(msg)
return redirect(
'home') # Should be 'raise' rather than redirect?
# raise Exception(msg)
else:
msg = '{} is not set in session'.format(
self.LAST_APPLICATION_FEE_ID)
logger.error(msg)
return redirect(
'home') # Should be 'raise' rather than redirect?
# raise Exception(msg)
except Exception as e:
# Should not reach here
msg = 'Failed to process the payment. {}'.format(str(e))
logger.error(msg)
# return redirect('home')
raise Exception(msg)
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': application_fee,
}
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
proposal = None
submitter = None
invoice = None
try:
dcv_permit_fee = get_session_dcv_permit_invoice(
request.session
) # This raises an exception when accessed 2nd time?
# Retrieve db processes stored when calculating the fee, and delete the session
db_operations = request.session['db_processes']
del request.session['db_processes']
dcv_permit = dcv_permit_fee.dcv_permit
# recipient = dcv_permit.applicant_email
submitter = dcv_permit.submitter
if self.request.user.is_authenticated():
basket = Basket.objects.filter(
status='Submitted', owner=request.user).order_by('-id')[:1]
else:
basket = Basket.objects.filter(
status='Submitted',
owner=dcv_permit.submitter).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
invoice_ref = invoice.reference
# fee_constructor = FeeConstructor.objects.get(id=db_operations['fee_constructor_id'])
fee_item = FeeItem.objects.get(id=db_operations['fee_item_id'])
try:
fee_item_additional = FeeItem.objects.get(
id=db_operations['fee_item_additional_id'])
except:
fee_item_additional = None
# Update the application_fee object
dcv_permit_fee.invoice_reference = invoice_ref
dcv_permit_fee.save()
dcv_permit_fee.fee_items.add(fee_item)
if fee_item_additional:
dcv_permit_fee.fee_items.add(fee_item_additional)
if dcv_permit_fee.payment_type == ApplicationFee.PAYMENT_TYPE_TEMPORARY:
try:
inv = Invoice.objects.get(reference=invoice_ref)
order = Order.objects.get(number=inv.order_number)
order.user = request.user
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an dcv_permit fee with an incorrect invoice'
.format('User {} with id {}'.
format(dcv_permit.submitter.get_full_name(
), dcv_permit.submitter.id) if dcv_permit.
submitter else 'An anonymous user'))
return redirect('external-dcv_permit-detail',
args=(dcv_permit.id, ))
# if inv.system not in ['0517']:
if inv.system not in [
PAYMENT_SYSTEM_PREFIX,
]:
logger.error(
'{} tried paying an dcv_permit fee with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
dcv_permit.submitter.get_full_name(),
dcv_permit.submitter.id)
if dcv_permit.submitter else 'An anonymous user',
inv.reference))
return redirect('external-dcv_permit-detail',
args=(dcv_permit.id, ))
# if fee_inv:
dcv_permit_fee.payment_type = ApplicationFee.PAYMENT_TYPE_INTERNET
dcv_permit_fee.expiry_time = None
update_payments(invoice_ref)
if dcv_permit and invoice.payment_status in (
'paid',
'over_paid',
):
self.adjust_db_operations(dcv_permit, db_operations)
dcv_permit.generate_dcv_permit_doc()
# proposal_submit(proposal, request)
else:
logger.error('Invoice payment status is {}'.format(
invoice.payment_status))
raise
dcv_permit_fee.save()
request.session[
self.LAST_DCV_PERMIT_FEE_ID] = dcv_permit_fee.id
delete_session_dcv_permit_invoice(request.session)
# DcvPermitFeeSuccessView.send_invoice_mail(dcv_permit, invoice, request)
# DcvPermitFeeSuccessView.send_notification_mail(dcv_permit, invoice, request)
send_dcv_permit_mail(dcv_permit, invoice, request)
context = {
'dcv_permit': dcv_permit,
'submitter': submitter,
'fee_invoice': dcv_permit_fee,
}
return render(request, self.template_name, context)
except Exception as e:
print('in ApplicationFeeSuccessView.get() Exception')
print(e)
if (self.LAST_DCV_PERMIT_FEE_ID in request.session
) and DcvPermitFee.objects.filter(
id=request.session[self.LAST_DCV_PERMIT_FEE_ID]).exists():
dcv_permit_fee = DcvPermitFee.objects.get(
id=request.session[self.LAST_DCV_PERMIT_FEE_ID])
dcv_permit = dcv_permit_fee.dcv_permit
submitter = dcv_permit.submitter
else:
return redirect('home')
context = {
'dcv_permit': dcv_permit,
'submitter': submitter,
'fee_invoice': dcv_permit_fee,
}
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
try:
print('1')
sticker_action_fee = get_session_sticker_action_invoice(
request.session
) # This raises an exception when accessed 2nd time?
print('2')
sticker_action_details = sticker_action_fee.sticker_action_details
if self.request.user.is_authenticated():
owner = request.user
else:
owner = sticker_action_details.first(
).sticker.approval.submitter
basket = Basket.objects.filter(status='Submitted',
owner=owner).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
sticker_action_fee.invoice_reference = invoice.reference
sticker_action_fee.save()
if sticker_action_fee.payment_type == StickerActionFee.PAYMENT_TYPE_TEMPORARY:
print('3')
try:
inv = Invoice.objects.get(reference=invoice.reference)
order = Order.objects.get(number=inv.order_number)
order.user = request.user
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an application fee with an incorrect invoice'
.format('User {} with id {}'.format(
owner.get_full_name(), owner.id)))
return redirect('external')
if inv.system not in [
PAYMENT_SYSTEM_PREFIX,
]:
logger.error(
'{} tried paying an application fee with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
owner.get_full_name(), owner.id),
inv.reference))
return redirect('external')
# if fee_inv:
sticker_action_fee.payment_type = ApplicationFee.PAYMENT_TYPE_INTERNET
sticker_action_fee.expiry_time = None
update_payments(invoice.reference)
for sticker_action_detail in sticker_action_details.all():
new_sticker = sticker_action_detail.sticker.request_replacement(
Sticker.STICKER_STATUS_LOST)
sticker_action_fee.save()
request.session[
self.LAST_STICKER_ACTION_FEE_ID] = sticker_action_fee.id
delete_session_sticker_action_invoice(
request.session
) # This leads to raise an exception at the get_session_sticker_action_invoice() above
# Send email with the invoice
send_sticker_replacement_email(request, new_sticker, invoice)
context = {
'submitter': owner,
'fee_invoice': sticker_action_fee,
}
print('render1')
return render(request, self.template_name, context)
except Exception as e:
print('4')
if (self.LAST_STICKER_ACTION_FEE_ID
in request.session) and StickerActionFee.objects.filter(
id=request.session[
self.LAST_STICKER_ACTION_FEE_ID]).exists():
sticker_action_fee = StickerActionFee.objects.get(
id=request.session[self.LAST_STICKER_ACTION_FEE_ID])
owner = sticker_action_fee.sticker_action_details.first(
).sticker.approval.submitter
else:
return redirect('home')
context = {
'submitter': owner,
'fee_invoice': sticker_action_fee,
}
print('render2')
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
print('in ApplicationFeeSuccessView.get()')
proposal = None
submitter = None
invoice = None
try:
application_fee = get_session_application_invoice(
request.session
) # This raises an exception when accessed 2nd time?
# Retrieve db processes stored when calculating the fee, and delete the session
db_operations = request.session['db_processes']
del request.session['db_processes']
proposal = application_fee.proposal
recipient = proposal.applicant_email
submitter = proposal.submitter
if self.request.user.is_authenticated():
basket = Basket.objects.filter(
status='Submitted', owner=request.user).order_by('-id')[:1]
else:
basket = Basket.objects.filter(
status='Submitted',
owner=proposal.submitter).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
invoice_ref = invoice.reference
fee_constructor = FeeConstructor.objects.get(
id=db_operations['fee_constructor_id'])
# Update the application_fee object
application_fee.invoice_reference = invoice_ref
application_fee.fee_constructor = fee_constructor
application_fee.save()
if application_fee.payment_type == ApplicationFee.PAYMENT_TYPE_TEMPORARY:
try:
inv = Invoice.objects.get(reference=invoice_ref)
order = Order.objects.get(number=inv.order_number)
order.user = request.user
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an application fee with an incorrect invoice'
.format('User {} with id {}'.
format(proposal.submitter.get_full_name(
), proposal.submitter.id) if proposal.
submitter else 'An anonymous user'))
return redirect('external-proposal-detail',
args=(proposal.id, ))
if inv.system not in ['0517']:
logger.error(
'{} tried paying an application fee with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
proposal.submitter.get_full_name(),
proposal.submitter.id) if proposal.submitter
else 'An anonymous user', inv.reference))
return redirect('external-proposal-detail',
args=(proposal.id, ))
# if fee_inv:
application_fee.payment_type = ApplicationFee.PAYMENT_TYPE_INTERNET
application_fee.expiry_time = None
update_payments(invoice_ref)
if proposal and invoice.payment_status in (
'paid',
'over_paid',
):
self.adjust_db_operations(db_operations)
proposal_submit(proposal, request)
else:
logger.error('Invoice payment status is {}'.format(
invoice.payment_status))
raise
application_fee.save()
request.session[
self.LAST_APPLICATION_FEE_ID] = application_fee.id
delete_session_application_invoice(request.session)
# send_application_fee_invoice_apiary_email_notification(request, proposal, invoice, recipients=[recipient])
#send_application_fee_confirmation_apiary_email_notification(request, application_fee, invoice, recipients=[recipient])
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': application_fee,
}
return render(request, self.template_name, context)
except Exception as e:
print('in ApplicationFeeSuccessView.get() Exception')
print(e)
if (self.LAST_APPLICATION_FEE_ID in request.session
) and ApplicationFee.objects.filter(
id=request.session[self.LAST_APPLICATION_FEE_ID]).exists():
application_fee = ApplicationFee.objects.get(
id=request.session[self.LAST_APPLICATION_FEE_ID])
proposal = application_fee.proposal
submitter = proposal.submitter
else:
return redirect('home')
context = {
'proposal': proposal,
'submitter': submitter,
'fee_invoice': application_fee,
}
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
print(" BOOKING SUCCESS ")
booking = None
submitter = None
invoice = None
try:
context = template_context(self.request)
basket = None
booking = get_session_booking(request.session)
proposal = booking.proposal
try:
recipient = proposal.applicant.email
submitter = proposal.applicant
except:
recipient = proposal.submitter.email
submitter = proposal.submitter
if self.request.user.is_authenticated():
basket = Basket.objects.filter(
status='Submitted', owner=request.user).order_by('-id')[:1]
else:
basket = Basket.objects.filter(
status='Submitted',
owner=booking.proposal.submitter).order_by('-id')[:1]
order = Order.objects.get(basket=basket[0])
invoice = Invoice.objects.get(order_number=order.number)
invoice_ref = invoice.reference
book_inv, created = BookingInvoice.objects.get_or_create(
booking=booking,
invoice_reference=invoice_ref,
payment_method=invoice.payment_method)
if booking.booking_type == Booking.BOOKING_TYPE_TEMPORARY:
try:
inv = Invoice.objects.get(reference=invoice_ref)
#if (inv.payment_method == Invoice.PAYMENT_METHOD_BPAY):
# # will return 1st of the next month + monthly_payment_due_period (days) e.g 20th of next month
# now = timezone.now().date()
# dt = date(now.year, now.month, 1) + relativedelta(months=1)
# inv.settlement_date = calc_payment_due_date(booking, dt) - relativedelta(days=1)
# inv.save()
order = Order.objects.get(number=inv.order_number)
order.user = submitter
order.save()
except Invoice.DoesNotExist:
logger.error(
'{} tried paying an admission fee with an incorrect invoice'
.format('User {} with id {}'.
format(proposal.submitter.get_full_name(
), proposal.submitter.id) if proposal.
submitter else 'An anonymous user'))
return redirect('external-proposal-detail',
args=(proposal.id, ))
if inv.system not in ['0557']:
logger.error(
'{} tried paying an admission fee with an invoice from another system with reference number {}'
.format(
'User {} with id {}'.format(
proposal.submitter.get_full_name(),
proposal.submitter.id) if proposal.submitter
else 'An anonymous user', inv.reference))
return redirect('external-proposal-detail',
args=(proposal.id, ))
if book_inv:
booking.booking_type = Booking.BOOKING_TYPE_INTERNET
booking.expiry_time = None
#booking.set_admission_number()
update_payments(invoice_ref)
if not (
invoice.payment_status == 'paid'
or invoice.payment_status == 'over_paid'
) and invoice.payment_method == Invoice.PAYMENT_METHOD_CC:
logger.error(
'Payment Method={} - Admission Fee Invoice payment status is {}'
.format(invoice.get_payment_method_display(),
invoice.payment_status))
raise
booking.save()
request.session['cols_last_booking'] = booking.id
delete_session_booking(request.session)
send_invoice_tclass_email_notification(
request, booking, invoice, recipients=[recipient])
send_confirmation_tclass_email_notification(
request, booking, invoice, recipients=[recipient])
context.update({
'booking_id': booking.id,
'submitter': submitter,
'invoice_reference': invoice.reference
})
return render(request, self.template_name, context)
except Exception as e:
#logger.error('{}'.format(e))
if ('cols_last_booking'
in request.session) and Booking.objects.filter(
id=request.session['cols_last_booking']).exists():
booking = Booking.objects.get(
id=request.session['cols_last_booking'])
proposal = booking.proposal
try:
recipient = proposal.applicant.email
submitter = proposal.applicant
except:
recipient = proposal.submitter.email
submitter = proposal.submitter
if BookingInvoice.objects.filter(booking=booking).count() > 0:
bi = BookingInvoice.objects.filter(booking=booking)
invoice = bi[0]
else:
return redirect('home')
context.update({
'booking_id': booking.id,
'submitter': submitter,
'invoice_reference': invoice.invoice_reference
})
return render(request, self.template_name, context)
def post(self, request, *args, **kwargs):
#def get(self, request, format='json'):
try:
if request.user.is_superuser or request.user.groups.filter(
name__in=['Mooring Licensing - Payment Officers'
]).exists():
money_from = request.POST.get('money_from', [])
money_to = request.POST.get('money_to', [])
bpoint_trans_split = request.POST.get('bpoint_trans_split', [])
refund_method = request.POST.get('refund_method', None)
booking_id = request.POST.get('booking_id', None)
newest_booking_id = request.POST.get('newest_booking_id', None)
booking = Proposal.objects.get(pk=newest_booking_id)
money_from_json = json.loads(money_from)
money_to_json = json.loads(money_to)
bpoint_trans_split_json = json.loads(bpoint_trans_split)
failed_refund = False
json_obj = {
'found': False,
'code': money_from,
'money_to': money_to,
'failed_refund': failed_refund
}
lines = []
if int(refund_method) == 1:
lines = []
for mf in money_from_json:
if Decimal(mf['line-amount']) > 0:
money_from_total = (Decimal(mf['line-amount']) -
Decimal(mf['line-amount']) -
Decimal(mf['line-amount']))
lines.append({
'ledger_description':
str(mf['line-text']),
"quantity":
1,
"price_incl_tax":
money_from_total,
"price_excl_tax":
calculate_excl_gst(money_from_total),
"oracle_code":
str(mf['oracle-code']),
"line_status":
3
})
for bp_txn in bpoint_trans_split_json:
bpoint_id = BpointTransaction.objects.get(
txn_number=bp_txn['txn_number'])
info = {
'amount':
Decimal('{:.2f}'.format(
float(bp_txn['line-amount']))),
'details':
'Refund via system'
}
if info['amount'] > 0:
lines.append({
'ledger_description':
str("Temp fund transfer " +
bp_txn['txn_number']),
"quantity":
1,
"price_incl_tax":
Decimal('{:.2f}'.format(
float(bp_txn['line-amount']))),
"price_excl_tax":
calculate_excl_gst(
Decimal('{:.2f}'.format(
float(bp_txn['line-amount'])))),
"oracle_code":
str(settings.UNALLOCATED_ORACLE_CODE),
'line_status':
1
})
order = utils.allocate_refund_to_invoice(
request,
booking,
lines,
invoice_text=None,
internal=False,
order_total='0.00',
user=booking.submitter,
system_invoice=True)
new_invoice = Invoice.objects.get(
order_number=order.number)
update_payments(new_invoice.reference)
#order = utils.allocate_refund_to_invoice(request, booking, lines, invoice_text=None, internal=False, order_total='0.00',user=booking.customer)
#new_order = Order.objects.get(basket=basket)
#new_invoice = Invoice.objects.get(order_number=order.number)
for bp_txn in bpoint_trans_split_json:
bpoint_id = None
try:
bpoint_id = BpointTransaction.objects.get(
txn_number=bp_txn['txn_number'])
info = {
'amount':
Decimal('{:.2f}'.format(
float(bp_txn['line-amount']))),
'details':
'Refund via system'
}
except Exception as e:
print(e)
info = {
'amount': Decimal('{:.2f}'.format('0.00')),
'details': 'Refund via system'
}
refund = None
lines = []
if info['amount'] > 0:
lines = []
#lines.append({'ledger_description':str("Temp fund transfer "+bp_txn['txn_number']),"quantity":1,"price_incl_tax":Decimal('{:.2f}'.format(float(bp_txn['line-amount']))),"oracle_code":str(settings.UNALLOCATED_ORACLE_CODE), 'line_status': 1})
try:
bpoint_money_to = (
Decimal('{:.2f}'.format(
float(bp_txn['line-amount']))) -
Decimal('{:.2f}'.format(
float(bp_txn['line-amount']))) -
Decimal('{:.2f}'.format(
float(bp_txn['line-amount']))))
lines.append({
'ledger_description':
str("Payment Gateway Refund to " +
bp_txn['txn_number']),
"quantity":
1,
"price_incl_tax":
bpoint_money_to,
"price_excl_tax":
calculate_excl_gst(bpoint_money_to),
"oracle_code":
str(settings.UNALLOCATED_ORACLE_CODE),
'line_status':
3
})
bpoint = BpointTransaction.objects.get(
txn_number=bp_txn['txn_number'])
refund = bpoint.refund(info, request.user)
except Exception as e:
failed_refund = True
bpoint_failed_amount = Decimal(
bp_txn['line-amount'])
lines = []
lines.append({
'ledger_description':
str("Refund failed for txn " +
bp_txn['txn_number']),
"quantity":
1,
"price_incl_tax":
'0.00',
"price_excl_tax":
'0.00',
"oracle_code":
str(settings.UNALLOCATED_ORACLE_CODE),
'line_status':
1
})
order = utils.allocate_refund_to_invoice(
request,
booking,
lines,
invoice_text=None,
internal=False,
order_total='0.00',
user=booking.submitter,
system_invoice=False)
new_invoice = Invoice.objects.get(
order_number=order.number)
if refund:
bpoint_refund = BpointTransaction.objects.get(
txn_number=refund.txn_number)
bpoint_refund.crn1 = new_invoice.reference
bpoint_refund.save()
new_invoice.settlement_date = None
new_invoice.save()
update_payments(new_invoice.reference)
else:
lines = []
for mf in money_from_json:
if Decimal(mf['line-amount']) > 0:
money_from_total = (Decimal(mf['line-amount']) -
Decimal(mf['line-amount']) -
Decimal(mf['line-amount']))
lines.append({
'ledger_description':
str(mf['line-text']),
"quantity":
1,
"price_incl_tax":
money_from_total,
"price_excl_tax":
calculate_excl_gst(money_from_total),
"oracle_code":
str(mf['oracle-code']),
'line_status':
3
})
for mt in money_to_json:
lines.append({
'ledger_description':
mt['line-text'],
"quantity":
1,
"price_incl_tax":
mt['line-amount'],
"price_excl_tax":
calculate_excl_gst(mt['line-amount']),
"oracle_code":
mt['oracle-code'],
'line_status':
1
})
order = utils.allocate_refund_to_invoice(
request,
booking,
lines,
invoice_text=None,
internal=False,
order_total='0.00',
user=booking.submitter,
system_invoice=False)
new_invoice = Invoice.objects.get(
order_number=order.number)
update_payments(new_invoice.reference)
json_obj['failed_refund'] = failed_refund
return Response(json_obj)
else:
raise serializers.ValidationError('Permission Denied.')
except Exception as e:
print(traceback.print_exc())
raise
def _post_save(sender, instance, **kwargs):
from ledger.payments.utils import update_payments
original_instance = getattr(instance, "_original_instance") if hasattr(instance, "_original_instance") else None
if not original_instance:
update_payments(instance.invoice.reference)
def _post_save(sender, instance, **kwargs):
from ledger.payments.utils import update_payments
original_instance = getattr(instance, "_original_instance") if hasattr(instance, "_original_instance") else None
if not original_instance:
update_payments(instance.invoice.reference)
