def post(self, request, *args, **kwargs):
"""
发起借钱请求, 需要三个字段（向谁借who, 借多少money，什么时候还pay_back_date）
"""
need_fields = ('who', 'money', 'pay_back_date')
for field in need_fields:
if not request.POST.get(field):
return JsonResponse(response_detail(400, f"{field}缺失"))
who = int(request.POST.get('who'))
money = int(request.POST.get('money'))
pay_back_date = str(request.POST.get('pay_back_date'))
try:
who = User.objects.get(id=who)
except:
return JsonResponse(response_detail(400, "请求失败！用户不存在！"))
if money < 0:
return JsonResponse(response_detail(400, "请求失败！金额应该大于0"))
try:
field_time = datetime.strptime(pay_back_date, '%Y-%m-%d')
except ValueError:
return JsonResponse(response_detail(400, '时间格式有误，应为 %Y-%m-%d'))
borrow_field = BorrowMoneyTable(borrower=request.user,
lender=who,
money=money,
repayment_date=field_time,
status=0)
borrow_field.save()
send_message(
request.user, who, "借钱信息", f"{request.user.username} 想向你借 {money}"
f"块钱，还款时间是: {field_time}, 是否同意？\n记录号：【{borrow_field.id}】", 3)
return JsonResponse(response_detail(200))
def get(self, request):
code = request.GET.get('code')
if not code:
return JsonResponse(response_detail(400))
data = {
'client_id': OAuth.OAuthByGitHubSetting['client_id'],
'client_secret': OAuth.OAuthByGitHubSetting['client_secret'],
'code': code
}
request = requests.post('https://github.com/login/oauth/access_token',
data=data).text
pattern = re.compile(r'^access_token=+[0-9a-zA-Z]+&.+$')
if not re.match(pattern, request):
return JsonResponse(response_detail(400, "登录失败！"))
try:
token = (request.split("=")[1]).split("&")[0]
except IndexError:
return JsonResponse(response_detail(400, "登录失败！"))
get_user_info = requests.get(
f'https://api.github.com/user?access_token={token}').json()
try:
username = get_user_info['login']
except NameError:
return JsonResponse(response_detail(400, "登录失败！"))
user = User.objects.filter(username=username).first()
if not user:
newOAuthUser = User(username=username, password='******')
newOAuthUser.save()
user = newOAuthUser
u4 = uuid.uuid4() # 生成uuid4
UserToken.objects.update_or_create(user=user, defaults={'token': u4})
return JsonResponse(response_detail(200, data={'token': u4}))
def post(request, *args, **kwargs):
# create new family
family_name = request.POST.get('family_name')
# 判断该用户能不能创建家庭（每个人只能加入一个家庭）
if request.user.family1:
return JsonResponse(response_detail(460, "每人只能加入一个家庭"))
try:
family_from_db = Family.objects.filter(
family_name=family_name)
except:
return JsonResponse(response_detail(500))
# if family_from_db:
# msg = CODE[400]
# msg['msg'] = "家庭名重复"
# return JsonResponse(msg)
try:
parent1 = User.objects.get(id=request.user.id)
new_family_member = FamilyMembers(parent1=parent1)
new_family_member.save()
new_family = Family(family_name=family_name,
family_member=new_family_member)
new_family.save()
parent1.family1 = new_family
parent1.save()
return JsonResponse(response_detail(200))
except:
return JsonResponse(response_detail(500))
def delete(request, *args, **kwargs):
DELETE = QueryDict(request.body)
token = DELETE.get('token')
try:
UserToken.objects.get(token=token).delete()
return JsonResponse(response_detail(200))
except:
return JsonResponse(response_detail(400, '登出失败'))
def get(self, request, *args, **kwargs):
"""
返回用户所有借的帐
"""
borrow_bills = BorrowMoneyTable.objects.filter(borrower=request.user)
if not borrow_bills:
return JsonResponse(response_detail(201))
borrow_data = BorrowSerializer(instance=borrow_bills, many=True)
return JsonResponse(response_detail(200, data=borrow_data.data),
safe=False)
def delete(self, request, *args, **kwargs):
# 删除消息
DELETE = QueryDict(request.body)
message_id = DELETE.get('id')
try:
prepare_delete_mes = Message.objects.get(id=message_id)
except:
return JsonResponse(response_detail(400))
# 只能删自己的信息
if request.user.id != prepare_delete_mes.receive_id:
return JsonResponse(response_detail(403, "你想上天啊！！"))
prepare_delete_mes.delete()
return JsonResponse(self._get_message(request), safe=False)
def get(self, request, *args, **kwargs):
"""
返回用户信息
:param request: Request
:return:
"""
try:
info = self.get_user_info(request, *args, **kwargs)
except AttributeError:
return JsonResponse(response_detail(500))
ret = response_detail(200)
ret.update(info)
return JsonResponse(ret, safe=False)
def post(request, *args, **kwargs):
try:
username = request.POST.get('username')
password = request.POST.get('password')
user = User.objects.filter(username=username,
password=password).first()
if not user:
return JsonResponse(response_detail(400, "用户名或密码错误"))
u4 = uuid.uuid4() # 生成uuid4
UserToken.objects.update_or_create(user=user,
defaults={'token': u4})
ret = response_detail(200)
ret['token'] = u4
return JsonResponse(ret)
except Exception:
return JsonResponse(response_detail(400))
def put(self, request, *args, **kwargs):
# 修改消息状态为已读或者星标
PUT = QueryDict(request.body)
message_id = PUT.get('id')
message_state = int(PUT.get('state'))
try:
message = Message.objects.get(id=message_id)
except:
return JsonResponse(response_detail(400))
if message_state not in (0, 1, 2, 3):
return JsonResponse(response_detail(400, "别搞了！！！"))
try:
message.state = message_state
message.save()
except:
return JsonResponse(response_detail(500))
return JsonResponse(self._get_message(request), safe=False)
def post(self, request, *args, **kwargs):
# 发送消息
receive = request.POST.get('receive')
title = request.POST.get('title')
text = request.POST.get('text')
try:
receive_id = User.objects.get(username=receive)
except Exception:
return JsonResponse(response_detail(400))
try:
new_message = Message(send=request.user,
receive=receive_id,
title=title,
text=text)
new_message.save()
except Exception:
return JsonResponse(response_detail(500))
return JsonResponse(self._get_message(request), safe=False)
def get(request, *args, **kwargs):
family_info = {'family': 'null'}
family = request.user.family1
if family:
family_info = family.toString()
ret = response_detail(200)
print(family_info)
ret.update(family_info)
return JsonResponse(ret, safe=False)
def put(self, request, *args, **kwargs):
"""
修改用户个人信息
:param request: Request
:return: 新的信息
"""
PUT = QueryDict(request.body)
data = PUT.dict()
for field in data:
if field in UserInfoView.user_info_matters:
if len(data[field]) != 0:
try:
setattr(request.user, field, data[field])
request.user.save()
except:
return JsonResponse(response_detail(500))
ret = self.get_user_info(request)
ret.update(response_detail(200))
return JsonResponse(ret, safe=False)
def _people_reached_upper_limit_judge(family_mumber):
"""
一个家庭最多允许加入8个人（算家长）这个方法用来判断家庭人数是否已满
:param family_mumber: QuerySet, 主要用来获取家庭成员信息，看还有没有空位
"""
fm_fields = [
getattr(family_mumber, f.name) for f in family_mumber._meta.fields
if f.name != 'id'
]
if None not in fm_fields:
return JsonResponse(response_detail(600, "这里人满了"))
def put(request, *args, **kwargs):
"""
家长审核请求加入的成员
1. 检查put过来的数据中有没有（家庭id，成员id，时间，是否同意）
2. 如果同意，发消息给成员(0同意，1不同意)
3. 加入家庭表
4. 不同意法消息给成员
TODO: 校验请求时间也先不写了，命没了
TODO： 目前是明文传输，前端需要加密（添加校验字段），后端解密
"""
member_list = ['members3', 'members4',
'members5', 'members6', 'members7', 'members8']
need_fields = ['parent_id', 'user_id', 'is_agree']
PUT = QueryDict(request.body)
put_data = PUT.dict()
for field in need_fields:
if not put_data.get(field):
return JsonResponse(response_detail(400, "您传递的数据不符合接口要求"))
if field == 'is_agree':
if put_data.get(field) not in ['0', '1']:
return JsonResponse(response_detail(400, "您只能选择同意或不同意"))
child = User.objects.get(id=int(put_data.get('user_id')))
# 根据家长ID找到家庭
try:
fm = User.objects.filter(id=int(put_data.get('parent_id'))).first().family1.family_member
except TypeError:
# 正常从前端界面发请求不会触发
return JsonResponse(response_detail(400, "没有这个家庭"))
the_family = User.objects.get(id=int(put_data.get('parent_id'))).family1
if put_data.get('is_agree') == '1':
send_message(request.user, child, "申请失败",
f"{request.user.username} 不同意你加入家庭{the_family.family_name}.", 1)
return JsonResponse(response_detail(200))
get_application = Application.objects.filter(applicant=child,
interviewer=request.user).first()
if not get_application:
return JsonResponse(response_detail(400, "该用户从来没发起过请求"))
for m in member_list:
m_value = getattr(fm, m)
# 将家庭加入到成员家庭项目中
if child.family1:
return JsonResponse(response_detail(460, "只能加入一个家庭"))
# 将新成员加入到家庭成员表中
# TODO：判断新成员是不是在家庭中了
if m_value is None:
setattr(fm, m, child)
fm.save()
child.family1 = the_family
child.save()
send_message(request.user, child, "加入成功",
f"{request.user.username} 同意你加入家庭{the_family.family_name}.", 1)
get_application.delete()
return JsonResponse(response_detail(200))
def _put(self, request, bill_type: int):
PUT = QueryDict(request.body)
put_data = PUT.dict()
need_field = ('bill_id', 'field_name', 'new_value')
# 检查request中是否包含所需要的字段
for field in need_field:
if field not in put_data:
return JsonResponse(response_detail(400, detail="参数缺失"))
# 检查每一个参数的正确性
bill = UserBills.objects.filter(id=int(put_data['bill_id']),
type=bill_type,
user=request.user).first()
if not bill:
return JsonResponse(response_detail(400, detail="账单不存在"))
if not getattr(UserBills, put_data['field_name'], None):
return JsonResponse(
response_detail(400, detail="参数错误(field_name is not find)"))
try:
setattr(bill, put_data['field_name'], put_data['new_value'])
bill.save()
data = self._get_info(request, bill_type)
return JsonResponse(response_detail(200, data=data))
except Exception:
return JsonResponse(response_detail(500, detail="修改失败"))
def post(request, *args, **kwargs):
try:
username = request.POST.get('username')
password = request.POST.get('password')
pwdagain = request.POST.get('pwdagain')
except:
return JsonResponse(response_detail(400))
try:
user_in_db = User.objects.filter(username=username)
except:
return JsonResponse(response_detail(500))
if user_in_db:
return JsonResponse(response_detail(400, "用户名重复"))
if password != pwdagain:
return JsonResponse(response_detail(400, '两次密码不一致'))
new_user = User.objects.create(username=username, password=password)
new_user.save()
u4 = uuid.uuid4() # 生成uuid4
UserToken.objects.update_or_create(user=new_user,
defaults={'token': u4})
ret = response_detail(200)
ret['token'] = u4
ret.update(new_user.toString())
return JsonResponse(ret)
def post(self, request, *args, **kwargs):
"""
普通用户请求加入某个家庭
:param request: Request
:return: 200
"""
family_id = request.POST.get('family_id')
family = Family.objects.filter(id=family_id).first()
if not family:
return JsonResponse(response_detail(400))
self_applicant = Application.objects.filter(
applicant=request.user).first()
if self_applicant:
# 如果用户发起过请求
if not timeout_judgment(self_applicant, 'start_time', '1/d'):
return JsonResponse(response_detail(460, "你已经申请过了，明天再来!!!!"),
safe=False)
# 限制一个用户只能加入一个家庭
if request.user.family1:
return JsonResponse(response_detail(460, "只能加入一个家庭!!!"))
family_mumber = family.family_member
self._people_reached_upper_limit_judge(family_mumber)
self._notify_all_parents(request, family_mumber)
return JsonResponse(response_detail(200), safe=False)
def _post(self, request):
print(request.data)
try:
bills_type = int(request.POST.get('bill_type'))
except TypeError:
return JsonResponse(response_detail(400, detail="类型缺失"))
print(bills_type)
if int(bills_type) not in (0, 1, 10, 11, 12):
return JsonResponse(response_detail(400, detail="类型错误"))
need_fields = ['money', 'remarks', 'time']
for field in need_fields:
if not request.POST.get(field):
return JsonResponse(response_detail(400, detail=f"{field}缺失"))
# 判断用户描述是否超出数据库长度限制
if len(request.POST.get('remarks')) > 1000:
return JsonResponse(response_detail(400, "长度超出数据库限制"))
# 判断金额是否超出限制
if int(request.POST.get('money')) > 9999999:
return JsonResponse(response_detail(400, "金额超出限制"))
# 加入到数据库
try:
field_time = datetime.strptime(request.POST['time'],
'%Y-%m-%d %H:%M:%S')
except ValueError:
return JsonResponse(
response_detail(400, '时间格式有误，应为 %Y-%m-%d %H:%M:%S'))
if request.POST.get('concrete_type'):
new_field = UserBills(user=request.user,
money=request.POST['money'],
type=bills_type,
time=field_time,
remarks=request.POST['remarks'],
concrete_type=request.POST['concrete_type'])
else:
new_field = UserBills(user=request.user,
money=request.POST['money'],
type=bills_type,
time=field_time,
remarks=request.POST['remarks'])
new_field.save()
# 如果用户有家庭，并且 is_add_to_family = 1， 就把该账单加入到家庭账单
print(request.user.family1)
if request.user.family1:
if int(request.POST.get('is_add_to_family')) == 1:
new_family_bill = FamilyBills(family_id=request.user.family1,
bills_id=new_field)
new_family_bill.save()
data = self.statistical_billing_data(request)
result = response_detail(200, data=data)
return JsonResponse(result)
def put(self, request):
"""
处理借钱请求，需要两个字段（是否同意【is_agree】 1代表不同意， 0代表同意, 借钱记录号【borrow_id】）
"""
need_fields = ('is_agree', 'borrow_id')
PUT = QueryDict(request.body)
put_data = PUT.dict()
for field in need_fields:
if not put_data.get(field):
return JsonResponse(response_detail(400, f"{field}缺失！"))
is_agree = int(put_data['is_agree'])
borrow_id = int(put_data['borrow_id'])
if is_agree not in (0, 1):
return JsonResponse(response_detail(400, "参数错误！"))
try:
borrow_field = BorrowMoneyTable.objects.filter(
id=borrow_id).first()
except:
return JsonResponse(response_detail(400, "记录不存在或过期！"))
if not borrow_field:
return JsonResponse(response_detail(400, '请求不存在'))
if borrow_field.status != 0:
return JsonResponse(response_detail(400, "已处理"))
if is_agree == 1:
send_message(request.user, borrow_field.borrower, "借款申请结果",
f"{request.user.username} 不同意您的借款申请", 1)
borrow_field.delete()
return JsonResponse(response_detail(200))
send_message(request.user, borrow_field.borrower, "借款申请结果",
f"{request.user.username} 同意了您的借款申请", 1)
bill_lender = UserBills(
user=request.user,
money=borrow_field.money,
type=10,
concrete_type="外借",
remarks=f"{borrow_field.date} 借给 {borrow_field.borrower.username},"
f" 还款日期： {borrow_field.repayment_date}")
bill_lender.save()
bill_borrower = UserBills(
user=borrow_field.borrower,
money=borrow_field.money,
type=0,
concrete_type="借款",
remarks=f"{borrow_field.date} 向 {borrow_field.lender.username} 借的。"
f"还款日期： {borrow_field.repayment_date}")
bill_borrower.save()
borrow_field.status = 1
borrow_field.save()
return JsonResponse(response_detail(200))
def post(self, request, *args, **kwargs):
need_fields = ('who', 'money', 'bill_id')
for field in need_fields:
if not request.POST.get(field):
return JsonResponse(response_detail(400, f"{field} 缺失！"))
who_id = int(request.POST.get('who'))
money = int(request.POST.get('money'))
bill_id = int(request.POST.get('bill_id'))
who = User.objects.filter(id=who_id).first()
if not who:
return JsonResponse(response_detail(400, "用户不存在！"))
if money <= 0:
return JsonResponse(response_detail(400, "还款金额不能小于等于0"))
# 校验通过后，首先删除或修改借还款数据表中的内容，添加双方账单，再给用户发消息
borrow_bill = BorrowMoneyTable.objects.filter(
borrower=request.user, lender=who,
id=bill_id).order_by('-money').first()
if not borrow_bill:
return JsonResponse(response_detail(400, "借款记录不存在"))
if borrow_bill.money < money:
return JsonResponse(response_detail(400, "金额超过欠账金额！"))
# TODO：一次性还清所有帐
borrow_bill.money -= money
if borrow_bill.money == 0:
borrow_bill.delete()
else:
borrow_bill.save()
bill_borrower = UserBills(user=request.user,
money=money,
type=10,
concrete_type="还款",
remarks=f"给{who.username} 还款！")
bill_borrower.save()
bill_lender = UserBills(user=who,
money=money,
type=0,
concrete_type="借款收回",
remarks=f"来自{request.user}的还款")
bill_lender.save()
send_message(request.user, who, "还钱啦", f"欠你的钱给你还了啊！金额：{money}元", 0)
return JsonResponse(response_detail(200))
def get(self, request, *args, **kwargs):
income_bill = UserBills.objects.filter(user=request.user, type=0)
bills = BillsSerializer(instance=income_bill, many=True)
return JsonResponse(response_detail(200, data=bills.data), safe=False)
def get(self, request, *args, **kwargs):
try:
data = self.statistical_billing_data(request)
except AssertionError:
return JsonResponse(response_detail(201))
return JsonResponse(response_detail(200, data=data))
