|
|
#!/usr/bin/env python
|
|
|
# encoding: utf-8
|
|
|
"""
|
|
|
@author: tx
|
|
|
@file: report.py
|
|
|
@time: 2023/6/9 19:40
|
|
|
@desc:
|
|
|
"""
|
|
|
from datetime import datetime, timedelta
|
|
|
|
|
|
import pytz
|
|
|
from fastapi import Request
|
|
|
from fastapi.encoders import jsonable_encoder
|
|
|
from pypika.functions import Cast
|
|
|
from tortoise.expressions import RawSQL
|
|
|
from tortoise.queryset import QuerySet, Q, Count
|
|
|
from tortoise import Tortoise, fields, models
|
|
|
|
|
|
from conf import setting
|
|
|
from models.drug_use_log import DrugUseLog, DrugUseStateEnum
|
|
|
from models.drug import Drug, DrugStateEnum
|
|
|
from models.cabinet import Cabinet
|
|
|
from models.dictionary import Dictionary
|
|
|
from models.template import Template
|
|
|
from models.user import User
|
|
|
from models.archive import Archive
|
|
|
from models.log import EnvironmentLogs
|
|
|
from helper.drug import milligram_to_gram, gram_to_milliliter
|
|
|
from helper.tool import parse_datetime
|
|
|
from endpoints.warning import get_already_expired
|
|
|
|
|
|
|
|
|
async def query_logs(query, out_drug_ids, other_drug_ids, archive_id):
|
|
|
if archive_id:
|
|
|
query = query.filter(drug__template__archive__id=archive_id)
|
|
|
out_drug_logs = await query.prefetch_related('drug').filter(drug_id__in=out_drug_ids).filter(state=DrugUseStateEnum.TAKE).all().order_by(
|
|
|
'-created_at')
|
|
|
other_drug_logs = await query.prefetch_related('drug').filter(drug_id__in=other_drug_ids).filter(state=DrugUseStateEnum.TAKE).all().order_by(
|
|
|
'-created_at')
|
|
|
drug_use_logs = await query.filter(state=DrugUseStateEnum.EMPTY) \
|
|
|
.filter(drug__template__archive__params__contains={'first_will_empty': True}) \
|
|
|
.prefetch_related('drug')
|
|
|
drug_logs = out_drug_logs + other_drug_logs + drug_use_logs
|
|
|
count = len(drug_logs)
|
|
|
return count, drug_logs
|
|
|
|
|
|
|
|
|
async def parse_cabinet_ids():
|
|
|
cabinet_obj = await Cabinet.filter(terminal_id=setting.TERMINAL_ID).prefetch_related("archive").first()
|
|
|
cabinets_ids = await Cabinet.filter(archive_id=cabinet_obj.archive.id).values_list("id", flat=True)
|
|
|
return cabinets_ids
|
|
|
|
|
|
|
|
|
async def parse_archive_cabinet_ids(archive_id: str, client_ids: list):
|
|
|
"""
|
|
|
根据大类ID获取柜体
|
|
|
如果传递客户端ids参数，则返回用户有权限的大类柜体列表
|
|
|
:param archive_id:
|
|
|
:param client_ids: 用户有权限的柜体id，如果不传则代表全部柜体
|
|
|
:return:
|
|
|
"""
|
|
|
query = QuerySet(Cabinet).filter()
|
|
|
if archive_id:
|
|
|
query = query.filter(archive_id=archive_id)
|
|
|
if client_ids:
|
|
|
query = query.filter(id__in=client_ids)
|
|
|
# 用户有权限的柜体
|
|
|
cabinets_ids = await query.values_list("id", flat=True)
|
|
|
return cabinets_ids
|
|
|
|
|
|
|
|
|
async def report_drug_logs(request: Request, keyword):
|
|
|
"""
|
|
|
平台流转日志列表
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
offset = (page_no - 1) * page_size
|
|
|
query = QuerySet(DrugUseLog)
|
|
|
if setting.TERMINAL_ID:
|
|
|
query = query.filter(terminal_id=setting.TERMINAL_ID)
|
|
|
if keyword.user_id:
|
|
|
query = query.filter(user_id=keyword.user_id)
|
|
|
else:
|
|
|
user = await User.filter(id=request.state.current_user.id).get_or_none()
|
|
|
if user.role_id!=1 and user.role_id!=100:
|
|
|
query = query.filter(user_id=request.state.current_user.id)
|
|
|
if keyword.state in [0, 1, 2, 3, 4]:
|
|
|
query = query.filter(state=keyword.state)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
# if keyword.drug_id:
|
|
|
# query = query.filter(drug_id=keyword.drug_id)
|
|
|
|
|
|
count = await query.count()
|
|
|
if page_no:
|
|
|
logs = await query.prefetch_related('drug').limit(page_size).offset(offset).order_by('-created_at')
|
|
|
else:
|
|
|
logs = await query.prefetch_related('drug').order_by('-created_at')
|
|
|
|
|
|
attribute_key = await logs[0].drug.attribute_drug_info() if logs else {}
|
|
|
result = list()
|
|
|
for log in logs:
|
|
|
if not log.drug:
|
|
|
continue
|
|
|
if log.state in [1, 3]:
|
|
|
use_weight = log.use_weight
|
|
|
finally_use_weight = "" if not use_weight and log.state != DrugUseStateEnum.PUT else use_weight
|
|
|
else:
|
|
|
finally_use_weight = ''
|
|
|
# weight > 1000 转换为g 保留一位小数否则返回mg
|
|
|
weight = float(log.weight) if log.weight else 0
|
|
|
if weight > 1000:
|
|
|
weight_str = f"{milligram_to_gram(log.weight)}g"
|
|
|
else:
|
|
|
weight_str = f"{log.weight}mg" if log.weight is not None else "-"
|
|
|
finally_use_weight_str = log.parse_use_weight(finally_use_weight)
|
|
|
attribute_drug = await log.drug.attribute_drug_info()
|
|
|
result.append({
|
|
|
**jsonable_encoder(log),
|
|
|
"drug_info": attribute_drug,
|
|
|
"weight": weight_str,
|
|
|
"use_weight": finally_use_weight_str,
|
|
|
**attribute_drug,
|
|
|
"created_at": log.created_at.strftime("%Y-%m-%d %H:%M:%S"),
|
|
|
})
|
|
|
return dict(count=count, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_inventory_drug(request: Request, keyword):
|
|
|
"""
|
|
|
库存明细报表
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
drug_name = keyword.drug_name
|
|
|
dictionary_id = keyword.dictionary_id
|
|
|
rfid = keyword.rfid
|
|
|
spec = keyword.spec
|
|
|
cabinet_ids = keyword.cabinet_ids
|
|
|
purity = keyword.purity
|
|
|
batch_no = keyword.batch_no
|
|
|
manufacturer = keyword.manufacturer
|
|
|
position = keyword.position
|
|
|
report_ids = keyword.report_ids
|
|
|
|
|
|
offset = (page_no - 1) * page_size
|
|
|
|
|
|
query = QuerySet(Drug).filter()
|
|
|
order_key = "remain_gross_weight"
|
|
|
|
|
|
if rfid:
|
|
|
query = query.filter(rfid=rfid)
|
|
|
if position:
|
|
|
query = query.filter(position=position)
|
|
|
if batch_no:
|
|
|
query = query.filter(fill_json_content__contains={"ph": batch_no})
|
|
|
# if manufacturer:
|
|
|
# query = query.filter(Q(fill_json_content__contains={"manufacturer": manufacturer})
|
|
|
# | Q(fill_json_content__contains={"cs": manufacturer}))
|
|
|
|
|
|
archive_id = request.state.archive_id
|
|
|
if cabinet_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinet_ids)
|
|
|
else:
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
else:
|
|
|
# 根据终端筛选
|
|
|
if setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
|
|
|
if drug_name or spec or purity:
|
|
|
dict_query = QuerySet(Dictionary)
|
|
|
if drug_name:
|
|
|
dict_query = dict_query.filter(k1__contains=drug_name)
|
|
|
if spec:
|
|
|
dict_query = dict_query.filter(k2__contains=spec)
|
|
|
if purity:
|
|
|
dict_query = dict_query.filter(k3__contains=purity)
|
|
|
dictionary_ids = await dict_query.all().values_list("id", flat=True)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, data=[], attribute_key=[])
|
|
|
query = query.filter(dictionary_id__in=dictionary_ids)
|
|
|
order_key = "expired_at"
|
|
|
if dictionary_id:
|
|
|
query = query.filter(dictionary_id__in=[dictionary_id])
|
|
|
order_key = "expired_at"
|
|
|
|
|
|
query = query.filter(state__in=[DrugStateEnum.IN, DrugStateEnum.OUT])
|
|
|
|
|
|
if report_ids:
|
|
|
query = query.filter(id__in=report_ids)
|
|
|
count = 0
|
|
|
drug_objs = await query.order_by(order_key)
|
|
|
attribute_key = await drug_objs[0].attribute_drug_info() if drug_objs else {}
|
|
|
result = list()
|
|
|
archive_obj = await Archive.get_or_none(id=archive_id)
|
|
|
archive_name = archive_obj.name if archive_obj else ""
|
|
|
for drug_obj in drug_objs:
|
|
|
if manufacturer and ((drug_obj.attribute("cs") and drug_obj.attribute("cs") != manufacturer)
|
|
|
or (drug_obj.attribute("manufacturer") and drug_obj.attribute("manufacturer") != manufacturer)):
|
|
|
continue
|
|
|
attribute_drug = await drug_obj.attribute_drug_info()
|
|
|
data = {
|
|
|
"id": drug_obj.id,
|
|
|
"dictionary_id": drug_obj.dictionary_id,
|
|
|
"drug_info": attribute_drug,
|
|
|
"rfid": drug_obj.rfid,
|
|
|
"position": drug_obj.position,
|
|
|
"expired_at": drug_obj.expired_at.strftime("%Y-%m-%d") if drug_obj.expired_at else "",
|
|
|
"net_weight": drug_obj.attribute("net_weight"),
|
|
|
"remain_gross_weight": await drug_obj.format_weight(),
|
|
|
"state": drug_obj.state,
|
|
|
"last_user": await drug_obj.attribute_last_user(),
|
|
|
"cas_code": drug_obj.attribute("cas_code") if drug_obj.attribute("cas_code") else drug_obj.attribute("cas"),
|
|
|
"manufacturer": drug_obj.attribute("manufacturer") if drug_obj.attribute("manufacturer") else drug_obj.attribute("cs"),
|
|
|
"batch_no": drug_obj.attribute("ph"),
|
|
|
"storage_at": drug_obj.storage_at.strftime("%Y-%m-%d") if drug_obj.storage_at else "",
|
|
|
**attribute_drug
|
|
|
}
|
|
|
if archive_name == "耗材":
|
|
|
data.update({
|
|
|
"remain_count": int(drug_obj.attribute("total_count")) - drug_obj.total_use_weight if drug_obj.attribute("total_count") else "-",
|
|
|
"unit_code": drug_obj.attribute("unit_code"),
|
|
|
"manufacturer": drug_obj.attribute("cs") # 生产厂商
|
|
|
})
|
|
|
result.append(data)
|
|
|
count += 1
|
|
|
if page_no:
|
|
|
result = result[offset: offset + page_size]
|
|
|
return dict(count=count, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_put_in_detail_drug(request: Request, keyword):
|
|
|
"""
|
|
|
入库明细
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
dictionary_id = keyword.dictionary_id
|
|
|
drug_name = keyword.drug_name
|
|
|
rfid = keyword.rfid
|
|
|
spec = keyword.spec
|
|
|
purity = keyword.purity
|
|
|
batch_no = keyword.batch_no
|
|
|
manufacturer = keyword.manufacturer
|
|
|
position = keyword.position
|
|
|
report_ids = keyword.report_ids
|
|
|
|
|
|
query = QuerySet(DrugUseLog).filter()
|
|
|
if rfid:
|
|
|
query = query.filter(drug__rfid=rfid)
|
|
|
if position:
|
|
|
query = query.filter(drug__position=position)
|
|
|
if batch_no:
|
|
|
query = query.filter(drug__fill_json_content__contains={"ph": batch_no})
|
|
|
|
|
|
if keyword.user_id:
|
|
|
query = query.filter(user_id=keyword.user_id)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
|
|
|
archive_id = request.state.archive_id
|
|
|
archive_obj = await Archive.get_or_none(id=archive_id)
|
|
|
archive_name = archive_obj.name if archive_obj else ""
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
else:
|
|
|
# 根据终端筛选
|
|
|
if setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
|
|
|
if drug_name or spec or purity:
|
|
|
dict_query = QuerySet(Dictionary)
|
|
|
if drug_name:
|
|
|
dict_query = dict_query.filter(k1__contains=drug_name)
|
|
|
if spec:
|
|
|
dict_query = dict_query.filter(k2__contains=spec)
|
|
|
if purity:
|
|
|
dict_query = dict_query.filter(k3__contains=purity)
|
|
|
dictionary_ids = await dict_query.all().values_list("id", flat=True)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, data=[], attribute_key=[])
|
|
|
query = query.filter(drug__dictionary_id__in=dictionary_ids)
|
|
|
if dictionary_id:
|
|
|
query = query.filter(drug__dictionary_id__in=[dictionary_id])
|
|
|
|
|
|
if report_ids:
|
|
|
query = query.filter(id__in=report_ids)
|
|
|
|
|
|
result_drug_logs = await query.filter(state__in=[DrugUseStateEnum.IN]).prefetch_related('drug', "drug__storage").all()
|
|
|
|
|
|
result = list()
|
|
|
total_count = 0
|
|
|
offset = (page_no - 1) * page_size
|
|
|
attribute_key = await result_drug_logs[0].drug.attribute_drug_info() if result_drug_logs else {}
|
|
|
for use_log in result_drug_logs:
|
|
|
if not use_log.drug:
|
|
|
continue
|
|
|
if manufacturer and ((use_log.drug.attribute("cs") and use_log.drug.attribute("cs") != manufacturer)
|
|
|
or (use_log.drug.attribute("manufacturer") and use_log.drug.attribute("manufacturer") != manufacturer)):
|
|
|
continue
|
|
|
total_count += 1
|
|
|
drug_info = await use_log.drug.attribute_drug_info()
|
|
|
data = {
|
|
|
"id": use_log.id,
|
|
|
"drug_info": ",".join(list(map(lambda x: str(x), drug_info.values()))),
|
|
|
"expired_at": use_log.drug.expired_at.strftime("%Y-%m-%d %H:%M:%S") if use_log.drug.expired_at else '',
|
|
|
"dictionary_id": use_log.drug.dictionary_id,
|
|
|
"rfid": use_log.drug.rfid,
|
|
|
"net_weight": use_log.drug.attribute("net_weight"),
|
|
|
"remain_gross_weight": await use_log.drug.format_weight(),
|
|
|
"position": use_log.drug.position,
|
|
|
"cas_code": use_log.drug.attribute("cas_code") if use_log.drug.attribute("cas_code") else use_log.drug.attribute("cas"),
|
|
|
"manufacturer": use_log.drug.attribute("manufacturer") if use_log.drug.attribute("manufacturer") else use_log.drug.attribute("cs"),
|
|
|
"batch_no": use_log.drug.attribute("ph"),
|
|
|
"storage_user": use_log.drug.storage.name,
|
|
|
"storage_at": use_log.drug.storage_at.strftime("%Y-%m-%d") if use_log.drug.storage_at else "",
|
|
|
"state": use_log.drug.state,
|
|
|
"created_at": use_log.created_at.strftime("%Y-%m-%d %H:%M:%S"),
|
|
|
**drug_info,
|
|
|
}
|
|
|
if archive_name == "耗材":
|
|
|
data.update({
|
|
|
"use_weight": use_log.use_weight,
|
|
|
"unit_code": use_log.drug.attribute("unit_code"), # 单位编号
|
|
|
"manufacturer": use_log.drug.attribute("cs") # 生产厂商
|
|
|
})
|
|
|
result.append(data)
|
|
|
if page_no:
|
|
|
result = result[offset: offset + page_size]
|
|
|
return dict(count=total_count, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_take_out_detail_drug(request: Request, keyword):
|
|
|
"""
|
|
|
出库明细
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
dictionary_id = keyword.dictionary_id
|
|
|
drug_name = keyword.drug_name
|
|
|
rfid = keyword.rfid
|
|
|
spec = keyword.spec
|
|
|
purity = keyword.purity
|
|
|
batch_no = keyword.batch_no
|
|
|
manufacturer = keyword.manufacturer
|
|
|
position = keyword.position
|
|
|
report_ids = keyword.report_ids
|
|
|
|
|
|
query = QuerySet(DrugUseLog).filter()
|
|
|
|
|
|
if rfid:
|
|
|
query = query.filter(drug__rfid=rfid)
|
|
|
if position:
|
|
|
query = query.filter(drug__position=position)
|
|
|
if batch_no:
|
|
|
query = query.filter(drug__fill_json_content__contains={"ph": batch_no})
|
|
|
|
|
|
if keyword.user_id:
|
|
|
query = query.filter(user_id=keyword.user_id)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
|
|
|
archive_id = request.state.archive_id
|
|
|
archive_obj = await Archive.get_or_none(id=archive_id)
|
|
|
archive_name = archive_obj.name if archive_obj else ""
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
else:
|
|
|
# 根据终端筛选
|
|
|
if setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
|
|
|
if drug_name or spec or purity:
|
|
|
dict_query = QuerySet(Dictionary)
|
|
|
if drug_name:
|
|
|
dict_query = dict_query.filter(k1__contains=drug_name)
|
|
|
if spec:
|
|
|
dict_query = dict_query.filter(k2__contains=spec)
|
|
|
if purity:
|
|
|
dict_query = dict_query.filter(k3__contains=purity)
|
|
|
dictionary_ids = await dict_query.all().values_list("id", flat=True)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, data=[], attribute_key=[])
|
|
|
query = query.filter(drug__dictionary_id__in=dictionary_ids)
|
|
|
if dictionary_id:
|
|
|
query = query.filter(drug__dictionary_id__in=[dictionary_id])
|
|
|
|
|
|
if report_ids:
|
|
|
query = query.filter(id__in=report_ids)
|
|
|
|
|
|
result_drug_logs = await query.filter(state__in=[DrugUseStateEnum.TAKE]).prefetch_related('drug').all()
|
|
|
|
|
|
result = list()
|
|
|
total_count = 0
|
|
|
offset = (page_no - 1) * page_size
|
|
|
attribute_key = await result_drug_logs[0].drug.attribute_drug_info() if result_drug_logs else {}
|
|
|
for use_log in result_drug_logs:
|
|
|
if not use_log.drug:
|
|
|
continue
|
|
|
if manufacturer and ((use_log.drug.attribute("cs") and use_log.drug.attribute("cs") != manufacturer)
|
|
|
or (use_log.drug.attribute("manufacturer") and use_log.drug.attribute("manufacturer") != manufacturer)):
|
|
|
continue
|
|
|
total_count += 1
|
|
|
drug_info = await use_log.drug.attribute_drug_info()
|
|
|
data = {
|
|
|
"id": use_log.id,
|
|
|
"drug_info": ",".join(list(map(lambda x: str(x), drug_info.values()))),
|
|
|
"expired_at": use_log.drug.expired_at.strftime("%Y-%m-%d %H:%M:%S") if use_log.drug.expired_at else '',
|
|
|
"dictionary_id": use_log.drug.dictionary_id,
|
|
|
"rfid": use_log.drug.rfid,
|
|
|
"net_weight": use_log.drug.attribute("net_weight"),
|
|
|
"remain_gross_weight": await use_log.drug.format_weight(),
|
|
|
"position": use_log.drug.position,
|
|
|
"cas_code": use_log.drug.attribute("cas_code") if use_log.drug.attribute("cas_code") else use_log.drug.attribute("cas"),
|
|
|
"manufacturer": use_log.drug.attribute("manufacturer") if use_log.drug.attribute("manufacturer") else use_log.drug.attribute("cs"),
|
|
|
"batch_no": use_log.drug.attribute("ph"),
|
|
|
"receive_user": use_log.users,
|
|
|
"receive_position": use_log.position,
|
|
|
"receive_at": use_log.created_at.strftime("%Y-%m-%d %H:%M:%S"),
|
|
|
"peer_ids": use_log.peer_ids,
|
|
|
"created_at": use_log.created_at.strftime("%Y-%m-%d %H:%M:%S"),
|
|
|
**drug_info,
|
|
|
}
|
|
|
if archive_name == "耗材":
|
|
|
data.update({
|
|
|
"use_weight": use_log.use_weight,
|
|
|
"unit_code": use_log.drug.attribute("unit_code"), # 单位编号
|
|
|
"manufacturer": use_log.drug.attribute("cs") # 生产厂商
|
|
|
})
|
|
|
result.append(data)
|
|
|
if page_no:
|
|
|
result = result[offset: offset + page_size]
|
|
|
return dict(count=total_count, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_use_drug(request: Request, keyword):
|
|
|
"""
|
|
|
使用明细
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
dictionary_id = keyword.dictionary_id
|
|
|
drug_name = keyword.drug_name
|
|
|
rfid = keyword.rfid
|
|
|
spec = keyword.spec
|
|
|
purity = keyword.purity
|
|
|
batch_no = keyword.batch_no
|
|
|
manufacturer = keyword.manufacturer
|
|
|
position = keyword.position
|
|
|
report_ids = keyword.report_ids
|
|
|
|
|
|
query = QuerySet(DrugUseLog).filter()
|
|
|
|
|
|
if rfid:
|
|
|
query = query.filter(drug__rfid=rfid)
|
|
|
if position:
|
|
|
query = query.filter(drug__position=position)
|
|
|
if batch_no:
|
|
|
query = query.filter(drug__fill_json_content__contains={"ph": batch_no})
|
|
|
|
|
|
if keyword.user_id:
|
|
|
query = query.filter(user_id=keyword.user_id)
|
|
|
if keyword.state:
|
|
|
query = query.filter(state=keyword.state)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
|
|
|
archive_id = request.state.archive_id
|
|
|
archive_obj = await Archive.get_or_none(id=archive_id)
|
|
|
archive_name = archive_obj.name if archive_obj else ""
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
else:
|
|
|
# 根据终端筛选
|
|
|
if setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
|
|
|
if drug_name or spec or purity:
|
|
|
dict_query = QuerySet(Dictionary)
|
|
|
if drug_name:
|
|
|
dict_query = dict_query.filter(k1__contains=drug_name)
|
|
|
if spec:
|
|
|
dict_query = dict_query.filter(k2__contains=spec)
|
|
|
if purity:
|
|
|
dict_query = dict_query.filter(k3__contains=purity)
|
|
|
dictionary_ids = await dict_query.all().values_list("id", flat=True)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, total_use=0, data=[], attribute_key=[])
|
|
|
query = query.filter(drug__dictionary_id__in=dictionary_ids)
|
|
|
if dictionary_id:
|
|
|
query = query.filter(drug__dictionary_id__in=[dictionary_id])
|
|
|
if report_ids:
|
|
|
query = query.filter(id__in=report_ids)
|
|
|
|
|
|
# out_drug_query = QuerySet(Drug).filter(state=DrugStateEnum.OUT)
|
|
|
# other_drug_query = QuerySet(Drug).filter(~Q(state=DrugStateEnum.OUT))
|
|
|
#
|
|
|
# if keyword.dictionary_id or keyword.drug_name:
|
|
|
# if keyword.dictionary_id:
|
|
|
# dictionary_ids = [keyword.dictionary_id]
|
|
|
# else:
|
|
|
# dictionary_ids = await Dictionary.filter(k1__contains=keyword.drug_name).all().values_list("id", flat=True)
|
|
|
#
|
|
|
# out_drug_query = out_drug_query.filter(dictionary_id__in=dictionary_ids)
|
|
|
# other_drug_query = other_drug_query.filter(Q(dictionary_id__in=dictionary_ids))
|
|
|
#
|
|
|
# out_drug_ids = await out_drug_query.all().values_list('id', flat=True)
|
|
|
# other_drug_ids = await other_drug_query.all().values_list('id', flat=True)
|
|
|
# count, result_drug_logs = await query_logs(query, out_drug_ids, other_drug_ids, archive_id)
|
|
|
|
|
|
result_drug_logs = await query.filter(state__in=[DrugUseStateEnum.TAKE, DrugUseStateEnum.EMPTY]).prefetch_related('drug').all()
|
|
|
|
|
|
result = list()
|
|
|
total_count = 0
|
|
|
total_use = 0
|
|
|
offset = (page_no - 1) * page_size
|
|
|
attribute_key = await result_drug_logs[0].drug.attribute_drug_info() if result_drug_logs else {}
|
|
|
out_count = 0;
|
|
|
for use_log in result_drug_logs:
|
|
|
if not use_log.drug: # or use_log.state != 2
|
|
|
continue
|
|
|
if manufacturer and ((use_log.drug.attribute("cs") and use_log.drug.attribute("cs") != manufacturer)
|
|
|
or (use_log.drug.attribute("manufacturer") and use_log.drug.attribute("manufacturer") != manufacturer)):
|
|
|
continue
|
|
|
return_at, return_position, return_users, use_weight = None, None, None, None
|
|
|
total_count += 1
|
|
|
drug_info = await use_log.drug.attribute_drug_info()
|
|
|
finally_use_weight_str = '-'
|
|
|
if use_log.return_log_id:
|
|
|
drug_return_log = await DrugUseLog.get(id=use_log.return_log_id).prefetch_related("drug")
|
|
|
# drug = await Drug.get(id=use_log.drug.id)
|
|
|
use_weight = drug_return_log.use_weight # 用量计算错误
|
|
|
finally_use_weight = "" if not use_weight and drug_return_log.state != DrugUseStateEnum.PUT else use_weight
|
|
|
finally_use_weight_str = drug_return_log.parse_use_weight(finally_use_weight)
|
|
|
|
|
|
return_at = drug_return_log.created_at.strftime("%Y-%m-%d %H:%M:%S")
|
|
|
return_position = drug_return_log.position
|
|
|
return_users = drug_return_log.users
|
|
|
# total_use = total_use + use_weight
|
|
|
|
|
|
if use_log.drug.state == 3:
|
|
|
state = 3
|
|
|
else:
|
|
|
state = 1 if use_log.return_log_id else 2
|
|
|
data = {
|
|
|
"id": use_log.id,
|
|
|
"receive_users": use_log.users,
|
|
|
"receive_at": use_log.created_at.strftime("%Y-%m-%d %H:%M:%S"),
|
|
|
"receive_position": use_log.position,
|
|
|
"return_users": return_users,
|
|
|
"return_at": return_at,
|
|
|
"return_position": return_position,
|
|
|
"drug_info": ",".join(list(map(lambda x: str(x), drug_info.values()))),
|
|
|
"state": state,
|
|
|
"expired_at": use_log.drug.expired_at.strftime("%Y-%m-%d %H:%M:%S") if use_log.drug.expired_at else '',
|
|
|
"use_weight": finally_use_weight_str,
|
|
|
"dictionary_id": use_log.drug.dictionary_id,
|
|
|
"rfid": use_log.drug.rfid,
|
|
|
"net_weight": use_log.drug.attribute("net_weight"),
|
|
|
"cas_code": use_log.drug.attribute("cas_code") if use_log.drug.attribute("cas_code") else use_log.drug.attribute("cas"),
|
|
|
"manufacturer": use_log.drug.attribute("manufacturer") if use_log.drug.attribute("manufacturer") else use_log.drug.attribute("cs"),
|
|
|
"batch_no": use_log.drug.attribute("ph"),
|
|
|
**drug_info,
|
|
|
}
|
|
|
if archive_name == "耗材":
|
|
|
data.update({
|
|
|
"use_weight": use_log.use_weight,
|
|
|
"unit_code": use_log.drug.attribute("unit_code"), # 单位编号
|
|
|
"manufacturer": use_log.drug.attribute("cs") # 生产厂商
|
|
|
})
|
|
|
if use_log.return_log_id:
|
|
|
result.append(data)
|
|
|
else:
|
|
|
result.insert(out_count, data)
|
|
|
out_count+=1
|
|
|
if page_no:
|
|
|
result = result[offset: offset + page_size]
|
|
|
return dict(count=total_count, total_use=total_use, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_slack_drug(request: Request, keyword):
|
|
|
"""
|
|
|
呆滞物料
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.get("page_no")
|
|
|
page_size = keyword.get("page_size")
|
|
|
slack_day = keyword.get("slack_day", 30)
|
|
|
drug_name = keyword.get("drug_name")
|
|
|
|
|
|
offset = (page_no - 1) * page_size
|
|
|
|
|
|
threshold_time = (datetime.now() - timedelta(days=slack_day)).strftime("%Y-%m-%d")
|
|
|
dictionary_ids = list()
|
|
|
if drug_name:
|
|
|
dictionary_ids = await Dictionary.filter(k1=drug_name).values_list("id", flat=True)
|
|
|
|
|
|
query = QuerySet(Drug).filter(
|
|
|
Q(last_receive_at__lt=threshold_time) |
|
|
|
(Q(last_receive_at__isnull=True) & Q(storage_at__lt=threshold_time))
|
|
|
)
|
|
|
if dictionary_ids:
|
|
|
query = query.filter(dictionary_id__in=dictionary_ids)
|
|
|
|
|
|
archive_id = request.state.archive_id
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
# 根据终端筛选
|
|
|
elif setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
count = await query.count()
|
|
|
if page_no:
|
|
|
slack_drug_objs = await query.limit(page_size).offset(offset).order_by("-created_at")
|
|
|
else:
|
|
|
slack_drug_objs = await query.order_by("-created_at")
|
|
|
|
|
|
attribute_key = await slack_drug_objs[0].attribute_drug_info() if slack_drug_objs else {}
|
|
|
|
|
|
result = list()
|
|
|
now_time = datetime.now(pytz.timezone('Asia/Shanghai'))
|
|
|
for drug_obj in slack_drug_objs:
|
|
|
now_slack_days = (now_time - drug_obj.last_receive_at).days if drug_obj.last_receive_at else (
|
|
|
now_time - drug_obj.storage_at).days
|
|
|
last_use_at = drug_obj.last_return_at.strftime("%Y-%m-%d") if drug_obj.last_return_at else ''
|
|
|
attribute_drug = await drug_obj.attribute_drug_info()
|
|
|
data = {
|
|
|
"drug_id": drug_obj.id,
|
|
|
"rfid": drug_obj.rfid,
|
|
|
"hole": drug_obj.hole,
|
|
|
"cabinet_id": drug_obj.cabinet_id if drug_obj.cabinet_id else await drug_obj.attribute_cabinet_id(),
|
|
|
"drawer_id": drug_obj.drawer_id,
|
|
|
"board_id": drug_obj.board_id,
|
|
|
"position": drug_obj.position,
|
|
|
"expired_at": drug_obj.expired_at.strftime("%Y-%m-%d") if drug_obj.expired_at else '-',
|
|
|
"remain_gross_weight": await drug_obj.format_weight(),
|
|
|
"drug_info": attribute_drug,
|
|
|
"now_slack_days": now_slack_days, # 呆滞天数
|
|
|
"last_use_at": last_use_at, # 最后使用时间
|
|
|
"last_user": await drug_obj.attribute_last_user(), # 最后使用人
|
|
|
**attribute_drug,
|
|
|
}
|
|
|
result.append(data)
|
|
|
return dict(count=count, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_put_in_drug(request: Request, keyword):
|
|
|
"""
|
|
|
入库统计报表
|
|
|
查询所有入库流转记录，根据药剂字典表分组后统计数量
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
archive_id = request.state.archive_id
|
|
|
archive_obj = await Archive.get_or_none(id=archive_id)
|
|
|
archive_name = archive_obj.name if archive_obj else ""
|
|
|
if archive_name == "耗材":
|
|
|
# query = QuerySet(Drug).filter(state=DrugStateEnum.IN)
|
|
|
query = QuerySet(DrugUseLog).filter(state=DrugUseStateEnum.IN)
|
|
|
else:
|
|
|
query = QuerySet(DrugUseLog).filter(state=DrugUseStateEnum.IN)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
# if not keyword.stime and not keyword.etime:
|
|
|
# stime = datetime.now() - timedelta(days=365)
|
|
|
# etime = datetime.now() + timedelta(days=1)
|
|
|
# query = query.filter(created_at__gte=stime, created_at__lte=etime)
|
|
|
|
|
|
cabinets_ids = []
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
# 根据终端筛选
|
|
|
elif setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
|
|
|
if keyword.drug_name or keyword.spec or keyword.dictionary_id:
|
|
|
dictionary_ids = await get_dictionary_ids(keyword.drug_name, keyword.spec, keyword.dictionary_id)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, data=[], attribute_key=[])
|
|
|
query = query.filter(drug__dictionary__id__in=dictionary_ids)
|
|
|
if keyword.report_ids:
|
|
|
query = query.filter(drug__dictionary__id__in=keyword.report_ids)
|
|
|
if keyword.cas_code:
|
|
|
query = query.filter(Q(drug__fill_json_content__contains={"cas": keyword.cas_code})
|
|
|
| Q(drug__fill_json_content__contains={"cas_code": keyword.cas_code}))
|
|
|
|
|
|
query = query.annotate(count=Count(1))
|
|
|
if keyword.custom_num:
|
|
|
query = query.filter(count=keyword.custom_num)
|
|
|
|
|
|
query = query.group_by("drug__dictionary__id")
|
|
|
if page_no:
|
|
|
offset = (page_no - 1) * page_size
|
|
|
count = await query.values("drug__dictionary__id", "drug__template__id", "count")
|
|
|
count = len(count) if count else 0
|
|
|
data_list = await (query.limit(page_size).offset(offset)
|
|
|
.values("drug__dictionary__id", "drug__template__id","count"))
|
|
|
else:
|
|
|
data_list = await query.values("drug__dictionary__id", "drug__template__id", "count")
|
|
|
count = len(data_list) if data_list else 0
|
|
|
|
|
|
data = list()
|
|
|
attribute_key = {}
|
|
|
for i in data_list:
|
|
|
dictionary_obj = await Dictionary.get_or_none(id=i.get("drug__dictionary__id"))
|
|
|
if not dictionary_obj:
|
|
|
continue
|
|
|
template_obj = await Template.get(id=i.get("drug__template__id"))
|
|
|
drug_obj = await Drug.filter(dictionary=i.get("drug__dictionary__id")).first()
|
|
|
parse_fill_json_content = await drug_obj.parse_fill_json_content()
|
|
|
drug_info = await dictionary_obj.attribute_dictionary_info(template_obj)
|
|
|
print("drug_info", drug_info)
|
|
|
json_data = {}
|
|
|
for n in parse_fill_json_content:
|
|
|
json_data={
|
|
|
"name":drug_info.get("试剂名称") if archive_name != "耗材" else drug_info.get("耗材名称"),
|
|
|
"purity":drug_info.get("试剂纯度"),
|
|
|
"speci":drug_info.get("试剂规格"),
|
|
|
"count":i.get("count"),
|
|
|
"expired_at":drug_obj.expired_at,
|
|
|
"manufacturer":parse_fill_json_content['厂商'] if '厂商' in parse_fill_json_content else '',
|
|
|
"distribution ":parse_fill_json_content['经销单位'] if '经销单位' in parse_fill_json_content else '',
|
|
|
"storage_at":drug_obj.storage_at
|
|
|
}
|
|
|
|
|
|
data.append({
|
|
|
"parse_fill_json_content":json_data,
|
|
|
"drug_info": drug_info,
|
|
|
"cas_code": drug_obj.attribute("cas_code") if drug_obj.attribute("cas_code") else drug_obj.attribute("cas"),
|
|
|
"count": i.get("count"),
|
|
|
"dictionary_id": i.get("drug__dictionary__id"),
|
|
|
**drug_info
|
|
|
})
|
|
|
attribute_key = drug_info
|
|
|
return dict(count=count, data=data, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_take_out_drug(request: Request, keyword):
|
|
|
"""
|
|
|
出库信息汇总
|
|
|
查询所有出库流转记录，根据药剂字典表分组后统计数量
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
archive_id = request.state.archive_id
|
|
|
query = QuerySet(DrugUseLog).filter(state=DrugUseStateEnum.TAKE)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
|
|
|
cabinets_ids = []
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
# 根据终端筛选
|
|
|
elif setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
if cabinets_ids:
|
|
|
query = query.filter(cabinet_id__in=cabinets_ids)
|
|
|
|
|
|
if keyword.drug_name or keyword.spec or keyword.dictionary_id:
|
|
|
dictionary_ids = await get_dictionary_ids(keyword.drug_name, keyword.spec, keyword.dictionary_id)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, data=[], attribute_key=[])
|
|
|
query = query.filter(drug__dictionary__id__in=dictionary_ids)
|
|
|
if keyword.report_ids:
|
|
|
query = query.filter(drug__dictionary__id__in=keyword.report_ids)
|
|
|
if keyword.cas_code:
|
|
|
query = query.filter(Q(drug__fill_json_content__contains={"cas": keyword.cas_code})
|
|
|
| Q(drug__fill_json_content__contains={"cas_code": keyword.cas_code}))
|
|
|
|
|
|
query = query.annotate(count=Count(1))
|
|
|
if keyword.custom_num:
|
|
|
query = query.filter(count=keyword.custom_num)
|
|
|
|
|
|
query = query.group_by("drug__dictionary__id")
|
|
|
if page_no:
|
|
|
offset = (page_no - 1) * page_size
|
|
|
count = await query.values("drug__dictionary__id", "drug__template__id", "count")
|
|
|
count = len(count) if count else 0
|
|
|
data_list = await (query.limit(page_size).offset(offset)
|
|
|
.values("drug__dictionary__id", "drug__template__id","count"))
|
|
|
else:
|
|
|
data_list = await query.values("drug__dictionary__id", "drug__template__id", "count")
|
|
|
count = len(data_list) if data_list else 0
|
|
|
|
|
|
data = list()
|
|
|
attribute_key = {}
|
|
|
for i in data_list:
|
|
|
dictionary_obj = await Dictionary.get_or_none(id=i.get("drug__dictionary__id"))
|
|
|
if not dictionary_obj:
|
|
|
continue
|
|
|
template_obj = await Template.get(id=i.get("drug__template__id"))
|
|
|
drug_obj = await Drug.filter(dictionary=i.get("drug__dictionary__id")).first()
|
|
|
drug_info = await dictionary_obj.attribute_dictionary_info(template_obj)
|
|
|
|
|
|
data.append({
|
|
|
"drug_info": drug_info,
|
|
|
"cas_code": drug_obj.attribute("cas_code") if drug_obj.attribute("cas_code") else drug_obj.attribute("cas"),
|
|
|
"count": i.get("count"),
|
|
|
"dictionary_id": i.get("drug__dictionary__id"),
|
|
|
**drug_info
|
|
|
})
|
|
|
attribute_key = drug_info
|
|
|
return dict(count=count, data=data, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def get_dictionary_ids(drug_name: str | None, spec: str | None, dictionary_id: str | None):
|
|
|
dict_query = QuerySet(Dictionary).filter()
|
|
|
if drug_name or spec:
|
|
|
if drug_name:
|
|
|
dict_query = dict_query.filter(k1__icontains=drug_name)
|
|
|
if spec:
|
|
|
dict_query = dict_query.filter(k2=spec)
|
|
|
if dictionary_id:
|
|
|
dict_query = dict_query.filter(id=dictionary_id)
|
|
|
dictionary_ids = await dict_query.filter().all().values_list("id", flat=True)
|
|
|
return dictionary_ids
|
|
|
|
|
|
|
|
|
async def report_remain_drug(request: Request, keyword):
|
|
|
"""
|
|
|
库存信息汇总（原 库存量统计）
|
|
|
所有在库与出库药剂数量统计
|
|
|
排序，根据瓶数降序排列
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
|
|
|
archive_id = request.state.archive_id
|
|
|
cabinets_ids = list()
|
|
|
if keyword.cabinet_ids:
|
|
|
cabinets_ids = keyword.cabinet_ids
|
|
|
else:
|
|
|
if archive_id:
|
|
|
cabinets_ids = await parse_archive_cabinet_ids(archive_id, [])
|
|
|
# 根据终端筛选
|
|
|
elif setting.TERMINAL_ID:
|
|
|
cabinets_ids = await parse_cabinet_ids()
|
|
|
|
|
|
drug_query = QuerySet(Drug).filter(state__in=[DrugStateEnum.IN, DrugStateEnum.OUT])
|
|
|
if keyword.drug_name or keyword.spec or keyword.dictionary_id:
|
|
|
dictionary_ids = await get_dictionary_ids(keyword.drug_name, keyword.spec, keyword.dictionary_id)
|
|
|
if not dictionary_ids:
|
|
|
return dict(count=0, data=[], attribute_key=[])
|
|
|
drug_query = drug_query.filter(dictionary_id__in=dictionary_ids)
|
|
|
if keyword.report_ids:
|
|
|
drug_query = drug_query.filter(dictionary_id__in=keyword.report_ids)
|
|
|
if cabinets_ids:
|
|
|
drug_query = drug_query.filter(cabinet_id__in=cabinets_ids)
|
|
|
# if keyword.position:
|
|
|
# drug_query = drug_query.filter(position=keyword.position)
|
|
|
|
|
|
if keyword.cas_code:
|
|
|
drug_query = drug_query.filter(Q(fill_json_content__contains={"cas": keyword.cas_code})
|
|
|
| Q(fill_json_content__contains={"cas_code": keyword.cas_code}))
|
|
|
if keyword.custom_num:
|
|
|
drug_query = drug_query.filter(count=keyword.custom_num)
|
|
|
|
|
|
drug_counts = await drug_query.prefetch_related("dictionary").annotate(count=Count('id')).group_by(
|
|
|
'dictionary_id').order_by("-count").values(
|
|
|
"dictionary_id",
|
|
|
"count",
|
|
|
"template_id")
|
|
|
|
|
|
offset = (page_no - 1) * page_size
|
|
|
count = len(drug_counts)
|
|
|
if page_no:
|
|
|
drug_offset_counts = drug_counts[offset: offset + page_size]
|
|
|
else:
|
|
|
drug_offset_counts = drug_counts
|
|
|
|
|
|
data = list()
|
|
|
template_dict = {}
|
|
|
attribute_key = {}
|
|
|
for i in drug_offset_counts:
|
|
|
dictionary_id = i.get("dictionary_id")
|
|
|
dictionary_obj = await Dictionary.get(id=dictionary_id)
|
|
|
# 避免多次重复查询模板信息
|
|
|
template_id = i.get("template_id")
|
|
|
template_obj = template_dict.get(template_id)
|
|
|
if template_obj is None:
|
|
|
template_obj = await Template.get(id=template_id)
|
|
|
template_dict[template_id] = template_obj
|
|
|
|
|
|
drug_info = await dictionary_obj.attribute_dictionary_info(template_obj)
|
|
|
drug_objs = await Drug.filter(dictionary_id = dictionary_id).all()
|
|
|
drug_obj = drug_objs[0]
|
|
|
total_count = sum([int(drug_obj.attribute("total_count")) for drug_obj in drug_objs if drug_obj.attribute("total_count")])
|
|
|
use_count = sum([drug_obj.total_use_weight for drug_obj in drug_objs if drug_obj.total_use_weight])
|
|
|
remain_count = total_count - use_count
|
|
|
|
|
|
data.append({
|
|
|
"drug_info": drug_info,
|
|
|
"cas_code": drug_obj.attribute("cas_code") if drug_obj.attribute("cas_code") else drug_obj.attribute("cas"),
|
|
|
"count": i.get("count"),
|
|
|
"dictionary_id": str(i.get("dictionary_id")),
|
|
|
"remain_count": remain_count,
|
|
|
**drug_info
|
|
|
})
|
|
|
attribute_key = drug_info
|
|
|
return dict(count=count, data=data, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
|
|
|
async def report_dosage_drug(request: Request, keyword):
|
|
|
"""
|
|
|
药剂用量报表
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.page_no
|
|
|
page_size = keyword.page_size
|
|
|
|
|
|
query = QuerySet(Dictionary).filter()
|
|
|
# 字典按大类划分
|
|
|
archive_id = request.state.archive_id
|
|
|
if keyword.drug_name or keyword.spec:
|
|
|
if keyword.drug_name:
|
|
|
query = query.filter(k1__icontains=keyword.drug_name)
|
|
|
if keyword.spec:
|
|
|
query = query.filter(k2=keyword.spec)
|
|
|
elif keyword.dictionary_id:
|
|
|
query = query.filter(id=keyword.dictionary_id)
|
|
|
elif archive_id:
|
|
|
query = query.filter(archive_id=archive_id)
|
|
|
if keyword.report_ids:
|
|
|
query = query.filter(id__in=keyword.report_ids)
|
|
|
dictionary_objs = await query.all()
|
|
|
data = list()
|
|
|
|
|
|
info = ""
|
|
|
attribute_key = {}
|
|
|
|
|
|
query = QuerySet(DrugUseLog)
|
|
|
if keyword.stime:
|
|
|
query = query.filter(created_at__gte=f"{keyword.stime} 00:00:00")
|
|
|
if keyword.etime:
|
|
|
query = query.filter(created_at__lte=f"{keyword.etime} 23:59:59")
|
|
|
|
|
|
if keyword.cas_code:
|
|
|
query = query.filter(Q(drug__fill_json_content__contains={"cas": keyword.cas_code})
|
|
|
| Q(drug__fill_json_content__contains={"cas_code": keyword.cas_code}))
|
|
|
|
|
|
for dictionary_obj in dictionary_objs:
|
|
|
drug_use_log_objs = await query.filter(drug__dictionary=dictionary_obj).prefetch_related(
|
|
|
'drug')
|
|
|
use_num = sum([1 for i in drug_use_log_objs if i.use_weight])
|
|
|
total_use_weight = sum([i.use_weight for i in drug_use_log_objs if i.use_weight])
|
|
|
if not total_use_weight:
|
|
|
continue
|
|
|
if keyword.custom_num and keyword.custom_num != use_num:
|
|
|
continue
|
|
|
|
|
|
drug_info = {}
|
|
|
if drug_use_log_objs:
|
|
|
template_obj = await drug_use_log_objs[0].drug.template
|
|
|
|
|
|
drug_info = await dictionary_obj.attribute_dictionary_info(template_obj)
|
|
|
drug = await Drug.filter(dictionary_id=dictionary_obj.id).first()
|
|
|
|
|
|
if total_use_weight > 1000:
|
|
|
weight_str = f"{milligram_to_gram(total_use_weight)}g"
|
|
|
else:
|
|
|
weight_str = f"{total_use_weight}mg"
|
|
|
density = drug.attribute("density") # 密度
|
|
|
if density:
|
|
|
volume = gram_to_milliliter(milligram_to_gram(total_use_weight), density)
|
|
|
if not volume:
|
|
|
print(f"密度格式错误:{density}")
|
|
|
info += f"密度格式错误:{density} "
|
|
|
weight_str = f"{weight_str}"
|
|
|
else:
|
|
|
weight_str = f"{weight_str}({volume}ml)"
|
|
|
|
|
|
data.append({
|
|
|
"total_use_weight": weight_str,
|
|
|
"use_num": use_num,
|
|
|
"cas_code": drug.attribute("cas_code") if drug.attribute("cas_code") else drug.attribute("cas"),
|
|
|
"drug_info": drug_info,
|
|
|
"dictionary_id": dictionary_obj.id,
|
|
|
**drug_info
|
|
|
})
|
|
|
attribute_key = drug_info
|
|
|
offset = (page_no - 1) * page_size
|
|
|
count = len(data)
|
|
|
|
|
|
if page_no:
|
|
|
result = data[offset: offset + page_size]
|
|
|
else:
|
|
|
result = data
|
|
|
desc = "成功" if not info else info
|
|
|
|
|
|
return dict(desc=desc, count=count, data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
async def report_expire_drug(request: Request, keyword):
|
|
|
"""
|
|
|
药剂过期报表
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
# result = await get_already_expired(**{"drug_name": keyword.drug_name})
|
|
|
result = await get_already_expired()
|
|
|
attribute_key = {}
|
|
|
if result:
|
|
|
drug_id = result[0].get("drug_id")
|
|
|
drug_obj = await Drug.filter(id=drug_id).prefetch_related("dictionary", "template").first()
|
|
|
attribute_key = await drug_obj.dictionary.attribute_dictionary_info(drug_obj.template)
|
|
|
return dict(data=result, attribute_key=list(attribute_key.keys()))
|
|
|
|
|
|
async def report_cabinet_environmental(request: Request, keyword):
|
|
|
"""
|
|
|
环境温度记录
|
|
|
:param request:
|
|
|
:param keyword:
|
|
|
:return:
|
|
|
"""
|
|
|
page_no = keyword.get("page_no")
|
|
|
page_size = keyword.get("page_size")
|
|
|
cabinet_id = keyword.get("cabinet_id")
|
|
|
stime = keyword.get("stime")
|
|
|
etime = keyword.get("etime")
|
|
|
|
|
|
offset = (page_no - 1) * page_size
|
|
|
query = QuerySet(EnvironmentLogs).filter()
|
|
|
if setting.TERMINAL_ID:
|
|
|
query = query.filter(cabinet__terminal=setting.TERMINAL_ID)
|
|
|
# 都为空则不显示
|
|
|
query = query.filter(
|
|
|
Q(left_temperature__isnull=False) | Q(right_temperature__isnull=False) | Q(voc__isnull=False) | Q(
|
|
|
humidity__isnull=False))
|
|
|
if cabinet_id:
|
|
|
query = query.filter(cabinet_id=cabinet_id)
|
|
|
if stime:
|
|
|
query = query.filter(created_at__gte=f"{stime} 00:00:00")
|
|
|
if etime:
|
|
|
query = query.filter(created_at__lte=f"{etime} 23:59:59")
|
|
|
if not stime and not etime:
|
|
|
stime = datetime.now() - timedelta(days=30)
|
|
|
etime = datetime.now()
|
|
|
query = query.filter(created_at__gte=stime, created_at__lte=etime)
|
|
|
count = await query.count()
|
|
|
if page_no:
|
|
|
en_log_objs = await query.prefetch_related("cabinet").limit(page_size).offset(offset).order_by("-created_at")
|
|
|
else:
|
|
|
en_log_objs = await query.prefetch_related("cabinet").order_by("-created_at")
|
|
|
|
|
|
result = list()
|
|
|
for en_log_obj in en_log_objs:
|
|
|
a = [en_log_obj.left_temperature, en_log_obj.right_temperature]
|
|
|
true_values = [str(item) for item in a if item]
|
|
|
temperature = ','.join(true_values) if len(true_values) == 2 else (true_values[0] if len(true_values) == 1 else "-")
|
|
|
result.append({
|
|
|
**jsonable_encoder(en_log_obj),
|
|
|
"cabinet_label": en_log_obj.cabinet.label,
|
|
|
"temperature": temperature,
|
|
|
"created_at": en_log_obj.created_at.strftime("%Y-%m-%d %H:%M:%S"),
|
|
|
})
|
|
|
return dict(desc="成功", count=count, data=result, attribute_key=[])
|
