def deposit_or_withdraw(client_id, account_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
accounty = get_account_for_client(client_id, account_id)
if accounty[1] == 404 or accounty[1] == 400:
return accounty
try:
change = request.json
if "deposit" in change.keys() and "withdraw" in change.keys():
return "Please choose to either deposit or withdraw, not both.", 400
elif "deposit" in change.keys():
new_account = BankingService.deposit_funds(client_id, account_id, change["deposit"])
return jsonify(new_account.json()), 200
elif "withdraw" in change.keys():
new_account = BankingService.withdraw_funds(client_id, account_id, change["withdraw"])
return jsonify(new_account.json()), 200
else:
return "Please choose to either deposit or withdraw.", 400
except decimal.InvalidOperation:
logging.warning("Must deposit or withdraw a numeric amount.")
return "The amount to deposit or withdraw must be numeric.", 400
except InsufficientFunds as e:
logging.warning("Attempted to withdraw more funds than exist in account.")
return e.message, 422
def transfer_funds(client_id, account1_id, account2_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
accounty1 = get_account_for_client(client_id, account1_id)
if accounty1[1] == 404 or accounty1[1] == 400:
return accounty1
accounty2 = get_account_for_client(client_id, account2_id)
if accounty2[1] == 404 or accounty2[1] == 400:
return accounty2
try:
change = request.json
if "transfer" in change.keys():
new_account1 = BankingService.withdraw_funds(client_id, account1_id, change["transfer"])
new_account2 = BankingService.deposit_funds(client_id, account2_id, change["transfer"])
return jsonify([new_account1.json(), new_account2.json()]), 200
else:
return "Please enter an amount to transfer.", 400
except decimal.InvalidOperation:
logging.warning("Must deposit or withdraw a numeric amount.")
return "The amount to deposit or withdraw must be numeric.", 400
except InsufficientFunds as e:
logging.warning("Attempted to withdraw more funds than exist in account.")
return e.message, 422
def delete_client(client_id):
try:
BankingService.delete_client(client_id)
return "", 204
except ValueError:
logging.warning("Invalid Client ID input.")
return "Not a valid Client ID.", 400
except ClientNotFound as c:
logging.warning(f"No client found with ID {client_id}.")
return c.message, 404
def put_client(client_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
try:
client = Client.json_parse(request.json)
client.client_id = int(client_id)
BankingService.update_client(client)
return jsonify(client.json()), 200
except KeyError:
logging.warning("User input resulted in KeyError.")
return "Please input both the new username and password to edit client account.", 400
def delete_account(client_id, account_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
try:
BankingService.delete_account(client_id, account_id)
return "", 204
except ValueError:
logging.warning("Invalid Account ID input.")
return "Not a valid Account ID.", 400
except AccountNotFound as a:
logging.warning(f"No account found with ID {account_id} for client with ID {client_id}.")
return a.message, 404
def test_delete_account_account_not_found(self):
try:
account = BankingService().delete_account(1000, 100000)
raise AssertionError("Account should not exist.")
except AccountNotFound as a:
self.assertEqual(
a.message,
"Account with ID 100000 not found for Client with ID 1000.")
def post_client():
try:
client = Client.json_parse(request.json)
client = BankingService.new_client(client)
return jsonify(client.json()), 201
except KeyError:
logging.exception("User input resulted in KeyError.")
return "A username and password are required to register a client.", 400
def put_account(client_id, account_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
accounty = get_account_for_client(client_id, account_id)
if accounty[1] == 404 or accounty[1] == 400:
return accounty
try:
account = Account.json_parse(request.json)
account.account_id = int(account_id)
account.client_id = int(client_id)
BankingService.update_account(account)
return jsonify(account.json()), 200
except KeyError:
logging.warning("Could not update account with information provided.")
return "Please input a new value for the account.", 400
def post_account(client_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
account = Account.json_parse(request.json)
account = BankingService.new_account(client_id, account)
return jsonify(account.json()), 201
def test_withdraw_funds_invalid_client(self):
try:
value = BankingService().withdraw_funds(client_id=100000,
account_id=100,
withdraw_amount=100)
raise AssertionError("Account should not exist.")
except AccountNotFound as a:
self.assertEqual(
a.message,
"Account with ID 100 not found for Client with ID 100000.")
def get_client(client_id):
try:
client = BankingService.get_client_by_id(int(client_id))
return jsonify(client.json()), 200
except ValueError:
logging.warning("Invalid Client ID input.")
return "Not a valid Client ID.", 400
except ClientNotFound as c:
logging.warning(f"No client found with ID {client_id}.")
return c.message, 404
def get_account_for_client(client_id, account_id):
clienty = get_client(client_id)
if clienty[1] == 404 or clienty[1] == 400:
return clienty
try:
account = BankingService.get_account(int(client_id), int(account_id))
return jsonify(account.json()), 200
except ValueError:
logging.warning("Invalid Account ID input.")
return f"Not a valid Account ID.", 400
except AccountNotFound as a:
logging.warning(f"No account found with ID {account_id} for client {client_id}.")
return a.message, 404
def get_all_accounts_for_client(client_id):
try:
max_value = float(request.args["amountLessThan"])
except BadRequestKeyError:
max_value = None
except ValueError:
return "Parameters must be of type int or float.", 400
try:
min_value = float(request.args["amountGreaterThan"])
except BadRequestKeyError:
min_value = 0
except ValueError as e:
logging.warning("Can't retrieve accounts in invalid range.")
return "Parameters must be of type int or float.", 400
if max_value and max_value < min_value:
return "This client has no linked accounts with given parameters.", 200
accounts = BankingService.get_all_client_accounts(client_id, min_value, max_value)
if accounts:
return jsonify(accounts), 200
else:
return "This client has no linked accounts with given parameters.", 200
def test_create_new_client(self):
client = Client(username="******", password="******")
new_client = BankingService().new_client(client)
self.assertEqual(isinstance(new_client, Client), True)
def test_get_client_not_found(self):
try:
client = BankingService().get_client_by_id(100000)
raise AssertionError("There should be no client with ID 100000.")
except ClientNotFound as c:
self.assertEqual(c.message, "Client with ID 100000 not found.")
def test_get_client_success(self):
check_client = Client(1, "marc", "password").json()
client = BankingService().get_client_by_id(1).json()
self.assertDictEqual(client, check_client)
def test_delete_client_no_client_found(self):
try:
BankingService().delete_client(100000)
raise AssertionError
except ClientNotFound as c:
self.assertEqual(c.message, "Client with ID 100000 not found.")
def test_update_client_success(self):
client = Client(777, "goose", "berry")
result = BankingService().update_client(client)
self.assertEqual(result, "")
def test_create_new_account_success(self):
account = Account(value=1000)
new_account = BankingService().new_account(1, account)
self.assertEqual(isinstance(new_account, Account), True)
def get_all_clients():
return jsonify(BankingService.get_all_clients()), 200
def test_get_all_client_accounts_success(self):
accounts = BankingService().get_all_client_accounts(1)
for account in accounts:
if not isinstance(Account.json_parse(account), Account):
raise AssertionError("Not every return is an Account object.")
assert True
def test_update_account_success(self):
account = Account(5, 1, 1000)
result = BankingService().update_account(account)
self.assertEqual(result, "")
def test_get_all_clients_success(self):
clients = BankingService().get_all_clients()
for client in clients:
if not isinstance(Client.json_parse(client), Client):
raise AssertionError("Not every return is a Client object.")
assert True