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 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_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 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_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 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_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 update(self, request, *args, **kwargs):
ins = PayType.objects.all().filter(id=self.kwargs.get("pk", 0))
if not ins:
return return_param_error("缴费类型不存在！")
ins = ins[0]
data = request.data
data.pop("creator", None)
data.pop("creator", None)
data["modifier"] = request.user.id
ser = PayTypeSerializer(instance=ins, data=data, partial=True)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
return return_success("修改成功！")
def create(self, request, *args, **kwargs):
data = {"applicant": request.user.id}
ser = AuditRecordSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ins = ser.save()
items = request.data
for item in items:
item["audit"] = ins.id
ser = AuditItemSerializer(data=items, many=True)
if not ser.is_valid():
ins.delete()
print(ser.errors)
return return_param_error()
ser.save()
return return_success("审核记录创建成功！")
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 update(self, request, *args, **kwargs):
user = User.objects.all().filter(id=self.kwargs.get("pk", ""))
ret, success = self._checkIsOwnerOrAdminUser(user, request)
if not success:
return ret
profile = ret.profile
profile_data = request.data.pop("profile", None)
data = request.data
data["username"] = ret.username
user_ser = UserSerializer(instance=ret,
data=request.data,
partial=True)
if not user_ser.is_valid():
return return_param_error()
# 更新profile
if profile_data and profile:
profile_data["modifier"] = request.user.id
ser = UserProfileSerializer(instance=profile,
data=profile_data,
partial=True)
# 请求数据出错
if not ser.is_valid():
return return_param_error()
ser.save()
# 创建profile
elif not profile and profile_data:
profile_data["user"] = ret.id
profile_data["creator"] = request.user.id
ser = UserProfileSerializer(data=profile_data)
# 请求数据出错
if not ser.is_valid():
return return_param_error()
ser.save()
user_ser.save()
return Response(data=UserSerializer(user).data,
status=status.HTTP_200_OK)
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 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 create(self, request, *args, **kwargs):
profile_data = request.data.pop("profile", None)
ser = GroupSerializer(data=request.data)
if not ser.is_valid():
return return_param_error()
group = ser.save()
# 没有profile直接返回
if not profile_data:
return return_create(ser.data)
profile_data["creator"] = request.user.id
profile_data["group"] = group.id
ser = GroupProfileSerializer(data=profile_data)
if not ser.is_valid():
group.delete()
return return_param_error()
ser.save()
return return_create(GroupSerializer(group).data)
def create(self, request, *args, **kwargs):
data = request.data
onset_date = data.get("onset_date", None)
patient_id = data.get("patient", None)
department_id = data.get("department", None)
if not all((onset_date, patient_id, department_id)):
return return_param_error()
data["onset_date"] = datetime.datetime.strptime(
onset_date, "%Y-%m-%d").date()
patient = User.objects.all().filter(id=patient_id)
department = Group.objects.all().filter(id=department_id)
if not patient or not department:
print("xxx")
return return_param_error()
patient = patient[0]
department = department[0]
pg = Group.objects.get(name="病人")
dg = Group.objects.get(name="科室")
if pg not in patient.groups.all() or dg not in get_all_groups(
department):
print("x")
return return_param_error()
data["time"] = datetime.datetime.now()
data["can_modify"] = 1
data["creator"] = request.user.id
ser = MedicalRecordSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ser.save()
return Response(data=ser.data, status=status.HTTP_201_CREATED)
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 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 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 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 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 create(self, request, *args, **kwargs):
request.data["creator"] = request.user.id
ser = RefundRecordSerializer(data=request.data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ins = ser.save()
items = request.data.get("items", None)
if not items:
return return_param_error()
for item in items:
item["record"] = ins.id
ser = RefundRecordItemSerializer(data=items, many=True)
if not ser.is_valid():
ins.delete()
print(ser.errors)
return return_param_error()
ser.save()
return return_success("退款记录创建成功！")
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 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 create(self, request, *args, **kwargs):
data = request.data
patient_id = data.get("patient", None)
reservation_id = data.get("reservation", None)
department_id = data.get("department", None)
pay_id = data.get("pay", None)
doctor_id = data.get("doctor", None)
wait_queues = self.get_wait_queues()
# 如果传入了预约，进行预约检查
if reservation_id:
reservation = Reservation.objects.all().filter(id=reservation_id)
if not reservation:
return return_param_error("预约不存在！")
reservation = reservation[0]
if reservation.is_cancel:
return return_param_error("该预约已取消！")
if reservation.date < datetime.datetime.today().date():
return return_param_error("该预约已过期！")
elif reservation.date > datetime.datetime.today().date():
return return_param_error("该预约时间不是今天！")
if reservation.time.end <= datetime.datetime.now().time():
return return_param_error("该预约已过期！")
if reservation.is_finish:
return return_param_error("该预约已经使用过，无效！")
if not reservation.is_paid or not reservation.pay:
return return_param_error("该预约还未缴费！")
data = {
"patient": reservation.patient.id,
"doctor":
reservation.doctor.id if reservation.doctor else None,
"department": reservation.department.id,
"pay": reservation.pay.id,
"reservation": reservation.id,
}
ser = WaitQueueSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
ins = ser.save()
if self._add_into_queue(ins, wait_queues):
# 更新
ins.reservation.is_finish = 1
ins.reservation.save()
return return_success("成功加入到排队队列中！")
else:
return return_param_error("已经在排队中，不能重复添加！")
# 不是预约，现场挂号病人排队
# 进行各项参数检查
if not all((patient_id, department_id, pay_id)):
return return_param_error()
patient = User.objects.all().filter(id=patient_id)
if not patient:
return return_param_error("病人不存在！")
patient = patient[0]
pg = Group.objects.get(name="病人")
if pg not in patient.groups.all():
return return_param_error("此用户不是病人！")
department = Group.objects.all().filter(id=department_id)
if not department:
return return_param_error("科室不存在！")
department = department[0]
dg = Group.objects.get(name="科室")
if dg not in get_all_groups(department):
return return_param_error("组不是科室！")
pay = PayRecord.objects.all().filter(id=pay_id)
if not pay:
return return_param_error("缴费记录不存在！")
pay = pay[0]
if pay.patient.id != patient.id:
return return_param_error("病人与缴费记录不对应！")
data = {
"patient": patient_id,
"department": department_id,
"pay": pay_id,
}
# 专家号再检查专家id
if doctor_id:
doctor = User.objects.all().filter(id=doctor_id)
if not doctor:
return return_param_error("医生不存在！")
doctor = doctor[0]
edg = Group.objects.get(name="专家医生")
if edg not in doctor.groups.all():
return return_param_error("用户不是专家医生！")
data["doctor"] = doctor_id
ser = WaitQueueSerializer(data=data)
if not ser.is_valid():
print(ser.errors)
return return_param_error()
if self._add_into_queue(ser.save(), wait_queues):
return return_success("成功加入到排队队列中！")
else:
return return_param_error("已经在排队中，不能重复添加！")
def list(self, request, *args, **kwargs):
pg = Group.objects.get(name="病人")
edg = Group.objects.get(name="专家医生")
ndg = Group.objects.get(name="医生")
dg = Group.objects.get(name="科室")
doctor_id = request.query_params.get("doctor", None)
department_id = request.query_params.get("department", None)
top = request.query_params.get("top", None)
if top and top != 1 and top != "1":
return return_param_error("top只能指定1！")
if all((doctor_id, department_id)):
return return_param_error("医生与科室不能同时指定！")
if top and not doctor_id and not department_id:
return return_param_error("指定top时必须指定doctor或department！")
data = {}
wait_queues = self.get_wait_queues()
if doctor_id:
doctor = User.objects.all().filter(id=doctor_id)
if not doctor:
return return_param_error("医生不存在！")
doctor = doctor[0]
if edg not in doctor.groups.all():
return return_param_error("必须指定专家医生！")
data["doctor"] = {doctor_id: []}
if doctor_id in wait_queues["doctor"].keys():
for p in wait_queues["doctor"][doctor_id]:
if top:
data = UserSerializer(p.patient).data
p.delete()
break
data["doctor"][doctor_id].append(
UserSerializer(p.patient).data)
if department_id:
department = Group.objects.all().filter(id=department_id)
if not department:
return return_param_error("科室不存在！")
department = department[0]
if dg not in get_all_groups(department):
return return_param_error("必须指定科室！")
department_id = int(department_id)
data["department"] = {department_id: []}
if department_id in wait_queues["department"].keys():
for p in wait_queues["department"][department_id]:
if top:
data = UserSerializer(p.patient).data
p.delete()
break
data["department"][department_id].append(
UserSerializer(p.patient).data)
# 两者都未指定时，返回全部排队信息
if not doctor_id and not department_id:
data = {"doctor": {}, "department": {}}
doctor = {}
department = {}
for key in wait_queues["doctor"]:
doctor[key] = []
for d in wait_queues["doctor"][key]:
doctor[key].append(UserSerializer(d.patient).data)
for key in wait_queues["department"]:
department[key] = []
for d in wait_queues["department"][key]:
department[key].append(UserSerializer(d.patient).data)
data["doctor"] = doctor
data["department"] = department
return Response(data=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,
)
