class User:
def __init__(self, first_name: str, last_name: str):
self.first_name = first_name
self.last_name = last_name
self.account = BankAccount(int_rate=.02, balance=0)
def make_deposit(self, amount: int):
self.account.deposit(amount)
return self
def make_withdrawal(self, amount: int):
self.account.withdraw(amount)
return self
def display_user_balance(self):
print(
f"{self.first_name} {self.last_name}, Balance: ${self.account.balance}"
)
return self
def transfer_money(self, other_user, amount: int):
print(
f"{self.first_name} {self.last_name} transferring ${amount} to {other_user.first_name} {other_user.last_name}"
)
self.make_withdrawal(amount)
other_user.make_deposit(amount)
return self
class IBank(cmd.Cmd):
'''Interactive Bank Application'''
intro = "Welcome to the iBank"
prompt = "bank> "
account = None
def account_valid(self):
return self.account != None
def do_new(self, line):
'''Create an account'''
if self.account_valid():
raise RuntimeError("Account already exists.")
else:
line = line.strip()
initial_balance = float(line) if len(line) > 0 else 0
print "creating new account: initial balance =", initial_balance
self.account = BankAccount(initial_balance)
def do_deposit(self, line):
'''deposit some money into account'''
if not self.account_valid():
print "No Account set up. Do 'new' first."
return
print "depositing money:", line
amount = float(line.strip())
self.account.deposit(amount)
def do_withdraw(self, line):
'''withdraw some money from account'''
if not self.account_valid():
print "No Account set up. Do 'new' first."
return
try:
print "withdrawing money:", line
amount = float(line.strip())
self.account.withdraw(amount)
except OverdrawnError:
print "Nice try. You don't have that much in the bank. You have: ", self.account.balance
def do_history(self, line):
'''dump the account history'''
if not self.account_valid():
print "No Account set up. Do 'new' first."
else:
print self.account.history
def do_quit(self, line):
'''exit the program'''
return True
def do_EOF(self, line):
return True
def postloop(self):
print
class TestBankAcount(unittest.TestCase):
def setUp(self):
# Create a test BankAccount object
self.account = BankAccount()
# Provide it with some property values
self.account.balance= 1000.0
def test_legal_deposit_works(self):
# deposit amount + into current balance.
result = self.account.deposit_funds(500.0)
self.assertEqual(self.account.balance,1500.0)
def test_illegal_deposit_raises_exception(self):
# deposit amount illegal amount like negative amount
self.assertRaises(ValueError ,self.account.deposit_funds,'fantastic')
self.assertRaises(ValueError ,self.account.deposit_funds,'-145.0')
def test_legal_withdrawal(self):
#withdraw amount from current balance
self.account.withdraw_funds(100.0)
self.assertEqual(self.account.balance,900.0)
def test_illegal_withdrawal(self):
# Your code here to test that withdrawing an illegal amount (like 'bananas'none)
self.assertRaises(ValueError ,self.account.withdraw_funds,'anything')
self.assertRaises(ValueError ,self.account.withdraw_funds,'-4.44')
def test_insufficient_funds_withdrawal(self):
#withdrawal fund is not more balance amount
self.assertRaises(ValueError ,self.account.withdraw_funds,3100.0)
self.assertRaises(ValueError ,self.account.withdraw_funds,3100.78)
def index():
user = BankAccount(session['username'], 0)
rec_trans = []
for x in user.recents():
a, b, c = x
fromz = tz.tzutc()
toz = tz.tzlocal()
utc = datetime.strptime(b, '%Y-%m-%d %H:%M:%S.%f')
utc = utc.replace(tzinfo=fromz)
b = utc.astimezone(toz)
rec_trans.append([
str(b.date()) + ' ' + str(b.hour) + ':' + str(b.minute) + ':' +
str(b.second),
str(c)
])
rec_trans = list(reversed(rec_trans))[0:9]
return render_template('index.html',
amount=str(user.getBalance()),
username=session['username'],
recents=convert(rec_trans))
def CreateAccount(self, bWantCard):
obj = BankAccount(500)
BankBranch.dctBankAccount[obj.getAccountNumber()] = obj
#objATM = ATM()
#objATM.ApplyCard(obj.getAccountNumber(), bWantCard)
return obj.getAccountNumber()
class IBank(cmd.Cmd):
'''Interactive Bank Application'''
intro = "Welcome to the iBank"
prompt = "bank> "
account = None
def account_valid(self):
return self.account != None
def do_new(self, line):
'''Create an account'''
if self.account_valid():
raise RuntimeError("Account already exists.")
else:
line = line.strip()
initial_balance = float(line) if len(line) > 0 else 0
print "creating new account: initial balance =", initial_balance
self.account = BankAccount(initial_balance)
def do_deposit(self, line):
'''deposit some money into account'''
if not self.account_valid():
print "No Account set up. Do 'new' first."
return
print "depositing money:", line
amount = float(line.strip())
self.account.deposit(amount)
def do_withdraw(self, line):
'''withdraw some money from account'''
if not self.account_valid():
print "No Account set up. Do 'new' first."
return
try:
print "withdrawing money:", line
amount = float(line.strip())
self.account.withdraw(amount)
except OverdrawnError:
print "Nice try. You don't have that much in the bank. You have: ", self.account.balance
def do_history(self, line):
'''dump the account history'''
if not self.account_valid():
print "No Account set up. Do 'new' first."
else:
print self.account.history
def do_quit(self, line):
'''exit the program'''
return True
def do_EOF(self, line):
return True
def postloop(self):
print
def do_new(self, line):
'''Create an account'''
if self.account_valid():
raise RuntimeError("Account already exists.")
else:
line = line.strip()
initial_balance = float(line) if len(line) > 0 else 0
print "creating new account: initial balance =", initial_balance
self.account = BankAccount(initial_balance)
def setUp(self):
# Create a test BankAccount object
self.account = BankAccount()
# test for save file
self.account.account_number = 1100
self.account.pin_number = 1100
# Provide it with some property values
self.account.balance = 1000.0
class TestBankAcount(unittest.TestCase):
def setUp(self):
# Create a test BankAccount object
self.account = BankAccount()
# Provide it with some property values
self.account.balance = 1000.0
def test_legal_deposit_works(self):
# Your code here to test that depsositing money using the account's
# 'deposit_funds' function adds the amount to the balance.
previous_balance = self.account.balance
self.account.deposit_funds(2000)
self.assertGreater(self.account.balance, previous_balance)
def test_illegal_deposit_raises_exception(self):
# Your code here to test that depositing an illegal value (like 'bananas'
# or such - something which is NOT a float) results in an exception being
# raised.
try:
self.account.deposit_funds("bananas")
except ValueError:
pass
except Exception as e:
self.fail('Unexpected exception raised:' + str(e))
def test_legal_withdrawal(self):
# Your code here to test that withdrawing a legal amount subtracts the
# funds from the balance.
previous_balance = self.account.balance
self.account.withdraw_funds(100)
self.assertLess(self.account.balance, previous_balance)
def test_illegal_withdrawal(self):
# Your code here to test that withdrawing an illegal amount (like 'bananas'
# or such - something which is NOT a float) raises a suitable exception.
try:
self.account.withdraw_funds("apple")
except ValueError:
pass
except Exception as e:
self.fail('Unexpected exception raised:' + str(e))
def test_insufficient_funds_withdrawal(self):
# Your code here to test that you can only withdraw funds which are available.
# For example, if you have a balance of 500.00 dollars then that is the maximum
# that can be withdrawn. If you tried to withdraw 600.00 then a suitable exception
# should be raised and the withdrawal should NOT be applied to the account balance
# or the account's transaction list.
try:
self.account.withdraw_funds(5000000)
except Exception as e:
pass
def withdraw():
if re.match(r'\d+', request.form['amount']):
user = BankAccount(session['username'], 0)
user.withdraw(float(request.form['amount']))
return redirect(url_for('index'))
else:
return redirect(url_for('index'))
def transfer():
if re.match(r'\d+', request.form['amount']):
user = BankAccount(session['username'])
user.transfer(float(request.form['amount']), request.form['target'])
return redirect(url_for('index'))
else:
return redirect(url_for('index'))
def account(start_ammount):
"""
Vytvoří účet s počátečním stavem 20000
Fixture může používat jinou fixture
"""
return BankAccount(start_ammount)
def log_in(event):
'''Function to log in to the banking system using a known account number and PIN.'''
global account
global pin_number
global account_number
filepath = ""
pin_number = account_pin_entry.get()
account_number = account_number_entry.get()
filepath = filepath + account_number
filepath = filepath + '.txt'
try:
ac_file = open(filepath, 'r')
account.account_number = ac_file.readline().strip()
account.pin_number = ac_file.readline().strip()
account.balance = ac_file.readline().strip()
account.interest_rate = ac_file.readline().strip()
if not account.pin_number == pin_number:
messagebox.showinfo("ERROR", "Invalid PIN")
clear_details()
account = BankAccount()
else:
transaction = ac_file.readline().strip()
while transaction:
account.transaction_list.append(transaction)
transaction = ac_file.readline().strip()
remove_all_widgets()
create_account_screen()
except IOError:
messagebox.showinfo("ERROR", "Invalid Account Number")
clear_details()
def do_new(self, line):
'''Create an account'''
if self.account_valid():
raise RuntimeError("Account already exists.")
else:
line = line.strip()
initial_balance = float(line) if len(line) > 0 else 0
print "creating new account: initial balance =", initial_balance
self.account = BankAccount(initial_balance)
class User: # declare a class and give it name User
def __init__(self, username, email_address):
self.name = username
self.email = email_address
self.account = BankAccount(int_rate=0.02, balance=0)
def make_deposit(self, amount):
self.account.deposit(amount)
return self
def make_withdrawl(self, amount):
self.account.withdraw(amount)
return self
def display_user_balance(self):
if self.account >= 0:
print(f"User: {self.name}, Balance: ${round(self.account,2)}")
return self
else:
print(f"User: {self.name}, Balance: -${round(self.account*-1,2)}")
return self
def transfer_money(self, other_user, amount):
self.account.withdraw(amount)
other_user.account.deposit(amount)
print(
f"{self.name} has successfully transferred ${amount} to {other_user.name}"
)
return self
#nina = User("Nina Gervaise Tompkin","*****@*****.**")
#guido = User("Guido Von Trapperson","*****@*****.**")
#dimitar = User("Dimitar Mi Ho","*****@*****.**")
ninaAccount = BankAccount("0.006", "5000")
guidoAccount = BankAccount("0.05", "1000")
ninaAccount.deposit(400).deposit(12.99).deposit(35.23).withdraw(
300).yield_interest().display_account_info()
guidoAccount.deposit(200).deposit(300).withdraw(100).withdraw(
40.23).withdraw(19.99).withdraw(
99.99).yield_interest().display_account_info()
#nina.make_deposit(100).make_deposit(200).make_deposit(50).make_withdrawl(300).display_user_balance()
#dimitar.make_deposit(42.32).make_deposit(59.99).make_withdrawl(24.99).make_withdrawl(6.60).display_user_balance()
#guido.make_deposit(1024.41).make_withdrawl(543.20).make_withdrawl(42.31).make_withdrawl(245.99).display_user_balance()
#nina.transfer_money(guido,200).display_user_balance()
#guido.display_user_balance()
def create_bank_account(self, account_id, balance):
bank_account = BankAccount(
account_id,
self.bank_id,
self.currency,
balance,
self.transaction_queue
)
self.bank_accounts[account_id] = bank_account
logger.debug(f'{self.bank_id}: Created account: {account_id}')
return bank_account
class TestBankAcount(unittest.TestCase):
def setUp(self):
# Create a test BankAccount object
self.account = BankAccount()
# Provide it with some property values
self.account.balance = 1000.0
def test_legal_deposit_works(self):
# Your code here to test that depsositing money using the account's
# 'deposit_funds' function adds the amount to the balance.
deposit = self.account.deposit_funds('2000')
self.assertEqual(deposit, '3000.0')
def test_illegal_deposit_raises_exception(self):
# Your code here to test that depositing an illegal value (like 'bananas'
# or such - something which is NOT a float) results in an exception being
# raised.
self.assertRaises(ValueError, self.account.deposit_funds, 'deposit')
def test_legal_withdrawal(self):
# Your code here to test that withdrawing a legal amount subtracts the
# funds from the balance.
withdrawal = self.account.withdraw_funds('100')
self.assertEqual(withdrawal, '900.0')
def test_illegal_withdrawal(self):
# Your code here to test that withdrawing an illegal amount (like 'bananas'
# or such - something which is NOT a float) raises a suitable exception.
self.assertRaises(ValueError, self.account.withdraw_funds,
'withdrawal')
def test_insufficient_funds_withdrawal(self):
# Your code here to test that you can only withdraw funds which are available.
# For example, if you have a balance of 500.00 dollars then that is the maximum
# that can be withdrawn. If you tried to withdraw 600.00 then a suitable exception
# should be raised and the withdrawal should NOT be applied to the account balance
# or the account's transaction list.
insufficient_money = self.account.withdraw_funds('2000')
self.assertNotEqual(insufficient_money, '-1000')
def save_and_log_out():
'''Function to overwrite the account file with the current state of
the account object (i.e. including any new transactions), remove
all widgets and display the login screen.'''
global account
# Save the account with any new transactions
#print(account)
account.save_to_file()
# Reset the bank acount object
account = BankAccount()
# Reset the account number and pin to blank
account.account_number = ''
account.pin_number = ''
# Remove all widgets and display the login screen again
remove_all_widgets()
create_login_screen()
class User: # here's what we have so far
def __init__(self, name, email):
self.name = name
self.email = email
self.account_balance = 0
self.account = BankAccount(int_rate=0.02, balance=0)
def example_method(self):
# we can call the BankAccount instance's methods
# self.account.deposit(100)
# print(self.account.balance)
pass
# adding the deposit method
def make_deposit(self, amount): # takes an argument that is the amount of the deposit
# the specific user's account increases by the amount of the value received
self.account.deposit(amount)
return self
def make_withdrawal(self, amount):
self.account.withdraw(amount)
# if (amount < self.account_balance):
# self.account_balance -= amount
# else:
# print(
# f'Sorry: {self.name}, requested amount is more than your balance.')
return self
def display_user_balance(self):
print(f'User: {self.name}, Balance: ${self.account.balance}')
return self
def transfer_money(self, other_user, amount):
if (amount < self.account.balance):
self.account.withdraw(amount)
other_user.make_deposit(amount)
else:
self.account.withdraw(amount)
return self
def main():
#Getting user's beginning balance through input
balance = float(input("Enter beginning balance: "))
#Making an object of the BankAccount class with the balance as he beginning value
account = BankAccount(balance)
#Getting user's desired amount to deposit
deposit = float(input("How much were you paid this week? "))
#Depositing the user's desired amount from the bank account object
account.deposit(deposit)
#Printing account's balance
print(account)
print()
#Getting user's desired amount to withdraw
withdraw = float(input("How much would you like to withdraw? "))
#Withdrawing the user's desired amount from the bank account object
account.withdraw(withdraw)
#Printing account's balance
print(account)
def test_balance(self):
acc = BankAccount(100)
self.assertEqual(100, acc.balance())
#!/usr/bin/env python3
from bankaccount import BankAccount
account = BankAccount("Rado", 0, "$")
print(account)
print(account.deposit(1000))
print(account.balance())
print(str(account))
print(account.history())
print(account.withdraw(500))
print(account.balance())
print(account.history())
print(account.withdraw(1000))
print(account.balance())
print(int(account))
print(account.history())
def __init__(self, first_name: str, last_name: str):
self.first_name = first_name
self.last_name = last_name
self.account = BankAccount(int_rate=.02, balance=0)
class TestBankAccount(unittest.TestCase):
def setUp(self):
self.account = BankAccount("Niki", 1350, "$")
self.second_account = BankAccount("Vayne", 0, '$')
self.account_diff_curr = BankAccount('Georgi', 260, 'e')
def test_b_account_init(self):
self.assertEqual(self.account.name, "Niki")
self.assertEqual(self.account._balance, 1350)
self.assertEqual(self.account.currency, "$")
def test_b_account_str(self):
self.assertEqual(str(self.account), 'Bank account for {} with balance of {}{}'.format(
self.account.name, self.account._balance, self.account.currency))
def test_b_account_int(self):
self.assertEqual(int(self.account._balance), 1350)
def test_b_account_deposit(self):
self.account.deposit(100)
self.assertEqual(self.account._balance, 1350 + 100)
def test_b_account_balance(self):
self.assertEqual(self.account._balance, 1350)
def test_b_account_withdraw(self):
self.assertTrue(self.account.withdraw(520))
self.assertEqual(self.account._balance, 1350 - 520)
def test_b_account_withdraw_with_no_balance(self):
self.assertFalse(self.second_account.withdraw(300))
def test_b_account_transfer_to_with_same_currencies(self):
self.assertTrue(self.account.transfer_to(self.second_account, 400))
self.assertEqual(self.account._balance, 1350 - 400)
self.assertEqual(self.second_account._balance, 0 + 400)
def test_b_account_transfer_to_with_diff_currencies(self):
self.assertFalse(self.account.transfer_to(self.account_diff_curr, 400))
self.assertFalse(self.account_diff_curr.transfer_to(self.account, 600))
self.assertEqual(self.account._balance, 1350)
self.assertEqual(self.second_account._balance, 0)
def test_b_account_history(self):
history_to_compare = ['Account was created']
self.account.deposit(320)
history_to_compare.append('Deposited 320{}'.format(
self.account.currency))
self.account.balance()
history_to_compare.append('Balance check -> {}{}'.format(
self.account._balance, self.account.currency))
self.account.withdraw(20)
history_to_compare.append('20{} was withdrawed'.format(
self.account.currency))
# check history when withdraw fail
self.account.withdraw(100000000)
history_to_compare.append('Withdraw for {}{} failed.'.format(
100000000, self.account.currency))
int(self.account)
history_to_compare.append('__int__ check -> {}{}'.format(
self.account._balance, self.account.currency))
self.account.transfer_to(self.second_account, 400)
# check other acc transfer history
self.assertEqual('Transfer from {} for {}{}'.format(
self.account.name, 400, self.account.currency),
self.second_account.history()[len(self.second_account.history()) - 1])
history_to_compare.append('Transfer to {} for {}{}'.format(
self.second_account.name, 400, self.second_account.currency))
self.assertEqual(self.account.history(), history_to_compare)
def __init__(self, name):
self.monthly_interest = 0.1
BankAccount.__init__(self, name)
balance_label = tk.Label(win, textvariable=balance_var)
brand_title_var = tk.StringVar()
brand_title_var.set("FedUni Banking")
brand_label = None
# The Entry widget to accept a numerical value to deposit or withdraw
amount_entry_var = tk.StringVar('')
amount_entry = tk.Entry(win, textvariable=amount_entry_var)
# The transaction text widget holds text of the accounts transactions
transaction_text_widget = tk.Text(win, height=10, width=48)
scrolbar = tk.Scrollbar(win)
# The bank account object we will work with
account = BankAccount()
# ---------- Button Handlers for Login Screen ----------
def clear_pin_entry(event):
'''Function to clear the PIN number entry when the Clear / Cancel button is clicked.'''
pin_number_var.set('')
account_number_var.set('')
# Clear the pin number entry here
def handle_pin_button(event):
'''Function to add the number of the button clicked to the PIN number entry via its associated variable.'''
data = pin_number_var.get()
if len(data) < 4:
def create_account_Test(self):
testobj = BankAccount("Palqk", 0, "Shekel")
self.assertEqual(("Palqk", 0, "Shekel"), (testobj._name, testobj.balance(), testobj._currency))
class TestBankAccount(unittest.TestCase):
def setUp(self):
self.account = BankAccount("Niki", 1350, "$")
self.second_account = BankAccount("Vayne", 0, '$')
self.account_diff_curr = BankAccount('Georgi', 260, 'e')
def test_b_account_init(self):
self.assertEqual(self.account.name, "Niki")
self.assertEqual(self.account._balance, 1350)
self.assertEqual(self.account.currency, "$")
def test_b_account_str(self):
self.assertEqual(
str(self.account),
'Bank account for {} with balance of {}{}'.format(
self.account.name, self.account._balance,
self.account.currency))
def test_b_account_int(self):
self.assertEqual(int(self.account._balance), 1350)
def test_b_account_deposit(self):
self.account.deposit(100)
self.assertEqual(self.account._balance, 1350 + 100)
def test_b_account_balance(self):
self.assertEqual(self.account._balance, 1350)
def test_b_account_withdraw(self):
self.assertTrue(self.account.withdraw(520))
self.assertEqual(self.account._balance, 1350 - 520)
def test_b_account_withdraw_with_no_balance(self):
self.assertFalse(self.second_account.withdraw(300))
def test_b_account_transfer_to_with_same_currencies(self):
self.assertTrue(self.account.transfer_to(self.second_account, 400))
self.assertEqual(self.account._balance, 1350 - 400)
self.assertEqual(self.second_account._balance, 0 + 400)
def test_b_account_transfer_to_with_diff_currencies(self):
self.assertFalse(self.account.transfer_to(self.account_diff_curr, 400))
self.assertFalse(self.account_diff_curr.transfer_to(self.account, 600))
self.assertEqual(self.account._balance, 1350)
self.assertEqual(self.second_account._balance, 0)
def test_b_account_history(self):
history_to_compare = ['Account was created']
self.account.deposit(320)
history_to_compare.append('Deposited 320{}'.format(
self.account.currency))
self.account.balance()
history_to_compare.append('Balance check -> {}{}'.format(
self.account._balance, self.account.currency))
self.account.withdraw(20)
history_to_compare.append('20{} was withdrawed'.format(
self.account.currency))
# check history when withdraw fail
self.account.withdraw(100000000)
history_to_compare.append('Withdraw for {}{} failed.'.format(
100000000, self.account.currency))
int(self.account)
history_to_compare.append('__int__ check -> {}{}'.format(
self.account._balance, self.account.currency))
self.account.transfer_to(self.second_account, 400)
# check other acc transfer history
self.assertEqual(
'Transfer from {} for {}{}'.format(self.account.name, 400,
self.account.currency),
self.second_account.history()[len(self.second_account.history()) -
1])
history_to_compare.append('Transfer to {} for {}{}'.format(
self.second_account.name, 400, self.second_account.currency))
self.assertEqual(self.account.history(), history_to_compare)
from bankaccount import BankAccount
hauptkonto = BankAccount("DE123", "Marko")
sparkonto = BankAccount("DE4432", "Marko")
print(hauptkonto.buchungen)
print(hauptkonto.iban)
print(sparkonto.owner_name)
hauptkonto.buchen(1234, "EUR", "Gehalt")
hauptkonto.buchen(-12, "EUR", "Mittagessen")
print(hauptkonto.buchungen)
print(hauptkonto.getbalance())
def __init__(self):
self._checkings = BankAccount()
self._savings = BankAccount()
def setUp(self):
self.account = BankAccount("Niki", 1350, "$")
self.second_account = BankAccount("Vayne", 0, '$')
self.account_diff_curr = BankAccount('Georgi', 260, 'e')
class Portfolio():
def __init__(self):
self._checkings = BankAccount()
self._savings = BankAccount()
def get_balance(self, account):
if account == "C":
self._checkings.getBalance()
elif account == "S":
self._savings.getBalance()
def deposit(self, amount, account):
if account == "C":
self._checkings.deposit(amount)
elif account == "S":
self._savings.deposit(amount)
def withdraw(self, amount, account):
if account == "C":
self._checkings.withdraw(amount)
elif account == "S":
self._savings.withdraw(amount)
def transfer(self, amount, account):
if account == "C":
amount_to_transfer = self._checkings.withdraw(amount)
self._savings.deposit(amount_to_transfer)
elif account == "S":
amount_to_transfer = self._savings.withdraw(amount)
self._checkings.deposit(amount_to_transfer)
def setUp(self):
self.account = BankAccount("Niki", 1350, "$")
self.second_account = BankAccount("Vayne", 0, '$')
self.account_diff_curr = BankAccount('Georgi', 260, 'e')
def log_in(event):
'''Function to log in to the banking system using a known account number and PIN.'''
global account
global pin_number_var
global account_number_var
# Create the filename from the entered account number with '.txt' on the end
filename = str(account_number_var.get()) + '.txt'
# Try to open the account file for reading
try:
# Open the account file for reading
fopen = open(filename, 'r')
# First line is account number
account.account_number = int(fopen.readline())
# Second line is PIN number, raise exceptionk if the PIN entered doesn't match account PIN read
account.pin_number = int(fopen.readline())
assert int(pin_number_var.get()) == account.pin_number
# Read third and fourth lines (balance and interest rate)
account.balance = float(fopen.readline())
account.interest_rate = float(fopen.readline())
# Section to read account transactions from file - start an infinite 'do-while' loop here
while True:
# Attempt to read a line from the account file, break if we've hit the end of the file. If we
# read a line then it's the transaction type, so read the next line which will be the transaction amount.
# and then create a tuple from both lines and add it to the account's transaction_list
transac_list = []
check = fopen.readline()
if check == '':
break
transac_list.append(check)
transac_list.append(float(fopen.readline()))
account.transaction_list.append(tuple(transac_list))
# Close the file now we're finished with it
fopen.close()
# Catch exception if we couldn't open the file or PIN entered did not match account PIN
except FileNotFoundError:
# Show error messagebox and & reset BankAccount object to default...
messagebox.showerror("Error",
"Invalid account number - please try again!")
account = BankAccount() # account balance wiil call here
# ...also clear PIN entry and change focus to account number entry
pin_number_var.set('')
account_number_var.set('')
return
except AssertionError:
messagebox.showerror("Error", "Wrong PIN entered!")
account = BankAccount()
pin_number_var.set('')
account_number_var.set('')
return
except ValueError:
messagebox.showerror("Error", "Enter some pin!")
account = BankAccount()
pin_number_var.set('')
account_number_var.set('')
return
# return the value here
# Got here without raising an exception? Then we can log in - so remove the widgets and display the account screen
remove_all_widgets()
create_account_screen()
def setUp(self):
# Create a test BankAccount object
self.account = BankAccount()
# Provide it with some property values
self.account.balance = 1000.0
class Portfolio():
def __init__(self):
self._checkings = BankAccount()
self._savings = BankAccount()
def get_balance(self, account):
if account == "C":
self._checkings.getBalance()
elif account == "S":
self._savings.getBalance()
def deposit(self, amount, account):
if account == "C":
self._checkings.deposit(amount)
elif account == "S":
self._savings.deposit(amount)
def withdraw(self, amount, account):
if account == "C":
self._checkings.withdraw(amount)
elif account == "S":
self._savings.withdraw(amount)
def transfer(self, amount, account):
if account == "C":
amount_to_transfer = self._checkings.withdraw(amount)
self._savings.deposit(amount_to_transfer)
elif account == "S":
amount_to_transfer = self._savings.withdraw(amount)
self._checkings.deposit(amount_to_transfer)
def log_in(event):
'''Function to log in to the banking system using a known account number and PIN.'''
global account
global pin_number_var
global account_number_var
read = event + '.txt'
# Create the filename from the entered account number with '.txt' on the end
# Try to open the account file for reading
accept_loging = False
try:
with open(str(read),
'r') as account_file: # Open the account file for reading
account_number = account_file.readline(
)[:-1] # First line is account number
account_pin = account_file.readline(
)[:
-1] # Second line is PIN number, raise exceptionk if the PIN entered doesn't match account PIN read
if account_pin != pin_number_var.get():
raise ValueError("Pin doesnt match")
else:
accept_loging = True
account_balance = float(account_file.readline(
)[:-1]) # Read third and fourth lines (balance and interest rate)
account_interest = float(account_file.readline()[:-1])
transaction_list = []
# Section to read account transactions from file - start an infinite 'do-while' loop here
# Attempt to read a line from the account file, break if we've hit the end of the file. If we
# read a line then it's the transaction type, so read the next line which will be the transaction amount.
# and then create a tuple from both lines and add it to the account's transaction_list
while True:
_type = account_file.readline()[:-1] # Attempt to read a line
if not _type: # If we failed, then exit
break
_amount = float(account_file.readline()[:-1])
transaction_list.append((_type.strip(), _amount))
account.account_number = account_number
account.account_pin = account_pin
account.balance = account_balance
account.account_interest = account_interest
account.transaction_list = transaction_list
# Close the file now we're finished with it (context manager is doing this for us)
except ValueError:
messagebox.showerror("Error", "Incorrect PIN")
account = BankAccount()
account.account_interest = .30
account = account_number_var
clear_pin_entry("event")
account_number_entry.focus_force()
except Exception:
# Catch exception if we couldn't open the file or PIN entered did not match account PIN
messagebox.showerror("Error", "file doesnt exists")
account = BankAccount()
clear_pin_entry("event")
account_number_entry.focus_force()
# Show error messagebox and & reset BankAccount object to default...
# ...also clear PIN entry and change focus to account number entry
if accept_loging:
remove_all_widgets()
create_account_screen()
def __init__(self):
self._checkings = BankAccount()
self._savings = BankAccount()
