def accountInterestEod(): print("Account Interest") interest_per_annam = 0.05 debit_interest = 0.15 all_accounts = session.query(Customer).all() for i in all_accounts: date = Getters.getSysDate().date # time.strftime('%Y-%m-%d') print("Interest for date: " + date) acc = i.acc_number print("Account picked is: " + str(acc)) eod_bal = float(i.working_bal) print("Working balance is: " + str(eod_bal)) if i.working_bal > 0: # interest charges on credit balances interest = (interest_per_annam / 365) * eod_bal else: # interest charged on negative balances interest = (debit_interest / 365) * eod_bal print("Interest Charges: " + str(interest)) table_update = Interest(date=date, account=acc, eod_bal=round(eod_bal, 2), interest_earned=round(interest, 4)) session.add(table_update) print("Record Account " + date + " || " + str(acc) + " || " + str( eod_bal) + " ==== daily interest ----" + str(interest) + " Updated on date : ----" + date) session.commit() print("Account interest Calculation complete")
def ttUpdate(t_type, amount, tran_date, tran_ref, acc_num): """ when a withdrawal or a deposit is done this is how the till is affected :param t_type: :param amount: :param tran_date: :param tran_ref: :param acc_num: :return: """ customer = session.query(Customer).filter_by( acc_number=acc_num).first() print("Till Details: {}".format(Getters.getTillDetails())) till_detail = session.query(Till).filter_by( till_account=Getters.getTillDetails().till_account).first() tt = TellerTransactions( tran_type=t_type.value, # CR or DR tranref=Auto.reference_string_generator(), amount=amount, date=tran_date, remark=tran_ref, create_date=datetime.datetime.now(), teller_id=till_detail.id, customer_id=customer.custid, user_id=Profile().user_details().uid) session.add(tt) session.commit() pass
def create_system_currencies(): currencies = [{ "currency_code": "USD", "description": "United States Dollar" }, { "currency_code": "ZAR", "description": "South African Rand" }, { "currency_code": "GBP", "description": "Great Britain Pound" }] for currency in currencies: code = currency.get("currency_code") description = currency.get("description") if code not in [ c.currency_code for c in session.query(Currency).all() ]: new_currency = Currency(currency_code=code, description=description, create_date=datetime.datetime.now()) session.add(new_currency) session.commit() else: continue
def create_banking_services(): service_dictionary = [{ "service_name": "Pay", "service_description": "for payments" }, { "service_name": "Transfer", "service_description": "Transfer funds to local banks" }, { "service_name": "CashSend", "service_description": "E-wallet services" }, { "service_name": "Bill Payments", "service_description": "Bill Payments" }] for service in service_dictionary: service_n = service.get("service_name") service_d = service.get("service_description") if service_n not in [ s.service_name for s in session.query(BankingServices).filter_by( service_name=service_n).all() ]: service_record = BankingServices(service_name=service_n, service_description=service_d) print("Banking service: {} create".format(service_n)) session.add(service_record) session.commit() else: continue
def create_account(self): """ this method does not take any parameter. it create a new account and associates it to the customer ID for the new customer created :return: 0 for exception, 1 for account created """ # suspense_account = session.query(Customer).filter_by(account_type='acccreate').first() try: customer = session.query(Customer).filter_by(acc_number=self.cr_account).one() except ValueError as value_error: print(value_error) SystemOBS().start_logging(value_error) return 0 # Update transactions Table CommitTransaction(trans_type=TransactionType.CREDIT.value, trans_ref=References().get_transaction_reference, trans_method=TransactionMethod.CASH.value, cheque_number='None', dr_account_number=self.suspense_account_new_account.acc_number, cr_account_number=self.cr_account, amount=self.amount, current_balance=round(self.amount, 2), remark='Account Creation', customer_id=customer.custid) \ .commit_to_database() # update the Account creation Suspense Account self.suspense_account_new_account.working_bal -= self.amount session.add(self.suspense_account_new_account) session.commit() SystemOBS.start_logging("Account Created: " + str(customer.acc_number)) return 1
def deposit(self, transaction_reference): """ This method takes an additional parameter @transaction_reference for a deposit transaction to be saved in the database. - A deposit affects the Teller Till account, this means theTeller Account is debited and Customer account credited. """ customer = session.query(Customer).filter_by(acc_number=self.cr_account).one() current_balance = float(self.amount) + float(customer.working_bal) trans_ref = References().get_transaction_reference CommitTransaction(trans_type=TransactionType.CREDIT.value, trans_ref=trans_ref, trans_method=TransactionMethod.CASH.value, trans_date=self.date, cheque_number='None', dr_account_number=self.suspense_account_teller.till_account, cr_account_number=self.cr_account, amount=self.amount, current_balance=round(current_balance, 2), remark='Deposit_' + transaction_reference, customer_id=customer.custid).commit_to_database() # Update customers working balance customer.working_bal = round(current_balance, 2) session.add(customer) session.commit() # ------------------------------- # Update Till Opening/Closing Balance self.suspense_account_teller.c_balance -= round(float(self.amount), 2) session.add(self.suspense_account_teller) session.commit()
def create_transaction_charge_type(): charge_types = [{ "tran_type": "CR", "tran_charge": 0 }, { "tran_type": "DR", "tran_charge": 1.50 }, { "tran_type": "TR", "tran_charge": 1.0 }, { "tran_type": "RTGS", "tran_charge": 5.0 }, { "tran_type": "SF", "tran_charge": 3.0 }] for charge in charge_types: trans_type = charge.get("tran_type") trans_charge = charge.get("tran_charge") if trans_type not in [ chg.tran_type for chg in session.query(TransactionCharge).all() ]: new_charge = TransactionCharge(tran_type=trans_type, tran_charge=trans_charge) session.add(new_charge) session.commit() print("Charge Type created") else: continue
def _create_user(cls, slack_id=None, username=None, first_name=None, real_name=None, *args, **kwargs): user = User() if not slack_id: slack_id = 'U%s' % str(uuid.uuid4())[:6] user.slack_id = slack_id if not username: username = str(uuid.uuid4())[:10] user.username = username if not first_name: first_name = str(uuid.uuid4())[:8] user.first_name = first_name if not real_name: real_name = str(uuid.uuid4())[:8] user.real_name = real_name for key, value in kwargs.iteritems(): setattr(user, key, value) session.add(user) session.flush() session.commit() return user
def write_coupons_to_db(self, id): # self.process_wordai() with app.app_context(): for row in self.coupons: coupon = Coupon( original_title=row.get('original_title'), title=row.get('original_title'), original_description=row.get('original_description'), description=row.get('original_description'), price=row.get('price'), expiry_date=row.get('expiry_date'), url=row.get('url'), code=row.get('code'), store_id=id) session.add(coupon) try: session.commit() except Exception as e: print(str(e)) session.rollback() store = Store.query.get(id) store.status = StoreStatus.done store.job_uid = None try: session.commit() return True except Exception as e: print(str(e)) session.rollback() return False
def accountInterestEom(): # Calculates the total interest for each account in the interest table # Credits the account with the interest credits the interests account # update the transaction table appropriately sys_date = datetime.datetime.strptime(Getters.getSysDate().date, '%Y-%m-%d') mo = sys_date.strftime('%m') all_accounts = session.query(Customer).all() if session.query(CobDates).filter_by(date=sys_date).filter_by(process='ai').first(): print("Account interest has already run") else: for i in all_accounts: account = i.acc_number selector = session.query(Interest).filter_by(account=account).filter( extract('month', Interest.date) == mo).all() total = 0 for x in selector: total += round(x.interest_earned, 2) tot = round(total, 2) i.working_bal += tot print("Account {} working balance upadated".format(i.working_bal)) session.add(i) session.commit() TransactionUpdate.accInterestUpdate(account, tot, i.working_bal, i.custid) print("Account interest updated for Account {} Amount: ${} working balance now ${}".format(account, tot, i.working_bal)) new = CobDates(date=sys_date, process='ai', status=1, create_date=datetime.datetime.now()) print("Cob Process for Account Interest done") session.add(new) session.commit() pass
def accCreationCash(date, amount, acc_num): # establish the account for account creation acc_creation_sus_acc = session.query(Customer).filter_by( account_type='acccreate').first() cus = session.query(Customer).filter_by(acc_number=acc_num).one() # Update transactions Table trans = Transactions(trantype='CR', tranref=Auto.reference_string_generator(), tranmethod='Cash', tran_date=date, cheque_num='None', acc_number=acc_creation_sus_acc.acc_number, cr_acc_number=acc_num, amount=amount, current_balance=round(amount, 2), remark='Account Creation', custid=cus.custid) session.add(trans) session.commit() # update the Account creation Suspanse Account acc_creation_sus_acc.working_bal -= amount session.add(acc_creation_sus_acc) session.commit() # --------------------------------------------- pass
def serviceFeesEom(): if Getters.getCobDates(Getters.getSysDate().date): if session.query(CobDates).filter_by(process='sf').filter_by(status=1): print("service process skipped") pass else: print("Effect the process table") pass else: charge = session.query(TransactionCharge).filter_by(tran_type='SF').first() all_accounts = session.query(Customer).all() for i in all_accounts: if i.contact_number == '09100000' or i.account_type == 'Student': print("account {} passed. Account Type is {}".format(i.acc_number, i.account_type)) pass else: account = i.acc_number # record = session.query(Customer).filter_by(acc_number=account).first() # update an EOM transaction update TransactionUpdate.eomServfeeTransactionUpdate(account, Getters.getSysDate().date, charge.tran_charge) print("Transaction updated " + str(account) + " " + str(charge.tran_charge) + " " + str(Getters.getSysDate().date) + " record effected") # TransactionUpdate.accChargeUpdate('SF', account, Getters.getSysDate().date) ChargeTransaction(Getters.getSysDate().date, account).charges(TransactionType.SERVICE_FEE) print("Charge effected for account {}".format(account)) new = CobDates(date=Getters.getSysDate().date, process='sf', status=1, create_date=datetime.datetime.now()) session.add(new) session.commit() print("Process table updated")
def amend_cus(): record = None if request.method == 'POST': acc_num = int(request.form['acc_number']) if Verify.account_exists(acc_num): a_record = session.query(Customer).filter_by( acc_number=acc_num).one() if request.form['first_name'] == a_record.first_name: pass else: a_record.first_name = request.form['first_name'] if request.form['last_name'] == a_record.last_name: pass else: a_record.last_name = request.form['last_name'] if request.form['dob'] == a_record.dob: pass else: a_record.dob = request.form['dob'] if request.form['gender'] == a_record.gender: pass else: a_record.gender = request.form['gender'] if request.form['contact_number'] == a_record.contact_number: pass else: a_record.contact_number = int(request.form['contact_number']) if request.form['email'] == a_record.email: pass else: a_record.email = request.form['email'] if request.form['address'] == a_record.address: pass else: a_record.address = request.form['address'] if request.form['country'] == a_record.country: pass else: a_record.country = request.form['country'] if request.form['account_type'] == a_record.account_type: pass else: a_record.account_type = request.form['account_type'] a_record.create_date = a_record.create_date session.add(a_record) session.commit() return redirect( url_for('customer.my_cus', user=Profile().user_details())) else: flash('Account Cannot be modified, Search Again') record = None return redirect(url_for('customer.amend_cus')) else: return render_template('customer/amend_cus.html', record=record, user=Profile().user_details(), account=Getters.getAccountType())
def withdrawal(self, transaction_reference): """ this methods takes in transaction reference generated at the point of withdrawal and save the record in the Transaction table. in a withdrawal, two transaction record are created, one for the debited account and the other for the credited account. - A withdrawal affects the Tellers till balance, this means the Teller account will be credited and customer account debited """ customer = session.query(Customer).filter_by(acc_number=self.cr_account).one() current_balance = float(customer.working_bal) - float(self.amount) main_withdrawal_transaction \ = Transactions(trantype='DR', tranref=transaction_reference, tranmethod='Cash', tran_date=self.date, cheque_num='None', acc_number=int(self.cr_account), cr_acc_number=int(self.suspense_account_teller.till_account), amount=self.amount, current_balance=round(current_balance, 2), remark='Withdrawal ' + transaction_reference, custid=customer.custid) session.add(main_withdrawal_transaction) session.commit() # update customer working balance customer.working_bal = round(current_balance, 2) session.add(customer) session.commit() # ------------------------------- # Update Till Opening/Closing balance self.suspense_account_teller.c_balance += round(self.amount, 2) session.add(self.suspense_account_teller) session.commit() # ------------------------------- # 2. charge details between customer and charge account # charge_account = session.query(Customer).filter_by(account_type='charges').first() get_charge = session.query(TransactionCharge).filter_by(tran_type=TransactionType.DEBIT).first() current_balance_after_charge = float(customer.working_bal) - float(get_charge.tran_charge) charge_withdrawal_transaction \ = Transactions(trantype='DR', tranref=Auto.reference_string_generator(), tranmethod='Charge Transfer', tran_date=transaction_reference, cheque_num='None', acc_number=int(self.cr_account), cr_acc_number=int(self.suspense_account_charges.acc_number), amount=float(get_charge.tran_charge), current_balance=round(current_balance_after_charge, 2), remark='Debit Charge', custid=customer.custid) session.add(charge_withdrawal_transaction) session.commit() # Update Working balance on charge customer.working_bal = round(current_balance_after_charge, 2) session.add(customer) session.commit()
def rollover_system_date(): date_change = session.query(SysDate).first() mydate = datetime.datetime.strptime(Getters.getSysDate().date, '%Y-%m-%d') add_day = datetime.timedelta(days=1) new_date = mydate + add_day date_change.date = new_date.strftime('%Y-%m-%d') session.add(date_change) session.commit()
def create_system_date(): date_obj = session.query(SysDate).all() if not date_obj: sys_date = SysDate(date=time.strftime('%Y-%m-%d'), create_date=datetime.datetime.now()) session.add(sys_date) session.commit() else: print("System Date Already Set To: {}".format(date_obj[0].date))
def link_banking_service(self, service_id): api_user = session.query(ApiUser).filter_by(account_number=self.account_number).first() service = session.query(BankingServices).filter_by(id=int(service_id)) record = CustomerBankingService(api_user_id=api_user.user_id, service_id=service_id, status="active") session.add(record) session.commit()
def hello_world(): product = Product(name="product_1") category = Category(name="category_1", description='description') product.categories = [category] session.add(product) session.commit() return 'Hello, World!'
def withdrawalTransactionUpdate(tran_date, acc_number, amount, tranref): # 1. withdrawal detail between customer and till customer = session.query(Customer).filter_by( acc_number=acc_number).one() till_detail = session.query(Till).filter_by( till_account=Getters.getTillDetails().till_account).first() cb = float(customer.working_bal) - float(amount) trans = Transactions(trantype='DR', tranref=tranref, tranmethod='Cash', tran_date=tran_date, cheque_num='None', acc_number=int(acc_number), cr_acc_number=int(till_detail.till_account), amount=amount, current_balance=round(cb, 2), remark='Withdrawal ' + tranref, custid=customer.custid) session.add(trans) session.commit() # update customer working balance customer.working_bal = round(cb, 2) session.add(customer) session.commit() # ------------------------------- # Update Till Opening/Closing balance till_detail.c_balance += round(amount, 2) session.add(till_detail) session.commit() # ------------------------------- # 2. charge details between customer and charge account charge_account = session.query(Customer).filter_by( account_type='charges').first() get_charge = session.query(TransactionCharge).filter_by( tran_type='DR').first() cb2 = float(customer.working_bal) - float(get_charge.tran_charge) trans2 = Transactions(trantype='DR', tranref=Auto.reference_string_generator(), tranmethod='Charge Transfer', tran_date=tran_date, cheque_num='None', acc_number=int(acc_number), cr_acc_number=int(charge_account.acc_number), amount=float(get_charge.tran_charge), current_balance=round(cb2, 2), remark='Debit Charge', custid=customer.custid) session.add(trans2) session.commit() # Update Working balance on charge customer.working_bal = round(cb2, 2) session.add(customer) session.commit()
def import_from_service(self, rows, source='myprivatevpn'): for row in rows: ip = row.get('proxy_ip') port = row.get('proxy_port') proxy = Proxy(name="{0}:{1}".format(ip, port), source=source) session.add(proxy) try: session.commit() return True except Exception as e: print(str(e)) session.rollback() return False
def create_customer(self): new_client = Customer(first_name=self.first_name, last_name=self.last_name, dob=self.dob, gender=self.gender, contact_number=self.contact_number, email=self.email, address=self.address, country=self.country, acc_number=self.acc_account, working_bal=self.working_bal, account_type=self.account_type, create_date=datetime.datetime.now(), inputter_id=self.inputter_id) session.add(new_client) session.commit()
def create_system_tellers(): record_till = session.query(Till).all() if len(record_till) <= 6: for _ in range(0, 6): print("Teller account created") new_teller = Till( branch_code='', o_balance=0, c_balance=0, till_account=Auto().system_account_number_generator(), currency="USD", remark='', date='', create_date=datetime.datetime.now(), user_id='') session.add(new_teller) session.commit()
def deposit(self): account_creation_current_balance = round(self.amount, 2) transaction = Transactions( trantype='CR', tranref=Auto.reference_string_generator(), tranmethod='Cash', tran_date=self.date, cheque_num='None', acc_number=self._suspence_account.acc_number, cr_acc_number=self.acc_number, amount=self.amount, current_balance=round(self.amount, 2), remark='Account Creation', custid=self._customer_account.custid) session.add(transaction) session.commit()
def commit_to_database(self): """ persists a transaction record in the database using the session instance. :return: """ transaction = Transactions(trantype=self.trans_type, tranref=self.trans_ref, tranmethod=self.trans_method, tran_date=self.trans_date, cheque_num=self.cheque_number, acc_number=self.dr_account_number, cr_acc_number=self.cr_account_number, amount=self.amount, current_balance=self.current_balance, remark=self.remark, custid=self.customer_id) session.add(transaction) session.commit()
def eomServfeeTransactionUpdate(acc_number, tran_date, amount): charged_customer = session.query(Customer).filter_by( acc_number=acc_number).first() current_balance = charged_customer.working_bal - amount servfee = session.query(Customer).filter_by( account_type='servfee').first() # same transactiion reference for customer and suspense account tranref = Auto.reference_string_generator() # transaction for Charged Customer trans = Transactions(trantype='SF', tranref=tranref, tranmethod='COB', tran_date=tran_date, cheque_num='None', acc_number=acc_number, cr_acc_number=servfee.acc_number, amount=amount, current_balance=round(current_balance, 2), remark='SERVFEES', custid=charged_customer.custid) session.add(trans) session.commit() # update customer working balance charged_customer.working_bal = round(current_balance, 2) session.add(charged_customer) session.commit() # ------------------------------- # transaction for Suspense account cb = servfee.working_bal + amount trans_sus = Transactions(trantype='SF', tranref=tranref, tranmethod='COB', tran_date=tran_date, cheque_num='None', acc_number=acc_number, cr_acc_number=servfee.acc_number, amount=amount, current_balance=round(cb, 2), remark='SERVFEES', custid=servfee.custid) session.add(trans_sus) session.commit() # update Suspence account Working balance servfee.working_bal = cb session.add(servfee) session.commit() # --------------------------------------- pass
def add_user(): """ create new user in db :return: """ username = args.username password = args.password name = args.name email = args.email if username and password and name and email: user = User(username=username, password=password, name=name, email=email) session.add(user) session.commit() print("User added successfully")
def add_product(self, name, description, price, category): """ Admin only activity Add new product to the database :return: """ try: category = self.db.query(Category).filter( Category.name.ilike(category)).one() new_product = Product(name=name, description=description, price=price, category_id=category.id) session.add(new_product) session.commit() print("\n'%s' added successfully\n" % name) return True except NoResultFound: return False
def accInterestUpdate(cr_acc, total_amount, cb, cust_id): dr_acc_record = session.query(Customer).filter_by( account_type='interest').first() trans2 = Transactions( trantype='CR', tranref=Auto.reference_string_generator(), tranmethod='Interest', tran_date=Getters.getSysDate().date, cheque_num='None', acc_number=int(dr_acc_record.acc_number), # interest account cr_acc_number=cr_acc, # Client account amount=float(total_amount), current_balance=round(cb, 2), remark='Interest', custid=cust_id) session.add(trans2) session.commit() pass
def create_system_branches(): branches = [{ "code": "01", "description": "Head Office" }, { "code": "02", "description": "Treasury" }, { "code": "03", "description": "Reconciliation" }] for branch in branches: branch_code = branch.get("code") description = branch.get("description") if branch_code not in [b.code for b in session.query(Branch).all()]: new_branch = Branch(code=branch_code, description=description) session.add(new_branch) session.commit() else: continue
def add_to_cart(self, product_name): """ Add given product to the cart :param username: :param product_name: :return: """ product = self.db.query(Product).filter( Product.name.ilike(product_name)).one() item = self.db.query(Cart).filter(Cart.user_id.like( self.user_id)).filter(Cart.product_id.like(product.id)).all() # check whether item already exist in the cart if not item: cart = Cart(user_id=self.user_id, product_id=product.id) session.add(cart) session.commit() print("\n'%s' added to the cart" % product_name) else: print("\n'%s' is already present in the cart" % product_name)