def query_customer_stock_invest(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
customer = Customer.objects.get(
customer_id=int(request.GET['customer_id']))
query_date = datetime.strptime(request.GET['query_date'],
DATE_TIME_FORMAT).date()
except (KeyError, ValueError, TypeError, Customer.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
stock_invest_list = _query_customer_product_invest(customer,
StockInvestment)
stock_invest_dict_list = []
for stock_invest in stock_invest_list:
curr_stock_price = get_stock_price_from_market(
stock=stock_invest.stock, search_date=query_date)
stock_invest_dict = stock_invest.to_dict()
stock_invest_dict['current_profit'] = None
total_position_share, cumulative_purchase_amount = \
_get_position_share_and_cumulative_purchase_amount(customer, stock_invest.stock, query_date)
if curr_stock_price and query_date >= stock_invest.purchase_date:
stock_invest_dict['current_profit'] = total_position_share * curr_stock_price \
- cumulative_purchase_amount
stock_invest_dict_list.append(stock_invest_dict)
return HttpResponse(json.dumps(stock_invest_dict_list))
def add_customer(request):
bank_teller = fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY])
if not bank_teller:
return HttpResponse(content='Unauthorized', status=401)
# TODO: 未做参数校验
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
name = parameter_dict['name']
phone = parameter_dict['phone']
id_number = parameter_dict['id_number']
deposit = float(parameter_dict['deposit'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
Customer.objects.get(id_number=id_number)
return HttpResponseBadRequest('id number conflict')
except Customer.DoesNotExist:
new_customer = Customer(name=name,
phone=phone,
id_number=id_number,
deposit=deposit,
bank_teller=bank_teller)
new_customer.save()
response_data = {
'msg': 'add new customer success',
'customer_id': new_customer.customer_id
}
return HttpResponse(json.dumps(response_data))
def issue_regular_deposit(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
regular_deposit_name = parameter_dict['regular_deposit_name']
issue_date = datetime.strptime(parameter_dict['issue_date'],
DATE_TIME_FORMAT).date()
return_cycle = int(parameter_dict['return_cycle'])
return_rate = float(parameter_dict['return_rate'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if return_rate <= 0 or return_rate > 0.2 or return_cycle < 7:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
RegularDeposit.objects.get(regular_deposit_name=regular_deposit_name)
return HttpResponseBadRequest(EM_PRODUCT_NAME_USED)
except RegularDeposit.DoesNotExist:
new_regular_deposit = RegularDeposit(
regular_deposit_name=regular_deposit_name,
issue_date=issue_date,
return_cycle=return_cycle,
return_rate=return_rate)
new_regular_deposit.save()
response_data = {
'msg': 'issue regular deposit success',
'regular_deposit_id': new_regular_deposit.regular_deposit_id
}
return HttpResponse(json.dumps(response_data))
def auto_repay_process(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
load_record_query_set = LoanRecord.objects.all()
for loan_record in load_record_query_set:
_calculate_fine(loan_record)
if loan_record.left_payment > 0 and datetime.now().date() >= loan_record.due_date:
customer = loan_record.customer
curr_repay = 0
left_payment_before = loan_record.left_payment
left_fine_before = loan_record.left_fine
if customer.deposit >= loan_record.left_fine:
curr_repay += loan_record.left_fine
customer.deposit -= loan_record.left_fine
loan_record.left_fine = 0
if customer.deposit >= loan_record.left_payment:
curr_repay += loan_record.left_payment
customer.deposit -= loan_record.left_payment
loan_record.left_payment = 0
loan_record.save()
customer.save()
if curr_repay > 0:
new_loan_repay = LoanRepay(loan_record=loan_record,
left_payment_before=left_payment_before,
left_fine_before=left_fine_before,
repay=curr_repay, current_deposit=customer.deposit)
new_loan_repay.save()
response_data = {'msg': 'auto repay process success'}
return HttpResponse(json.dumps(response_data))
def issue_stock(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
stock_name = parameter_dict['stock_name']
issue_date = datetime.strptime(parameter_dict['issue_date'],
DATE_TIME_FORMAT).date()
issue_price = float(parameter_dict['issue_price'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if issue_price <= 0:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
Stock.objects.get(stock_name=stock_name)
return HttpResponseBadRequest(EM_PRODUCT_NAME_USED)
except Stock.DoesNotExist:
new_stock = Stock(stock_name=stock_name,
issue_date=issue_date,
issue_price=issue_price)
new_stock.save()
StockPriceRecord(stock_id=new_stock.stock_id,
record_date=issue_date,
price=issue_price).save()
response_data = {
'msg': 'issue stock success',
'stock_id': new_stock.stock_id
}
return HttpResponse(json.dumps(response_data))
def buy_regular_deposit(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
customer_id = int(parameter_dict['customer_id'])
regular_deposit_id = int(parameter_dict['regular_deposit_id'])
purchase_amount = float(parameter_dict['purchase_amount'])
purchase_date = datetime.strptime(parameter_dict['purchase_date'], DATE_TIME_FORMAT).date()
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
customer = Customer.objects.get(customer_id=customer_id)
regular_deposit = RegularDeposit.objects.get(regular_deposit_id=regular_deposit_id)
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
except RegularDeposit.DoesNotExist:
raise Http404('No such regular deposit')
if not _fine_repay(customer):
return HttpResponseForbidden(EM_CANNOT_PAY_FINE)
if customer.deposit < purchase_amount:
return HttpResponseForbidden(EM_DEPOSIT_NOT_ENOUGH)
customer.deposit -= purchase_amount
customer.save()
RegularDepositInvestment(customer=customer, regular_deposit=regular_deposit,
purchase_date=purchase_date,
due_date=purchase_date + timedelta(days=regular_deposit.return_cycle),
purchase_amount=purchase_amount, current_deposit=customer.deposit).save()
response_data = {'msg': 'purchase success'}
return HttpResponse(json.dumps(response_data))
def request_loan(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
customer_id = int(parameter_dict['customer_id'])
# print(parameter_dict['customer_id'])
payment = float(parameter_dict['payment'])
# print(parameter_dict['payment'])
repay_cycle = int(parameter_dict['repay_cycle'])
# print(parameter_dict['repay_cycle'])
created_time = datetime.strptime(parameter_dict['created_time'], DATE_TIME_FORMAT).date()
# print(parameter_dict['created_time'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if payment <= 0:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
customer = Customer.objects.get(customer_id=customer_id)
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
new_loan_record = LoanRecord(customer=customer, payment=payment, current_deposit=customer.deposit,
repay_cycle=repay_cycle, due_date=created_time + timedelta(days=repay_cycle),
next_overdue_date=created_time + timedelta(days=repay_cycle),
left_payment=payment, left_fine=0.0, created_time=created_time)
new_loan_record.save()
response_data = {'msg': 'loan request success', 'loan_record_id': new_loan_record.loan_record_id}
return HttpResponse(json.dumps(response_data))
def customer_deposit(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
customer_id = int(parameter_dict['customer_id'])
new_deposit = float(parameter_dict['new_deposit'])
deposit_date = datetime.strptime(parameter_dict['deposit_date'],
DATE_TIME_FORMAT).date()
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if new_deposit <= 0:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
customer = Customer.objects.get(customer_id=customer_id)
customer.deposit += new_deposit
DepositRecord(customer=customer,
payment=new_deposit,
current_deposit=customer.deposit,
created_time=deposit_date).save()
customer.save()
response_data = {'msg': 'customer deposit success'}
return HttpResponse(json.dumps(response_data))
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
def bank_teller_logout(request):
token = request.META.get(TOKEN_HEADER_KEY)
bank_teller = fetch_bank_teller_by_token(token)
if bank_teller:
expire_token(token)
response_data = {'msg': 'logout success'}
return HttpResponse(json.dumps(response_data))
else:
print(bank_teller)
return HttpResponseForbidden("invalid token")
def query_loan_record_by_id(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
loan_record_id = int(request.GET['loan_record_id'])
loan_record = LoanRecord.objects.get(loan_record_id=loan_record_id)
except (KeyError, ValueError, TypeError, LoanRecord.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
return HttpResponse(json.dumps(loan_record.to_dict()))
def query_customer_by_id_number(request):
bank_teller = fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY])
if not bank_teller:
return HttpResponse(content='Unauthorized', status=401)
try:
customer = Customer.objects.get(id_number=request.GET['id_number'])
return HttpResponse(json.dumps(customer.to_dict()))
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
def buy_stock(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
customer_id = int(parameter_dict['customer_id'])
stock_id = int(parameter_dict['stock_id'])
new_position_share = int(parameter_dict['new_position_share']) # 新买入的股数
purchase_date = datetime.strptime(parameter_dict['purchase_date'], DATE_TIME_FORMAT).date()
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
customer = Customer.objects.get(customer_id=customer_id)
stock = Stock.objects.get(stock_id=stock_id)
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
except Stock.DoesNotExist:
raise Http404('No such stock')
if not _fine_repay(customer):
return HttpResponseForbidden(EM_CANNOT_PAY_FINE)
stock_price = get_stock_price_from_market(stock, purchase_date)
if not stock_price:
return HttpResponseForbidden('invalid purchase')
purchase_amount = stock_price * new_position_share
if customer.deposit < purchase_amount:
return HttpResponseForbidden(EM_DEPOSIT_NOT_ENOUGH)
if _get_customer_credit(customer)['credit_level'] > Credit.CREDIT_PRIMARY_ACCOUNT:
return HttpResponseForbidden('credit level forbidden')
customer.deposit -= purchase_amount
try:
stock_investment = StockInvestment.objects.get(customer=customer, stock=stock)
stock_investment.cumulative_purchase_amount += purchase_amount
stock_investment.position_share += new_position_share
stock_investment.current_deposit = customer.deposit
except StockInvestment.DoesNotExist:
stock_investment = StockInvestment(customer=customer, stock=stock,
position_share=new_position_share,
purchase_date=purchase_date,
cumulative_purchase_amount=purchase_amount,
current_deposit=customer.deposit)
StockInvestmentRecord(customer=customer, stock=stock, position_share=new_position_share,
purchase_date=purchase_date, purchase_amount=purchase_amount,
current_deposit=customer.deposit).save()
customer.save()
stock_investment.save()
response_data = {'msg': 'stock purchase success'}
return HttpResponse(json.dumps(response_data))
def query_deposits_by_customer_id(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
customer_id = int(request.GET['customer_id'])
customer = Customer.objects.get(customer_id=customer_id)
except (KeyError, ValueError, TypeError, Customer.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
response_data = []
for deposit_record in customer.depositrecord_set.all():
response_data.append(deposit_record.to_dict())
return HttpResponse(json.dumps(response_data))
def get_customer_credit(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
customer_id = int(request.GET['customer_id'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
customer = Customer.objects.get(customer_id=customer_id)
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
return HttpResponse(json.dumps(_get_customer_credit(customer)))
def buy_fund(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
customer_id = int(parameter_dict['customer_id'])
fund_id = int(parameter_dict['fund_id'])
purchase_amount = float(parameter_dict['purchase_amount'])
purchase_date = datetime.strptime(parameter_dict['purchase_date'], DATE_TIME_FORMAT).date()
return_cycle = int(parameter_dict['return_cycle'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
customer = Customer.objects.get(customer_id=customer_id)
fund = Fund.objects.get(fund_id=fund_id)
except Customer.DoesNotExist:
raise Http404(EM_NO_SUCH_CUSTOMER)
except Fund.DoesNotExist:
raise Http404('No such fund')
if not _fine_repay(customer):
return HttpResponseForbidden(EM_CANNOT_PAY_FINE)
if customer.deposit < purchase_amount:
return HttpResponseForbidden(EM_DEPOSIT_NOT_ENOUGH)
if _get_customer_credit(customer)['credit_level'] > Credit.CREDIT_SECONDARY_ACCOUNT:
return HttpResponseForbidden('credit level forbidden')
fund_price = get_fund_price_from_market(fund, purchase_date)
if not fund_price:
return HttpResponseForbidden('invalid purchase')
customer.deposit -= purchase_amount
customer.save()
fund_investment = FundInvestment(customer=customer, fund=fund,
position_share=purchase_amount / fund_price,
purchase_amount=purchase_amount,
purchase_date=purchase_date,
due_date=purchase_date + timedelta(days=return_cycle),
current_deposit=customer.deposit)
fund_investment.save()
response_data = {'msg': 'fund purchase success'}
return HttpResponse(json.dumps(response_data))
def query_customer_regular_deposit_invest(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
customer = Customer.objects.get(
customer_id=int(request.GET['customer_id']))
except (KeyError, ValueError, TypeError, Customer.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
regular_deposit_invest_list = _query_customer_product_invest(
customer, RegularDepositInvestment)
regular_deposit_invest_dict_list = []
for regular_deposit_invest in regular_deposit_invest_list:
return_rate = regular_deposit_invest.regular_deposit.return_rate
regular_deposit_invest_dict = regular_deposit_invest.to_dict()
regular_deposit_invest_dict[
'expecting_profit'] = return_rate * regular_deposit_invest.purchase_amount
regular_deposit_invest_dict_list.append(regular_deposit_invest_dict)
return HttpResponse(json.dumps(regular_deposit_invest_dict_list))
def loan_repay(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
parameter_dict = fetch_parameter_dict(request, 'POST')
loan_record_id = int(parameter_dict['loan_record_id'])
repay = float(parameter_dict['repay'])
except (KeyError, ValueError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if repay <= 0:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
try:
loan_record = LoanRecord.objects.get(loan_record_id=loan_record_id)
except LoanRecord.DoesNotExist:
raise Http404('No such loan record')
_calculate_fine(loan_record)
if _loan_repay(loan_record, repay, False):
response_data = {'msg': 'loan repay success'}
return HttpResponse(json.dumps(response_data))
return HttpResponseBadRequest('too much repay')
def query_customer_fund_invest(request):
if not fetch_bank_teller_by_token(request.META[TOKEN_HEADER_KEY]):
return HttpResponse(content='Unauthorized', status=401)
try:
customer = Customer.objects.get(
customer_id=int(request.GET['customer_id']))
query_date = datetime.strptime(request.GET['query_date'],
DATE_TIME_FORMAT).date()
except (KeyError, ValueError, TypeError, Customer.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
fund_invest_list = _query_customer_product_invest(customer, FundInvestment)
fund_invest_dict_list = []
for fund_invest in fund_invest_list:
curr_fund_price = get_fund_price_from_market(fund=fund_invest.fund,
search_date=query_date)
fund_invest_dict = fund_invest.to_dict()
fund_invest_dict['current_profit'] = None
if curr_fund_price and query_date >= fund_invest.purchase_date:
fund_invest_dict['current_profit'] = fund_invest.position_share * curr_fund_price \
- fund_invest.purchase_amount
fund_invest_dict_list.append(fund_invest_dict)
return HttpResponse(json.dumps(fund_invest_dict_list))