Compare commits

..
Author SHA1 Message Date
zlwuandCursor 8349b0ce73 fix(web-admin): 隐藏生产/质检中试服务 Tab 并从「所有」排除 (#160)
客户已下线中试业务:侧栏不再展示中试 Tab,前端在「所有」列表过滤出库中试数据(含 bizType 缺省)。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 14:48:58 +08:00
cykj 85fe63fa9f fix(web-admin): 下线市场侧栏中试服务菜单 (#158)
fix(web-admin): 下线市场侧栏中试服务菜单 (#158)

Merge pull request #159
2026-11-20 06:35:05 +00:00
zlwuandCursor 77cdeede15 fix(web-admin): 下线市场侧栏中试服务菜单
超管在 frontend 模式下走静态路由全量展示,仅解绑 sys_role_menu 无效;同步移除 sqxp/STATIC_MENU_TREE 并软删对应 sys_menu。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 14:33:31 +08:00
cykj 4dc352e4f4 fix(sql): 解除市场中试服务菜单与角色绑定 (#156)
fix(sql): 解除市场中试服务菜单与角色绑定 (#156)

Merge pull request #157
2026-11-20 06:26:18 +00:00
zlwuandCursor c5f26912bd fix(sql): 解除市场中试服务菜单与角色绑定
软删市场→中试服务目录及其全部子菜单/按钮在 sys_role_menu 上的有效授权,菜单本身保留,避免误伤其他业务线下的同名菜单。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 14:24:39 +08:00
cykj 5ec997228d Merge pull request 'feat(qc): 修改记录同次提交合并节点并附件化展示 (#153)' (#154) from codex/issue-153-chg-group-fc14c4ae0ee7 into V2.0
continuous-integration/drone/tag Build is passing
feat(qc): 修改记录同次提交合并节点并附件化展示 (#153)\n\nMerge pull request #154
2026-11-20 05:25:22 +00:00
zlwu fb4bceb6b0 merge(V2.0): 同步集成分支后再合入 #153 2026-11-20 13:24:46 +08:00
zlwuandCursor cc17ac2425 feat(qc): 修改记录同次提交合并节点并附件化展示
批量保存写入 operateBatchId;弹窗按批次合并时间线,检测材料复用附件只读组件。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 13:23:26 +08:00
zlwuandCursor 70ebd4eff7 feat(web-admin): 市场侧栏新增器械销售菜单与施工中占位页
在市场模块末位注册器械销售目录及三类/二类医疗器械、化妆品子路由,同步后端静态菜单与 SQL 迁移写入 sys_menu 并向已有市场权限角色授权;子页面暂用统一施工中占位。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 13:17:02 +08:00
cykj 4d4856d4c2 Merge pull request 'fix(qc): 修改记录图标、空列表与弹窗尺寸 (#151)' (#152) from codex/issue-151-qc-hist-icon-7be0e4fa7247 into V2.0
fix(qc): 修改记录图标、空列表与弹窗尺寸 (#151)

Merge pull request #152
2026-11-20 03:57:14 +00:00
zlwuandCursor fb67f3dbd7 fix(web-admin): 放大质检修改记录弹窗宽高
验收反馈:弹窗过小;宽度 560→800,正文区 min-height 480 并限制可滚动高度。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 11:55:26 +08:00
zlwuandCursor 38bad4232a fix(qc): 修改记录批量查询避免路由误匹配并空列表返回
/qc-tasks/result-change-logs 须先于 /qc-tasks/{task_id} 注册;
无留痕时返回 [],不再因路径被当成任务 ID 报「任务不存在」。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 11:53:13 +08:00
zlwuandCursor e396b1a6eb fix(web-admin): 质检任务卡片修改记录改为右上角图标
验收反馈 #151:去掉底部文字按钮,改用 Clock 图标固定在卡片右上角。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 11:51:20 +08:00
cykj 7640052c96 Merge pull request 'feat(qc): 检测结果默认已完成/通过并记录修改历史 (#148/#149)' (#150) from codex/issue-148-qc-result-hist-dd33d3d3b407 into V2.0
feat(qc): 检测结果默认已完成/通过并记录修改历史 (#148/#149)

Closes related delivery for #148 #149 via PR.
2026-11-20 03:41:06 +00:00
zlwuandCursor 99583b38ce fix(qc): 任务软删级联清理检测结果留痕
删除质检任务/工单时同步软删修改记录,避免批量查询仍返回已删任务历史;
实验室填写结论回显优先沿用列表行结论。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 11:39:41 +08:00
zlwuandCursor 9b6228860f feat(qc): 检测结果默认已完成/通过并记录修改历史
填写弹窗未落结论时默认任务状态已完成、结论通过(实验室与第三方);
每次保存追加操作留痕,卡片可查看修改时间线。关联 #148 #149。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-20 11:34:18 +08:00
cykj 8d7b2ada59 Merge pull request 'feat(web-admin): 采集协议详情样本卡展示作废原因问号 (#146)' (#147) from codex/issue-146-protocol-view-sample-status-84884352219b into V2.0
详情样本卡头 SampleStatusTag;界面验收留给用户。
2026-11-19 07:39:06 +00:00
zlwuandCursor 332711ad36 feat(web-admin): 采集协议详情样本卡展示作废原因问号
详情样本卡头复用 SampleStatusTag,已作废时展示作废原因。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-19 15:38:18 +08:00
cykj 03acf5115a Merge pull request 'fix(protocol): 列表 sampleItems 返回样本作废原因 (#144)' (#145) from codex/issue-144-audit-sample-void-desc-7e739b6f7441 into V2.0
协议审核列表展示样本 voidDesc;单元测试 3 ok;构建验收留给用户。
2026-11-19 07:32:01 +00:00
zlwuandCursor 12cf373a49 fix(protocol): 列表 sampleItems 返回样本作废原因
协议审核/捐赠列表与样本信息列表此前未带回样本 voidDesc,导致已作废问号显示暂无作废原因。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-19 15:31:26 +08:00
cykj 0434999603 Merge pull request 'fix(qc): 样本接收废弃时将备注写入作废原因 (#142)' (#143) from codex/issue-142-reception-void-desc-315d12855585 into V2.0
接收废弃同步 void_desc;单元测试 8 ok;构建验收留给用户。
2026-11-19 07:19:01 +00:00
zlwuandCursor f40d33b07a fix(qc): 样本接收废弃时将备注写入作废原因
接收结论为废弃时同步样本 yzf,并把接收备注写入 void_desc,改回接收时一并清空。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-19 15:17:29 +08:00
cykj e5f84b4693 feat(sample): 样本废弃弹窗展示实验室入库编码 (#140) (#141)
feat(sample): 样本废弃弹窗展示实验室入库编码 (#140)
2026-11-19 07:05:41 +00:00
zlwuandCursor 71424ff576 feat(sample): 样本废弃弹窗展示实验室入库编码
在样本编码前展示实验室入库编码;生产/质检工单打开弹窗时传入该字段(#140)。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-19 15:04:51 +08:00
cykj fbe62c7a9b fix(market): 催缴/运费/实验室处理列表返回样本状态 (#138) (#139)
fix(market): 催缴/运费/实验室处理列表返回样本状态 (#138)
2026-11-19 07:00:48 +00:00
zlwuandCursor 034a4da1ad fix(market): 催缴/运费/实验室处理列表返回样本状态
Web 三处列表 CRUD 补齐 sampleStatus/voidDesc,与缴费信息修复同类缺口(#138)。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-19 14:59:56 +08:00
cykj dbc4a24543 fix(payment): 缴费信息列表返回样本状态与作废原因 (#136) (#137)
fix(payment): 缴费信息列表返回样本状态与作废原因 (#136)
2026-11-19 06:52:16 +00:00
50 changed files with 2254 additions and 155 deletions

No files matched your search

+50 -32
View File
@@ -7,7 +7,7 @@ from app.core.response import success_response
router = APIRouter(prefix="/web/menu", tags=["菜单管理"])
# 与 web-admin/src/router/modules/sqxp.ts 一致:6 个一级菜单分组
# 市场二级顺序:存储服务、科研捐赠、市场基础信息、中试服务、基础实验
# 市场二级顺序:存储服务、科研捐赠、市场基础信息、基础实验、器械销售
STATIC_MENU_TREE = [
{
"id": "TOP00000000000000000000000000006",
@@ -298,36 +298,6 @@ STATIC_MENU_TREE = [
],
},
# 中试服务
{
"id": "PIL00000000000000000000000000001",
"name": "PilotService",
"path": "pilot-service",
"component": "",
"meta": {
"title": "中试服务",
"icon": "ri:flask-line",
"keepAlive": False,
"roles": ["admin"],
},
"children": [
{
"id": "80000000000000000000000000000010",
"name": "PilotApplication",
"path": "pilot-application",
"component": "/pilot-service/pilot-application/index",
"meta": {"title": "中试服务申请单", "keepAlive": True, "menuCode": "pilot-service:pilot-application:list"},
},
{
"id": "PIL00000000000000000000000000004",
"name": "PilotOutboundRelease",
"path": "outbound-release-review",
"component": "/pilot-service/outbound-release-review/index",
"meta": {"title": "出库放行审核", "keepAlive": True, "menuCode": "pilot-service:outbound-release-review:list"},
},
],
},
# 基础实验
{
"id": "BEX00000000000000000000000000001",
@@ -375,7 +345,55 @@ STATIC_MENU_TREE = [
},
},
],
}
},
# 器械销售(市场侧栏末位)
{
"id": "DEV00000000000000000000000000001",
"name": "DeviceSales",
"path": "device-sales",
"component": "",
"meta": {
"title": "器械销售",
"icon": "ri:shopping-bag-3-line",
"keepAlive": False,
"roles": ["admin"],
},
"children": [
{
"id": "DEV00000000000000000000000000002",
"name": "DeviceSalesClassIii",
"path": "class-iii",
"component": "/device-sales/under-construction/index",
"meta": {
"title": "三类医疗器械",
"keepAlive": False,
"menuCode": "device-sales:class-iii:list",
},
},
{
"id": "DEV00000000000000000000000000003",
"name": "DeviceSalesClassIi",
"path": "class-ii",
"component": "/device-sales/under-construction/index",
"meta": {
"title": "二类医疗器械",
"keepAlive": False,
"menuCode": "device-sales:class-ii:list",
},
},
{
"id": "DEV00000000000000000000000000004",
"name": "DeviceSalesCosmetics",
"path": "cosmetics",
"component": "/device-sales/under-construction/index",
"meta": {
"title": "化妆品产品",
"keepAlive": False,
"menuCode": "device-sales:cosmetics:list",
},
},
],
},
],
},
+57
View File
@@ -29,6 +29,7 @@ from app.crud import qc_lab_test_item as lab_svc
from app.crud import qc_inspection_item_template as iit_svc
from app.crud import qc_item_param as param_svc
from app.crud import qc_task_result as result_svc
from app.crud import qc_task_result_change_log as result_change_log_svc
from app.crud import qc_task as task_svc
from app.crud import qc_third_party_company as tpc_svc
from app.crud import qc_third_party_item as tpi_svc
@@ -448,6 +449,7 @@ class TaskCompleteWithResultBody(BaseModel):
third_party_attachments: Optional[str] = Field(None, alias="thirdPartyAttachments")
material_usages: Optional[List[Dict[str, Any]]] = Field(None, alias="materialUsages")
task_status: Optional[str] = Field(None, alias="taskStatus")
operate_batch_id: Optional[str] = Field(None, alias="operateBatchId")
@router.get("/qc-lab-test-items")
@@ -1234,6 +1236,29 @@ async def list_qc_tasks(
return error_response(400, str(e))
@router.get("/qc-tasks/result-change-logs")
async def list_qc_task_result_change_logs_batch(
taskIds: str = Query("", description="逗号分隔的任务ID"),
db: Session = Depends(get_db),
user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
"""批量查询检测结果修改记录。须注册在 /qc-tasks/{task_id} 之前,避免被当成任务 ID。"""
try:
tenant_no = _get_tenant_no(db, user)
ids = [x.strip() for x in (taskIds or "").split(",") if x.strip()]
if not ids:
return success_response([])
return success_response(
result_change_log_svc.list_task_result_change_logs_by_task_ids(
db, task_ids=ids, tenant_no=tenant_no
)
)
except PermissionError as e:
return error_response(403, str(e))
except Exception as e:
return error_response(400, str(e))
@router.get("/qc-tasks/{task_id}")
async def get_qc_task_detail(
task_id: str,
@@ -1349,6 +1374,26 @@ async def get_task_material_usages(
return error_response(400, str(e))
@router.get("/qc-tasks/{task_id}/result-change-logs")
async def list_qc_task_result_change_logs(
task_id: str,
db: Session = Depends(get_db),
user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
try:
tenant_no = _get_tenant_no(db, user)
# 无任务或无留痕均返回空列表,避免前端把“暂无记录”当成错误
return success_response(
result_change_log_svc.list_task_result_change_logs(
db, task_id=task_id, tenant_no=tenant_no
)
)
except PermissionError as e:
return error_response(403, str(e))
except Exception as e:
return error_response(400, str(e))
@router.post("/qc-tasks/{task_id}/complete-with-result")
async def complete_task_with_result(
task_id: str,
@@ -1364,6 +1409,7 @@ async def complete_task_with_result(
if not t:
return error_response(404, "任务不存在")
was_done = (t.task_status or "").strip() == "ywc"
before = result_change_log_svc.snapshot_task_result_state(db, t, tenant_no)
if body.results:
result_svc.save_results_for_task(
db, task_id, body.results, tenant_no, user_id, commit=False,
@@ -1384,6 +1430,17 @@ async def complete_task_with_result(
task_status=body.task_status,
commit=False,
)
after = result_change_log_svc.snapshot_task_result_state(db, obj, tenant_no)
result_change_log_svc.append_task_result_change_log(
db,
task=obj,
tenant_no=tenant_no,
user_id=user_id,
operator_user_name=str(user.get("nickName") or user.get("nick_name") or ""),
before=before,
after=after,
operate_batch_id=body.operate_batch_id,
)
db.commit()
db.refresh(obj)
if (obj.task_status or "").strip() == "ywc":
+1
View File
@@ -1394,6 +1394,7 @@ def list_collection_protocols(
"sampleTypeName": type_name,
"sampleCode": code,
"sampleStatus": (s.sample_status or "").strip(),
"voidDesc": (getattr(s, "void_desc", None) or "").strip(),
"labStorageCode": lab_code_map.get(code, "") if code else "",
"transport": transport_dict,
"freight": freight_by_sample.get(s.id),
+6
View File
@@ -269,10 +269,13 @@ def _build_cell_system(
clear_flag = checked
break
sample_status = str(getattr(sample, "sample_status", None) or "").strip()
base: Dict[str, Any] = {
"receptionId": rec.id,
"sampleCode": (rec.sample_code or sample.sample_code or "").strip(),
"labStorageCode": (rec.lab_storage_code or "").strip(),
"sampleStatus": sample_status,
"voidDesc": str(getattr(sample, "void_desc", None) or "").strip(),
"motherName": (party.mother_name if party else "") or "",
"collectionTime": ledger.format_cn_datetime(coll.sample_collect_time if coll else None),
"collectionTimeRaw": _fmt_raw(coll.sample_collect_time if coll else None),
@@ -353,10 +356,13 @@ def _build_donation_system(
qc_process: Dict[str, str],
) -> Dict[str, Any]:
prod = prod or {}
sample_status = str(getattr(sample, "sample_status", None) or "").strip()
base: Dict[str, Any] = {
"receptionId": rec.id,
"sampleCode": (rec.sample_code or sample.sample_code or "").strip(),
"labStorageCode": (rec.lab_storage_code or "").strip(),
"sampleStatus": sample_status,
"voidDesc": str(getattr(sample, "void_desc", None) or "").strip(),
"motherName": (party.mother_name if party else "") or "",
"receptionTime": ledger.format_cn_datetime(rec.reception_time),
"receptionTimeRaw": _fmt_raw(rec.reception_time),
@@ -410,7 +410,8 @@ def list_protocol_sample_collections(
item["newbornDeliveryTime"] = _fmt_dt(party.newborn_delivery_time) if party else ""
item["protocolRemark"] = (proto.remark or "") if proto else ""
item["voidType"] = (proto.void_type or "") if proto else ""
item["voidDesc"] = (proto.void_desc or "") if proto else ""
# 样本状态问号展示样本作废原因,不用协议作废描述
item["voidDesc"] = (getattr(psample, "void_desc", None) or "").strip()
item["protocolAttachments"] = (proto.protocol_attachments or "") if proto else ""
item["consentFormUrls"] = (proto.consent_form_urls or "") if proto else ""
item["healthSurveyFormUrls"] = (proto.health_survey_form_urls or "") if proto else ""
+40 -1
View File
@@ -2245,6 +2245,40 @@ def list_payment_chase_page(
for u in db.query(SysUser.id, SysUser.nick_name).filter(SysUser.id.in_(sales_ids)).all():
sales_name_map[u.id] = u.nick_name or ""
sample_codes = list(
{
(sp.sample_code or sch.sample_code or "").strip()
for sch, sp, _, _, _ in candidates
if (sp.sample_code or sch.sample_code or "").strip()
}
)
sample_status_by_code: Dict[str, Dict[str, str]] = {}
if sample_codes:
s_rows = (
db.query(BizProtocolSample)
.filter(
BizProtocolSample.tenant_no == tenant_no,
BizProtocolSample.del_flag == 0,
BizProtocolSample.sample_code.in_(sample_codes),
)
.order_by(
BizProtocolSample.update_time.desc(),
BizProtocolSample.create_time.desc(),
BizProtocolSample.id.desc(),
)
.all()
)
for sample in s_rows:
code = str(sample.sample_code or "").strip()
if not code or code in sample_status_by_code:
continue
status = str(sample.sample_status or "").strip()
sample_status_by_code[code] = {
"sampleStatus": status,
"sampleStatusLabel": _SAMPLE_STATUS_LABELS.get(status, ""),
"voidDesc": str(getattr(sample, "void_desc", None) or "").strip(),
}
ct = (chase_type or "").strip()
rows: List[Dict[str, Any]] = []
for sch, sp, proto, party, ci in candidates:
@@ -2274,6 +2308,8 @@ def list_payment_chase_page(
continue
days_overdue = (today_d - due_d).days if overdue else 0
days_until = (due_d - today_d).days if not overdue else 0
sample_code = sp.sample_code or sch.sample_code or ""
sample_state = sample_status_by_code.get(str(sample_code).strip(), {})
rows.append(
{
"scheduleId": sch.id,
@@ -2282,7 +2318,10 @@ def list_payment_chase_page(
"protocolNo": (proto.protocol_no if proto else "") or "",
"motherName": (party.mother_name if party else "") or "",
"motherPhone": (party.mother_phone if party else "") or "",
"sampleCode": sp.sample_code or sch.sample_code or "",
"sampleCode": sample_code,
"sampleStatus": sample_state.get("sampleStatus", ""),
"sampleStatusLabel": sample_state.get("sampleStatusLabel", ""),
"voidDesc": sample_state.get("voidDesc", ""),
"salesUserId": (ci.sales_user_id if ci else "") or "",
"salesUserName": sales_name_map.get(
(ci.sales_user_id if ci else "") or "", ""
+13
View File
@@ -1095,6 +1095,7 @@ def delete_qc_task(db: Session, task_id: str, tenant_no: str, user_id: Optional[
# 软删除任务结果
from app.models.qc_param import BizQcTaskResult
from app.models.models import BizQcTaskResultChangeLog
results = db.query(BizQcTaskResult).filter(
and_(BizQcTaskResult.task_id == task_id, BizQcTaskResult.del_flag == 0)
@@ -1104,6 +1105,18 @@ def delete_qc_task(db: Session, task_id: str, tenant_no: str, user_id: Optional[
r.update_by = user_id
r.update_time = now
change_logs = db.query(BizQcTaskResultChangeLog).filter(
and_(
BizQcTaskResultChangeLog.task_id == task_id,
BizQcTaskResultChangeLog.tenant_no == tenant_no,
BizQcTaskResultChangeLog.del_flag == 0,
)
).all()
for log in change_logs:
log.del_flag = 1
log.update_by = user_id
log.update_time = now
# 同步软删批次明细行(配置弹窗勾选来源)
_soft_delete_source_line_for_task(
db, task, tenant_no=tenant_no, user_id=user_id, now=now
@@ -0,0 +1,254 @@
"""质检任务检测结果操作留痕"""
from __future__ import annotations
import json
from datetime import datetime
from typing import Any, Dict, List, Optional
from sqlalchemy.orm import Session
from app.core.utils import generate_uuid
from app.models.models import BizQcTask, BizQcTaskResultChangeLog, SysUser
from app.models.qc_param import BizQcTaskResult
_TASK_STATUS_LABELS = {"dzx": "待执行", "jxz": "进行中", "ywc": "已完成"}
_CONCLUSION_LABELS = {"": "待结论", "tg": "通过", "btg": "不通过"}
def _fmt_dt(v: Optional[datetime]) -> str:
if not v:
return ""
return v.strftime("%Y-%m-%d %H:%M:%S")
def _display_status(code: Optional[str]) -> str:
c = (code or "").strip()
return _TASK_STATUS_LABELS.get(c, c or "—")
def _display_conclusion(code: Optional[str]) -> str:
c = (code or "").strip()
return _CONCLUSION_LABELS.get(c, c or "待结论")
def _norm_text(v: Any) -> str:
if v is None:
return ""
return str(v).strip()
def _param_key(param_id: Optional[str], param_code: Optional[str], param_name: Optional[str]) -> str:
pid = _norm_text(param_id)
if pid:
return f"paramId:{pid}"
code = _norm_text(param_code)
if code:
return f"paramCode:{code}"
return f"paramName:{_norm_text(param_name)}"
def snapshot_task_result_state(db: Session, task: BizQcTask, tenant_no: str) -> Dict[str, Any]:
"""保存前快照:任务结论字段 + 已存参数值。"""
rows = (
db.query(BizQcTaskResult)
.filter(
BizQcTaskResult.task_id == task.id,
BizQcTaskResult.tenant_no == tenant_no,
BizQcTaskResult.del_flag == 0,
)
.order_by(BizQcTaskResult.create_time.asc())
.all()
)
params: Dict[str, Dict[str, str]] = {}
for r in rows:
key = _param_key(r.param_id, r.param_code, r.param_name)
params[key] = {
"label": _norm_text(r.param_name) or key,
"value": _norm_text(r.param_value),
}
return {
"taskStatus": _norm_text(task.task_status),
"conclusion": _norm_text(task.conclusion),
"remark": _norm_text(task.remark),
"attachments": _norm_text(task.third_party_attachments),
"params": params,
}
def build_result_changes(
before: Dict[str, Any],
after: Dict[str, Any],
) -> List[Dict[str, str]]:
changes: List[Dict[str, str]] = []
def add(field_key: str, label: str, old_v: str, new_v: str) -> None:
if old_v == new_v:
return
changes.append(
{
"fieldKey": field_key,
"fieldLabel": label,
"oldValue": old_v,
"newValue": new_v,
}
)
add(
"taskStatus",
"任务状态",
_display_status(before.get("taskStatus")),
_display_status(after.get("taskStatus")),
)
add(
"conclusion",
"结论",
_display_conclusion(before.get("conclusion")),
_display_conclusion(after.get("conclusion")),
)
add("remark", "备注", _norm_text(before.get("remark")), _norm_text(after.get("remark")))
add(
"attachments",
"检测材料",
_norm_text(before.get("attachments")),
_norm_text(after.get("attachments")),
)
before_params: Dict[str, Dict[str, str]] = before.get("params") or {}
after_params: Dict[str, Dict[str, str]] = after.get("params") or {}
keys = sorted(set(before_params.keys()) | set(after_params.keys()))
for key in keys:
b = before_params.get(key) or {"label": key, "value": ""}
a = after_params.get(key) or {"label": b.get("label") or key, "value": ""}
label = _norm_text(a.get("label")) or _norm_text(b.get("label")) or key
add(key, label, _norm_text(b.get("value")), _norm_text(a.get("value")))
return changes
def _resolve_operator_name(db: Session, user_id: Optional[str], fallback: str = "") -> str:
uid = _norm_text(user_id)
if not uid:
return _norm_text(fallback)
row = db.query(SysUser.nick_name).filter(SysUser.id == uid).first()
if row and row[0]:
return str(row[0]).strip()
return _norm_text(fallback) or uid
def append_task_result_change_log(
db: Session,
*,
task: BizQcTask,
tenant_no: str,
user_id: Optional[str],
operator_user_name: str = "",
before: Dict[str, Any],
after: Dict[str, Any],
operate_time: Optional[datetime] = None,
operate_batch_id: Optional[str] = None,
) -> BizQcTaskResultChangeLog:
"""追加一条检测结果保存留痕(不 commit)。无字段差异也写入。"""
now = operate_time or datetime.now()
changes = build_result_changes(before, after)
has_change = "1" if changes else "0"
name = _resolve_operator_name(db, user_id, operator_user_name)
batch_id = _norm_text(operate_batch_id) or None
obj = BizQcTaskResultChangeLog(
id=generate_uuid(),
task_id=task.id,
work_order_id=_norm_text(task.work_order_id) or None,
sample_code=_norm_text(task.sample_code) or None,
item_name=_norm_text(task.item_name) or None,
operate_time=now,
operator_user_id=user_id,
operator_user_name=name or None,
operate_batch_id=batch_id,
has_field_change=has_change,
changes_json=json.dumps(changes, ensure_ascii=False),
tenant_no=tenant_no,
order_num=0,
remark=None,
create_by=user_id,
create_dept_id="",
create_time=now,
update_by=user_id,
update_time=now,
del_flag=0,
)
db.add(obj)
return obj
def _row_to_dict(row: BizQcTaskResultChangeLog) -> Dict[str, Any]:
changes: List[Dict[str, Any]] = []
raw = row.changes_json or ""
if raw.strip():
try:
parsed = json.loads(raw)
if isinstance(parsed, list):
changes = parsed
except json.JSONDecodeError:
changes = []
return {
"id": row.id,
"taskId": row.task_id,
"workOrderId": row.work_order_id or "",
"sampleCode": row.sample_code or "",
"itemName": row.item_name or "",
"operateTime": _fmt_dt(row.operate_time),
"operatorUserId": row.operator_user_id or "",
"operatorUserName": row.operator_user_name or "",
"operateBatchId": row.operate_batch_id or "",
"hasFieldChange": row.has_field_change == "1",
"changes": changes,
"createTime": _fmt_dt(row.create_time),
}
def list_task_result_change_logs(
db: Session,
*,
task_id: str,
tenant_no: str,
) -> List[Dict[str, Any]]:
tid = _norm_text(task_id)
if not tid:
return []
rows = (
db.query(BizQcTaskResultChangeLog)
.filter(
BizQcTaskResultChangeLog.task_id == tid,
BizQcTaskResultChangeLog.tenant_no == tenant_no,
BizQcTaskResultChangeLog.del_flag == 0,
)
.order_by(
BizQcTaskResultChangeLog.operate_time.desc(),
BizQcTaskResultChangeLog.create_time.desc(),
)
.all()
)
return [_row_to_dict(r) for r in rows]
def list_task_result_change_logs_by_task_ids(
db: Session,
*,
task_ids: List[str],
tenant_no: str,
) -> List[Dict[str, Any]]:
ids = [_norm_text(x) for x in task_ids if _norm_text(x)]
if not ids:
return []
rows = (
db.query(BizQcTaskResultChangeLog)
.filter(
BizQcTaskResultChangeLog.task_id.in_(ids),
BizQcTaskResultChangeLog.tenant_no == tenant_no,
BizQcTaskResultChangeLog.del_flag == 0,
)
.order_by(
BizQcTaskResultChangeLog.operate_time.desc(),
BizQcTaskResultChangeLog.create_time.desc(),
)
.all()
)
return [_row_to_dict(r) for r in rows]
+23
View File
@@ -2753,6 +2753,16 @@ def _soft_delete_tasks_by_source_line_ids(
{"del_flag": 1, "update_time": now},
synchronize_session="fetch",
)
from app.models.models import BizQcTaskResultChangeLog
db.query(BizQcTaskResultChangeLog).filter(
BizQcTaskResultChangeLog.task_id.in_(task_ids),
BizQcTaskResultChangeLog.tenant_no == tenant_no,
BizQcTaskResultChangeLog.del_flag == 0,
).update(
{"del_flag": 1, "update_time": now},
synchronize_session="fetch",
)
for t in tasks:
t.del_flag = 1
t.update_time = now
@@ -3884,6 +3894,8 @@ def delete_qc_work_order(db: Session, work_order_id: str, tenant_no: str, user_i
).all()
from app.models.qc_param import BizQcTaskResult
from app.models.models import BizQcTaskResultChangeLog
for task in tasks:
results = db.query(BizQcTaskResult).filter(
and_(BizQcTaskResult.task_id == task.id, BizQcTaskResult.del_flag == 0)
@@ -3892,6 +3904,17 @@ def delete_qc_work_order(db: Session, work_order_id: str, tenant_no: str, user_i
r.del_flag = 1
r.update_by = user_id
r.update_time = now
change_logs = db.query(BizQcTaskResultChangeLog).filter(
and_(
BizQcTaskResultChangeLog.task_id == task.id,
BizQcTaskResultChangeLog.tenant_no == tenant_no,
BizQcTaskResultChangeLog.del_flag == 0,
)
).all()
for log in change_logs:
log.del_flag = 1
log.update_by = user_id
log.update_time = now
task.del_flag = 1
task.update_by = user_id
task.update_time = now
+1
View File
@@ -976,6 +976,7 @@ def list_donations(
"sampleTypeName": type_name,
"sampleCode": code,
"sampleStatus": (s.sample_status or "").strip(),
"voidDesc": (getattr(s, "void_desc", None) or "").strip(),
"labStorageCode": lab_code_map.get(code, "") if code else "",
"transport": transport_dict,
"freight": freight_by_sample.get(s.id),
+29 -2
View File
@@ -194,6 +194,14 @@ def _item_to_dict(item: BizSampleFreightItem) -> Dict[str, Any]:
}
_SAMPLE_STATUS_LABELS = {
"ycj": "已采集",
"jcz": "检测中",
"yrk": "已入库",
"yzf": "已作废",
}
def _item_to_dict_enriched(
item: BizSampleFreightItem,
*,
@@ -201,12 +209,19 @@ def _item_to_dict_enriched(
sample_type_name: str = "",
mother_name: str = "",
newborn_name: str = "",
sample_status: str = "",
void_desc: str = "",
) -> Dict[str, Any]:
data = _item_to_dict(item)
data["protocolNo"] = protocol_no or ""
data["sampleTypeName"] = sample_type_name or ""
data["motherName"] = mother_name or ""
data["newbornName"] = newborn_name or ""
status = str(sample_status or "").strip()
if str(item.sample_code or "").strip():
data["sampleStatus"] = status
data["sampleStatusLabel"] = _SAMPLE_STATUS_LABELS.get(status, "")
data["voidDesc"] = str(void_desc or "").strip()
return data
@@ -257,6 +272,8 @@ def _enrich_items_maps(
BizCellSampleType.type_name,
BizProtocolPartyCustomer.mother_name,
BizProtocolPartyCustomer.newborn_name,
BizProtocolSample.sample_status,
BizProtocolSample.void_desc,
)
.outerjoin(
BizCollectionProtocol,
@@ -287,12 +304,14 @@ def _enrich_items_maps(
)
.all()
)
for sid, pno, tname, mname, nname in rows:
for sid, pno, tname, mname, nname, status, void_desc in rows:
out[f"{SAMPLE_SOURCE_CELL}|{sid}"] = {
"protocolNo": pno or "",
"sampleTypeName": tname or "",
"motherName": mname or "",
"newbornName": nname or "",
"sampleStatus": str(status or "").strip(),
"voidDesc": str(void_desc or "").strip(),
}
if donation_ids:
@@ -303,6 +322,8 @@ def _enrich_items_maps(
BizCellSampleType.type_name,
BizResearchDonationParty.mother_name,
BizResearchDonationParty.newborn_name,
BizResearchDonationSample.sample_status,
BizResearchDonationSample.void_desc,
)
.outerjoin(
BizResearchDonation,
@@ -334,12 +355,14 @@ def _enrich_items_maps(
)
.all()
)
for sid, dno, tname, mname, nname in rows:
for sid, dno, tname, mname, nname, status, void_desc in rows:
out[f"{SAMPLE_SOURCE_DONATION}|{sid}"] = {
"protocolNo": dno or "",
"sampleTypeName": tname or "",
"motherName": mname or "",
"newbornName": nname or "",
"sampleStatus": str(status or "").strip(),
"voidDesc": str(void_desc or "").strip(),
}
return out
@@ -541,6 +564,8 @@ def list_freights(
sample_type_name=info.get("sampleTypeName", ""),
mother_name=info.get("motherName", ""),
newborn_name=info.get("newbornName", ""),
sample_status=info.get("sampleStatus", ""),
void_desc=info.get("voidDesc", ""),
)
)
data["items"] = enriched
@@ -584,6 +609,8 @@ def get_freight_detail(
sample_type_name=info.get("sampleTypeName", ""),
mother_name=info.get("motherName", ""),
newborn_name=info.get("newbornName", ""),
sample_status=info.get("sampleStatus", ""),
void_desc=info.get("voidDesc", ""),
)
)
data["items"] = enriched
+1
View File
@@ -444,6 +444,7 @@ def _rows_to_sample_list_items(
"sampleTypeName": type_map.get(sample.sample_type_id or "", ""),
"collectAmount": _dec(sample.collect_amount),
"sampleStatus": sample.sample_status or "",
"voidDesc": (getattr(sample, "void_desc", None) or "").strip(),
"motherName": (party.mother_name if party else "") or "",
"newbornName": (party.newborn_name if party else "") or "",
"sampleCollectTime": (
+27
View File
@@ -2394,6 +2394,33 @@ class BizQcTask(Base):
del_flag = Column(SmallInteger, nullable=False, default=0, comment="删除标记")
class BizQcTaskResultChangeLog(Base):
"""质检任务检测结果操作留痕 biz_qc_task_result_change_log(Issue #148/#149)"""
__tablename__ = "biz_qc_task_result_change_log"
id = Column(String(64), primary_key=True, comment="主键ID")
task_id = Column(String(64), nullable=False, comment="质检任务ID")
work_order_id = Column(String(64), nullable=True, comment="质检工单ID快照")
sample_code = Column(String(32), nullable=True, comment="样本编码快照")
item_name = Column(String(200), nullable=True, comment="检测项目名称快照")
operate_time = Column(DateTime, nullable=False, comment="业务操作时间")
operator_user_id = Column(String(64), nullable=True, comment="操作人用户ID")
operator_user_name = Column(String(64), nullable=True, comment="操作人姓名快照")
operate_batch_id = Column(String(64), nullable=True, comment="同一次保存批次ID(多任务共用)")
has_field_change = Column(CHAR(1), nullable=False, default="0", comment="1有字段变更 0仅保存无变更")
changes_json = Column(Text, nullable=True, comment="变更明细JSON")
tenant_no = Column(String(64), nullable=False, default="zkxw", comment="租户编号")
order_num = Column(Integer, nullable=True, comment="排序号")
remark = Column(String(512), nullable=True, comment="备注")
create_by = Column(String(64), nullable=True, comment="创建人id")
create_dept_id = Column(String(64), nullable=False, default="", comment="创建人部门ID")
create_time = Column(DateTime, nullable=False, default=datetime.now, comment="创建时间")
update_by = Column(String(64), nullable=True, comment="更新人id")
update_time = Column(DateTime, nullable=False, default=datetime.now, onupdate=datetime.now, comment="更新时间")
del_flag = Column(SmallInteger, nullable=False, default=0, comment="删除标记")
class BizQcTaskAssignee(Base):
"""质检任务负责人 biz_qc_task_assignee"""
@@ -1,8 +1,9 @@
"""市场协议无效态 ↔ 样本接收废弃 / 样本状态作废联动。
规则(细胞存储 / 科研捐赠):
1. 单条样本接收结论为废弃(bj)时:仅该样本 `sample_status` 置为已作废(yzf)并写 `void_date`;
协议状态保持不变。接收结论改回接收(js)且协议仍有效时:若该样本为 yzf,则清空状态与 void_date。
1. 单条样本接收结论为废弃(bj)时:仅该样本 `sample_status` 置为已作废(yzf),
写 `void_date`,并将接收备注写入 `void_desc`(备注为空则作废原因为空);
协议状态保持不变。接收结论改回接收(js)且协议仍有效时:若该样本为 yzf,则清空状态、void_date 与 void_desc。
2. 协议变为已作废(yzf)或属地废弃(sdfq)时:
- 协议下全部样本接收结论自动为废弃(bj);
- 协议下全部有效样本 `sample_status` 置为已作废(yzf),并写入 `void_date`。
@@ -585,13 +586,17 @@ def void_sample_for_discarded_reception(
tenant_no: str,
user_id: Optional[str] = None,
) -> bool:
"""单条接收废弃:仅将该样本置为已作废。"""
"""单条接收废弃:将该样本置为已作废,作废原因取接收备注。"""
_source, sample = _find_sample_for_reception(db, reception=reception, tenant_no=tenant_no)
if not sample:
return False
now = datetime.now()
reason = (reception.remark or "").strip()
if len(reason) > 512:
reason = reason[:512]
sample.sample_status = SAMPLE_VOID_STATUS
sample.void_date = _void_date_yyyymmdd(void_time=reception.reception_time or now)
sample.void_desc = reason or None
sample.update_by = user_id
sample.update_time = now
db.add(sample)
@@ -0,0 +1,53 @@
"""市场下「中试服务」已从静态菜单树下线(Issue #158)。"""
import ast
import re
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
MENU_PY = ROOT / "backend/app/api/menu.py"
SQXP_TS = ROOT / "web-admin/src/router/modules/sqxp.ts"
HIDE_SQL = ROOT / "docs/sql/migrations/2026-11-20-hide-market-pilot-service-menus.sql"
def _market_children_titles_from_menu_py() -> list[str]:
source = MENU_PY.read_text(encoding="utf-8")
tree_match = re.search(r"STATIC_MENU_TREE\s*=\s*(\[[\s\S]*?\n\])\s*\n", source)
assert tree_match, "STATIC_MENU_TREE not found"
tree = ast.literal_eval(tree_match.group(1))
market = next(
node
for node in tree
if isinstance(node, dict) and (node.get("meta") or {}).get("menuCode") == "menu:market"
)
titles = []
for child in market.get("children") or []:
meta = child.get("meta") or {}
titles.append(str(meta.get("title") or ""))
return titles
def test_backend_static_menu_has_no_market_pilot_service():
titles = _market_children_titles_from_menu_py()
assert "中试服务" not in titles
assert "中试服务申请单" not in titles
def test_frontend_sqxp_has_no_market_pilot_service_block():
text = SQXP_TS.read_text(encoding="utf-8")
assert "name: 'PilotService'" not in text
assert "id: 'PIL00000000000000000000000000001'" not in text
assert "pilot-service:pilot-application:list" not in text
# 基础实验 / 临床仍可复用出库放行组件与权限码前缀
assert "basic-experiment:outbound-release-review:list" in text
assert "clinical-application:outbound-release-review:list" in text
def test_hide_sql_soft_deletes_sys_menu_only_under_market_pilot():
sql = HIDE_SQL.read_text(encoding="utf-8")
compact = re.sub(r"\s+", " ", re.sub(r"--[^\n]*", "", sql))
assert re.search(r"UPDATE\s+sys_menu", compact, re.IGNORECASE)
assert re.search(r"SET\s+m\.del_flag\s*=\s*1", compact, re.IGNORECASE)
assert "menu:market" in compact
assert "中试服务" in compact
assert not re.search(r"DELETE\s+FROM\s+sys_menu", compact, re.IGNORECASE)
+61
View File
@@ -3,6 +3,7 @@ from __future__ import annotations
import unittest
from datetime import datetime
from types import SimpleNamespace
from app.services.lab_sample_process import (
format_cn_datetime,
@@ -38,5 +39,65 @@ class LabSampleProcessServiceTests(unittest.TestCase):
self.assertEqual(merged["motherName"], "张三")
class LabSampleProcessRowStatusTests(unittest.TestCase):
def test_cell_and_donation_rows_expose_sample_status(self):
from app.crud.lab_sample_process import (
_build_cell_system,
_build_donation_system,
)
rec = SimpleNamespace(
id="r1",
sample_code="S1",
lab_storage_code="B0000108",
reception_time=None,
receive_temperature="",
handler_name="",
remark="",
create_time=None,
)
sample = SimpleNamespace(
sample_code="S1",
sample_status="yrk",
void_desc="",
)
voided = SimpleNamespace(
sample_code="S2",
sample_status="yzf",
void_desc="溶血",
)
cell = _build_cell_system(
tab_key="cell_hsc",
rec=rec,
sample=sample,
party=None,
coll=None,
protocol=None,
prod={},
hospital_name="",
check_flags={},
storage_status="已入库",
qc_mother={},
qc_process={},
)
self.assertEqual(cell["sampleStatus"], "yrk")
self.assertEqual(cell["voidDesc"], "")
self.assertEqual(cell["cellCode"], "B0000108")
donation = _build_donation_system(
tab_key="donation_hsc",
rec=rec,
sample=voided,
party=None,
coll=None,
prod={},
storage_status="",
qc_mother={},
qc_process={},
)
self.assertEqual(donation["sampleStatus"], "yzf")
self.assertEqual(donation["voidDesc"], "溶血")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,46 @@
"""协议/捐赠列表 sampleItems 须返回样本 voidDesc,供审核列表问号展示。"""
from __future__ import annotations
import inspect
import re
import unittest
_SAMPLE_ITEM_VOID_DESC = re.compile(
r'"sampleStatus"\s*:\s*\(s\.sample_status[^)]*\)\.strip\(\),\s*'
r'"voidDesc"\s*:\s*\(getattr\(s,\s*"void_desc"',
re.S,
)
class TestProtocolListSampleVoidDesc(unittest.TestCase):
def test_collection_protocol_list_includes_sample_void_desc(self):
from app.crud import collection_protocol as cp
src = inspect.getsource(cp.list_collection_protocols)
self.assertRegex(src, _SAMPLE_ITEM_VOID_DESC)
def test_research_donation_list_includes_sample_void_desc(self):
from app.crud import research_donation as rd
# 捐赠列表函数名
fn = None
for name, obj in inspect.getmembers(rd, inspect.isfunction):
if "list" in name and "donation" in name:
src = inspect.getsource(obj)
if "sample_items.append" in src and '"sampleStatus"' in src:
fn = obj
break
self.assertIsNotNone(fn, "未找到组装 sampleItems 的捐赠列表函数")
self.assertRegex(inspect.getsource(fn), _SAMPLE_ITEM_VOID_DESC)
def test_sample_collection_list_uses_sample_void_desc(self):
from app.crud import protocol_sample_collection as psc
src = inspect.getsource(psc)
self.assertIn('getattr(psample, "void_desc"', src)
self.assertNotIn('item["voidDesc"] = (proto.void_desc or "") if proto else ""', src)
if __name__ == "__main__":
unittest.main()
@@ -440,6 +440,7 @@ class TestProtocolReceptionDiscardSync(unittest.TestCase):
accept_conclusion="bj",
reception_source="cell_storage",
sample_code="ZKA",
remark="母血乙肝阳性",
tenant_no="tenant-a",
create_dept_id="",
create_time=now,
@@ -471,6 +472,7 @@ class TestProtocolReceptionDiscardSync(unittest.TestCase):
}
self.assertEqual(by_id["sa"].sample_status, SAMPLE_VOID_STATUS)
self.assertEqual(by_id["sa"].void_date, "20261105")
self.assertEqual(by_id["sa"].void_desc, "母血乙肝阳性")
self.assertEqual(by_id["sb"].sample_status, "ycj")
self.assertEqual(by_id["sc"].sample_status, "ycj")
@@ -496,6 +498,7 @@ class TestProtocolReceptionDiscardSync(unittest.TestCase):
sample_code="ZKCLR",
sample_status=SAMPLE_VOID_STATUS,
void_date="20261101",
void_desc="旧作废原因",
tenant_no="tenant-a",
create_dept_id="",
create_time=now,
@@ -535,6 +538,7 @@ class TestProtocolReceptionDiscardSync(unittest.TestCase):
sample = db.query(BizProtocolSample).filter(BizProtocolSample.id == "s-clear").one()
self.assertFalse((sample.sample_status or "").strip())
self.assertFalse((sample.void_date or "").strip())
self.assertFalse((sample.void_desc or "").strip())
if __name__ == "__main__":
@@ -0,0 +1,38 @@
"""质检检测结果留痕:字段差异与空保存。"""
from app.crud.qc_task_result_change_log import build_result_changes
def test_build_changes_for_status_and_param():
before = {
"taskStatus": "dzx",
"conclusion": "",
"remark": "",
"attachments": "",
"params": {"paramCode:HBsAg": {"label": "HBsAg", "value": "阴性"}},
}
after = {
"taskStatus": "ywc",
"conclusion": "tg",
"remark": "",
"attachments": "",
"params": {"paramCode:HBsAg": {"label": "HBsAg", "value": "阳性"}},
}
changes = build_result_changes(before, after)
keys = {c["fieldKey"] for c in changes}
assert "taskStatus" in keys
assert "conclusion" in keys
assert "paramCode:HBsAg" in keys
hbs = next(c for c in changes if c["fieldKey"] == "paramCode:HBsAg")
assert hbs["oldValue"] == "阴性"
assert hbs["newValue"] == "阳性"
def test_build_changes_empty_when_identical():
state = {
"taskStatus": "ywc",
"conclusion": "tg",
"remark": "ok",
"attachments": "a.png",
"params": {"paramCode:X": {"label": "X", "value": "1"}},
}
assert build_result_changes(state, state) == []
@@ -0,0 +1,62 @@
"""Static checks for market/pilot-service role-menu revoke migration (#156)."""
import re
from pathlib import Path
MIGRATION = (
Path(__file__).resolve().parents[2]
/ "docs/sql/migrations/2026-11-20-revoke-market-pilot-service-role-menus.sql"
)
def _sql() -> str:
return MIGRATION.read_text(encoding="utf-8")
def _compact(sql: str) -> str:
return re.sub(r"\s+", " ", sql)
def _without_comments(sql: str) -> str:
return re.sub(r"--[^\n]*", "", sql)
def test_migration_file_exists():
assert MIGRATION.is_file()
def test_scopes_to_market_pilot_service_tree():
compact = _compact(_without_comments(_sql()))
assert "menu:market" in compact
assert "中试服务" in compact
assert re.search(r"pilot\.menu_name\s*=\s*'中试服务'", compact)
assert re.search(r"market\.perms\s*=\s*'menu:market'", compact)
def test_revokes_role_menu_by_soft_delete_only():
compact = _compact(_without_comments(_sql()))
assert re.search(r"UPDATE\s+sys_role_menu", compact, re.IGNORECASE)
assert re.search(
r"UPDATE\s+sys_role_menu\s+rm\b.*SET\s+rm\.del_flag\s*=\s*1",
compact,
re.IGNORECASE,
)
assert not re.search(r"DELETE\s+FROM\s+sys_role_menu", compact, re.IGNORECASE)
assert not re.search(r"UPDATE\s+sys_menu\s+SET\s+del_flag\s*=\s*1", compact, re.IGNORECASE)
assert not re.search(r"DELETE\s+FROM\s+sys_menu", compact, re.IGNORECASE)
def test_includes_children_and_button_descendants():
compact = _compact(_without_comments(_sql()))
assert re.search(r"child\.parent_id\s*=\s*pilot\.id", compact)
assert re.search(r"btn\.parent_id\s*=\s*child\.id", compact)
assert compact.count("UNION") >= 2
def test_update_only_touches_active_bindings():
compact = _compact(_without_comments(_sql()))
assert re.search(
r"SET\s+rm\.del_flag\s*=\s*1[\s\S]*WHERE\s+rm\.del_flag\s*=\s*0",
compact,
re.IGNORECASE,
)
+14
View File
@@ -79,12 +79,26 @@ class TestFreightListHelpers(unittest.TestCase):
sample_type_name="脐带血",
mother_name="张三",
newborn_name="张小宝",
sample_status="ycj",
void_desc="",
)
self.assertEqual(d["protocolNo"], "CP001")
self.assertEqual(d["sampleTypeName"], "脐带血")
self.assertEqual(d["sampleSource"], "cell_storage")
self.assertEqual(d["motherName"], "张三")
self.assertEqual(d["newbornName"], "张小宝")
self.assertEqual(d["sampleStatus"], "ycj")
self.assertEqual(d["sampleStatusLabel"], "已采集")
self.assertEqual(d["voidDesc"], "")
voided = _item_to_dict_enriched(
I(),
sample_status="yzf",
void_desc="运输破损",
)
self.assertEqual(voided["sampleStatus"], "yzf")
self.assertEqual(voided["sampleStatusLabel"], "已作废")
self.assertEqual(voided["voidDesc"], "运输破损")
def test_row_dict_includes_create_by(self):
from app.crud.sample_freight import _row_to_dict
@@ -97,5 +97,13 @@ class TestPaymentListSampleStatus(unittest.TestCase):
self.assertEqual(voided["voidDesc"], "客户放弃存储")
class TestPaymentChaseSampleStatusLabels(unittest.TestCase):
def test_status_label_map_covers_voided(self):
from app.crud.protocol_sample_payment import _SAMPLE_STATUS_LABELS
self.assertEqual(_SAMPLE_STATUS_LABELS.get("ycj"), "已采集")
self.assertEqual(_SAMPLE_STATUS_LABELS.get("yzf"), "已作废")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,164 @@
-- 市场模块新增「器械销售」及三个子菜单;授权给已有 menu:market 的角色。
-- 不新建角色/用户;用户经现有 sys_user_role 自动带上菜单。
-- MySQL 5.7,可重复执行。目标库:测试库(如 zkxw-sc)。
-- 1) 二级目录:器械销售(挂在市场下,order_num=6 末位)
INSERT INTO sys_menu (
id, menu_name, parent_id, menu_type, path, component, perms,
is_frame, visible, status, tenant_no, order_num, remark,
create_by, create_dept_id, create_time, update_by, update_time, del_flag
)
SELECT
'DEV00000000000000000000000000001',
'器械销售',
m.id,
'M',
'device-sales',
NULL,
'menu:device-sales',
1, '1', '1', m.tenant_no, 6,
'市场-器械销售',
'migration', '', NOW(), 'migration', NOW(), 0
FROM sys_menu m
WHERE m.del_flag = 0 AND m.perms = 'menu:market'
AND NOT EXISTS (
SELECT 1 FROM sys_menu e
WHERE e.id = 'DEV00000000000000000000000000001' AND e.del_flag = 0
);
-- 2) 子菜单:三类 / 二类 / 化妆品
INSERT INTO sys_menu (
id, menu_name, parent_id, menu_type, path, component, perms,
is_frame, visible, status, tenant_no, order_num, remark,
create_by, create_dept_id, create_time, update_by, update_time, del_flag
)
SELECT
x.id, x.menu_name, 'DEV00000000000000000000000000001', 'C', x.path,
'device-sales/under-construction/index', x.perms,
1, '1', '1', p.tenant_no, x.order_num, x.remark,
'migration', '', NOW(), 'migration', NOW(), 0
FROM sys_menu p
JOIN (
SELECT 'DEV00000000000000000000000000002' AS id, '三类医疗器械' AS menu_name,
'class-iii' AS path, 'device-sales:class-iii:list' AS perms, 1 AS order_num,
'市场-器械销售-三类医疗器械' AS remark
UNION ALL
SELECT 'DEV00000000000000000000000000003', '二类医疗器械',
'class-ii', 'device-sales:class-ii:list', 2,
'市场-器械销售-二类医疗器械'
UNION ALL
SELECT 'DEV00000000000000000000000000004', '化妆品产品',
'cosmetics', 'device-sales:cosmetics:list', 3,
'市场-器械销售-化妆品产品'
) x ON 1 = 1
WHERE p.del_flag = 0 AND p.id = 'DEV00000000000000000000000000001'
AND NOT EXISTS (
SELECT 1 FROM sys_menu e WHERE e.id = x.id AND e.del_flag = 0
);
-- 3) 给已有「市场」顶级菜单授权的角色,授予器械销售目录+三个子菜单
-- (含祖先目录,满足选中子菜单须含祖先)
INSERT INTO sys_role_menu (
id, role_id, menu_id, tenant_no, order_num, remark,
create_by, create_dept_id, create_time, update_by, update_time, del_flag
)
SELECT
INSERT(INSERT(MD5(CONCAT('device-sales-rm:', r.tenant_no, ':', r.id, ':', m.id)), 13, 1, '3'), 17, 1, '8'),
r.id, m.id, r.tenant_no, NULL,
'grant device-sales from menu:market',
'migration', '', NOW(), 'migration', NOW(), 0
FROM sys_role r
JOIN sys_role_menu src
ON src.role_id = r.id AND src.tenant_no = r.tenant_no AND src.del_flag = 0
JOIN sys_menu top
ON top.id = src.menu_id AND top.tenant_no = src.tenant_no AND top.del_flag = 0
AND top.perms = 'menu:market'
JOIN sys_menu m
ON m.tenant_no = r.tenant_no AND m.del_flag = 0 AND m.status = '1'
AND m.id IN (
'DEV00000000000000000000000000001',
'DEV00000000000000000000000000002',
'DEV00000000000000000000000000003',
'DEV00000000000000000000000000004'
)
WHERE r.del_flag = 0
AND NOT EXISTS (
SELECT 1 FROM sys_role_menu existing
WHERE existing.role_id = r.id
AND existing.menu_id = m.id
AND existing.tenant_no = r.tenant_no
AND existing.del_flag = 0
);
-- 3b) 超级管理员同步授予(角色管理勾选与超管侧栏数据一致)
INSERT INTO sys_role_menu (
id, role_id, menu_id, tenant_no, order_num, remark,
create_by, create_dept_id, create_time, update_by, update_time, del_flag
)
SELECT
INSERT(INSERT(MD5(CONCAT('device-sales-sa:', r.tenant_no, ':', r.id, ':', m.id)), 13, 1, '3'), 17, 1, '8'),
r.id, m.id, r.tenant_no, NULL,
'grant device-sales to super admin',
'migration', '', NOW(), 'migration', NOW(), 0
FROM sys_role r
JOIN sys_menu m
ON m.del_flag = 0 AND m.status = '1'
AND m.id IN (
'DEV00000000000000000000000000001',
'DEV00000000000000000000000000002',
'DEV00000000000000000000000000003',
'DEV00000000000000000000000000004'
)
WHERE r.del_flag = 0 AND r.role_name = '超级管理员'
AND NOT EXISTS (
SELECT 1 FROM sys_role_menu existing
WHERE existing.role_id = r.id
AND existing.menu_id = m.id
AND existing.tenant_no = r.tenant_no
AND existing.del_flag = 0
);
-- 3c) 恢复已挂到上述角色、但被软删的用户-角色关联(打通 用户→角色→菜单)
UPDATE sys_user_role ur
JOIN sys_role r ON r.id = ur.role_id AND r.del_flag = 0
JOIN sys_role_menu rm
ON rm.role_id = r.id AND rm.del_flag = 0
AND rm.menu_id = 'DEV00000000000000000000000000001'
JOIN sys_user u ON u.id = ur.user_id AND u.del_flag = 0
SET ur.del_flag = 0,
ur.update_by = 'migration',
ur.update_time = NOW()
WHERE ur.del_flag = 1;
-- 4) 核对
SELECT id, menu_name, parent_id, path, perms, order_num, visible, del_flag
FROM sys_menu
WHERE id LIKE 'DEV0000000000000000000000000000%'
ORDER BY order_num, menu_name;
SELECT COUNT(DISTINCT rm.role_id) AS roles_granted,
COUNT(*) AS role_menu_rows
FROM sys_role_menu rm
WHERE rm.del_flag = 0
AND rm.menu_id IN (
'DEV00000000000000000000000000001',
'DEV00000000000000000000000000002',
'DEV00000000000000000000000000003',
'DEV00000000000000000000000000004'
);
-- 抽样:有市场权限的用户是否能通过角色落到器械销售菜单
SELECT u.nick_name, u.phone_no, r.role_name, m.menu_name, m.perms
FROM sys_user u
JOIN sys_user_role ur ON ur.user_id = u.id AND ur.del_flag = 0
JOIN sys_role r ON r.id = ur.role_id AND r.del_flag = 0
JOIN sys_role_menu rm ON rm.role_id = r.id AND rm.del_flag = 0
JOIN sys_menu m ON m.id = rm.menu_id AND m.del_flag = 0
WHERE u.del_flag = 0
AND m.id IN (
'DEV00000000000000000000000000002',
'DEV00000000000000000000000000003',
'DEV00000000000000000000000000004'
)
ORDER BY u.nick_name, m.order_num
LIMIT 30;
@@ -0,0 +1,129 @@
-- 软删【市场】下【中试服务】目录及其子菜单(含按钮),与前端静态路由下线对齐。
-- Issue #158(承接 #156:仅解绑角色对超管侧栏无效)
-- MySQL 5.7,可重复执行;不影响基础实验/临床应用下同名菜单。
-- 0) 预览目标菜单
SELECT
m.tenant_no,
m.id AS menu_id,
m.menu_name,
m.menu_type,
m.perms,
m.parent_id,
m.del_flag
FROM sys_menu m
JOIN (
SELECT pilot.id AS menu_id, pilot.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT child.id, child.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT btn.id, btn.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
JOIN sys_menu btn
ON btn.parent_id = child.id
AND btn.tenant_no = market.tenant_no
AND btn.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
) tgt
ON tgt.menu_id = m.id
AND tgt.tenant_no = m.tenant_no
WHERE m.del_flag = 0
ORDER BY m.tenant_no, m.menu_type, m.order_num, m.menu_name;
-- 1) 软删目标菜单
UPDATE sys_menu m
JOIN (
SELECT pilot.id AS menu_id, pilot.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT child.id, child.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT btn.id, btn.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
JOIN sys_menu btn
ON btn.parent_id = child.id
AND btn.tenant_no = market.tenant_no
AND btn.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
) tgt
ON tgt.menu_id = m.id
AND tgt.tenant_no = m.tenant_no
SET
m.del_flag = 1,
m.update_by = 'migration',
m.update_time = NOW()
WHERE m.del_flag = 0;
-- 2) 核对:市场下不应再有有效「中试服务」目录(期望 0 行)
SELECT
market.tenant_no,
pilot.id,
pilot.menu_name,
pilot.del_flag
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market';
@@ -0,0 +1,8 @@
-- 质检检测结果留痕:同一次批量保存共用 operate_batch_id(Issue #153)
-- 历史行可为空;前端对无批次号的旧数据做短时窗口合并兜底。
ALTER TABLE `biz_qc_task_result_change_log`
ADD COLUMN `operate_batch_id` varchar(64) DEFAULT NULL COMMENT '同一次保存批次ID(多任务共用)' AFTER `operator_user_name`;
ALTER TABLE `biz_qc_task_result_change_log`
ADD KEY `idx_qc_result_chg_batch` (`tenant_no`, `operate_batch_id`, `del_flag`);
@@ -0,0 +1,27 @@
-- 质检任务检测结果操作留痕(Issue #148 / #149)
-- 每次「填写检测结果」保存追加一条;即使字段无变更也记录操作人与时间。
CREATE TABLE IF NOT EXISTS `biz_qc_task_result_change_log` (
`id` varchar(64) NOT NULL COMMENT '主键ID',
`task_id` varchar(64) NOT NULL COMMENT '质检任务ID',
`work_order_id` varchar(64) DEFAULT NULL COMMENT '质检工单ID快照',
`sample_code` varchar(32) DEFAULT NULL COMMENT '样本编码快照',
`item_name` varchar(200) DEFAULT NULL COMMENT '检测项目名称快照',
`operate_time` datetime NOT NULL COMMENT '业务操作时间',
`operator_user_id` varchar(64) DEFAULT NULL COMMENT '操作人用户ID',
`operator_user_name` varchar(64) DEFAULT NULL COMMENT '操作人姓名快照',
`has_field_change` char(1) NOT NULL DEFAULT '0' COMMENT '1有字段变更 0仅保存无变更',
`changes_json` mediumtext COMMENT '变更明细JSON:[{fieldKey,fieldLabel,oldValue,newValue}]',
`tenant_no` varchar(64) NOT NULL DEFAULT 'zkxw' COMMENT '租户编号',
`order_num` int(11) DEFAULT NULL COMMENT '排序号',
`remark` varchar(512) DEFAULT NULL COMMENT '备注',
`create_by` varchar(64) DEFAULT NULL COMMENT '创建人id',
`create_dept_id` varchar(64) NOT NULL DEFAULT '' COMMENT '创建人部门ID',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_by` varchar(64) DEFAULT NULL COMMENT '更新人id',
`update_time` datetime NOT NULL COMMENT '更新时间',
`del_flag` smallint(6) NOT NULL DEFAULT '0' COMMENT '删除标记',
PRIMARY KEY (`id`),
KEY `idx_qc_result_chg_task` (`tenant_no`,`task_id`,`del_flag`,`operate_time`),
KEY `idx_qc_result_chg_wo` (`tenant_no`,`work_order_id`,`del_flag`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='质检任务检测结果操作留痕';
@@ -0,0 +1,256 @@
-- 解除【市场】下【中试服务】目录及其全部子菜单(含按钮)与角色的绑定。
-- Issue #156
-- 仅软删 sys_role_menu(del_flag=1),不删除/隐藏菜单本身。
-- 按树定位:menu:market → menu_name=中试服务 → 直系子菜单 → 孙级按钮;
-- 不匹配基础实验/临床应用等其他目录下的同名「出库放行审核」。
-- MySQL 5.7,可重复执行(只处理 del_flag=0 的绑定)。
-- ---------------------------------------------------------------------------
-- 0) 预览:将要解绑的目标菜单(目录 + 子菜单 + 按钮)
-- ---------------------------------------------------------------------------
SELECT
m.tenant_no,
m.id AS menu_id,
m.menu_name,
m.menu_type,
m.perms,
m.parent_id,
m.path
FROM sys_menu m
JOIN (
SELECT pilot.id AS menu_id, pilot.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT child.id, child.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT btn.id, btn.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
JOIN sys_menu btn
ON btn.parent_id = child.id
AND btn.tenant_no = market.tenant_no
AND btn.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
) tgt
ON tgt.menu_id = m.id
AND tgt.tenant_no = m.tenant_no
WHERE m.del_flag = 0
ORDER BY m.tenant_no, m.menu_type, m.order_num, m.menu_name;
-- ---------------------------------------------------------------------------
-- 1) 预览:将要软删的角色-菜单绑定
-- ---------------------------------------------------------------------------
SELECT
rm.tenant_no,
r.id AS role_id,
r.role_name,
m.id AS menu_id,
m.menu_name,
m.menu_type,
m.perms,
rm.id AS role_menu_id
FROM sys_role_menu rm
JOIN sys_role r
ON r.id = rm.role_id
AND r.tenant_no = rm.tenant_no
AND r.del_flag = 0
JOIN sys_menu m
ON m.id = rm.menu_id
AND m.tenant_no = rm.tenant_no
AND m.del_flag = 0
JOIN (
SELECT pilot.id AS menu_id, pilot.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT child.id, child.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT btn.id, btn.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
JOIN sys_menu btn
ON btn.parent_id = child.id
AND btn.tenant_no = market.tenant_no
AND btn.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
) tgt
ON tgt.menu_id = rm.menu_id
AND tgt.tenant_no = rm.tenant_no
WHERE rm.del_flag = 0
ORDER BY rm.tenant_no, r.role_name, m.menu_name;
-- ---------------------------------------------------------------------------
-- 2) 软删绑定(可重复执行)
-- ---------------------------------------------------------------------------
UPDATE sys_role_menu rm
JOIN (
SELECT pilot.id AS menu_id, pilot.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT child.id, child.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT btn.id, btn.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
JOIN sys_menu btn
ON btn.parent_id = child.id
AND btn.tenant_no = market.tenant_no
AND btn.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
) tgt
ON tgt.menu_id = rm.menu_id
AND tgt.tenant_no = rm.tenant_no
SET
rm.del_flag = 1,
rm.update_by = 'migration',
rm.update_time = NOW()
WHERE rm.del_flag = 0;
-- ---------------------------------------------------------------------------
-- 3) 核对:目标菜单上不应再有有效角色绑定(期望 0 行)
-- ---------------------------------------------------------------------------
SELECT
rm.tenant_no,
r.role_name,
m.menu_name,
m.perms,
COUNT(*) AS active_role_menu_rows
FROM sys_role_menu rm
JOIN sys_role r
ON r.id = rm.role_id
AND r.tenant_no = rm.tenant_no
AND r.del_flag = 0
JOIN sys_menu m
ON m.id = rm.menu_id
AND m.tenant_no = rm.tenant_no
AND m.del_flag = 0
JOIN (
SELECT pilot.id AS menu_id, pilot.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT child.id, child.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
UNION
SELECT btn.id, btn.tenant_no
FROM sys_menu market
JOIN sys_menu pilot
ON pilot.parent_id = market.id
AND pilot.tenant_no = market.tenant_no
AND pilot.del_flag = 0
AND pilot.menu_name = '中试服务'
JOIN sys_menu child
ON child.parent_id = pilot.id
AND child.tenant_no = market.tenant_no
AND child.del_flag = 0
JOIN sys_menu btn
ON btn.parent_id = child.id
AND btn.tenant_no = market.tenant_no
AND btn.del_flag = 0
WHERE market.del_flag = 0
AND market.perms = 'menu:market'
) tgt
ON tgt.menu_id = rm.menu_id
AND tgt.tenant_no = rm.tenant_no
WHERE rm.del_flag = 0
GROUP BY rm.tenant_no, r.role_name, m.menu_name, m.perms;
+2
View File
@@ -4,6 +4,8 @@ export type SampleVoidTarget = {
receptionSource: 'cell_storage' | 'research_donation'
sampleId?: string
sampleCode?: string
/** 仅弹窗展示,不参与作废请求 */
labStorageCode?: string
protocolId?: string
}
+37
View File
@@ -51,6 +51,7 @@ export function fetchCompleteTaskWithResult(
remark?: string
thirdPartyAttachments?: string
taskStatus?: 'dzx' | 'jxz' | 'ywc'
operateBatchId?: string
materialUsages?: Array<{
requisitionUsageId: string
qty: number
@@ -66,3 +67,39 @@ export function fetchCompleteTaskWithResult(
data
})
}
export type QcTaskResultChangeItem = {
fieldKey: string
fieldLabel: string
oldValue: string
newValue: string
}
export type QcTaskResultChangeLog = {
id: string
taskId: string
workOrderId?: string
sampleCode?: string
itemName?: string
operateTime: string
operatorUserId?: string
operatorUserName?: string
operateBatchId?: string
hasFieldChange: boolean
changes: QcTaskResultChangeItem[]
createTime?: string
}
export function fetchQcTaskResultChangeLogs(taskId: string) {
return request.get<QcTaskResultChangeLog[]>({
url: `/web/admin/qc-tasks/${taskId}/result-change-logs`
})
}
export function fetchQcTaskResultChangeLogsBatch(taskIds: string[]) {
const ids = taskIds.map((x) => (x || '').trim()).filter(Boolean)
return request.get<QcTaskResultChangeLog[]>({
url: `/web/admin/qc-tasks/result-change-logs`,
params: { taskIds: ids.join(',') }
})
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 95 KiB

@@ -20,6 +20,9 @@
class="biz-dialog-form"
>
<div class="form-grid-2">
<el-form-item label="实验室入库编码" class="form-col-span-2">
<span class="sample-void-dialog__code">{{ labStorageCodeDisplay }}</span>
</el-form-item>
<el-form-item v-if="sampleCode" label="样本编码" class="form-col-span-2">
<span class="sample-void-dialog__code">{{ sampleCode }}</span>
</el-form-item>
@@ -84,6 +87,9 @@
]
}
const labStorageCodeDisplay = computed(
() => String(props.target?.labStorageCode || '').trim() || '—'
)
const sampleCode = computed(() => String(props.target?.sampleCode || '').trim())
watch(
+51 -68
View File
@@ -60,8 +60,8 @@ export const sqxpAdminRoutes: AppRouteRecord[] = [
},
// ═══════════════════════════════════════════════════════════════════════════
// 1. 市场 (menu:market)
// 二级菜单:存储服务、科研捐赠、市场基础信息、中试服务、基础实验
// (主推存储/捐赠在前;中试/基础实验及关联基础信息后置)
// 二级菜单:存储服务、科研捐赠、市场基础信息、基础实验、器械销售
// (主推存储/捐赠在前;中试/基础实验及关联基础信息后置;器械销售在末位)
// ═══════════════════════════════════════════════════════════════════════════
{
id: 'TOP00000000000000000000000000001',
@@ -553,72 +553,6 @@ export const sqxpAdminRoutes: AppRouteRecord[] = [
]
},
// ── 中试服务 ──────────────────────────────────────────────────────────
{
id: 'PIL00000000000000000000000000001',
name: 'PilotService',
path: 'pilot-service',
component: '',
meta: {
title: '中试服务',
icon: 'ri:flask-line',
keepAlive: false,
roles: ['admin']
},
children: [
{
id: '80000000000000000000000000000010',
name: 'PilotApplication',
path: 'pilot-application',
component: '/pilot-service/pilot-application/index',
meta: {
title: '中试服务申请单',
keepAlive: true,
menuCode: 'pilot-service:pilot-application:list'
},
props: { bizType: 'pilot_service' }
},
{
id: 'PIL00000000000000000000000000002',
name: 'PilotCheckupManagement',
path: 'checkup-management',
component: '/pilot-service/checkup-management/index',
meta: {
title: '体检管理',
keepAlive: false,
isHide: true,
menuCode: 'pilot-service:checkup-management:list'
},
props: { bizType: 'pilot_service' }
},
{
id: 'PIL00000000000000000000000000003',
name: 'PilotInfusionSchedule',
path: 'infusion-schedule-management',
component: '/pilot-service/infusion-schedule-management/index',
meta: {
title: '输注计划管理',
keepAlive: false,
isHide: true,
menuCode: 'pilot-service:infusion-schedule-management:list'
},
props: { bizType: 'pilot_service' }
},
{
id: 'PIL00000000000000000000000000004',
name: 'PilotOutboundRelease',
path: 'outbound-release-review',
component: '/pilot-service/outbound-release-review/index',
meta: {
title: '出库放行审核',
keepAlive: true,
menuCode: 'pilot-service:outbound-release-review:list'
},
props: { bizType: 'pilot_service' }
}
]
},
// ── 基础实验 ──────────────────────────────────────────────────────────
{
id: 'BEX00000000000000000000000000001',
@@ -669,6 +603,55 @@ export const sqxpAdminRoutes: AppRouteRecord[] = [
props: { bizType: 'basic_experiment' }
}
]
},
// ── 器械销售(市场侧栏末位;占位页待完善)────────────────────────────
{
id: 'DEV00000000000000000000000000001',
name: 'DeviceSales',
path: 'device-sales',
component: '',
meta: {
title: '器械销售',
icon: 'ri:shopping-bag-3-line',
keepAlive: false,
roles: ['admin']
},
children: [
{
id: 'DEV00000000000000000000000000002',
name: 'DeviceSalesClassIii',
path: 'class-iii',
component: '/device-sales/under-construction/index',
meta: {
title: '三类医疗器械',
keepAlive: false,
menuCode: 'device-sales:class-iii:list'
}
},
{
id: 'DEV00000000000000000000000000003',
name: 'DeviceSalesClassIi',
path: 'class-ii',
component: '/device-sales/under-construction/index',
meta: {
title: '二类医疗器械',
keepAlive: false,
menuCode: 'device-sales:class-ii:list'
}
},
{
id: 'DEV00000000000000000000000000004',
name: 'DeviceSalesCosmetics',
path: 'cosmetics',
component: '/device-sales/under-construction/index',
meta: {
title: '化妆品产品',
keepAlive: false,
menuCode: 'device-sales:cosmetics:list'
}
}
]
}
]
},
@@ -6,7 +6,8 @@ import {
resolveTabKeyFromWorkOrder,
getProductionWorkOrderTab,
toWorkOrderListQuery,
isAllProductionWorkOrderTab
isAllProductionWorkOrderTab,
workOrderMatchesTab
} from '@/utils/production-work-order-tabs'
import { toAllTabListQuery, workOrderMatchesCategory } from '@/utils/production-work-order-category'
import { matchesWorkOrderStatusFilter } from '@/utils/status-tag-registry'
@@ -231,9 +232,7 @@ export function filterMineEntriesByWorkOrderSearch(
const tabKey = filters.tabKey
return entries.filter((entry) => {
const row = entry.workOrder
if (!isAllProductionWorkOrderTab(tabKey) && resolveTabKeyFromWorkOrder(row) !== tabKey) {
return false
}
if (!workOrderMatchesTab(row, tabKey)) return false
if (
isAllProductionWorkOrderTab(tabKey) &&
!workOrderMatchesCategory(row, filters.productionCategory || '')
@@ -0,0 +1,32 @@
import { describe, it } from 'node:test'
import assert from 'node:assert/strict'
import {
PRODUCTION_WORK_ORDER_VISIBLE_TABS,
parseProductionWorkOrderTabKey,
workOrderMatchesTab,
isPilotServiceOutboundWorkOrder
} from './production-work-order-tabs'
import { PRODUCTION_WORK_ORDER_CATEGORY_OPTIONS } from './production-work-order-category'
describe('production work order tabs — hide pilot service', () => {
it('visible tabs exclude outbound_pilot_service', () => {
assert.ok(!PRODUCTION_WORK_ORDER_VISIBLE_TABS.some((t) => t.key === 'outbound_pilot_service'))
assert.ok(!PRODUCTION_WORK_ORDER_CATEGORY_OPTIONS.some((o) => o.key === 'outbound_pilot_service'))
})
it('parse: hidden pilot key and outbound alias fall back safely', () => {
assert.equal(parseProductionWorkOrderTabKey('outbound_pilot_service'), 'all')
assert.equal(parseProductionWorkOrderTabKey('outbound'), 'outbound_basic_experiment')
})
it('「所有」excludes pilot outbound (incl. default bizType)', () => {
const pilot = { workOrderType: 'outbound', bizType: 'pilot_service' }
const defaultPilot = { workOrderType: 'outbound' }
const basic = { workOrderType: 'outbound', bizType: 'basic_experiment' }
assert.equal(isPilotServiceOutboundWorkOrder(pilot), true)
assert.equal(isPilotServiceOutboundWorkOrder(defaultPilot), true)
assert.equal(workOrderMatchesTab(pilot as any, 'all'), false)
assert.equal(workOrderMatchesTab(defaultPilot as any, 'all'), false)
assert.equal(workOrderMatchesTab(basic as any, 'all'), true)
})
})
@@ -53,7 +53,9 @@ export const PRODUCTION_WORK_ORDER_TABS: ProductionWorkOrderTabConfig[] = [
group: 'outbound',
workOrderType: 'outbound',
bizType: 'pilot_service',
listLayout: 'standalone'
listLayout: 'standalone',
/** 客户已下线中试业务:侧栏不展示,路由 key 保留供历史解析 */
hidden: true
},
{
key: 'outbound_basic_experiment',
@@ -97,7 +99,7 @@ export function parseProductionWorkOrderTabKey(raw?: string | null): ProductionW
const tab = getProductionWorkOrderTab(k)
if (tab && !tab.hidden) return tab.key
if (k === 'inbound') return 'inbound_cell_storage'
if (k === 'outbound') return 'outbound_pilot_service'
if (k === 'outbound') return 'outbound_basic_experiment'
if (k === 'temporary') return 'temporary'
return DEFAULT_PRODUCTION_WORK_ORDER_TAB
}
@@ -145,11 +147,19 @@ export function keywordPlaceholderForTab(tab: ProductionWorkOrderTabConfig): str
return '工单号/样本编码/入库编码'
}
/** 出库中试服务(含 bizType 缺省落成中试) */
export function isPilotServiceOutboundWorkOrder(row: {
workOrderType?: string
bizType?: string
}): boolean {
return resolveTabKeyFromWorkOrder(row) === 'outbound_pilot_service'
}
export function workOrderMatchesTab(
row: ProductionWorkOrderItem,
tabKey: ProductionWorkOrderTabKey
): boolean {
if (tabKey === 'all') return true
if (tabKey === 'all') return !isPilotServiceOutboundWorkOrder(row)
return resolveTabKeyFromWorkOrder(row) === tabKey
}
+3 -4
View File
@@ -10,7 +10,8 @@ import {
tabUsesInfusionTimeFilter,
getQcWorkOrderTab,
toWorkOrderListQuery,
isAllQcWorkOrderTab
isAllQcWorkOrderTab,
workOrderMatchesTab
} from '@/utils/qc-work-order-tabs'
import {
matchesAllTabTriggerSource,
@@ -101,9 +102,7 @@ export function filterMineEntriesByWorkOrderSearch(
const tab = getQcWorkOrderTab(tabKey)!
return entries.filter((entry) => {
const row = entry.workOrder
if (!isAllQcWorkOrderTab(tabKey) && resolveTabKeyFromWorkOrder(row) !== tabKey) {
return false
}
if (!workOrderMatchesTab(row, tabKey)) return false
if (isAllQcWorkOrderTab(tabKey) && !workOrderMatchesCategory(row, filters.qcCategory || '')) {
return false
}
@@ -0,0 +1,43 @@
/** 填写检测结果弹窗默认值(Issue #148):未落结论时默认已完成 + 通过 */
export type QcResultFillStatus = 'dzx' | 'jxz' | 'ywc'
export type QcResultFillConclusion = '' | 'tg' | 'btg'
export function normalizeFillConclusion(raw?: string | null): QcResultFillConclusion {
const c = (raw || '').trim()
return c === 'tg' || c === 'btg' ? c : ''
}
/**
* 打开填写弹窗时的任务状态 / 结论默认。
* - 已有结论或已是已完成:回显实际值
* - 尚未落结论:默认 已完成 + 通过
*/
export function resolveQcResultFillDefaults(input: {
taskStatus?: string | null
conclusion?: string | null
}): { saveStatus: QcResultFillStatus; conclusion: QcResultFillConclusion } {
const status = (input.taskStatus || '').trim()
const conclusion = normalizeFillConclusion(input.conclusion)
if (conclusion || status === 'ywc') {
const saveStatus: QcResultFillStatus =
status === 'dzx' || status === 'jxz' || status === 'ywc' ? status : 'ywc'
return {
saveStatus: saveStatus === 'ywc' ? 'ywc' : saveStatus,
conclusion: conclusion || (saveStatus === 'ywc' ? 'tg' : '')
}
}
return { saveStatus: 'ywc', conclusion: 'tg' }
}
/** 第三方弹窗仅展示待执行/已完成 */
export function resolveThirdPartyFillDefaults(input: {
taskStatus?: string | null
conclusion?: string | null
}): { saveStatus: 'dzx' | 'ywc'; conclusion: QcResultFillConclusion } {
const resolved = resolveQcResultFillDefaults(input)
return {
saveStatus: resolved.saveStatus === 'ywc' ? 'ywc' : 'dzx',
conclusion: resolved.conclusion
}
}
@@ -0,0 +1,33 @@
import { describe, it } from 'node:test'
import assert from 'node:assert/strict'
import {
QC_WORK_ORDER_VISIBLE_TABS,
parseQcWorkOrderTabKey,
workOrderMatchesTab,
isPilotServiceOutboundWorkOrder
} from './qc-work-order-tabs'
import { QC_WORK_ORDER_CATEGORY_OPTIONS } from './qc-work-order-category'
describe('qc work order tabs — hide pilot service', () => {
it('visible tabs exclude outbound_pilot_service', () => {
assert.ok(!QC_WORK_ORDER_VISIBLE_TABS.some((t) => t.key === 'outbound_pilot_service'))
assert.ok(!QC_WORK_ORDER_CATEGORY_OPTIONS.some((o) => o.key === 'outbound_pilot_service'))
})
it('parse: hidden pilot key and outbound alias fall back safely', () => {
// 质检默认 Tab 为细胞存储(「所有」本身也是 hidden)
assert.equal(parseQcWorkOrderTabKey('outbound_pilot_service'), 'inbound_cell_storage')
assert.equal(parseQcWorkOrderTabKey('outbound'), 'outbound_basic_experiment')
})
it('「所有」excludes pilot outbound (incl. default bizType)', () => {
const pilot = { workOrderType: 'outbound', bizType: 'pilot_service' }
const defaultPilot = { workOrderType: 'outbound' }
const basic = { workOrderType: 'outbound', bizType: 'basic_experiment' }
assert.equal(isPilotServiceOutboundWorkOrder(pilot), true)
assert.equal(isPilotServiceOutboundWorkOrder(defaultPilot), true)
assert.equal(workOrderMatchesTab(pilot as any, 'all'), false)
assert.equal(workOrderMatchesTab(defaultPilot as any, 'all'), false)
assert.equal(workOrderMatchesTab(basic as any, 'all'), true)
})
})
+13 -3
View File
@@ -53,7 +53,9 @@ export const QC_WORK_ORDER_TABS: QcWorkOrderTabConfig[] = [
group: 'outbound',
workOrderType: 'outbound',
bizType: 'pilot_service',
listLayout: 'outbound-grouped'
listLayout: 'outbound-grouped',
/** 客户已下线中试业务:侧栏不展示,路由 key 保留供历史解析 */
hidden: true
},
{
key: 'outbound_basic_experiment',
@@ -95,7 +97,7 @@ export function parseQcWorkOrderTabKey(raw?: string | null): QcWorkOrderTabKey {
const tab = getQcWorkOrderTab(k)
if (tab && !tab.hidden) return tab.key
if (k === 'inbound') return 'inbound_cell_storage'
if (k === 'outbound') return 'outbound_pilot_service'
if (k === 'outbound') return 'outbound_basic_experiment'
if (k === 'temporary') return 'temporary'
return DEFAULT_QC_WORK_ORDER_TAB
}
@@ -160,8 +162,16 @@ export function filterTimeLabelForTab(tab: QcWorkOrderTabConfig): string {
return '创建时间'
}
/** 出库中试服务(含 bizType 缺省落成中试) */
export function isPilotServiceOutboundWorkOrder(row: {
workOrderType?: string
bizType?: string
}): boolean {
return resolveTabKeyFromWorkOrder(row) === 'outbound_pilot_service'
}
export function workOrderMatchesTab(row: QcWorkOrder, tabKey: QcWorkOrderTabKey): boolean {
if (tabKey === 'all') return true
if (tabKey === 'all') return !isPilotServiceOutboundWorkOrder(row)
return resolveTabKeyFromWorkOrder(row) === tabKey
}
+2
View File
@@ -8,12 +8,14 @@ describe('resolveSampleVoidTarget', () => {
receptionSource: 'cell_storage',
protocolSampleId: 'ps-1',
sampleCode: 'S1',
labStorageCode: 'B0000108',
collectionProtocolId: 'p-1'
})
assert.deepEqual(target, {
receptionSource: 'cell_storage',
sampleId: 'ps-1',
sampleCode: 'S1',
labStorageCode: 'B0000108',
protocolId: 'p-1'
})
})
+3
View File
@@ -8,6 +8,7 @@ export function resolveSampleVoidTarget(input: {
receptionSource?: string | null
protocolSampleId?: string | null
sampleCode?: string | null
labStorageCode?: string | null
collectionProtocolId?: string | null
fallbackSource?: string | null
}): SampleVoidTarget | null {
@@ -18,12 +19,14 @@ export function resolveSampleVoidTarget(input: {
if (source !== 'cell_storage' && source !== 'research_donation') return null
const sampleId = String(input.protocolSampleId || '').trim()
const sampleCode = String(input.sampleCode || '').trim()
const labStorageCode = String(input.labStorageCode || '').trim()
const protocolId = String(input.collectionProtocolId || '').trim()
if (!sampleId && !sampleCode) return null
return {
receptionSource: source,
sampleId: sampleId || undefined,
sampleCode: sampleCode || undefined,
labStorageCode: labStorageCode || undefined,
protocolId: protocolId || undefined
}
}
@@ -141,9 +141,10 @@
<span class="sample-card__seq">{{ sIdx + 1 }}</span>
{{ sampleTypeName(row.sampleTypeId) }}
</div>
<el-tag :type="sampleStatusTagType(String(row.sampleStatus || ''))" size="small">
{{ sampleStatusLabel(String(row.sampleStatus || '')) }}
</el-tag>
<SampleStatusTag
:status="row.sampleStatus"
:void-desc="row.voidDesc"
/>
</div>
<div class="sample-card__body">
<div class="sample-card__section">
@@ -1254,6 +1255,7 @@
import SampleQcInfoGroupedPanel from '@/components/business/sample-qc-info-grouped-panel/index.vue'
import SampleReceptionDualReadonlyPanel from '@/components/business/sample-reception-dual-readonly-panel/index.vue'
import SampleCodeWithSpecialDisplay from '@/components/business/sample-code-with-special-display/index.vue'
import SampleStatusTag from '@/components/business/sample-status-tag/index.vue'
import SampleProductionInfoCards from '@/components/business/sample-production-info-cards/index.vue'
import SampleStorageReleaseInfo from '@/components/business/sample-storage-release-info/index.vue'
import ProtocolHandlePanel from '@/components/business/protocol-handle-panel/index.vue'
@@ -1284,8 +1286,6 @@
payModeTagType,
newbornSexLabel,
deliveryModeLabel,
sampleStatusLabel,
sampleStatusTagType,
transportTypeLabel,
payStatusLabel,
payStatusTagType
@@ -0,0 +1,63 @@
<!-- 器械销售占位页:施工中 -->
<template>
<div class="page-container under-construction-page">
<section class="panel under-construction-panel">
<img
class="under-construction-img"
src="@/assets/images/common/under-construction.jpg"
alt="正在施工"
/>
<p class="under-construction-title">{{ pageTitle }}</p>
<p class="under-construction-hint">待完善</p>
</section>
</div>
</template>
<script setup lang="ts">
import { computed } from 'vue'
import { useRoute } from 'vue-router'
defineOptions({ name: 'DeviceSalesUnderConstruction' })
const route = useRoute()
const pageTitle = computed(() => String(route.meta?.title || '器械销售'))
</script>
<style scoped lang="scss">
.under-construction-page {
min-height: calc(100vh - 140px);
display: flex;
}
.under-construction-panel {
flex: 1;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 12px;
padding: 48px 24px;
text-align: center;
}
.under-construction-img {
width: min(420px, 70vw);
max-height: 280px;
object-fit: contain;
border-radius: 12px;
}
.under-construction-title {
margin: 8px 0 0;
font-size: 16px;
font-weight: 600;
color: #111827;
}
.under-construction-hint {
margin: 0;
font-size: 18px;
font-weight: 600;
color: #10b981;
}
</style>
@@ -499,6 +499,7 @@
receptionSource: row.receptionSource,
protocolSampleId: row.protocolSampleId,
sampleCode: row.sampleCode,
labStorageCode: row.labStorageCode,
collectionProtocolId: row.collectionProtocolId,
fallbackSource: productionVoidFallbackSource(row)
})
@@ -509,6 +510,7 @@
receptionSource: row.receptionSource,
protocolSampleId: row.protocolSampleId,
sampleCode: row.sampleCode,
labStorageCode: row.labStorageCode,
collectionProtocolId: row.collectionProtocolId,
fallbackSource: productionVoidFallbackSource(row)
})
@@ -22,6 +22,7 @@ import {
isAllProductionWorkOrderTab,
tabSupportsInactiveProtocolFilter,
resolveTabKeyFromWorkOrder,
workOrderMatchesTab,
type ProductionWorkOrderTabKey
} from '@/utils/production-work-order-tabs'
import { toAllTabListQuery } from '@/utils/production-work-order-category'
@@ -164,8 +165,16 @@ export function useProductionWorkOrderTabPage(
...listQuery,
...buildPlannedStartTimeParams()
})
tableData.value = res.list || []
pagination.total = res.total ?? 0
const rawList = res.list || []
const list = isAllProductionWorkOrderTab(tabKey.value)
? rawList.filter((row) => workOrderMatchesTab(row, 'all'))
: rawList
tableData.value = list
// 「所有」前端排除中试时,按本页剔除量修正 total(后端未改)
pagination.total = Math.max(
0,
(res.total ?? 0) - (rawList.length - list.length)
)
selectedRows.value = selectedRows.value.filter((row) =>
tableData.value.some((item) => item.id === row.id)
)
@@ -154,6 +154,7 @@
type QcTaskResultItem
} from '@/api/qc-task-result'
import { taskStatusLabel, taskStatusTagType } from '@/utils/qc-labels'
import { resolveThirdPartyFillDefaults } from '@/utils/qc-result-fill-defaults'
import { parseQcParamOptions } from '@/utils/qc-item-param-options'
import {
pickSharedRemarkAndAttachments,
@@ -233,16 +234,6 @@
emit('update:visible', false)
}
/** 第三方弹窗仅展示待执行/已完成;其它状态按待执行回显 */
function normalizeThirdPartySaveStatus(status?: string): 'dzx' | 'ywc' {
return (status || '').trim() === 'ywc' ? 'ywc' : 'dzx'
}
function normalizeConclusion(raw?: string): '' | 'tg' | 'btg' {
const c = (raw || '').trim()
return c === 'tg' || c === 'btg' ? c : ''
}
function normalizeResultParams(items: QcTaskResultItem[]): QcTaskResultItem[] {
return (items || []).map((p) => ({
...p,
@@ -319,13 +310,17 @@
companyId: detail?.companyId ?? task.companyId,
companyName: detail?.companyName ?? task.companyName
}
const fillDefaults = resolveThirdPartyFillDefaults({
taskStatus: merged.taskStatus,
conclusion: merged.conclusion
})
const item: ItemState = {
taskId: task.id,
itemName: merged.itemName || '—',
companyName: thirdPartyCompanyDisplayName(merged),
params: normalizeResultParams(results || []),
saveStatus: normalizeThirdPartySaveStatus(merged.taskStatus),
conclusion: normalizeConclusion(merged.conclusion)
saveStatus: fillDefaults.saveStatus,
conclusion: fillDefaults.conclusion
}
return { item, merged }
})
@@ -385,6 +380,11 @@
const thirdPartyAttachments = financeAttachmentsToUrlString(attachments.value)
const remarkVal = remark.value
// 同一次批量保存共用批次号,修改记录弹窗合并为一个时间线节点
const operateBatchId =
typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
? crypto.randomUUID().replace(/-/g, '').toUpperCase()
: `BATCH${Date.now()}${Math.random().toString(16).slice(2, 10)}`.toUpperCase()
saving.value = true
const failures: string[] = []
let successCount = 0
@@ -404,7 +404,8 @@
})),
remark: remarkVal,
thirdPartyAttachments,
taskStatus: item.saveStatus
taskStatus: item.saveStatus,
operateBatchId
},
props.operateScope
)
@@ -0,0 +1,445 @@
<!-- 质检任务 · 检测结果修改记录 -->
<template>
<el-dialog
:model-value="visible"
:title="dialogTitle"
width="800px"
class="dialog-form-layout qc-task-result-change-log-dialog"
align-center
modal-class="protocol-dialog-mask"
append-to-body
destroy-on-close
:close-on-click-modal="false"
@update:model-value="onVisibleChange"
>
<DialogFormBody :loading="loading" body-class="qc-result-chg-body">
<el-empty
v-if="!loading && !timelineNodes.length"
description="暂无修改记录"
:image-size="72"
/>
<div v-else class="qc-result-chg-tl">
<div
v-for="(node, idx) in timelineNodes"
:key="node.key"
class="qc-result-chg-tl__item"
>
<div class="qc-result-chg-tl__rail">
<span class="qc-result-chg-tl__dot" />
<span v-if="idx < timelineNodes.length - 1" class="qc-result-chg-tl__line" />
</div>
<div class="qc-result-chg-tl__content">
<div class="qc-result-chg-tl__meta">
{{ node.operateTime || '—' }} · {{ node.operatorUserName || '—' }}
<template v-if="node.entries.length > 1">
· 共 {{ node.entries.length }} 项
</template>
</div>
<div v-if="node.sharedAttachment" class="qc-result-chg-tl__change">
<div class="qc-result-chg-tl__line-text">
{{ node.sharedAttachment.fieldLabel }}:
<template
v-if="
node.sharedAttachment.oldValue &&
node.sharedAttachment.oldValue !== node.sharedAttachment.newValue
"
>
已更新
</template>
<template v-else-if="!node.sharedAttachment.newValue">已清空</template>
</div>
<ProtocolAttachmentReadonly
v-if="attachmentFilesFromValue(node.sharedAttachment.newValue).length"
size="compact"
:files="attachmentFilesFromValue(node.sharedAttachment.newValue)"
@preview="onAttachmentPreview"
@download="onAttachmentDownload"
/>
<span
v-else-if="!node.sharedAttachment.newValue"
class="qc-result-chg-tl__line-text"
>—</span>
</div>
<div
v-for="entry in node.entries"
:key="entry.id"
class="qc-result-chg-tl__entry"
>
<div
v-if="showItemName && entry.itemName"
class="qc-result-chg-tl__item-name"
>
{{ entry.itemName }}
</div>
<template v-if="visibleChanges(entry, node).length">
<div
v-for="(chg, cIdx) in visibleChanges(entry, node)"
:key="`${entry.id}-${cIdx}`"
class="qc-result-chg-tl__change"
>
<template v-if="isAttachmentChange(chg)">
<div class="qc-result-chg-tl__line-text">
{{ chg.fieldLabel }}:
<template v-if="chg.oldValue && chg.oldValue !== chg.newValue">
已更新
</template>
<template v-else-if="!chg.newValue">已清空</template>
</div>
<ProtocolAttachmentReadonly
v-if="attachmentFilesFromValue(chg.newValue).length"
size="compact"
:files="attachmentFilesFromValue(chg.newValue)"
@preview="onAttachmentPreview"
@download="onAttachmentDownload"
/>
<span
v-else-if="!chg.newValue"
class="qc-result-chg-tl__line-text"
>—</span>
</template>
<div v-else class="qc-result-chg-tl__line-text">
<template v-if="chg.oldValue">
{{ chg.fieldLabel }}:{{ chg.oldValue || '—' }} →
{{ chg.newValue || '—' }}
</template>
<template v-else>
{{ chg.fieldLabel }}:{{ chg.newValue || '—' }}
</template>
</div>
</div>
</template>
<div
v-else-if="!entry.hasFieldChange || !entry.changes?.length"
class="qc-result-chg-tl__line-text"
>
保存操作(字段无变更)
</div>
</div>
<div v-if="node.allNoFieldChange" class="qc-result-chg-tl__note">
即使未改值,点击保存也会记一条操作留痕
</div>
</div>
</div>
</div>
</DialogFormBody>
<template #footer>
<el-button class="btn-ghost" @click="close">
<el-icon><Close /></el-icon>关闭
</el-button>
</template>
</el-dialog>
</template>
<script setup lang="ts">
import { computed, ref, watch } from 'vue'
import { ElMessage } from 'element-plus'
import { Close } from '@element-plus/icons-vue'
import DialogFormBody from '@/components/business/dialog-form-body/index.vue'
import ProtocolAttachmentReadonly from '@/views/cell-storage/protocol/ProtocolAttachmentReadonly.vue'
import { downloadAttachmentFile } from '@/utils/download-attachment'
import {
qcAttachmentFullUrl,
qcPreviewAttachment
} from './composables/useQcViewAttachmentHelpers'
import {
fetchQcTaskResultChangeLogsBatch,
type QcTaskResultChangeItem,
type QcTaskResultChangeLog
} from '@/api/qc-task-result'
defineOptions({ name: 'QcTaskResultChangeLogDialog' })
type TimelineNode = {
key: string
operateTime: string
operatorUserName: string
entries: QcTaskResultChangeLog[]
allNoFieldChange: boolean
/** 多任务同次提交且检测材料一致时,提到节点级只展示一次 */
sharedAttachment: QcTaskResultChangeItem | null
}
/** 无批次号的旧数据:同操作人且时间差 ≤15s 合并为一次提交 */
const LEGACY_GROUP_WINDOW_MS = 15_000
const props = withDefaults(
defineProps<{
visible: boolean
taskIds: string[]
titleSuffix?: string
}>(),
{
titleSuffix: ''
}
)
const emit = defineEmits<{
'update:visible': [value: boolean]
}>()
const loading = ref(false)
const entries = ref<QcTaskResultChangeLog[]>([])
let loadSeq = 0
const showItemName = computed(() => (props.taskIds || []).length > 1)
const dialogTitle = computed(() => {
const suffix = (props.titleSuffix || '').trim()
return suffix ? `修改记录 · ${suffix}` : '修改记录'
})
const timelineNodes = computed(() => groupChangeLogs(entries.value))
function onVisibleChange(v: boolean) {
emit('update:visible', v)
}
function close() {
emit('update:visible', false)
}
function isAttachmentChange(chg: QcTaskResultChangeItem) {
return (chg.fieldKey || '') === 'attachments'
}
function pickSharedAttachment(rows: QcTaskResultChangeLog[]) {
if (rows.length < 2) return null
const attChanges = rows
.map((r) => (r.changes || []).find((c) => isAttachmentChange(c)))
.filter(Boolean) as QcTaskResultChangeItem[]
if (!attChanges.length || attChanges.length !== rows.length) return null
const first = attChanges[0]
const same = attChanges.every(
(c) => c.newValue === first.newValue && c.oldValue === first.oldValue
)
return same ? first : null
}
function visibleChanges(entry: QcTaskResultChangeLog, node: TimelineNode) {
const list = entry.changes || []
if (!node.sharedAttachment) return list
return list.filter((c) => !isAttachmentChange(c))
}
function attachmentFilesFromValue(raw: string | undefined) {
const text = String(raw || '').trim()
if (!text) return [] as Array<Record<string, unknown>>
return text
.split(',')
.map((u, i) => {
const url = u.trim()
if (!url) return null
const name = url.includes('/') ? url.split('/').pop() || `附件${i + 1}` : url
return {
id: `chg_att_${i}_${name}`,
fileUrl: url,
fileName: name
}
})
.filter(Boolean) as Array<Record<string, unknown>>
}
function onAttachmentPreview(file: Record<string, unknown>) {
qcPreviewAttachment(file)
}
function onAttachmentDownload(file: Record<string, unknown>) {
downloadAttachmentFile(file, { fullFileUrl: qcAttachmentFullUrl })
}
function parseOperateTimeMs(text: string | undefined) {
const s = String(text || '').trim()
if (!s) return NaN
const t = Date.parse(s.replace(/-/g, '/'))
return Number.isFinite(t) ? t : NaN
}
function groupChangeLogs(list: QcTaskResultChangeLog[]): TimelineNode[] {
const sorted = [...(list || [])].sort((a, b) => {
const tb = parseOperateTimeMs(b.operateTime)
const ta = parseOperateTimeMs(a.operateTime)
if (Number.isFinite(tb) && Number.isFinite(ta) && tb !== ta) return tb - ta
return String(b.id || '').localeCompare(String(a.id || ''))
})
const batchBuckets = new Map<string, QcTaskResultChangeLog[]>()
const orphans: QcTaskResultChangeLog[] = []
for (const row of sorted) {
const batch = String(row.operateBatchId || '').trim()
if (batch) {
const arr = batchBuckets.get(batch) || []
arr.push(row)
batchBuckets.set(batch, arr)
} else {
orphans.push(row)
}
}
const nodes: TimelineNode[] = []
for (const [batch, rows] of batchBuckets) {
nodes.push(toNode(`batch:${batch}`, rows))
}
// 旧数据兜底:按时间序贪心合并同操作人短窗口
const used = new Set<string>()
for (let i = 0; i < orphans.length; i++) {
const head = orphans[i]
if (used.has(head.id)) continue
const group = [head]
used.add(head.id)
const headTs = parseOperateTimeMs(head.operateTime)
const headOp = String(head.operatorUserId || head.operatorUserName || '')
for (let j = i + 1; j < orphans.length; j++) {
const cur = orphans[j]
if (used.has(cur.id)) continue
const curOp = String(cur.operatorUserId || cur.operatorUserName || '')
if (curOp !== headOp) continue
const curTs = parseOperateTimeMs(cur.operateTime)
if (!Number.isFinite(headTs) || !Number.isFinite(curTs)) continue
if (Math.abs(curTs - headTs) > LEGACY_GROUP_WINDOW_MS) continue
group.push(cur)
used.add(cur.id)
}
nodes.push(toNode(`legacy:${head.id}`, group))
}
return nodes.sort((a, b) => {
const tb = parseOperateTimeMs(b.operateTime)
const ta = parseOperateTimeMs(a.operateTime)
if (Number.isFinite(tb) && Number.isFinite(ta) && tb !== ta) return tb - ta
return a.key.localeCompare(b.key)
})
}
function toNode(key: string, rows: QcTaskResultChangeLog[]): TimelineNode {
const first = rows[0]
return {
key,
operateTime: first?.operateTime || '',
operatorUserName: first?.operatorUserName || '',
entries: rows,
allNoFieldChange: rows.every((r) => !r.hasFieldChange),
sharedAttachment: pickSharedAttachment(rows)
}
}
async function loadLogs() {
const seq = ++loadSeq
const ids = (props.taskIds || []).map((x) => (x || '').trim()).filter(Boolean)
loading.value = true
entries.value = []
try {
const list = ids.length ? await fetchQcTaskResultChangeLogsBatch(ids) : []
if (seq !== loadSeq) return
entries.value = Array.isArray(list) ? list : []
} catch {
if (seq !== loadSeq) return
entries.value = []
ElMessage.error('加载修改记录失败')
} finally {
if (seq === loadSeq) loading.value = false
}
}
watch(
() => [props.visible, (props.taskIds || []).join(',')] as const,
([vis]) => {
if (vis) void loadLogs()
}
)
</script>
<style scoped lang="scss">
:deep(.qc-result-chg-body) {
min-height: 480px;
max-height: min(70vh, 640px);
overflow-y: auto;
}
.qc-result-chg-tl {
display: flex;
flex-direction: column;
gap: 4px;
padding: 4px 0 8px;
min-height: 420px;
}
.qc-result-chg-tl__item {
display: flex;
gap: 12px;
}
.qc-result-chg-tl__rail {
display: flex;
flex-direction: column;
align-items: center;
width: 12px;
flex-shrink: 0;
}
.qc-result-chg-tl__dot {
width: 10px;
height: 10px;
margin-top: 4px;
border-radius: 50%;
background: var(--mint-primary, #10b981);
flex-shrink: 0;
}
.qc-result-chg-tl__line {
width: 2px;
flex: 1;
min-height: 36px;
margin-top: 4px;
background: var(--mint-primary-bg, #ecfdf5);
}
.qc-result-chg-tl__content {
flex: 1;
min-width: 0;
padding-bottom: 14px;
}
.qc-result-chg-tl__meta {
font-size: 12px;
font-weight: 600;
color: var(--mint-primary-dark, #059669);
margin-bottom: 8px;
}
.qc-result-chg-tl__entry {
margin-bottom: 10px;
&:last-child {
margin-bottom: 0;
}
}
.qc-result-chg-tl__item-name {
font-size: 13px;
font-weight: 600;
color: var(--mint-text, #1e293b);
margin-bottom: 4px;
}
.qc-result-chg-tl__change {
margin: 4px 0;
}
.qc-result-chg-tl__line-text {
font-size: 13px;
color: var(--mint-text, #1e293b);
margin: 2px 0;
word-break: break-word;
}
.qc-result-chg-tl__note {
margin-top: 6px;
font-size: 12px;
color: var(--mint-text-muted, #334155);
}
</style>
@@ -419,6 +419,7 @@
receptionSource: props.row.receptionSource,
protocolSampleId: props.row.protocolSampleId,
sampleCode: props.row.sampleCode,
labStorageCode: props.row.labStorageCode,
collectionProtocolId: props.row.collectionProtocolId,
fallbackSource: inboundVoidFallbackSource()
})
@@ -33,6 +33,16 @@
@click="openAllThirdResult(item)"
@dblclick="openAllThirdResult(item)"
>
<el-button
class="qc-task-card__history-icon"
link
type="primary"
title="修改记录"
aria-label="修改记录"
@click.stop="openChangeLogForTasks(item.tasks, ALL_THIRD_PARTY_CARD_TITLE)"
>
<el-icon><Clock /></el-icon>
</el-button>
<div class="qc-task-card__line qc-task-card__line--top">
<span class="qc-task-card__name">{{ ALL_THIRD_PARTY_CARD_TITLE }}</span>
<div class="qc-task-card__sub">
@@ -77,6 +87,16 @@
class="qc-task-card qc-task-card--compact"
@dblclick="handleView(item.task)"
>
<el-button
class="qc-task-card__history-icon"
link
type="primary"
title="修改记录"
aria-label="修改记录"
@click.stop="openChangeLogForTask(item.task)"
>
<el-icon><Clock /></el-icon>
</el-button>
<div class="qc-task-card__line qc-task-card__line--top">
<span class="qc-task-card__name">{{ item.task.itemName || '—' }}</span>
<div class="qc-task-card__tags">
@@ -414,6 +434,12 @@
@saved="handleTaskMutationSuccess"
/>
<QcTaskResultChangeLogDialog
v-model:visible="changeLogVisible"
:task-ids="changeLogTaskIds"
:title-suffix="changeLogTitleSuffix"
/>
<SystemViewDialog
v-model:visible="viewVisible"
title="任务详情"
@@ -575,7 +601,8 @@
EditPen,
Plus,
More,
Delete
Delete,
Clock
} from '@element-plus/icons-vue'
import ProtocolFinanceConfirmFields from '@/components/business/protocol-finance-confirm-fields/index.vue'
import ProtocolAttachmentReadonly from '@/views/cell-storage/protocol/ProtocolAttachmentReadonly.vue'
@@ -612,6 +639,7 @@
import { fetchItemUnitList } from '@/api/admin'
import { SHOW_QC_TASK_MATERIAL_USAGE } from '@/utils/qc-material-ui'
import { parseQcParamOptions } from '@/utils/qc-item-param-options'
import { resolveQcResultFillDefaults } from '@/utils/qc-result-fill-defaults'
import {
taskTypeLabel,
taskTypeTagType,
@@ -656,6 +684,7 @@
type QcTaskListDisplayItem
} from '@/utils/qc-company-task-group'
import QcCompanyTaskResultDialog from './QcCompanyTaskResultDialog.vue'
import QcTaskResultChangeLogDialog from './QcTaskResultChangeLogDialog.vue'
/** 根据来源类型返回协议状态标签 */
function protocolStatusLabelBySource(status: string, source: string, voidType?: string): string {
@@ -739,6 +768,25 @@
const companyDialogReadonly = ref(false)
const companyDialogTasks = ref<QcTask[]>([])
const companyDialogName = ref(ALL_THIRD_PARTY_CARD_TITLE)
const changeLogVisible = ref(false)
const changeLogTaskIds = ref<string[]>([])
const changeLogTitleSuffix = ref('')
function openChangeLogForTask(task: QcTask) {
const id = (task.id || '').trim()
if (!id) return
changeLogTaskIds.value = [id]
changeLogTitleSuffix.value = task.itemName || task.taskNo || ''
changeLogVisible.value = true
}
function openChangeLogForTasks(tasks: QcTask[], title: string) {
const ids = tasks.map((t) => (t.id || '').trim()).filter(Boolean)
if (!ids.length) return
changeLogTaskIds.value = ids
changeLogTitleSuffix.value = title || ''
changeLogVisible.value = true
}
function openAllThirdResult(item: QcTaskListAllThirdItem, forceReadonly?: boolean) {
let tasks = item.tasks
@@ -864,11 +912,6 @@
const resultDialogWidth = computed(() => (resultTaskType.value === 'sysz' ? '1200px' : '960px'))
function normalizeResultSaveStatus(status?: string): 'dzx' | 'jxz' | 'ywc' {
if (status === 'dzx' || status === 'jxz' || status === 'ywc') return status
return 'jxz'
}
function canFillResult(row: QcTask) {
if (row.taskType === 'sysz') {
return row.taskStatus === 'jxz' || row.taskStatus === 'ywc'
@@ -1391,12 +1434,16 @@
}
return
}
const initialDefaults = resolveQcResultFillDefaults({
taskStatus: row.taskStatus,
conclusion: row.conclusion
})
resultTaskStatus.value = row.taskStatus
resultSaveStatus.value = normalizeResultSaveStatus(row.taskStatus)
resultSaveStatus.value = initialDefaults.saveStatus
resultTaskId.value = row.id
resultTaskType.value = row.taskType
resultRemark.value = row.remark || ''
resultConclusion.value = ''
resultConclusion.value = initialDefaults.conclusion
resultAttachments.value = apiFilesToFinanceItems(row.attachmentFiles)
materialUsages.value = []
requisitionOptions.value = []
@@ -1404,10 +1451,13 @@
try {
const detail = await fetchQcTaskDetail(row.id)
resultTaskStatus.value = detail.taskStatus || row.taskStatus
resultSaveStatus.value = normalizeResultSaveStatus(detail.taskStatus || row.taskStatus)
const fillDefaults = resolveQcResultFillDefaults({
taskStatus: detail.taskStatus || row.taskStatus,
conclusion: detail.conclusion ?? row.conclusion
})
resultSaveStatus.value = fillDefaults.saveStatus
resultRemark.value = detail.remark || row.remark || ''
const c = (detail.conclusion || '').trim()
resultConclusion.value = c === 'tg' || c === 'btg' ? c : ''
resultConclusion.value = fillDefaults.conclusion
resultAttachments.value = apiFilesToFinanceItems(detail.attachmentFiles)
const results = await fetchQcTaskResults(row.id)
resultParams.value = normalizeResultParams(results || [])
@@ -1675,6 +1725,7 @@
}
.qc-task-card {
position: relative;
display: flex;
flex-direction: column;
gap: 6px;
@@ -1702,7 +1753,7 @@
width: 100%;
max-width: 220px;
gap: 4px;
padding: 6px 8px;
padding: 6px 28px 6px 8px;
}
&--company {
@@ -1717,6 +1768,26 @@
}
}
.qc-task-card__history-icon {
position: absolute;
top: 4px;
right: 4px;
z-index: 1;
width: 22px;
height: 22px;
padding: 0;
margin: 0;
color: var(--mint-primary-dark, #059669);
:deep(.el-icon) {
font-size: 14px;
}
&:hover {
color: var(--mint-primary, #10b981);
}
}
.qc-task-card__sub {
width: 100%;
font-size: 11px;
@@ -20,6 +20,7 @@ import {
isAllQcWorkOrderTab,
isInboundSampleQcTab,
resolveTabKeyFromWorkOrder,
workOrderMatchesTab,
type QcWorkOrderTabKey
} from '@/utils/qc-work-order-tabs'
import { toAllTabListQuery } from '@/utils/qc-work-order-category'
@@ -210,7 +211,10 @@ export function useQcWorkOrderTabPage(
...listQuery,
...timeParams
})
const list = res.list || []
const rawList = res.list || []
const list = isAllQcWorkOrderTab(tabKey.value)
? rawList.filter((row) => workOrderMatchesTab(row, 'all'))
: rawList
const ids = list.map((row) => row.id).filter(Boolean)
const batchMap = ids.length
? (await fetchQcInspectionBatchesBatch(ids).catch(() => ({}))) || {}
@@ -218,7 +222,8 @@ export function useQcWorkOrderTabPage(
// 先写入批次摘要,再渲染卡片,避免子组件在 preset 未就绪时逐条请求 inspection-batches
presetBatchesByWorkOrderId.value = batchMap
tableData.value = list
pagination.total = res.total ?? 0
// 「所有」前端排除中试时,按本页剔除量修正 total(后端未改)
pagination.total = Math.max(0, (res.total ?? 0) - (rawList.length - list.length))
} finally {
loading.value = false
}