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)