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))