def get_prescriptions(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
pg = Group.objects.get(name="病人")
d = Group.objects.get(name="医生")
data = []
pres = None
if pg in user.groups.all():
if hasattr(user, "get_prescriptions"):
pres = user.get_prescriptions.all()
elif d in user.groups.all():
if hasattr(user, "created_prescriptions"):
pres = user.created_prescriptions.all()
if pres:
for pre in pres:
d = PrescriptionSerializer(pre).data
if hasattr(pre, "items"):
d["items"] = PrescriptionItemSerializer(pre.items,
many=True).data
data.append(d)
return Response(data=data, status=status.HTTP_200_OK)
def get_laboratories(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
pg = Group.objects.get(name="病人")
d = Group.objects.get(name="医生")
data = []
las = None
if pg in user.groups.all():
if hasattr(user, "laboratories"):
las = user.laboratories.all()
elif d in user.groups.all():
if hasattr(user, "created_laboratories"):
las = user.created_laboratories.all()
if las:
for la in las:
d = LaboratorySerializer(la).data
items = None
if hasattr(la, "items"):
items = LaboratoryItemSerializer(la.items, many=True).data
d["items"] = items
data.append(d)
return Response(data=data, status=status.HTTP_200_OK)
def get_refund_records(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
data = []
inss = None
if hasattr(user, "created_refund_records"):
inss = user.created_refund_records.all()
inss = filter_date(
inss,
start=request.data.get("start", None),
end=request.data.get("end", None),
format="%Y-%m-%d",
kind=1,
attr="create_time",
)
if inss:
for ins in inss:
data.append(
get_data_nested(
ins,
RefundRecordSerializer,
RefundRecordItemSerializer,
many=True,
))
return Response(data=data, status=status.HTTP_200_OK)
def get_pay_records(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
pg = Group.objects.get(name="病人")
data = []
prs = None
if pg in user.groups.all():
if hasattr(user, "paid_records"):
prs = user.paid_records.all().filter(
Q(receive__isnull=False) & Q(refund__isnull=False))
else:
if hasattr(user, "created_pay_records"):
prs = user.created_pay_records.all().filter(
Q(receive__isnull=False) & Q(refund__isnull=False))
if prs:
for pr in prs:
data.append(
get_data_nested(pr,
PayRecordSerializer,
PayItemSerializer,
many=True))
return Response(data=data, status=status.HTTP_200_OK)
def update(self, request, *args, **kwargs):
record = MedicalRecord.objects.all().filter(
id=self.kwargs.get("pk", 0))
if not record:
return return_not_find("病历不存在！")
record = record[0]
if not record.can_modify:
return return_param_error("此病历不可编辑！")
data = request.data
data["modifier"] = request.user.id
onset_date = request.data.get("onset_date", None)
if onset_date:
data["onset_date"] = datetime.datetime.strptime(
onset_date, "%Y-%m-%d").date()
# 弹出不可更改的字段
data.pop("id", None)
data.pop("time", None)
data.pop("create_time", None)
data.pop("modify_time", None)
data.pop("patient", None)
data.pop("department", None)
data.pop("creator", None)
ser = MedicalRecordSerializer(instance=record, data=data, partial=True)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
return return_success("修改成功！")
def get_reservations(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
ress = Reservation.objects.all()
pg = Group.objects.get(name="病人")
expert = Group.objects.get(name="专家医生")
# 如果请求都是病人
if pg in request.user.groups.all():
if user != request.user:
return return_forbiden()
ress = ress.filter(patient_id=user.id)
# 请求者是对应的专家医生
elif expert in request.user.groups.all():
ress = ress.filter(doctor_id=request.user.id)
# 并且请求都也不是管理员，无权限访问
elif not request.user.is_staff:
return return_forbiden()
ser = ReservationSerializer(ress, many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
def _checkIsOwnerOrAdminUser(self, user_set, request):
# 用户不存在
if not user_set:
return return_not_find("用户不存在！"), None
# 不是本人也不是管理员
user = user_set[0]
if user != request.user and not request.user.is_staff:
return return_forbiden(), None
return user, True
def get_group_users(self, request, pk=None):
if not pk:
return return_param_error()
group = Group.objects.filter(id=pk)
if not group:
return return_not_find("用户组不存在！")
group = group[0]
ser = UserSerializer(group.user_set.all(), many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs):
group = Group.objects.filter(id=self.kwargs.get("pk", 0))
if not group:
return return_not_find("用户组不存在！")
group = group[0]
profile = group.profile
if profile:
profile.delete()
group.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def list(self, request, *args, **kwargs):
name = request.query_params.get("name", None)
groups = Group.objects.all()
many = False
if name:
groups = groups.filter(name=name)
many = True
if not groups:
return return_not_find("没有相应的组！")
ser = GroupSerializer(groups, many=many)
return Response(data=ser.data, status=status.HTTP_200_OK)
def get_users(self, request, pk=None):
if not pk:
return return_param_error()
occ = Occupation.objects.all().filter(id=pk)
if not occ:
return return_not_find("职业不存在！")
occ = occ[0]
users = User.objects.all().filter(profile__occupation=occ)
ser = UserSerializer(users, many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
def retrieve(self, request, *args, **kwargs):
ins = AuditRecord.objects.all().filter(id=self.kwargs.get("pk", 0))
if not ins:
return return_not_find("审核记录不存在！")
ins = ins[0]
return Response(
get_data_nested(ins,
AuditRecordSerializer,
AuditItemSerializer,
many=True),
status=status.HTTP_200_OK,
)
def retrieve(self, request, *args, **kwargs):
record = RefundRecord.objects.all().filter(id=self.kwargs.get("pk", 0))
if not record:
return return_not_find()
record = record[0]
data = get_data_nested(
record,
RefundRecordSerializer,
RefundRecordItemSerializer,
many=True,
)
return Response(data=data, status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs):
user = User.objects.all().filter(id=self.kwargs.get("pk", ""))
if not user:
return return_not_find("用户不存在！")
user = user[0]
profile = user.profile
if profile:
profile.delete()
user.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def retrieve(self, request, *args, **kwargs):
pre = Prescription.objects.all().filter(id=self.kwargs.get("pk", 0))
if not pre:
return return_not_find("处方签不存在！")
pre = pre[0]
data = PrescriptionSerializer(pre).data
items = None
if hasattr(pre, "items"):
items = PrescriptionItemSerializer(pre.items, many=True).data
data["items"] = items
return Response(data=data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
# 验证是否传入patient和items
patient_id = request.data.pop("patient", None)
items = request.data.pop("items", None)
if not patient_id or not items:
return return_param_error()
# 验证此id是否存在
patient = User.objects.all().filter(id=patient_id)
if not patient:
return return_not_find("病人不存在！")
patient = patient[0]
# 验证此id对应用户是否为病人
p = Group.objects.get(name="病人")
if p not in patient.groups.all():
return return_param_error("此用户不是病人！")
# 创建处方签
data = {
"patient": patient_id,
"is_paid": 0,
"creator": request.user.id,
}
ser = PrescriptionSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
pre = ser.save()
for item in items:
item["prescription"] = pre.id
ser = PrescriptionItemSerializer(data=items, many=True)
if not ser.is_valid():
pre.delete()
print(ser.errors)
return return_param_error()
ser.save()
# 创建药单
data = {"creator": request.user.id, "prescription": pre.id}
ser = MedicineHandoutRecordSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
return return_success("创建成功！")
def get_reservations(self, request, pk=None):
if not pk:
return return_param_error()
group = Group.objects.filter(id=pk)
if not group:
return return_not_find("用户组不存在！")
group = group[0]
if not hasattr(group, "reservations"):
return Response(data=[], status=status.HTTP_200_OK)
ser = ReservationSerializer(group.reservations.all(), many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
def add_group_users(self, request, pk=None):
if not pk:
return return_param_error()
group = Group.objects.filter(id=pk)
if not group:
return return_not_find("用户组不存在！")
group = group[0]
user_id = request.data.get("user", None)
if not user_id:
return return_param_error()
user = User.objects.filter(id=user_id)
if not user:
return return_not_find("用户不存在！")
user = user[0]
if user in group.user_set.all():
return return_param_error("用户已在所添加的组内！")
group.user_set.add(user)
return return_success("添加成功！")
def retrieve(self, request, *args, **kwargs):
user = User.objects.all().filter(id=self.kwargs.get("pk", 0))
if not user:
return return_not_find("用户不存在！")
user = user[0]
# 如果请求者是病人，则不能查看别人的信息
g = Group.objects.get(name="病人")
if g in request.user.groups.all() and user != request.user:
return return_forbiden()
ser = UserSerializer(user)
return Response(ser.data, status=status.HTTP_200_OK)
def add_user_groups(self, request, pk=None):
if not pk:
return return_param_error()
if not request.user or not request.user.is_staff:
return return_forbiden()
user = User.objects.all().filter(id=pk)
if not user:
return return_not_find("用户不存在！")
group_id = request.data.get("group", None)
if not group_id:
return return_param_error()
group = Group.objects.all().filter(id=group_id)
if not group:
return return_not_find("用户组不存在！")
group = group[0]
user = user[0]
user.groups.add(group)
return return_success("添加成功！")
def get_user_groups(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.all().filter(id=pk)
if not user:
return return_not_find("用户不存在！")
ret, success = self._checkIsOwnerOrAdminUser(user, request)
if not success:
return ret
user = ret
groups = user.groups.all()
ser = GroupSerializer(groups, many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
def get_visit(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
expert = Group.objects.get(name="专家医生")
# 对应用户不是专家医生，就不存在坐诊时间
if expert not in user.groups.all():
return return_param_error()
ser = VisitSerializer(user.visits, many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
def retrieve(self, request, *args, **kwargs):
record = PayRecord.objects.all().filter(id=self.kwargs.get("pk", 0))
# record = record.filter(
# Q(receive__isnull=False) & Q(refund__isnull=False)
# )
if not record:
return return_not_find("缴费记录不存在！")
record = record[0]
data = get_data_nested(
record,
PayRecordSerializer,
PayItemSerializer,
"items",
"items",
True,
)
return Response(data=data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
data = request.data.pop("profile", None)
group_id = request.data.pop("group", None)
# 用户名重复
user = User.objects.all().filter(username=request.data.get("username"))
if user:
return return_param_error("用户已存在！")
# 用户组别，不传时默认为病人
group = Group.objects.all().filter(name="病人")
if group_id:
group = Group.objects.all().filter(id=group_id)
if not group:
return return_not_find("用户组不存在！")
group = group[0]
user_ser = UserSerializer(data=request.data)
if not user_ser.is_valid():
return return_param_error()
user = user_ser.save()
# 如果没有传profile则直接返回
if not data:
return return_create(UserSerializer(user).data)
# 创建对应profile
data["user"] = user.id
data["creator"] = (request.user.id
if not isinstance(request.user, AnonymousUser) else
user.id)
ser = UserProfileSerializer(data=data)
# 创建成功
if ser.is_valid():
ser.save()
gs = get_all_groups(group)
for g in gs:
user.groups.add(g)
return return_create(UserSerializer(user).data)
else:
# 如果profile创建失败，将原来已经添加的用户删除
user.delete()
return return_param_error()
def get_pay_records(self, request, pk=None):
if not pk:
return return_param_error()
ins = PayType.objects.all().filter(id=pk)
if not ins:
return return_not_find("缴费类型不存在！")
ins = ins[0]
data = []
if hasattr(ins, "records"):
records = ins.records.all().filter(
Q(receive__isnull=False) & Q(refund__isnull=False))
for rec in records:
data.append(
get_data_nested(rec,
PayRecordSerializer,
PayItemSerializer,
many=True))
return Response(data=data, status=status.HTTP_200_OK)
def update(self, request, *args, **kwargs):
ins = AuditRecord.objects.all().filter(id=self.kwargs.get("pk", 0))
if not ins:
return return_not_find("审核记录不存在！")
ins = ins[0]
data = {
"result": request.data.get("result", None),
"commet": request.data.get("commet", None),
}
if data["result"]:
data["result"] = 1
data["auditor"] = request.user.id
ser = AuditRecordSerializer(instance=ins, data=data, partial=True)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
return return_success("审核记录修改成功！")
def get_medical_records(self, request, pk=None):
if not pk:
return return_param_error()
user = User.objects.filter(id=pk)
if not user:
return return_not_find("用户不存在！")
user = user[0]
pg = Group.objects.get(name="病人")
d = Group.objects.get(name="医生")
data = []
if pg in user.groups.all():
if hasattr(user, "medical_records"):
data = MedicalRecordSerializer(user.medical_records,
many=True).data
elif d in user.groups.all():
if hasattr(user, "created_medical_records"):
data = MedicalRecordSerializer(user.created_medical_records,
many=True).data
return Response(data=data, status=status.HTTP_200_OK)
def update(self, request, *args, **kwargs):
record = PayRecord.objects.all().filter(id=self.kwargs.get("pk", 0))
if not record:
return return_not_find("缴费记录不存在！")
record = record[0]
receive = request.data.get("receive", None)
refund = request.data.get("refund", None)
method = request.data.get("method", None)
if not all((receive, method)):
return return_param_error()
data = {
"receive": receive,
"method": method,
"refund": refund if refund else 0,
}
ser = PayRecordSerializer(instance=record, data=data, partial=True)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
if hasattr(record, "reservation"):
record.reservation.is_paid = True
record.reservation.save()
if hasattr(record, "prescription"):
record.prescription.is_paid = True
record.prescription.save()
return Response(
data=get_data_nested(record,
PayRecordSerializer,
PayItemSerializer,
many=True),
status=status.HTTP_200_OK,
)
def update(self, request, *args, **kwargs):
profile_data = request.data.pop("profile", None)
group = Group.objects.filter(id=self.kwargs.get("pk"))
if not group:
return return_not_find("用户组不存在！")
group = group[0]
group_ser = GroupSerializer(instance=group,
data=request.data,
partial=True)
if not group_ser.is_valid():
return return_param_error()
profile = group.profile
# 更新profile
if profile_data and profile:
profile_data["modifier"] = request.user.id
profile_ser = GroupProfileSerializer(instance=profile,
data=profile_data,
partial=True)
if not profile_ser.is_valid():
return return_param_error()
profile_ser.save()
# 创建profile
elif not profile and profile_data:
profile_data["group"] = group.id
profile_data["creator"] = request.user.id
profile_ser = GroupProfileSerializer(data=profile_data)
if not profile_ser.is_valid():
return return_param_error()
profile_ser.save()
group_ser.save()
return Response(data=GroupSerializer(group).data,
status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
pay_type_id = request.data.get("type", None)
re_id = request.data.get("id", None)
if not all((pay_type_id, re_id)):
return return_param_error()
pay_type = PayType.objects.all().filter(id=pay_type_id)
if not pay_type:
return return_not_find("缴费类型不存在！")
pay_type = pay_type[0]
data = {}
# 默认为预约费用，此时的病人为请求者
data["patient"] = request.user.id
data["creator"] = request.user.id
data["pay_type"] = pay_type_id
# 更改patient
obj = None
if pay_type.name == "化验单费用":
obj = Laboratory.objects.all().filter(id=re_id)
elif pay_type.name == "处方签费用":
obj = Prescription.objects.all().filter(id=re_id)
else:
obj = User.objects.all().filter(id=re_id)
if not obj:
return return_param_error()
obj = obj[0]
if not isinstance(obj, User):
# 此单号已经缴费过了
if obj.pay:
return Response(
get_data_nested(
obj.pay,
PayRecordSerializer,
PayItemSerializer,
many=True,
))
data["patient"] = obj.patient_id
else:
pg = Group.objects.get(name="病人")
if pg not in obj.groups.all():
return return_param_error("此用户不是病人！")
data["patient"] = re_id
# 创建记录
ser = PayRecordSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
record = ser.save()
# 创建对应item
if isinstance(obj, User):
data = {
"record": record.id,
"name": pay_type.name,
"count": 1,
"price": pay_type.price,
}
ser = PayItemSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
return Response(
data=get_data_nested(record,
PayRecordSerializer,
PayItemSerializer,
many=True),
status=status.HTTP_201_CREATED,
)
else:
# 如果对应处方、化验单没有对应的条目（不允许这种情况出现）
if not hasattr(obj, "items"):
return return_param_error()
data = []
items = obj.items.all()
# 如果是化验单
if isinstance(obj, Laboratory):
for item in items:
d = {
"record": record.id,
"name": item.laboratory_type.name,
"count": 1,
"price": item.laboratory_type.price,
}
data.append(d)
# 如果是处方签
else:
for item in items:
d = {
"record": record.id,
"name": item.medicine.name,
"count": item.count,
"price": item.medicine.price * item.count,
}
data.append(d)
ser = PayItemSerializer(data=data, many=True)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
obj.pay = record
obj.save()
return Response(
data=get_data_nested(record,
PayRecordSerializer,
PayItemSerializer,
many=True),
status=status.HTTP_201_CREATED,
)
