def loans():
request_data = request.get_json()
try:
validate(request_data, schemas["loan"])
except ValidationError as validation_error:
return generate_error_message(validation_error.message, 400)
date = ciso8601.parse_datetime(request_data["date"])
if date is None:
return generate_error_message("Specified date doesn't follow the ISO8601 norm", 400)
amount = request_data["amount"]
term = request_data["term"]
rate = request_data["rate"]
loan = Loan(id=str(uuid.uuid4()), amount=amount, term=term, rate=rate, date=date)
loan.save()
response = jsonify({"loan_id": loan.id, "installment": Loan.calculate_loan_payment(rate, term, amount)})
response.status_code = 201
return response
def api_create_loan(current_user):
"""API endpoint to create new loans. Only accessible by users of type agent"""
if current_user.type_of_user != 1:
return jsonify({"Message": "Unauthorized"})
else:
data = request.get_json()
if not data:
return jsonify({"message": "No data"})
if "userid" not in data.keys():
return jsonify({"message": "userid not found"})
if "principle" not in data.keys():
return jsonify({"message": "principle not found"})
if "roi" not in data.keys():
return jsonify({"message": "roi not found"})
if "tenure" not in data.keys():
return jsonify({"message": "tenure not found"})
loan = Loan(
user=int(data["userid"]),
principle=data["principle"],
roi=data["roi"],
tenure=data["tenure"],
)
loan.emicalc()
loan.create_uid = current_user.id
db.session.add(loan)
db.session.commit()
return jsonify({"message": "Loan created"})
def setUp(self):
db.create_all()
user = User(username="******",
email="*****@*****.**",
type_of_user=0)
user.set_password(password="******")
db.session.add(user)
user = User(username="******",
email="*****@*****.**",
type_of_user=0)
user.set_password(password="******")
db.session.add(user)
user = User(username="******", email="*****@*****.**", type_of_user=2)
user.set_password(password="******")
db.session.add(user)
user = User(username="******", email="*****@*****.**", type_of_user=1)
user.set_password(password="******")
db.session.add(user)
loan = Loan(tenure=10, principle=1200, roi=12, user=1)
loan.emicalc()
db.session.add(loan)
loan = Loan(tenure=12, principle=1500, roi=14, user=2)
loan.emicalc()
db.session.add(loan)
self.assertEqual(app.debug, True)
def test_sum_of_loan_balances(self):
"""Test is self-explanatory."""
u, v, l, r = self.test_add_user_loan_report()
l2 = Loan(balance=100, currency='GBP', debtor=u)
db.session.add(l2)
db.session.commit()
r.assign(l)
r.assign(l2)
amount = l.balance + l2.balance
self.assertTrue(amount == r.sum_of_loans())
def create_loan():
try:
payload = json.loads(request.data)
error = check_types(payload)
if(error): return error
new_loan = Loan(
amount=payload["amount"],
interest_rate=payload["interest_rate"],
loan_length=payload["loan_length"],
monthly_payment=payload["monthly_payment"],
)
db.session.add(new_loan)
db.session.commit()
return {"message": "Loan Created",
"loan": new_loan.to_dict()}, 201
except (ValueError, KeyError, TypeError) as e:
db.session.rollback()
return make_error(400, f'JSON Format Error: {repr(e)}')
except SQLAlchemyError as e:
db.session.rollback()
return make_error(500, f'Internal Server Error: {repr(e)}')
def test_find_reports(self):
"""Test that the reports that a loan belongs to are found correctly."""
u, v, l, r = self.test_add_user_loan_report()
# Create reports, and assign them to loan l2 except the fifth one
l2 = Loan(balance=100, currency='USD', debtor=u)
db.session.add(l2)
rep = []
for i in range(5):
rep.append(
Report(title="report" + str(i),
body="This is the body of the report",
author=v))
db.session.add(rep[i])
db.session.commit()
for i in range(4):
l2.refer(rep[i])
# Check that all but the fifth are referring l2
for i in range(5):
if i != 4:
self.assertTrue(l2.is_referred(rep[i]))
else:
self.assertFalse(l2.is_referred(rep[i]))
# Check that the rep list is NOT l2.reports
self.assertFalse(l2.reports == rep)
# Check that the first 4 items in rep are in the list of l2.reports
for i in range(len(rep[:4])):
self.assertTrue(rep[i] in l2.reports)
def test_add_user_loan_report(self):
"""Test that the test worked."""
u = User(name="Uu")
v = User(name="Vv")
l = Loan(balance=10, currency='GBP', debtor=u)
r = Report(title="The Report",
body="This is the body of the report",
author=v)
db.session.add(u)
db.session.add(v)
db.session.add(r)
db.session.add(l)
db.session.commit()
return u, v, l, r
def balance(loan_id):
if re.match(loan_id_re, loan_id) is None:
response = jsonify({"error": "Specified loan id is not valid"})
response.status_code = 400
return response
if len(request.args) != 1:
return generate_error_message("Invalid number of arguments", 400)
date = request.args.get('date')
if date is None:
return generate_error_message("Invalid query parameter", 400)
transformed_date = ciso8601.parse_datetime(date)
if transformed_date is None:
return generate_error_message("Specified date doesn't follow the ISO8601 norm", 400)
if transformed_date.tzinfo is None or transformed_date.tzinfo.utcoffset(transformed_date) is None:
transformed_date = transformed_date.replace(tzinfo=pytz.UTC)
db_loan = Loan.get_loan(loan_id)
if db_loan is None:
return generate_error_message("Specified loan id doesn't exist", 400)
total_to_pay = db_loan.amount
db_loan_payments = Payment.get_loan_payments(loan_id)
for payment in db_loan_payments:
if payment.payment == "made" and payment.date <= transformed_date:
total_to_pay -= payment.amount
response = jsonify({"balance": float(round(total_to_pay, 2))})
response.status_code = 200
return response
def createloan():
"""Endpoint to create loans"""
form = LoanForm()
if current_user.type_of_user == 1:
if form.validate_on_submit():
loan = Loan(
user=int(form.user.data),
principle=form.principle.data,
roi=form.roi.data,
tenure=form.tenure.data,
)
loan.createuid(current_user.id)
loan.emicalc()
db.session.add(loan)
db.session.commit()
flash("Loan Created")
return redirect(url_for("index"))
return render_template("createloan.html",
title="Create Loan",
form=form)
else:
flash("You are not authorised to view this!")
return redirect(url_for("index"))
def payments(loan_id):
request_data = request.get_json()
if re.match(loan_id_re, loan_id) is None:
response = jsonify({"error": "Specified loan id is not valid"})
response.status_code = 400
return response
try:
validate(request_data, schemas["payment"])
except ValidationError as validation_error:
return generate_error_message(validation_error.message, 400)
date = ciso8601.parse_datetime(request_data["date"])
if date is None:
return generate_error_message("Specified date doesn't follow the ISO8601 norm", 400)
if date.tzinfo is None or date.tzinfo.utcoffset(date) is None:
date = date.replace(tzinfo=pytz.UTC)
db_loan = Loan.get_loan(loan_id)
if db_loan is None:
return generate_error_message("Specified loan id doesn't exist", 400)
db_loan_installment = Loan.calculate_loan_payment(db_loan.rate, db_loan.term, db_loan.amount)
if request_data["amount"] != db_loan_installment:
return generate_error_message(
"Specified amount is not equal to monthly installment of {}".format(db_loan_installment), 400)
db_loan_payments = Payment.get_loan_payments(loan_id)
if len(db_loan_payments) != 0:
made_payments = []
for payment in db_loan_payments:
if payment.payment == "made":
made_payments.append(payment)
if len(made_payments) == db_loan.term:
return generate_error_message("This loan has already been paid", 409)
db_loan_last_payment = db_loan_payments[-1]
months = relativedelta.relativedelta(date, db_loan_last_payment.date).months
if abs(months) < 1:
return generate_error_message(
"Payments work in a monthly base. Since last payment {} one month hasn't passed".format(
db_loan_last_payment.date), 409)
request_data = request.get_json()
payment = request_data["payment"]
amount = request_data["amount"]
payment = Payment(id=str(uuid.uuid4()), loan_id=loan_id, payment=payment, date=date, amount=amount)
payment.save()
response = jsonify({"message": "Payment successful"})
response.status_code = 201
return response
def build_sample_db(app):
"""
Populate a small db with some example entries.
"""
import string
import random
from app.models import User, CoOp, Role, Loan, Transaction
with app.app_context():
db.drop_all()
db.create_all()
bcrypt = Bcrypt(app)
user_role = Role(name='member')
super_user_role = Role(name='officer')
db.session.add(user_role)
db.session.add(super_user_role)
db.session.commit()
co_op_1 = CoOp(
name='ABC',
is_active=True,
location='Seattle',
interest=5,
initial_balance=2000,
expected_repayment=2200,
current_balance=1500
)
co_op_2 = CoOp(
name='DEF',
is_active=True,
location='New York',
interest=5,
initial_balance=4000,
expected_repayment=4400,
current_balance=35000
)
db.session.add(co_op_1)
db.session.add(co_op_2)
db.session.commit()
# create password hash
pw_hash = bcrypt.generate_password_hash('admin')
pw_hash1 = bcrypt.generate_password_hash('12345')
admin_user = User(
first_name='Admin',
last_name='User',
email='admin',
password=pw_hash,
phone='254798745678',
role_id=super_user_role.id,
co_op_id=co_op_1.id
)
test_user = User(
first_name='Test',
last_name='User',
email='*****@*****.**',
password=pw_hash1,
phone='254987654321',
role_id=user_role.id,
co_op_id=co_op_1.id
)
db.session.add(admin_user)
db.session.add(test_user)
db.session.commit()
test_user_loan = Loan(
user=test_user,
initial_balance=2000,
balance=2000,
interest=2,
)
db.session.add(test_user_loan)
db.session.commit()
return