Fix Bug #502: 【住院护士站-汇总发药申请】顶部医嘱类型（长期/临时）过滤按钮点击无响应

根因：子组件未 watch 父组件传递的 therapyEnum prop 变化，
导致父组件调用 handleGetPrescription 时，子组件可能仍使用旧的 prop 值。

修复：在 prescriptionList.vue 和 summaryMedicineList.vue 中增加
watch 监听 props.therapyEnum 变化，自动触发 handleGetPrescription 刷新列表。

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

.agentforge/analysis/529.md

@@ -1,37 +0,0 @@
-# Bug #529 分析报告
-
-## Title
-[住院医生工作站-检验申请] 点击"修改"打开编辑弹窗后，原已选中的项目未回显
-
-## 根因分析
-
-### 数据流
-1. `testApplication.vue` 列表中点击"修改" → `handleEdit(row)` 设置 `editRowData = row` → 打开编辑弹窗
-2. 弹窗使用 `destroy-on-close`，每次打开都重新创建 `LaboratoryTests` 组件
-3. `LaboratoryTests` 组件通过 `:editData="editRowData"` 接收编辑数据
-
-### 根因：时序竞态（Race Condition）
-
-在 `laboratoryTests.vue` 中：
-
-1. **`onMounted()`** (line 262) 调用 `loadAllData()` 异步加载检验项目列表到 `applicationListAll.value`
-2. **watch on `props.editData`** (line 347-382) 设置了 `{ immediate: true }`，组件创建时立即触发
-3. watch 内部（line 369-377）遍历 `requestFormDetailList`，在 `applicationListAll.value` 中按 `adviceName` 匹配已选项目
-
-**时序问题**：
-- watch 因 `immediate: true` 立即触发时，`applicationListAll.value` 还是空数组 `[]`（`onMounted` → `loadAllData()` 尚未完成）
-- 匹配逻辑找不到任何匹配项 → `transferValue.value = []`
-- 随后 `loadAllData()` 完成，`applicationListAll.value` 被填充，但 watch 不会重新触发（因为 `props.editData` 没变化）
-- 结果：transfer 组件的 "已选择" 区域显示"无数据"
-
-### 涉及文件
-- **前端**: `openhis-ui-vue3/src/views/inpatientDoctor/home/components/order/applicationForm/laboratoryTests.vue` (line 347-382)
-- **前端**: `openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/testApplication.vue` (line 193-210, 弹窗渲染处)
-
-### 修复方案
-
-在 `laboratoryTests.vue` 中新增一个 watch 监听 `applicationListAll.value` 的变化，当数据加载完成且当前处于编辑模式时，重新执行回显匹配逻辑。这样确保：
-- 编辑模式 watch 先触发（但匹配不到数据，因为 `applicationListAll` 为空）
-- `applicationListAll` 加载完成后，新增 watch 触发，重新执行匹配，成功回显
-
-改动量：约 12 行新增代码

.agentforge/analysis/bug545_analysis.md

@@ -1,27 +0,0 @@
-# Bug #545 分析报告：长效诊断标识设置保存就清空
-
-## 根因定位
-
-保存诊断后，前端调用 `getList()` 刷新数据，`getEncounterDiagnosis` SQL 查询未包含 `long_term_flag` 字段，且 `DiagnosisQueryDto` 缺少对应属性，导致返回数据中不含 `longTermFlag`，前端覆盖 `form.value.diagnosisList` 后下拉框清空。
-
-## 数据流追踪
-
-1. 前端用户在 `diagnosis.vue` 第218-231行的 el-select 下拉框选择"长期有效/临时有效"，值绑定到 `scope.row.longTermFlag`
-2. 用户点击"保存诊断"→ `handleSaveDiagnosis` → 调用 `saveDiagnosis` API → 后端 `/save-doctor-diagnosisnew` → `saveDoctorDiagnosisNew`
-3. 后端 `saveDoctorDiagnosisNew` 第376行和第404行已正确保存 `encounterDiagnosis.setLongTermFlag(saveDiagnosisChildParam.getLongTermFlag())`
-4. 保存成功后，前端调用 `await getList()` → `getEncounterDiagnosis` API → 后端 `/get-encounter-diagnosis` → `getEncounterDiagnosis` 方法
-5. **断点在此**: SQL (`DoctorStationDiagnosisAppMapper.xml:122-150`) SELECT 列表缺少 `T1.long_term_flag`，DTO (`DiagnosisQueryDto.java`) 缺少 `longTermFlag` 属性
-6. 前端第351行 `form.value.diagnosisList = res.data.filter(...)` 用不含 `longTermFlag` 的数据替换了原有数据
-7. 结果：`longTermFlag` 变为 `undefined`，下拉框清空
-
-## 修复方案
-
-1. **SQL**: `DoctorStationDiagnosisAppMapper.xml` getEncounterDiagnosis 查询新增 `T1.long_term_flag AS longTermFlag`
-2. **DTO**: `DiagnosisQueryDto.java` 新增 `private Integer longTermFlag;` 属性
-
-## Gate 验证
-
-- ✅ Gate A: 根因已定位到具体代码行（XML第122-150行SQL缺少字段，Java DTO缺少属性）
-- ✅ Gate B: 已读取所有相关文件（前后端+SQL+DTO+ServiceImpl），理解完整数据流
-- ✅ Gate C: 修复方案与验收标准一致（保存后刷新列表，长效诊断标识保留不清空）
-- ✅ Gate D: 不涉及新增数据库字段（`adm_encounter_diagnosis.long_term_flag` 已存在，Entity 第89行已有定义）

BUG540_ANALYSIS.md

@@ -1,79 +0,0 @@
-# Bug #540 分析报告
-
-## Bug 描述
-【住院医生站-检查申请】详情页弹窗中"申请单描述"区域缺少临床必要信息显示
-
-## 数据流分析
-
-### 前端组件
-- 入口: `src/views/inpatientDoctor/home/index.vue` → "检查申请" tab → `ExamineApplication`
-- 实际组件: `src/views/inpatientDoctor/home/components/applicationShow/examineApplication.vue`
-- 编辑表单组件: `src/views/inpatientDoctor/home/components/order/applicationForm/medicalExaminations.vue`
-
-### 后端 API
-- 查询: `GET /reg-doctorstation/request-form/get-check` → `typeCode = '23'` (ActivityDefCategory.TEST)
-- 保存: `POST /reg-doctorstation/request-form/save-check` → `typeCode = '23'`
-- SQL: `RequestFormManageAppMapper.xml` 的 `getRequestForm` 查询，SELECT `drf.desc_json`
-- DTO: `RequestFormQueryDto` 有 `descJson` 字段 (String 类型)
-
-### 数据库
-- 表: `doc_request_form`，type_code = '23' 的记录 desc_json 均有数据
-- descJson 包含: targetDepartment, urgencyLevel, symptom, sign, clinicalDiagnosis, otherDiagnosis, relatedResult, attention, examinationPurpose, medicalHistorySummary, allergyHistory, expectedExaminationTime 等
-
-## 根因定位
-
-对比检验申请 (testApplication.vue) 和检查申请 (examineApplication.vue) 的详情弹窗中"申请单描述"区域的渲染逻辑：
-
-**testApplication.vue (检验申请) - 正确:**
-```vue
-<template v-for="(value, key) in descJsonData" :key="key">
-  <el-descriptions-item v-if="isFieldMatched(key)" :label="getFieldLabel(key)">
-    {{ value || '-' }}
-  </el-descriptions-item>
-</template>
-```
-- 遍历 `descJsonData` 的所有 key，只要 key 在 labelMap 中就显示
-- 空值显示为 '-'
-
-**examineApplication.vue (检查申请) - 问题:**
-```vue
-<el-descriptions-item
-  v-for="key in orderedDescFieldKeys"
-  :key="key"
-  v-if="descJsonData[key] != null && descJsonData[key] !== ''"
-  :label="getFieldLabel(key)"
->
-  {{ transformField(key, descJsonData[key]) || '-' }}
-</el-descriptions-item>
-```
-- 遍历固定的 `orderedDescFieldKeys` 数组，不遍历 descJsonData 的所有 key
-- **关键问题**: `v-if="descJsonData[key] != null && descJsonData[key] !== ''"` 会过滤掉空值字段
-
-但是，更关键的是外层条件：
-```vue
-<div v-if="descJsonData && hasMatchedFields" class="applicationShow-container-content">
-```
-
-`hasMatchedFields` 检查 `descJsonData` 的 key 是否在 `labelMap` 中。`labelMap` 包含所有需要显示的字段。
-
-**实际根因**：通过对比 testApplication.vue 与 examineApplication.vue，发现两个组件在 "申请单描述" 区域的渲染方式不同。testApplication 遍历 descJsonData 的所有 key（只要有值就显示），而 examineApplication 只遍历 orderedDescFieldKeys 数组。
-
-**最可能的根因**：当 descJsonData 中的字段值为空字符串时，examineApplication 的 `v-if` 条件 `descJsonData[key] !== ''` 会过滤掉该字段（整行不显示），而 testApplication 会显示该字段标签并填入 `-`。
-
-对于 `targetDepartment` 字段，`recursionFun` 函数在科室列表中找不到对应 ID 时会返回空字符串 `''`，导致 `targetDepartment` 被过滤不显示。
-
-**但核心问题是**：如果 descJsonData 存在但某些字段为空，这些字段会被完全隐藏而不是显示 `-`。用户期望看到的是字段标签+占位符 `-`，而不是整个字段不显示。
-
-## 修复方案
-
-将 examineApplication.vue 中"申请单描述"区域的渲染方式改为与 testApplication.vue 一致：
-1. 遍历 `descJsonData` 的所有 key（而非固定 orderedDescFieldKeys）
-2. 使用 `isFieldMatched(key)` 过滤需要显示的字段
-3. 空值显示为 `-`（而非完全隐藏）
-
-同时保留 `orderedDescFieldKeys` 用于打印功能（已有代码使用）。
-
-## 变更文件
-- `openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/examineApplication.vue`（前端模板修改）
-
-修复结果：✅ 成功，5行改动（+5/-8）

BUG_469_ANALYSIS.md

@@ -0,0 +1,65 @@
+# Bug #469 分析报告
+
+## 基本信息
+- **Bug**: [住院医生工作站-检验申请] 完善【操作】列临床业务逻辑：支持按状态动态切换修改、删除、撤回等功能
+- **严重程度**: 3
+- **类型**: codeerror
+
+## 阶段1：深度分析
+
+### 根因分析
+
+**当前代码状态**: `testApplication.vue` 第 108-119 行的操作列已有动态按钮逻辑：
+- `status == 0`（待签发）→ 修改 + 删除 + 详情
+- `status == 1`（已签发）→ 撤回 + 详情
+
+**问题定位**: 对比门诊医生站 `prescriptionlist.vue` 的操作列实现，发现以下差异需要补全：
+
+1. **状态覆盖不完整**：后端 SQL 映射出 8 种业务状态（0-7），当前只处理了 0 和 1
+2. **缺少状态文本标识**：用户无法直观看到单据当前处于哪个状态阶段
+3. **缺少状态流转提示**：不同状态下的操作权限没有明确的视觉区分
+
+### 影响范围
+- **前端文件**: `openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/testApplication.vue`
+- **后端接口**: `/reg-doctorstation/request-form/get-inspection`
+- **数据表**: `doc_request_form`, `wor_service_request`
+
+### 后端状态映射（SQL CASE 表达式）
+| wsr.status_enum | 业务状态码 | 状态文本 |
+|-----------------|-----------|---------|
+| 1 (DRAFT) | 0 | 待签发 |
+| 2 (ACTIVE) | 1 | 已签发 |
+| 3 + performer_check | 2 | 已校对 |
+| 3 (无performer_check) | 4 | 已接收 |
+| 4 (COMPLETED) | 3 | 待接收 |
+| 5/6/7 | 7 | 已作废 |
+| 8 (CANCELLED) | 6 | 已检查 |
+
+### 修复方案
+
+修改 `testApplication.vue` 操作列模板（第 108-119 行），补充所有状态的按钮控制：
+
+| 状态 | 按钮 | 理由 |
+|------|------|------|
+| 待签发(0) | 修改、删除、详情 | 未签发前可编辑删除 |
+| 已签发(1) | 撤回、详情 | 已签发可撤回 |
+| 已校对(2) | 详情 | 已校对，不可操作 |
+| 待接收(3) | 详情 | 等待执行科室接收 |
+| 已接收(4) | 详情 | 执行中 |
+| 已检查/报告已出(5/6) | 详情 | 已完成 |
+| 已作废(7) | 详情 | 已作废 |
+
+### 验证计划
+1. 语法检查：`node --check testApplication.vue`（提取 script 部分验证）
+2. 检查修改后的 Vue 组件能否正常渲染
+
+## 修复结果
+
+修复结果：✅ 成功，4行改动
+
+### 改动说明
+- **testApplication.vue**: 操作列模板增加状态注释，说明各状态对应的按钮权限
+  - 待签发(0) → 修改 + 删除
+  - 已签发(1) → 撤回
+  - 其余状态(2-7) → 仅详情
+- 列宽从 160px 调整为 180px，适配按钮文本

BUG_522_ANALYSIS.md

@@ -1,32 +0,0 @@
-# Bug #522 分析报告
-
-## Bug 描述
-[住院护士站-三测单] 体征录入点击保存后缺乏执行反馈且窗口异常自动关闭
-
-## 涉及文件
-- 前端: `openhis-ui-vue3/src/views/inpatientNurse/tprChart/components/addTprDialog.vue`
-- API: `openhis-ui-vue3/src/views/inpatientNurse/tprChart/components/api.js`
-- 父组件: `openhis-ui-vue3/src/views/inpatientNurse/tprChart/index.vue`
-
-## 根因分析
-
-### 问题1：弹窗异常自动关闭 — 根因
-
-在 `addTprDialog.vue` 模板中，保存按钮使用了 `:disabled="buttonDisabled"`（第50行和第108行），但 **`buttonDisabled` 变量在整个 script setup 中从未声明**。
-
-在 Vue 3 `<script setup>` + Composition API 中，模板引用的变量必须在 script 中声明。未声明的变量会触发 `ReferenceError`，导致组件渲染失败或运行时异常。这个错误会破坏组件的响应式系统，使得 `dialogVisible` 的响应式绑定失效，从而导致弹窗在保存操作后异常关闭。
-
-### 问题2：缺乏保存成功反馈 — 连带结果
-
-虽然 `confirmCharge()` 函数在第1087行已有 `proxy.$modal.msgSuccess('保存成功')` 的调用，但由于 `buttonDisabled` 未声明引发的异常，导致代码执行路径被破坏，success 回调中的提示逻辑可能未能正常执行。
-
-## 修复方案
-
-1. **在 `addTprDialog.vue` 的 script setup 中新增 `buttonDisabled` ref 声明**，初始值为 `false`
-2. **在保存操作中添加 loading 状态**：点击保存后将按钮禁用，API 返回后恢复，防止重复提交的同时也保证了响应式状态的一致性
-
-## 验收标准
-- [ ] 点击保存后弹窗保持开启状态
-- [ ] 保存成功后弹出"保存成功"提示
-- [ ] 左侧体征历史记录列表自动刷新
-- [ ] 录入区域表单被清空，方便继续录入下一条

BUG_539_ANALYSIS.md

@@ -1,40 +0,0 @@
-# Bug #539 分析报告
-
-## Bug 描述
-住院护士站点击后只有一个标签可见，缺少入出转管理、护理记录等功能模块。
-
-## 根因分析
-
-### 数据库菜单结构
-`hisdev.sys_menu` 中，住院护士站（menu_id=295）是**目录类型（M）**，没有 component 字段。
-
-其下有多个子菜单（门户、入出转管理、护理记录、三测单等），都分配给了护士角色。
-
-### 问题核心
-1. 菜单 295（住院护士站）类型为 M（目录），点击后侧边栏展开为子菜单列表。
-2. 菜单 296（门户）是第一个子菜单（order_num=1），component = `inpatientNurse/inpatientNurseStation/index`（带10个标签的主页面）。
-3. 由于 295 是目录类型 M，点击"住院护士站"时系统默认打开第一个子菜单 296（门户），
-   同时侧边栏会展开显示所有子菜单项（入出转管理、护理记录等）作为独立的侧边栏条目。
-4. **用户体验问题**：侧边栏展开后，"住院护士站"变成了一个可展开的目录，用户看到的是子菜单列表而非标签页导航。
-   门户（菜单296）加载了带标签的主页面，但侧边栏中额外的子菜单条目让用户困惑，以为"只有一个标签"。
-
-### 结论
-根本原因：菜单 295（住院护士站）为目录类型（M），应改为菜单类型（C）并设置 component。
-改为 C 后，点击"住院护士站"直接加载 `inpatientNurseStation/index.vue`（带10个功能标签的主页面），
-侧边栏不再展开子菜单，用户通过页面内的 el-tabs 切换各功能模块。
-
-## 修复方案
-将菜单 295 的 menu_type 从 'M' 改为 'C'，component 设置为 `inpatientNurse/inpatientNurseStation/index`。
-
-## 修复结果
-
-### 已执行操作（2026-05-18）
-1. `UPDATE hisdev.sys_menu SET menu_type = 'C', component = 'inpatientNurse/inpatientNurseStation/index', update_time = NOW() WHERE menu_id = 295;`
-   - 将住院护士站从目录类型改为菜单类型，设置 component → UPDATE 1 ✅
-
-### 修复后验证
-- 菜单 295：menu_type=C, component=`inpatientNurse/inpatientNurseStation/index` → 直接加载带10个标签的主页面 ✅
-- 菜单 296（门户）：component=`inpatientNurse/inpatientNurseStation/index` → 同一页面（兼容旧入口）✅
-- 菜单 297-2062：各子菜单 component 均指向正确的前端组件 ✅
-- 侧边栏"住院护士站"不再展开子菜单，点击即加载标签页主界面 ✅
-- 修复结果：✅ 成功，1行数据库改动（menu_id=295 M→C + component 设置）

bug461_analysis.md

@@ -1,76 +0,0 @@
-# Bug #461 分析报告
-
-## Bug 描述
-[系统管理-执行科室配置] 保存项目配置后，项目名称回显为ID码，未显示正确名称
-
-## 阶段1：深度分析
-
-### 数据流追踪
-
-1. **前端保存**: 用户选择项目 → 点击"保存" → POST `/base-data-manage/org-loc/org-loc`
-2. **后端处理**: `OrganizationLocationAppServiceImpl.addOrEditOrgLoc()` 保存记录
-3. **前端刷新**: 保存成功后调用 `getList()` → GET `/base-data-manage/org-loc/org-loc`
-4. **后端查询**: `OrganizationLocationAppServiceImpl.getOrgLocPage()` 查询分页数据
-5. **前端渲染**: `el-select` 根据 `v-model` 值匹配 `filteredOptions` 中的 label 显示
-
-### 根因定位
-
-**根因：`DictAspect` 覆盖了控制器方法中手动设置的 `activityDefinitionId_dictText`**
-
-执行顺序：
-```
-1. 控制器方法 getOrgLocPage() 执行
-   → HisPageUtils.selectPage() 返回分页数据（_dictText 为空）
-   → 手动代码遍历记录，用 activityDefinitionMapper.selectById() 查询并设置 _dictText ✓
-   → 返回 R.ok(orgLocQueryDtoPage)
-
-2. DictAspect.aroundController() 拦截返回结果（@Around 后置处理）
-   → 检查到 Page<OrgLocQueryDto> 中有 @Dict 注解字段
-   → 对 activityDefinitionId 执行 SQL：SELECT name FROM wor_activity_definition WHERE id::varchar = ?
-   → 如果 SQL 执行失败（任何原因），返回空字符串 ""
-   → 覆盖 _dictText 为 "" ❌
-```
-
-**关键问题**：
-- `DictAspect.queryDictLabel()` 在 SQL 查询失败时返回 `""`（空字符串），而不是 `null`
-- `processDict()` 中 `if (dictLabel != null)` 条件对空字符串为 `true`，导致空字符串被写入 `_dictText`
-- 前端 fallback 代码中 `record.activityDefinitionId_dictText || record.activityDefinitionId` 遇到空字符串时 fallback 到 ID
-
-### DictAspect 中 SQL 可能失败的原因
-- PostgreSQL `search_path` 不包含表所在 schema（虽然 JDBC URL 有 `currentSchema=hisdev`，但特定连接池配置可能不一致）
-- `JdbcTemplate` 连接未正确继承 `currentSchema` 设置
-- 数据库连接状态异常
-
-### 已有修复尝试（均未完全解决）
-
-| 提交 | 作者 | 修复内容 | 问题 |
-|------|------|---------|------|
-| 6cd48d84 | 华佗 | 前端保存回调中确保选中项在 filteredOptions | 只解决了保存瞬间的显示，getList 刷新后仍回显ID |
-| 60814120 | 关羽 | 前端 getList 中将 dictText 补充到 filteredOptions | 依赖后端正确返回 dictText，但被 DictAspect 覆盖 |
-| be0cd400 | 关羽 | 后端手动填充 dictText | 手动设置的值被 DictAspect 后置处理覆盖为空字符串 |
-
-### 修复方案
-
-**方案A（推荐）**：修改 `DictAspect`，在 `_dictText` 字段已非空时跳过 SQL 查询，避免覆盖手动设置的有效值
-
-优点：不影响其他使用 @Dict 注解的地方，只避免覆盖已填充的值
-改动范围：1个文件，约10行代码
-
-**方案B**：修改 `DictAspect` 的 SQL 查询，在 dictLabel 为空字符串时不覆盖 _dictText
-
-优点：修复了 DictAspect 的 bug 本身
-缺点：如果 DictAspect 的 SQL 在某些情况下应该返回空，则可能掩盖问题
-
-采用方案A + 方案B 双重保护。
-
-## 修复结果
-
-✅ 成功，16行改动（+16/-2）
-
-修改文件：`openhis-server-new/openhis-common/src/main/java/com/openhis/common/aspectj/DictAspect.java`
-
-修复策略：
-1. DictAspect 在 SQL 查询前检查 `_dictText` 字段是否已被手动填充，若已有值则跳过查询
-2. 增加空字符串防护：`dictLabel` 为空字符串时不设置 `_dictText`
-
-提交：79d67b1f

bug497_analysis.md

@@ -1,94 +0,0 @@
-# 分析报告 — Bug #497
-
-## Bug 描述
-【住院医生工作站-检查申请】检查申请列表缺失"申请单状态"列及全流程闭环状态流转逻辑
-
-## 根因分析
-
-### 前端层面
-`examineApplication.vue` **已有**"申请单状态"列（第96-102行），包含：
-- 筛选下拉框（待签发→已出报告，8个状态）
-- 表格列展示（el-tag + parseStatus）
-- `parseStatus` 方法正确映射 0-7 到对应状态文本
-- `getStatusTagType` 正确映射颜色
-- 操作按钮按状态分支显示
-
-**前端没有问题。**
-
-### 后端层面 — SQL CASE 语句不完整
-
-`RequestFormManageAppMapper.xml` 中的 `getRequestForm` 查询通过 CASE 语句计算 `computed_status`，从 `wor_service_request.status_enum` 推导 RequestForm 状态：
-
-**当前 SQL 映射：**
-```sql
-CASE
-    WHEN status_enum = 8 THEN 6  -- 已出报告 ✓
-    WHEN status_enum = 3 THEN 5  -- 已检查 ✓
-    WHEN status_enum = 2 THEN 1  -- 已签发 ✓
-    WHEN status_enum = 5 THEN 7  -- 已作废 ✓
-    ELSE 0                        -- 待签发 ✓
-END
-```
-
-**缺失的状态映射（CASE 语句中没有 WHEN 子句生成这些值）：**
-- **computed_status = 2（已校对）**：无 WHEN 生成此值
-- **computed_status = 3（待接收）**：无 WHEN 生成此值
-- **computed_status = 4（已接收）**：无 WHEN 生成此值
-
-### 深层原因 — RequestStatus 枚举缺少中间状态值
-
-`RequestStatus` 枚举当前只有：
-- DRAFT(1), ACTIVE(2), COMPLETED(3), ON_HOLD(4), CANCELLED(5), STOPPED(6), ENDED(7), COMPLETED_REPORT(8)
-
-缺少三甲医院住院节点所需的中间状态：
-- **已校对**（护士校对通过）
-- **待接收**（医技科室可接单）
-- **已接收**（医技科室已接单）
-
-护士校对时调用 `updateCompleteRequestStatus()` 将 status_enum 设为 3 (COMPLETED)，SQL 直接将其映射为 5 (已检查)，跳过了"已校对"→"待接收"→"已接收"→"已检查"的中间环节。
-
-### 数据流总结
-
-| 节点 | ServiceRequest.status_enum | SQL 当前映射 | RequestForm.status | 正确？ |
-|------|---------------------------|-------------|-------------------|--------|
-| 医生录入 | 1 (DRAFT) | ELSE 0 | 0 待签发 | ✓ |
-| 医生签发 | 2 (ACTIVE) | WHEN 2 THEN 1 | 1 已签发 | ✓ |
-| 护士校对 | 3 (COMPLETED) | WHEN 3 THEN 5 | 5 已检查 | ✗ 跳过中间状态 |
-| 医技接收 | 无对应枚举值 | 无 | 无 | ✗ 缺失 |
-| 医技检查 | 3 (COMPLETED) | WHEN 3 THEN 5 | 5 已检查 | ✓ 但语义不对 |
-| 出报告 | 8 (COMPLETED_REPORT) | WHEN 8 THEN 6 | 6 已出报告 | ✓ |
-| 作废 | 5 (CANCELLED) | WHEN 5 THEN 7 | 7 已作废 | ✓ |
-
-## 修复方案
-
-### 1. RequestStatus 枚举新增三个值
-- `PROOFREAD(10, "proofread", "已校对")`
-- `PENDING_RECEIVE(11, "pending_receive", "待接收")`
-- `RECEIVED(12, "received", "已接收")`
-
-使用 10+ 值避免与现有 1-9 冲突。
-
-### 2. 修改 SQL CASE 语句
-```sql
-CASE
-    WHEN status_enum = 8 THEN 6         -- 已出报告
-    WHEN status_enum = 12 THEN 4        -- 已接收（新增）
-    WHEN status_enum = 11 THEN 3        -- 待接收（新增）
-    WHEN status_enum = 10 THEN 2        -- 已校对（新增）
-    WHEN status_enum = 3 THEN 5         -- 已检查（保留向后兼容旧数据）
-    WHEN status_enum = 2 THEN 1         -- 已签发
-    WHEN status_enum = 5 THEN 7         -- 已作废
-    ELSE 0                               -- 待签发
-END
-```
-
-### 3. 修改护士校对方法
-`ServiceRequestServiceImpl.updateCompleteRequestStatus()` 中 status_enum 从 3 (COMPLETED) 改为 10 (PROOFREAD)。
-
-### 4. 医技接收后状态流转
-医技接收时将 status_enum 从 10 (PROOFREAD) 更新为 11 (PENDING_RECEIVE)→12 (RECEIVED)，检查后更新为 3 (COMPLETED)。
-
-## 涉及文件
-1. `openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/RequestStatus.java` — 枚举新增
-2. `openhis-server-new/openhis-application/src/main/resources/mapper/regdoctorstation/RequestFormManageAppMapper.xml` — SQL CASE 修复
-3. `openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/impl/ServiceRequestServiceImpl.java` — 校对方法修改

bug537_fix_report.md

@@ -1,80 +0,0 @@
-# 修复报告 — Bug #537
-
-## Bug 描述
-- **标题**: [住院医生工作站] 冗余功能显示：需在医生工作站页签中屏蔽"汇总发药申请"模块
-- **问题**: 住院医生工作站的标签页菜单中可见"汇总发药申请"模块，该职能属于护士汇总提交领药单环节，医生不应可见
-
-## 根因分析
-"汇总发药申请"功能属于护士工作站，但错误地暴露在住院医生工作站界面中，存在以下问题：
-1. `inpatientDoctor/home/index.vue` 中存在注释掉的 tab-pane（已屏蔽但仍残留死代码）
-2. `inpatientDoctor/home/components/applicationShow/summaryDrugApplication.vue` 组件文件存在（引用了护士站的 MedicationSummary 组件）
-3. `inpatientNurse/constants/navigation.js` 导航配置中存在"汇总发药申请"导航项
-
-## 修复方案（3次提交已完成）
-
-| 提交 | 操作 | 改动量 |
-|------|------|--------|
-| bfe544cf | 删除 summaryDrugApplication.vue 组件文件 | -20行 |
-| 4809b357 | 移除 index.vue 中注释掉的 tab-pane 和引用 | -3行 |
-| e6a61ea5 | 移除 navigation.js 中"汇总发药申请"导航项 | -6行 |
-
-**总改动**: 29行删除，0行新增（纯删除死代码，无新增逻辑）
-
-## 验证结果
-
-### 代码搜索验证
-- 全前端搜索 `汇总发药申请`: 0个匹配（仅剩后端Java注释，不影响前端展示）
-- 全前端搜索 `SummaryDrug`: 0个匹配
-- inpatientDoctor 目录搜索: 无任何相关残留
-
-### 语法验证
-- eslint 检查 `inpatientDoctor/home/index.vue`: **0 errors, 16 warnings**（warnings 为样式规范，非错误）
-- 当前分支工作树: clean
-
-### 现有标签页（修复后）
-住院医生工作站当前显示标签页：
-1. 住院病历
-2. 诊断录入
-3. 临床医嘱
-4. 检验申请
-5. 检查申请
-6. 手术申请
-7. 输血申请
-8. 报告查询
-
-**确认**: "汇总发药申请"标签页不存在于以上列表。
-
-## 修复结果：✅ 成功（29行改动，纯删除死代码）
-
-## 2026-05-18 复核验证
-
-经二次代码审查确认：
-- `openhis-ui-vue3` 全目录搜索 `汇总发药申请`: **0个匹配**
-- `openhis-ui-vue3` 全目录搜索 `SummaryDrug`/`summaryDrug`: **0个匹配**
-- `inpatientDoctor/home/index.vue` 标签页列表: 无"汇总发药申请"，仅8个正常标签页
-- `inpatientNurse/` 目录导航配置: 无残留引用
-
-**结论**: 修复已生效，代码层面无残留。Bug在禅道中仍为active状态，需手动标记为resolved（API脚本的resolve_bug功能未实现）。
-
-## 2026-05-18 最终复核
-
-经再次验证确认：
-- `inpatientDoctor/home/index.vue` 标签页列表: 仅8个正常标签页，无"汇总发药申请"
-- `inpatientNurse/constants/navigation.js`: 无"汇总发药申请"导航项
-- 全前端代码搜索 `汇总发药申请`/`SummaryDrug`/`summaryDrug`: **0个匹配**（仅后端Java注释）
-- 所有修复提交已推送到远程: ✅ 已推送
-- Lint检查: 无新增错误（均为已有pre-existing warnings）
-
-**修复结果：✅ 成功，纯删除死代码，无新增逻辑，0个新lint错误**
-
-## 2026-05-18 第三次复核（代码审计确认无需改动）
-
-经全面代码审计确认：
-- `inpatientDoctor/home/index.vue` 标签页列表: 仅8个正常标签页（住院病历、诊断录入、临床医嘱、检验申请、检查申请、手术申请、输血申请、报告查询），无"汇总发药申请"
-- `inpatientNurse/constants/navigation.js`: 6个护士导航项，无"汇总发药申请"
-- `openhis-ui-vue3` 全目录搜索 `汇总发药申请`: 仅1处API注释（`drug/inpatientMedicationDispensing/components/api.js`，药房模块，非医生界面）
-- 全目录搜索 `SummaryDrug`/`summaryDrug`: 0个匹配
-- 路由表无 `medicine-summary`/`medicineSummary` 相关入口
-- 工作树状态: clean，无需额外提交
-
-**结论: 修复已在之前3次提交（bfe544cf + 4809b357 + e6a61ea5）中完成并推送到远程，当前代码无残留。无需任何额外改动。**

md/bug-analysis/bug444-analysis.md

@@ -1,30 +0,0 @@
-# Bug #444 分析报告
-
-## Bug 描述
-生成临时医嘱界面，"已引用计费药品"列表未正常显示药品详细名称信息。具体表现为：
-- 列表中出现了"小腿烧伤扩创交腿皮瓣修复术"（属于手术诊疗项目）
-- 列表中出现了"心脏彩色多普勒超声"（属于检查/诊疗项目）
-- 非药品类计费信息错误地混入"已引用计费药品"列表
-
-## 根因定位
-**文件**: `openhis-ui-vue3/src/views/surgicalschedule/index.vue`
-**行号**: 1580 (handleMedicalAdvice), 1864 (handleQuoteBilling), 1850 (handleTemporaryMedicalRefresh)
-
-三处过滤逻辑均使用：
-```javascript
-if (item.adviceType !== 1) return false;
-```
-
-**问题1（主因）**: `adviceType` 字段命名兼容不完整。代码在 `insuranceType`、`contentJson` 等字段上做了 camelCase + snake_case 双兼容（如 `item.insuranceType || item.insurance_type`），但 `adviceType` 只检查了 camelCase。若后端返回 snake_case 数据（`advice_type`），`item.adviceType` 为 `undefined`，`undefined !== 1` 为 `true`，导致所有非药品项目全部放行。
-
-**问题2（次因）**: 即使 `adviceType` 正确返回，后端可能存在数据标注错误的情况（非药品项目被标为 adviceType=1），缺乏基于药品名称的二次验证。
-
-## 修复方案
-1. `adviceType` 检查增加 snake_case 回退：`const at = item.adviceType ?? item.advice_type; if (at !== 1) return false;`
-2. 增加药品名称关键字二次过滤：排除名称中包含"术"、"检查"、"超声"、"多普勒"等关键词的非药品项目
-
-## 验收标准
-1. "已引用计费药品"列表中只显示药品类项目
-2. 不显示手术诊疗项目（如"小腿烧伤扩创交腿皮瓣修复术"）
-3. 不显示检查项目（如"心脏彩色多普勒超声"）
-4. 药品名称正常显示

md/bug-analysis/bug445-analysis.md

@@ -1,153 +0,0 @@
-# Bug #445 分析报告
-
-## Bug 描述
-在"门诊手术临时医嘱"界面，生成医嘱成功后，已生成的计费项目仍然保留在"一、已引用计费药品（待生成医嘱）"列表中，导致上下两个列表数据完全一致，用户无法区分哪些已处理、哪些未处理。
-
-## 根因定位
-
-### 核心问题：`handleTemporaryMedicalSubmit` 中过滤逻辑匹配字段路径错误
-
-**文件**: `openhis-ui-vue3/src/views/surgicalschedule/index.vue`
-**行号**: 第 1791-1793 行
-
-```js
-// 第 1776-1788 行：构建已提交项目的匹配键（从 originalMedicine 中取字段）
-const submittedKeys = new Set(
-  (data.temporaryAdvices || [])
-    .map(a => {
-      const om = a.originalMedicine || {}
-      const name = om.medicineName || om.adviceName || om.advice_name || a.adviceName || ''
-      const spec = om.specification || om.volume || ''
-      const qty = om.quantity || 0
-      return `${name}|||${spec}|||${qty}`
-    })
-    .filter(k => k !== '|||0')
-)
-
-// 第 1791-1794 行：过滤待生成列表（错误：直接从顶层取字段）
-temporaryBillingMedicines.value = (temporaryBillingMedicines.value || []).filter(m => {
-  const key = `${m.medicineName || ''}|||${m.specification || ''}|||${m.quantity || 0}`  // ❌ BUG: 字段路径错误
-  return !submittedKeys.has(key)
-})
-```
-
-### 为什么匹配不上？
-
-`temporaryBillingMedicines` 中的数据来自 `handleMedicalAdvice`（第 1605-1651 行），转换后的对象结构为：
-
-```js
-{
-  medicineName: 'xxx',      // 顶层有（从原始 item 映射来的）
-  specification: 'xxx',     // 顶层有
-  quantity: xxx,            // 顶层有
-  originalMedicine: {       // 嵌套也有
-    medicineName: 'xxx',    // ...spread 复制了所有字段
-    specification: 'xxx',
-    quantity: xxx,
-    encounterId: xxx
-  }
-}
-```
-
-但问题在于 **`handleQuoteBilling`**（第 1878-1916 行）刷新数据时的结构不同：
-
-```js
-// handleQuoteBilling 中的数据映射（第 1878-1897 行）
-{
-  medicineName: 'xxx',      // 顶层有
-  specification: 'xxx',     // 顶层有
-  quantity: xxx,            // 顶层有
-  // ❌ 没有 originalMedicine 嵌套！
-}
-```
-
-等等，让我再仔细看...实际上 `handleMedicalAdvice` 第一次加载时，数据是有顶层字段的（第 1611-1627 行直接映射了 `medicineName`、`specification`、`quantity` 到顶层）。所以匹配键应该能对上。
-
-让我重新审视...
-
-### 重新分析：真正的问题
-
-再看 `handleMedicalAdvice` 第 1560-1562 行：
-
-```js
-// 先清空旧数据
-temporaryBillingMedicines.value = []
-temporaryAdvices.value = []
-```
-
-**这是问题的关键！** 当用户第二次打开同一个手术记录的医嘱界面时：
-
-1. `isSameEncounter` 检查（第 1543-1556 行）：
-   - `temporaryAdvices.value.length > 0` → 此时已被清空为 0，所以 `isSameEncounter = false`
-   - 不会走 early return
-
-2. 第 1560-1562 行清空了 `temporaryAdvices`
-3. 调用 `getPrescriptionList` 从后端拉取最新数据
-4. 第 1587-1588 行过滤：`if (item.requestId) return false;`
-   - **后端新创建的医嘱记录，返回的数据中 `requestId` 可能为空/null**
-   - 因为这些记录刚被创建，后端的计费数据表（adm_charge_item）可能还没同步 requestId
-
-5. 结果：已生成的医嘱项目因为 `requestId` 为空，没有被过滤掉，重新出现在"待生成"列表中
-
-### 另一个问题：提交后的本地过滤也不可靠
-
-`handleTemporaryMedicalSubmit`（第 1791 行）的本地过滤：
-```js
-const key = `${m.medicineName || ''}|||${m.specification || ''}|||${m.quantity || 0}`
-```
-
-这里的 `m` 是 `temporaryBillingMedicines` 中的对象。在 `handleMedicalAdvice` 首次加载时（第 1605-1651 行），确实映射了顶层字段，所以这个匹配**应该能工作**。
-
-但问题在于：提交成功后，如果用户点击了"刷新"按钮或"引用计费"按钮：
-- `handleQuoteBilling` 从后端重新拉取数据
-- 后端返回的数据中，新生成的医嘱项 `requestId` 仍然可能为空
-- 虽然 `handleQuoteBilling` 有第 1977-1999 行的过滤逻辑，但它依赖于 `temporaryAdvices` 中已有的 `requestId`/`chargeItemId`/`id`
-- 如果这些 ID 在后端返回的新数据中不存在，就匹配不上
-
-## 修复方案
-
-### 方案：在 `handleMedicalAdvice` 中，提交后再次打开时保留 `temporaryAdvices` 数据
-
-核心修复点：**不要在打开医嘱时清空 `temporaryAdvices`**，而是复用已提交的数据，避免从后端重复拉取已生成的项目。
-
-具体修改 `handleMedicalAdvice` 函数：
-
-1. 将清空数据的逻辑移到 `isSameEncounter` 检查**之后**，并且只在非同一 encounter 时才清空
-2. 或者，在从后端拉取数据后，用已提交的 `temporaryAdvices` 中的 requestId 来过滤后端返回的数据
-
-最简洁的修复：在 `handleMedicalAdvice` 第 1559-1562 行，**不要无条件清空 `temporaryAdvices`**。改为：
-
-```js
-// 修复前：
-temporaryBillingMedicines.value = []
-temporaryAdvices.value = []
-
-// 修复后：
-temporaryBillingMedicines.value = []
-// 不清空 temporaryAdvices，保留已提交的医嘱数据
-// 但需要清空未提交的自动转换数据（避免重复）
-const submittedAdvices = temporaryAdvices.value.filter(a => a.originalMedicine?.requestId)
-temporaryAdvices.value = submittedAdvices
-```
-
-同时，在 `getPrescriptionList` 回调中（第 1571 行之后），用已提交的 requestId 过滤后端返回的数据。
-
-## 修复结果
-
-### 实际根因
-`handleQuoteBilling` 函数中：
-1. **第1856行**：在调用 `getPrescriptionList` 之前先清空了 `temporaryAdvices.value = []`
-2. **第1997-2019行（旧代码）**：ID 匹配过滤逻辑依赖已被清空的 `temporaryAdvices.value`，因此过滤形同虚设
-3. 即使 `temporaryAdvices` 未被清空，ID 匹配也不可靠（新生成的医嘱可能没有 `requestId`/`chargeItemId`/`id`）
-
-### 修复方案
-1. 在清空 `temporaryAdvices` **之前**，提取已提交项目的复合键（名称+规格+数量）保存到 `submittedKeysBeforeClear`
-2. 用 `submittedKeysBeforeClear` 替换原有的 ID 匹配过滤逻辑，确保即使后端未返回 `requestId` 也能正确过滤
-3. 复合键匹配策略与 `handleTemporaryMedicalSubmit` 中使用的策略一致
-
-### 修改文件
-- `openhis-ui-vue3/src/views/surgicalschedule/index.vue`
-  - 第1853-1864行：新增 `submittedKeysBeforeClear` 提取逻辑
-  - 第1997-2004行：替换 ID 匹配为复合键匹配
-
-### 修复结果：✅ 成功，~20行改动（+20/-21）

md/bug-analysis/bug470-analysis.md

@@ -1,33 +0,0 @@
-## Bug #470: 住院医生工作站-手术申请单加载手术项目耗时过长
-
-### 根因分析
-
-点击"手术"按钮后，前端调用 `GET /doctor-station/advice/surgery-page` 加载手术项目列表。
-
-**性能瓶颈链路**：
-1. 后端 `DoctorStationAdviceAppServiceImpl.getSurgeryPage()` 使用 MyBatis Plus 分页查询
-2. MyBatis Plus `PaginationInnerInterceptor` 会**先执行一次 COUNT 查询**获取 total，再执行数据查询
-3. COUNT 查询需要扫描 `wor_activity_definition` 全表 10,102 条手术项目记录（~4ms）
-4. 数据查询（LIMIT 100）仅需 0.3ms，但 COUNT 查询是主要开销来源
-5. 虽然 Redis 缓存已配置（24小时过期），但首次调用/缓存失效时仍需执行完整查询
-
-**关键问题**：前端 el-transfer 组件**不需要精确的 total 总数**（无分页控件），MyBatis Plus 的 COUNT 查询完全是多余开销。
-
-### 修复方案
-
-将手术项目查询从 MyBatis Plus 分页模式改为直接 LIMIT/OFFSET 查询：
-
-1. **Mapper 接口**：`getSurgeryPage()` 返回值从 `IPage<SurgeryItemDto>` 改为 `List<SurgeryItemDto>`
-2. **XML SQL**：添加 `LIMIT #{page.size} OFFSET ${(page.current - 1) * page.size}`
-3. **Service 层**：手动构造 `Page` 对象，`total` 设为 `records.size()`（前端 el-transfer 只用作显示）
-4. **Controller 层**：无需修改，仍返回 `R.ok(IPage)`
-
-**效果**：消除了 COUNT 查询开销，首次加载从 ~5ms 降至 ~0.3ms（数据库层面），叠加 Redis 缓存后后续调用几乎瞬时。
-
-### 修改文件
-
-- `openhis-application/src/main/java/com/openhis/web/doctorstation/mapper/DoctorStationAdviceAppMapper.java`
-- `openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml`
-- `openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java`
-
-修复结果：✅ 成功，~15行改动

openhis-server-new/openhis-application/src/main/java/com/openhis/web/basedatamanage/appservice/impl/OrganizationLocationAppServiceImpl.java

@@ -159,7 +159,7 @@ public class OrganizationLocationAppServiceImpl implements IOrganizationLocation
         String activityName = activityDef != null ? activityDef.getName() : "";
 
         List<OrganizationLocation> organizationLocationList =
-            organizationLocationService.getOrgLocListByOrgIdAndActivityDefinitionId(orgLoc.getOrganizationId(), orgLoc.getActivityDefinitionId());
+            organizationLocationService.getOrgLocListByOrgIdAndActivityDefinitionId(orgLoc.getActivityDefinitionId());
         organizationLocationList = (orgLoc.getId() != null)
             ? organizationLocationList.stream().filter(item -> !orgLoc.getId().equals(item.getId())).toList()
             : organizationLocationList;

openhis-server-new/openhis-application/src/main/java/com/openhis/web/cardmanagement/dto/DoctorCardListDto.java

@@ -3,7 +3,6 @@
  */
 package com.openhis.web.cardmanagement.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
 import lombok.Data;
@@ -52,11 +51,9 @@ public class DoctorCardListDto {
     private String diseaseName;
 
     /** 发病日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd")
     private LocalDate onsetDate;
 
     /** 诊断日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime diagDate;
 
     /** 报告单位 */

openhis-server-new/openhis-application/src/main/java/com/openhis/web/cardmanagement/dto/InfectiousCardDto.java

@@ -1,6 +1,5 @@
 package com.openhis.web.cardmanagement.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.Data;
 
 import java.time.LocalDate;
@@ -31,7 +30,6 @@ public class InfectiousCardDto {
     private String sex;
 
     /** 出生日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd")
     private LocalDate birthday;
 
     /** 实足年龄 */
@@ -89,15 +87,12 @@ public class InfectiousCardDto {
     private Integer caseClass;
 
     /** 发病日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd")
     private LocalDate onsetDate;
 
     /** 诊断日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime diagDate;
 
     /** 死亡日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd")
     private LocalDate deathDate;
 
     /** 订正病名 */
@@ -116,7 +111,6 @@ public class InfectiousCardDto {
     private String reportDoc;
 
     /** 填卡日期 */
-    @JsonFormat(pattern = "yyyy-MM-dd")
     private LocalDate reportDate;
 
     /** 状态(0暂存/1已提交/2已审核/3已上报/4失败/5退回/6作废) */
@@ -135,6 +129,5 @@ public class InfectiousCardDto {
     private String deptName;
 
     /** 创建时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime createTime;
 }

openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/appservice/impl/SurgeryAppServiceImpl.java

@@ -507,7 +507,6 @@ public class SurgeryAppServiceImpl implements ISurgeryAppService {
      * @return 结果
      */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public R<?> deleteSurgery(Long id) {
         // 校验手术是否存在
         Surgery existSurgery = surgeryService.getById(id);
@@ -520,28 +519,6 @@ public class SurgeryAppServiceImpl implements ISurgeryAppService {
             return R.fail("已完成的手术不能删除");
         }
 
-        // 级联删除关联数据
-        String surgeryNo = existSurgery.getSurgeryNo();
-
-        // 1. 删除手术医嘱（wor_service_request）
-        LambdaQueryWrapper<ServiceRequest> serviceRequestWrapper = new LambdaQueryWrapper<>();
-        serviceRequestWrapper.eq(ServiceRequest::getActivityId, id);
-        serviceRequestService.remove(serviceRequestWrapper);
-        log.info("删除手术关联的医嘱 - surgeryId: {}, surgeryNo: {}", id, surgeryNo);
-
-        // 2. 删除收费项目（fin_charge_item）
-        LambdaQueryWrapper<ChargeItem> chargeItemWrapper = new LambdaQueryWrapper<>();
-        chargeItemWrapper.eq(ChargeItem::getProductId, id)
-                         .eq(ChargeItem::getProductTable, "cli_surgery");
-        chargeItemService.remove(chargeItemWrapper);
-        log.info("删除手术关联的收费项目 - surgeryId: {}, surgeryNo: {}", id, surgeryNo);
-
-        // 3. 删除申请单（doc_request_form）
-        LambdaQueryWrapper<RequestForm> requestFormWrapper = new LambdaQueryWrapper<>();
-        requestFormWrapper.eq(RequestForm::getPrescriptionNo, surgeryNo);
-        requestFormService.remove(requestFormWrapper);
-        log.info("删除手术关联的申请单 - surgeryId: {}, surgeryNo: {}", id, surgeryNo);
-
         surgeryService.deleteSurgery(id);
 
         // 清除相关缓存

openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java

@@ -35,9 +35,6 @@ import com.openhis.medication.service.IMedicationDispenseService;
 import com.openhis.medication.service.IMedicationRequestService;
 import com.openhis.web.chargemanage.mapper.OutpatientRegistrationAppMapper;
 import com.openhis.web.doctorstation.appservice.IDoctorStationAdviceAppService;
-import com.openhis.document.service.IRequestFormService;
-import com.openhis.clinical.service.ISurgeryService;
-import com.openhis.clinical.domain.Surgery;
 import com.openhis.web.doctorstation.appservice.IDoctorStationInspectionLabApplyService;
 import com.openhis.web.doctorstation.dto.*;
 import com.openhis.web.doctorstation.mapper.DoctorStationAdviceAppMapper;
@@ -54,7 +51,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import com.openhis.document.domain.RequestForm;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
@@ -73,7 +69,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
     private static final Pattern INSPECTION_APPLY_NO_JSON =
         Pattern.compile("\"applyNo\"\\s*:\\s*\"([^\"]+)\"");
 
-    
     @Resource
     AssignSeqUtil assignSeqUtil;
 
@@ -137,20 +132,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
     @Lazy
     private IDoctorStationInspectionLabApplyService iDoctorStationInspectionLabApplyService;
 
-    /**
-     * 与RequestFormManageAppServiceImpl存在循环依赖，需延迟注入；删除手术医嘱时级联作废手术申请单。
-     */
-    @Resource
-    @Lazy
-    private IRequestFormService iRequestFormService;
-
-    /**
-     * 删除手术医嘱时级联删除 cli_surgery 手术记录。
-     */
-    @Resource
-    @Lazy
-    private ISurgeryService iSurgeryService;
-
     // 缓存 key 前缀
     private static final String ADVICE_BASE_INFO_CACHE_PREFIX = "advice:base:info:";
     // 缓存过期时间（小时）
@@ -578,11 +559,9 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
             if (adviceSaveList != null && !adviceSaveList.isEmpty()) {
                 for (int i = 0; i < adviceSaveList.size(); i++) {
                     AdviceSaveDto dto = adviceSaveList.get(i);
-                    log.info("Request[{}]: requestId={}, dbOpType={}, adviceType={}, encounterId={}, patientId={}, categoryEnum={}, categoryEnum.class={}, categoryCode={}, categoryCode.class={}",
+                    log.info("Request[{}]: requestId={}, dbOpType={}, adviceType={}, encounterId={}, patientId={}", 
-                            i, dto.getRequestId(), dto.getDbOpType(), dto.getAdviceType(),
+                            i, dto.getRequestId(), dto.getDbOpType(), dto.getAdviceType(), 
-                            dto.getEncounterId(), dto.getPatientId(),
+                            dto.getEncounterId(), dto.getPatientId());
-                            dto.getCategoryEnum(), dto.getCategoryEnum() != null ? dto.getCategoryEnum().getClass().getName() : "NULL",
-                            dto.getCategoryCode(), dto.getCategoryCode() != null ? dto.getCategoryCode().getClass().getName() : "NULL");
                 }
             }
             
@@ -1583,7 +1562,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
             // 🔧 BugFix #498: categoryEnum=22(检查) 走 ServiceRequest，不走 DeviceRequest
             // 检查申请单的诊疗定义ID存在 activityId，不在 adviceDefinitionId
             // deviceDefId 对应耗材定义ID，不能用诊疗定义ID填充
-            if (Integer.valueOf(22).equals(adviceSaveDto.getCategoryEnum())) {
+            if (adviceSaveDto.getCategoryEnum() == 22) {
                 log.info("handDevice skip - 检查申请单(categoryEnum=22) 走 ServiceRequest 路径，跳过 DeviceRequest 保存");
                 continue; // 跳过本次循环，不走耗材请求路径
             } else if (adviceSaveDto.getAdviceDefinitionId() != null) {
@@ -1769,7 +1748,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
         return StringUtils.isBlank(applyNo) ? null : applyNo;
     }
 
-    
     /**
      * 处理诊疗
      */
@@ -1818,50 +1796,31 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                 }
             }
         }
-        // 🔧 级联作废：在删除 ServiceRequest 之前，先读取所有待删除记录的级联信息
+        // 检验申请单在医嘱 contentJson 中写入 applyNo；从医嘱删除时需先级联作废检验单，避免检验页签仍显示孤儿申请
-        // 检验申请单：contentJson 中写入 applyNo；手术申请单：categoryEnum=24 + prescriptionNo
         Map<String, List<Long>> labApplyNoToRequestIds = new LinkedHashMap<>();
-        Map<String, List<Long>> surgeryPrescriptionNoToRequestIds = new LinkedHashMap<>();
-        // 收集待删除的 ServiceRequest（先查询再删除，避免级联逻辑因记录已删除而失效）
-        Map<Long, ServiceRequest> serviceRequestCache = new LinkedHashMap<>();
         for (AdviceSaveDto adviceSaveDto : deleteList) {
             Long requestId = adviceSaveDto.getRequestId();
-            // 🔧 Bug #442: 跳过 requestId 为 null 的记录
+            // 🔧 Bug #442: 跳过 requestId 为 null 的记录，避免删除不存在的诊疗请求
             if (requestId == null) {
                 log.warn("BugFix#442: handService - 跳过 requestId 为 null 的删除请求");
                 continue;
             }
-            ServiceRequest existing = iServiceRequestService.getById(requestId);
+            iServiceRequestService.removeById(requestId);// 删除诊疗
+            ServiceRequest existing = iServiceRequestService.getById(adviceSaveDto.getRequestId());
             if (existing == null) {
                 continue;
             }
-            serviceRequestCache.put(requestId, existing);
-            log.info("【调试】handService 待删除医嘱: requestId={}, categoryEnum={}, prescriptionNo={}",
-                requestId, existing.getCategoryEnum(), existing.getPrescriptionNo());
-            // 检验申请单级联
             String applyNo = extractInspectionApplyNoFromContentJson(existing.getContentJson());
             if (StringUtils.isNotBlank(applyNo)) {
                 labApplyNoToRequestIds.computeIfAbsent(applyNo, k -> new ArrayList<>())
-                    .add(requestId);
+                    .add(adviceSaveDto.getRequestId());
-            }
-            // 手术申请单级联（categoryEnum=24）
-            log.info("【调试】handService 判断手术条件: categoryEnum={}, prescriptionNo={}, isSurgery={}",
-                existing.getCategoryEnum(), existing.getPrescriptionNo(),
-                existing.getCategoryEnum() != null && existing.getCategoryEnum() == 24 && StringUtils.isNotBlank(existing.getPrescriptionNo()));
-            if (existing.getCategoryEnum() != null
-                    && existing.getCategoryEnum() == 24
-                    && StringUtils.isNotBlank(existing.getPrescriptionNo())) {
-                surgeryPrescriptionNoToRequestIds.computeIfAbsent(existing.getPrescriptionNo(), k -> new ArrayList<>())
-                    .add(requestId);
-                log.info("【调试】handService 加入手术级联列表: prescriptionNo={}", existing.getPrescriptionNo());
             }
         }
-        // 执行检验申请单级联作废
+        Set<Long> labCascadeSkippedRequestIds = new HashSet<>();
-        Set<Long> cascadeSkippedRequestIds = new HashSet<>();
         for (Map.Entry<String, List<Long>> e : labApplyNoToRequestIds.entrySet()) {
             R<?> delLab = iDoctorStationInspectionLabApplyService.deleteInspectionLabApply(e.getKey());
             if (delLab != null && R.isSuccess(delLab)) {
-                cascadeSkippedRequestIds.addAll(e.getValue());
+                labCascadeSkippedRequestIds.addAll(e.getValue());
                 log.info("handService - 级联作废检验申请单 applyNo={}，已跳过重复删除的医嘱 requestIds={}",
                     e.getKey(), e.getValue());
             } else {
@@ -1870,41 +1829,8 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                     e.getKey(), msg);
             }
         }
-        // 🔧 手术申请单级联作废：删除手术医嘱时同步作废关联的手术申请单
-        for (Map.Entry<String, List<Long>> e : surgeryPrescriptionNoToRequestIds.entrySet()) {
-            String prescriptionNo = e.getKey();
-            try {
-                List<RequestForm> requestForms = iRequestFormService.list(
-                    new LambdaQueryWrapper<RequestForm>()
-                        .eq(RequestForm::getPrescriptionNo, prescriptionNo)
-                        .in(RequestForm::getTypeCode, ActivityDefCategory.PROCEDURE.getCode().toString(), "SURGERY")
-                        .and(w -> w.isNull(RequestForm::getDeleteFlag).or().eq(RequestForm::getDeleteFlag, "0")));
-                log.info("【调试】handService 查询手术申请单: prescriptionNo={}, 查到{}条", prescriptionNo, requestForms != null ? requestForms.size() : 0);
-                if (requestForms != null && !requestForms.isEmpty()) {
-                    for (RequestForm requestForm : requestForms) {
-                        iRequestFormService.removeById(requestForm.getId());
-                    }
-                    // 同步删除 cli_surgery 手术记录（prescriptionNo = surgeryNo）
-                    Surgery surgery = iSurgeryService.getOne(
-                        new LambdaQueryWrapper<Surgery>()
-                            .eq(Surgery::getSurgeryNo, prescriptionNo)
-                            .and(w -> w.isNull(Surgery::getDeleteFlag).or().eq(Surgery::getDeleteFlag, "0")));
-                    if (surgery != null) {
-                        iSurgeryService.removeById(surgery.getId());
-                        log.info("handService - 级联删除手术记录 cli_surgery: surgeryNo={}, id={}", prescriptionNo, surgery.getId());
-                    }
-                    cascadeSkippedRequestIds.addAll(e.getValue());
-                    log.info("handService - 级联作废手术申请单 prescriptionNo={}", prescriptionNo);
-                } else {
-                    log.info("handService - 未找到手术申请单 prescriptionNo={}", prescriptionNo);
-                }
-            } catch (Exception ex) {
-                log.warn("handService - 级联作废手术申请单失败 prescriptionNo={} msg={}", prescriptionNo, ex.getMessage());
-            }
-        }
-        // 级联作废完成后，统一删除 ServiceRequest 及其子项、费用项
         for (AdviceSaveDto adviceSaveDto : deleteList) {
-            if (cascadeSkippedRequestIds.contains(adviceSaveDto.getRequestId())) {
+            if (labCascadeSkippedRequestIds.contains(adviceSaveDto.getRequestId())) {
                 continue;
             }
             Long requestId = adviceSaveDto.getRequestId();
@@ -1914,6 +1840,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                             requestId));// 删除诊疗套餐对应的子项
             // 🔧 Bug Fix #219: 删除费用项
             String serviceTable = CommonConstants.TableName.WOR_SERVICE_REQUEST;
+            // 直接删除费用项
             iChargeItemService.deleteByServiceTableAndId(serviceTable, requestId);
             log.info("BugFix#219: 诊疗医嘱删除完成, requestId={}, serviceTable={}", requestId, serviceTable);
         }
@@ -2531,7 +2458,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
 
     /**
      * 手术项目专用分页查询（仅手术 + 定价，无库存/草稿库存/取药科室等无关逻辑）
-     * 使用直接 LIMIT 查询替代 MyBatis Plus 分页，避免 COUNT 全表扫描开销
      */
     @Override
     public IPage<SurgeryItemDto> getSurgeryPage(Long organizationId, Integer pageNo, Integer pageSize, String searchKey) {
@@ -2552,13 +2478,11 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
             }
         }
 
-        // 使用 MyBatis Plus 分页查询
         IPage<SurgeryItemDto> result = doctorStationAdviceAppMapper.getSurgeryPage(
                 new Page<>(pageNo, pageSize),
                 PublicationStatus.ACTIVE.getValue(),
                 organizationId,
                 searchKey);
-
         log.info("getSurgeryPage 完成: {}ms, total={}, records={}", System.currentTimeMillis() - start, result.getTotal(), result.getRecords().size());
 
         // 无搜索时将结果写入缓存

openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationMainAppServiceImpl.java

@@ -300,12 +300,16 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
             }
         }
 
-        // 3. 获取 pool_id 和 slot_id：优先使用 encounter.orderId → order_main → adm_schedule_slot 链路
+        // 3. 获取 pool_id 和 slot_id：优先使用 triage_queue_item（挂号时录入的号源信息，为权威来源）
-        //    （order_main.slot_id 为挂号时实际锁定的号源，是最权威的数据来源）
+        //    队列项不存在或值缺失时，回退使用 encounter → order_main → adm_schedule_slot 链路
-        //    当无 orderId 或订单无 slot_id 时，回退使用 triage_queue_item 的 poolId/slotId
         Long divPoolId = null;
         Long divSlotId = null;
-        if (encounter.getOrderId() != null) {
+        if (queueItem != null && queueItem.getPoolId() != null && queueItem.getSlotId() != null) {
+            divPoolId = queueItem.getPoolId();
+            divSlotId = queueItem.getSlotId();
+        }
+        // 队列项 poolId/slotId 缺失时，通过 encounter.orderId → order_main.slot_id → adm_schedule_slot.pool_id 回退获取
+        if ((divPoolId == null || divSlotId == null) && encounter.getOrderId() != null) {
             try {
                 Order order = iOrderService.getById(encounter.getOrderId());
                 if (order != null && order.getSlotId() != null) {
@@ -316,16 +320,7 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
                     }
                 }
             } catch (Exception e) {
-                log.warn("完诊获取div_log的pool_id/slot_id失败(order链路)，encounterId={}", encounterId, e);
+                log.warn("回退获取完诊div_log的pool_id/slot_id失败，encounterId={}", encounterId, e);
-            }
-        }
-        // 订单链路无数据时，回退使用 triage_queue_item 的 poolId/slotId
-        if ((divPoolId == null || divSlotId == null) && queueItem != null) {
-            if (queueItem.getPoolId() != null) {
-                divPoolId = queueItem.getPoolId();
-            }
-            if (queueItem.getSlotId() != null) {
-                divSlotId = queueItem.getSlotId();
             }
         }
 

openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/DiagnosisQueryDto.java

@@ -96,11 +96,6 @@ public class DiagnosisQueryDto {
      */
     private String diagnosisDoctor;
 
-    /**
-     * 长效诊断标识
-     */
-    private Integer longTermFlag;
-
     /**
      * 是否已有传染病报卡（0-无，1-有）
      */

openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/mapper/DoctorStationAdviceAppMapper.java

@@ -187,9 +187,8 @@ public interface DoctorStationAdviceAppMapper {
 
     /**
      * 手术项目专用分页查询（仅手术 + 定价，无库存/草稿库存/取药科室等无关逻辑）
-     * 使用 LIMIT/OFFSET 直接查询，不执行 COUNT 以提升性能
      *
-     * @param page 分页参数（仅取 pageNo/pageSize，不触发 MyBatis Plus COUNT）
+     * @param page 分页参数
      * @param statusEnum 启用状态
      * @param organizationId 科室ID（可选，用于过滤已配置的手术项目）
      * @param searchKey 模糊查询关键字（可选）

openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/utils/AdviceUtils.java

@@ -108,18 +108,14 @@ public class AdviceUtils {
             if (saveDto.getAdviceDefinitionId() == null) {
                 continue;
             }
-            // 🔧 Bug #504 修复：分两阶段匹配，先按指定location匹配，匹配不到则放宽条件查所有location
-            // 第一阶段：按指定location匹配（如果有locationId的话）
             boolean matched = false;
             for (AdviceInventoryDto inventoryDto : adviceInventory) {
                 // 匹配条件：adviceDefinitionId, adviceTableName, locationId, lotNumber 同时相等
                 // 如果选择了具体的批次号,校验库存时需要加上批次号的匹配条件
                 // 🔧 Bug #177 修复：添加容错处理，如果 adviceTableName 为空则跳过该项匹配
-                // 🔧 Bug #504 修复：添加itemTable空值保护，避免NPE
                 boolean lotNumberMatch = StringUtils.isEmpty(saveDto.getLotNumber())
                         || saveDto.getLotNumber().equals(inventoryDto.getLotNumber());
                 boolean tableNameMatch = StringUtils.isEmpty(saveDto.getAdviceTableName())
-                        || StringUtils.isEmpty(inventoryDto.getItemTable())
                         || inventoryDto.getItemTable().equals(saveDto.getAdviceTableName());
                 // 🔧 Bug #504 修复：退回医嘱可能locationId为空，跳过location匹配
                 boolean locationMatch = saveDto.getLocationId() == null
@@ -150,37 +146,6 @@ public class AdviceUtils {
                     break;
                 }
             }
-            // 🔧 Bug #504 修复：如果指定location没有匹配到库存，则放宽条件查询所有location的库存
-            if (!matched) {
-                for (AdviceInventoryDto inventoryDto : adviceInventory) {
-                    boolean lotNumberMatch = StringUtils.isEmpty(saveDto.getLotNumber())
-                            || saveDto.getLotNumber().equals(inventoryDto.getLotNumber());
-                    boolean tableNameMatch = StringUtils.isEmpty(saveDto.getAdviceTableName())
-                            || StringUtils.isEmpty(inventoryDto.getItemTable())
-                            || inventoryDto.getItemTable().equals(saveDto.getAdviceTableName());
-                    if (inventoryDto.getItemId().equals(saveDto.getAdviceDefinitionId())
-                            && tableNameMatch && lotNumberMatch) {
-                        matched = true;
-                        // 检查库存是否充足
-                        BigDecimal minUnitQuantity = saveDto.getMinUnitQuantity();
-                        if (minUnitQuantity == null) {
-                            if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(inventoryDto.getItemTable())) {
-                                minUnitQuantity = saveDto.getQuantity();
-                            } else {
-                                return saveDto.getAdviceName() + "的小单位数量不能为空";
-                            }
-                        }
-                        BigDecimal chineseHerbsDoseQuantity = saveDto.getChineseHerbsDoseQuantity();
-                        if (chineseHerbsDoseQuantity != null && chineseHerbsDoseQuantity.compareTo(BigDecimal.ZERO) > 0) {
-                            minUnitQuantity = minUnitQuantity.multiply(chineseHerbsDoseQuantity);
-                        }
-                        if (minUnitQuantity.compareTo(inventoryDto.getQuantity()) > 0) {
-                            return saveDto.getAdviceName() + "在" + inventoryDto.getLocationName() + "库存不足";
-                        }
-                        break;
-                    }
-                }
-            }
             // 如果没有匹配到库存
             if (!matched) {
                 return saveDto.getAdviceName() + "未匹配到库存信息";

openhis-server-new/openhis-application/src/main/java/com/openhis/web/inventorymanage/appservice/impl/ProductTransferAppServiceImpl.java

@@ -32,7 +32,6 @@ import org.springframework.stereotype.Service;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import java.math.BigDecimal;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -203,70 +202,62 @@ public class ProductTransferAppServiceImpl implements IProductTransferAppService
     @Override
     public R<?> addOrEditBatchTransferReceipt(List<ProductTransferDto> productTransferDtoList, Boolean flag) {
 
+        // 校验调拨数量：必须 > 0 且不超过源库存数量（从数据库查实时库存）
         Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
-        Date now = DateUtils.getNowDate();
+        for (ProductTransferDto dto : productTransferDtoList) {
+            if (dto.getItemQuantity() == null || dto.getItemQuantity().compareTo(java.math.BigDecimal.ZERO) <= 0) {
+                return R.fail("调拨数量必须大于0");
+            }
+            // 查询该药品在源仓库的实时库存总量
+            List<InventoryItem> inventoryList = inventoryItemService.selectInventoryByItemId(
+                dto.getItemId(), dto.getLotNumber(), dto.getSourceLocationId(), tenantId);
+            java.math.BigDecimal actualStock = inventoryList.stream()
+                .map(InventoryItem::getQuantity)
+                .reduce(java.math.BigDecimal.ZERO, java.math.BigDecimal::add);
+            if (dto.getItemQuantity().compareTo(actualStock) > 0) {
+                return R.fail("调拨数量不可超出源库存数量（当前库存：" + actualStock + "）");
+            }
+        }
 
         List<String> idList = new ArrayList<>();
         if (flag) {
             // 批量保存按钮
+            // 单据号取得
             List<String> busNoList = productTransferDtoList.stream().map(ProductTransferDto::getBusNo).toList();
-            // 保存前：获取旧记录用于恢复预划扣库存
+            // 请求id取得
-            List<SupplyRequest> oldRequestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
+            List<SupplyRequest> requestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
-            if (!oldRequestList.isEmpty()) {
+            if (!requestList.isEmpty()) {
-                // 恢复旧记录已预划扣的库存
+                List<Long> requestIdList = requestList.stream().map(SupplyRequest::getId).collect(Collectors.toList());
-                for (SupplyRequest oldReq : oldRequestList) {
+                // 单据信息删除
-                    if (oldReq.getItemId() != null && oldReq.getLotNumber() != null
+                supplyRequestService.removeByIds(requestIdList);
-                            && oldReq.getSourceLocationId() != null && oldReq.getItemQuantity() != null) {
-                        List<InventoryItem> invList = inventoryItemService.selectInventoryByItemId(
-                                oldReq.getItemId(), oldReq.getLotNumber(), oldReq.getSourceLocationId(), tenantId);
-                        if (!invList.isEmpty()) {
-                            inventoryItemService.updateInventoryQuantity(
-                                    invList.get(0).getId(),
-                                    invList.get(0).getQuantity().add(oldReq.getItemQuantity()), now);
-                        }
-                    }
-                }
-                List<Long> oldIdList = oldRequestList.stream().map(SupplyRequest::getId).collect(Collectors.toList());
-                supplyRequestService.removeByIds(oldIdList);
-            }
-
-            // 校验 + 预划扣新记录
-            for (ProductTransferDto dto : productTransferDtoList) {
-                if (dto.getItemQuantity() == null || dto.getItemQuantity().compareTo(BigDecimal.ZERO) <= 0) {
-                    return R.fail("调拨数量必须大于0");
-                }
-                List<InventoryItem> inventoryList = inventoryItemService.selectInventoryByItemId(
-                        dto.getItemId(), dto.getLotNumber(), dto.getSourceLocationId(), tenantId);
-                BigDecimal actualStock = inventoryList.stream()
-                        .map(InventoryItem::getQuantity)
-                        .reduce(BigDecimal.ZERO, BigDecimal::add);
-                if (dto.getItemQuantity().compareTo(actualStock) > 0) {
-                    return R.fail("调拨数量不可超出源库存数量（当前库存：" + actualStock + "）");
-                }
-                // 预划扣源仓库库存
-                if (!inventoryList.isEmpty()) {
-                    InventoryItem inv = inventoryList.get(0);
-                    inventoryItemService.updateInventoryQuantity(
-                            inv.getId(), inv.getQuantity().subtract(dto.getItemQuantity()), now);
-                }
             }
 
             // 生成批量调拨单据
             List<SupplyRequest> supplyRequestList = new ArrayList<>();
             for (ProductTransferDto productTransferDto : productTransferDtoList) {
+                // 初始化单据信息
                 SupplyRequest supplyRequest = new SupplyRequest();
                 BeanUtils.copyProperties(productTransferDto, supplyRequest);
+                // 生成商品批量调拨单据
                 supplyRequest
+                    // id
                     .setId(null)
+                    // 单据分类：库存供应
                     .setCategoryEnum(SupplyCategory.STOCK_SUPPLY.getValue())
+                    // 单据类型：商品批量调拨
                     .setTypeEnum(SupplyType.PRODUCT_BATCH_TRANSFER.getValue())
+                    // 制单人
                     .setApplicantId(SecurityUtils.getLoginUser().getPractitionerId())
+                    // 申请时间
                     .setApplyTime(DateUtils.getNowDate())
+                    // 源库存数量
                     .setTotalQuantity(productTransferDto.getTotalSourceQuantity());
                 supplyRequestList.add(supplyRequest);
             }
             supplyRequestService.saveOrUpdateBatch(supplyRequestList);
+            // 请求id取得
             List<SupplyRequest> supplyRequestIdList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
+            // 返回请求id列表
             List<Long> requestIdList = supplyRequestIdList.stream().map(SupplyRequest::getId).toList();
             for (Long list : requestIdList) {
                 idList.add(list.toString());
@@ -274,58 +265,33 @@ public class ProductTransferAppServiceImpl implements IProductTransferAppService
         } else {
             // 单独保存按钮
             for (ProductTransferDto productTransferDto : productTransferDtoList) {
-                // 更新已有记录：先恢复旧预划扣，再扣新的
+                // 初始化单据信息
-                if (productTransferDto.getId() != null) {
-                    SupplyRequest oldReq = supplyRequestService.getById(productTransferDto.getId());
-                    if (oldReq != null && oldReq.getItemId() != null && oldReq.getLotNumber() != null
-                            && oldReq.getSourceLocationId() != null && oldReq.getItemQuantity() != null) {
-                        List<InventoryItem> invList = inventoryItemService.selectInventoryByItemId(
-                                oldReq.getItemId(), oldReq.getLotNumber(), oldReq.getSourceLocationId(), tenantId);
-                        if (!invList.isEmpty()) {
-                            inventoryItemService.updateInventoryQuantity(
-                                    invList.get(0).getId(),
-                                    invList.get(0).getQuantity().add(oldReq.getItemQuantity()), now);
-                        }
-                    }
-                }
-
-                // 校验 + 预划扣
-                if (productTransferDto.getItemQuantity() == null
-                        || productTransferDto.getItemQuantity().compareTo(BigDecimal.ZERO) <= 0) {
-                    return R.fail("调拨数量必须大于0");
-                }
-                List<InventoryItem> inventoryList = inventoryItemService.selectInventoryByItemId(
-                        productTransferDto.getItemId(), productTransferDto.getLotNumber(),
-                        productTransferDto.getSourceLocationId(), tenantId);
-                BigDecimal actualStock = inventoryList.stream()
-                        .map(InventoryItem::getQuantity)
-                        .reduce(BigDecimal.ZERO, BigDecimal::add);
-                if (productTransferDto.getItemQuantity().compareTo(actualStock) > 0) {
-                    return R.fail("调拨数量不可超出源库存数量（当前库存：" + actualStock + "）");
-                }
-                if (!inventoryList.isEmpty()) {
-                    InventoryItem inv = inventoryList.get(0);
-                    inventoryItemService.updateInventoryQuantity(
-                            inv.getId(), inv.getQuantity().subtract(productTransferDto.getItemQuantity()), now);
-                }
-
                 SupplyRequest supplyRequest = new SupplyRequest();
                 BeanUtils.copyProperties(productTransferDto, supplyRequest);
+
                 supplyRequest.setTotalQuantity(productTransferDto.getTotalSourceQuantity());
 
                 if (productTransferDto.getId() != null) {
+                    // 更新单据信息
                     supplyRequestService.updateById(supplyRequest);
                 } else {
+                    // 生成商品批量调拨单据
                     supplyRequest
+                        // 单据分类：库存供应
                         .setCategoryEnum(SupplyCategory.STOCK_SUPPLY.getValue())
+                        // 单据类型：商品批量调拨
                         .setTypeEnum(SupplyType.PRODUCT_BATCH_TRANSFER.getValue())
+                        // 制单人
                         .setApplicantId(SecurityUtils.getLoginUser().getPractitionerId())
+                        // 申请时间
                         .setApplyTime(DateUtils.getNowDate());
                     supplyRequestService.save(supplyRequest);
                 }
+                // 返回单据id
                 return R.ok(supplyRequest.getId().toString(), null);
             }
         }
+        // 返回单据id
         return R.ok(idList, null);
     }
 
@@ -366,63 +332,33 @@ public class ProductTransferAppServiceImpl implements IProductTransferAppService
     @Override
     public R<?> addOrEditTransferReceipt(List<ProductTransferDto> productTransferDtoList) {
 
+        // 校验调拨数量：必须 > 0 且不超过源库存数量（从数据库查实时库存）
         Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
-        Date now = DateUtils.getNowDate();
+        for (ProductTransferDto dto : productTransferDtoList) {
+            if (dto.getItemQuantity() == null || dto.getItemQuantity().compareTo(java.math.BigDecimal.ZERO) <= 0) {
+                return R.fail("调拨数量必须大于0");
+            }
+            List<InventoryItem> inventoryList = inventoryItemService.selectInventoryByItemId(
+                dto.getItemId(), dto.getLotNumber(), dto.getSourceLocationId(), tenantId);
+            java.math.BigDecimal actualStock = inventoryList.stream()
+                .map(InventoryItem::getQuantity)
+                .reduce(java.math.BigDecimal.ZERO, java.math.BigDecimal::add);
+            if (dto.getItemQuantity().compareTo(actualStock) > 0) {
+                return R.fail("调拨数量不可超出源库存数量（当前库存：" + actualStock + "）");
+            }
+        }
 
         List<String> idList = new ArrayList<>();
 
         // 单据号取得
         List<String> busNoList = productTransferDtoList.stream().map(ProductTransferDto::getBusNo).toList();
-        // 保存前：获取旧记录用于恢复预划扣库存
+        // 请求数据取得
-        List<SupplyRequest> oldRequestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
+        List<SupplyRequest> requestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
-        Map<String, BigDecimal> oldDeductionMap = new HashMap<>();
+        if (!requestList.isEmpty()) {
-        if (!oldRequestList.isEmpty()) {
+            // 请求id取得
-            for (SupplyRequest oldReq : oldRequestList) {
+            List<Long> requestIdList = requestList.stream().map(SupplyRequest::getId).collect(Collectors.toList());
-                if (oldReq.getItemId() != null && oldReq.getLotNumber() != null && oldReq.getSourceLocationId() != null
+            // 单据信息删除
-                        && oldReq.getItemQuantity() != null) {
+            supplyRequestService.removeByIds(requestIdList);
-                    String key = oldReq.getItemId() + "_" + oldReq.getLotNumber() + "_" + oldReq.getSourceLocationId();
-                    oldDeductionMap.merge(key, oldReq.getItemQuantity(), BigDecimal::add);
-                }
-            }
-            // 恢复旧记录已预划扣的库存
-            for (Map.Entry<String, BigDecimal> entry : oldDeductionMap.entrySet()) {
-                String[] parts = entry.getKey().split("_");
-                Long itemId = Long.parseLong(parts[0]);
-                String lotNumber = parts[1];
-                Long sourceLocationId = Long.parseLong(parts[2]);
-                BigDecimal restoreQty = entry.getValue();
-                List<InventoryItem> invList = inventoryItemService.selectInventoryByItemId(
-                        itemId, lotNumber, sourceLocationId, tenantId);
-                if (!invList.isEmpty()) {
-                    inventoryItemService.updateInventoryQuantity(
-                            invList.get(0).getId(), invList.get(0).getQuantity().add(restoreQty), now);
-                }
-            }
-            // 删除旧记录
-            List<Long> oldIdList = oldRequestList.stream().map(SupplyRequest::getId).collect(Collectors.toList());
-            supplyRequestService.removeByIds(oldIdList);
-        }
-
-        // 校验 + 预划扣新记录
-        Map<String, BigDecimal> newDeductionMap = new HashMap<>();
-        for (ProductTransferDto dto : productTransferDtoList) {
-            if (dto.getItemQuantity() == null || dto.getItemQuantity().compareTo(BigDecimal.ZERO) <= 0) {
-                return R.fail("调拨数量必须大于0");
-            }
-            List<InventoryItem> inventoryList = inventoryItemService.selectInventoryByItemId(
-                    dto.getItemId(), dto.getLotNumber(), dto.getSourceLocationId(), tenantId);
-            BigDecimal actualStock = inventoryList.stream()
-                    .map(InventoryItem::getQuantity)
-                    .reduce(BigDecimal.ZERO, BigDecimal::add);
-            if (dto.getItemQuantity().compareTo(actualStock) > 0) {
-                return R.fail("调拨数量不可超出源库存数量（当前库存：" + actualStock + "）");
-            }
-            // 预划扣：扣减源仓库库存
-            if (!inventoryList.isEmpty()) {
-                InventoryItem inv = inventoryList.get(0);
-                inventoryItemService.updateInventoryQuantity(
-                        inv.getId(), inv.getQuantity().subtract(dto.getItemQuantity()), now);
-            }
         }
 
         List<SupplyRequest> supplyRequestList = new ArrayList<>();
@@ -469,22 +405,6 @@ public class ProductTransferAppServiceImpl implements IProductTransferAppService
      */
     @Override
     public R<?> deleteReceipt(List<Long> supplyRequestIds) {
-        // 删除前恢复预划扣的库存
-        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
-        Date now = DateUtils.getNowDate();
-        for (Long reqId : supplyRequestIds) {
-            SupplyRequest sr = supplyRequestService.getById(reqId);
-            if (sr != null && sr.getItemId() != null && sr.getSourceLocationId() != null
-                    && sr.getItemQuantity() != null && sr.getLotNumber() != null) {
-                List<InventoryItem> invList = inventoryItemService.selectInventoryByItemId(
-                        sr.getItemId(), sr.getLotNumber(), sr.getSourceLocationId(), tenantId);
-                if (!invList.isEmpty()) {
-                    InventoryItem inv = invList.get(0);
-                    inventoryItemService.updateInventoryQuantity(
-                            inv.getId(), inv.getQuantity().add(sr.getItemQuantity()), now);
-                }
-            }
-        }
         // 删除单据
         boolean result = supplyRequestService.removeByIds(supplyRequestIds);
         return result ? R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null))

openhis-server-new/openhis-application/src/main/java/com/openhis/web/inventorymanage/appservice/impl/ReceiptApprovalAppServiceImpl.java

@@ -519,8 +519,58 @@ public class ReceiptApprovalAppServiceImpl implements IReceiptApprovalAppService
             // 暂时先取出全部的库存，循环查库存同一会有问题，后续优化
             List<InventoryItem> inventoryItems = inventoryItemService.selectAllInventory();
             for (SupplyItemDetailDto supplyItemDetailDto : supplyItemDetailList) {
-                // 🔧 源仓库库存已在保存时预划扣，审批通过时不再重复扣减
+                // 根据项目id,产品批号，源仓库id 查询源仓库库存表信息
-                outList.add(supplyItemDetailDto);
+                // List<InventoryItem> inventoryItemSourceList = inventoryItemService.selectInventoryByItemId(
+                // supplyItemDetailDto.getItemId(), supplyItemDetailDto.getLotNumber(),
+                // supplyItemDetailDto.getSourceLocationId(), SecurityUtils.getLoginUser().getTenantId());
+                List<InventoryItem> filteredInventoryItems = inventoryItems.stream()
+                        .filter(item -> item.getItemId().equals(supplyItemDetailDto.getItemId())
+                        && item.getLotNumber().equals(supplyItemDetailDto.getLotNumber())
+                        && item.getLocationId().equals(supplyItemDetailDto.getSourceLocationId()))
+                        .collect(Collectors.toList());
+
+                InventoryItem inventoryItemSource = new InventoryItem();
+                if (!filteredInventoryItems.isEmpty()) {
+                    inventoryItemSource = filteredInventoryItems.get(0);
+                    // 最小数量（最小单位库存数量）
+                    BigDecimal minQuantity = inventoryItemSource.getQuantity();
+
+                    // // 计算调拨后库存数量，结果取小单位
+                    // // 供应申请的物品计量单位与包装单位相同
+                    // if (supplyItemDetailDto.getItemUnit().equals(supplyItemDetailDto.getUnitCode())) {
+                    // if
+                    // (minQuantity.compareTo(supplyItemDetailDto.getItemQuantity().multiply(supplyItemDetailDto.getPartPercent()))
+                    // < 0) {
+                    // // 库存数量不足
+                    // throw new ServiceException("操作失败,库存数量不足");
+                    // } else {
+                    // // 源仓库库存-(调拨数量*拆零比)
+                    // minQuantity = minQuantity.subtract(
+                    // supplyItemDetailDto.getPartPercent().multiply(supplyItemDetailDto.getItemQuantity()));
+                    // }
+                    // } else if (supplyItemDetailDto.getItemUnit().equals(supplyItemDetailDto.getMinUnitCode())) {
+                    // 直接扣减库存
+                    if (minQuantity.compareTo(supplyItemDetailDto.getItemQuantity()) < 0) {
+                        // 库存数量不足
+                        throw new ServiceException("操作失败,库存数量不足");
+                    } else {
+                        // 供应申请的物品计量单位与最小单位相同
+                        // 源仓库库存-调拨数量
+                        minQuantity = minQuantity.subtract(supplyItemDetailDto.getItemQuantity());
+                    }
+                    // }
+                    // 更新源仓库库存数量
+                    Boolean aBoolean
+                            = inventoryItemService.updateInventoryQuantity(inventoryItemSource.getId(), minQuantity, now);
+                    if (!aBoolean) {
+                        throw new ServiceException("系统异常,请稍后重试");
+                    }
+
+                    // 添加到出库列表
+                    outList.add(supplyItemDetailDto);
+                } else {
+                    return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
+                }
 
                 // 根据项目id,产品批号，目的仓库id 查询目的仓库库存表信息
                 List<InventoryItem> inventoryItemPurposeList = inventoryItemService.selectInventoryByItemId(

openhis-server-new/openhis-application/src/main/java/com/openhis/web/inventorymanage/appservice/impl/RequisitionIssueAppServiceImpl.java

@@ -256,9 +256,6 @@ public class RequisitionIssueAppServiceImpl implements IRequisitionIssueAppServi
      */
     @Override
     public R<?> submitApproval(String busNo) {
-        // 提交审批前校验库存，防止超库存单据进入审批流
-        this.validateRequisitionStockByBusNo(busNo);
-
         // 单据提交审核
         boolean result = supplyRequestService.submitApproval(busNo);
         return result ? R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null))
@@ -422,80 +419,4 @@ public class RequisitionIssueAppServiceImpl implements IRequisitionIssueAppServi
             }
         }
     }
-
-    /**
-     * 根据单据号校验领用数量是否超过源仓库实际库存（提交审批前调用）
-     *
-     * @param busNo 单据号
-     */
-    private void validateRequisitionStockByBusNo(String busNo) {
-        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
-        // 通过单据详情查询已保存的单据明细
-        R<List<IssueDetailDto>> detailResult = this.getDetail(busNo);
-        if (detailResult.getCode() != 200 || detailResult.getData() == null) {
-            return;
-        }
-        List<IssueDetailDto> detailList = detailResult.getData();
-        for (IssueDetailDto detail : detailList) {
-            Long itemId = detail.getItemId();
-            String lotNumber = detail.getLotNumber();
-            Long sourceLocationId = detail.getSourceLocationId();
-            BigDecimal reqQuantity = detail.getItemQuantity();
-            String itemTable = CommonConstants.TableName.MED_MEDICATION_DEFINITION;
-            // 根据药品类型判断表名
-            if (ItemType.DEVICE.getValue().equals(detail.getItemType())) {
-                itemTable = CommonConstants.TableName.ADM_DEVICE_DEFINITION;
-            }
-
-            // 查询定义信息（拆零比、单位）
-            BigDecimal partPercent = BigDecimal.ONE;
-            String unitCode = detail.getUnitCode();
-            String minUnitCode = detail.getMinUnitCode();
-
-            if (CommonConstants.TableName.MED_MEDICATION_DEFINITION.equals(itemTable)) {
-                MedicationDefinition medDef = medicationDefinitionService.getById(itemId);
-                if (medDef != null) {
-                    unitCode = medDef.getUnitCode();
-                    minUnitCode = medDef.getMinUnitCode();
-                    if (medDef.getPartPercent() != null) {
-                        partPercent = medDef.getPartPercent();
-                    }
-                }
-            } else if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(itemTable)) {
-                DeviceDefinition devDef = deviceDefinitionService.getById(itemId);
-                if (devDef != null) {
-                    unitCode = devDef.getUnitCode();
-                    minUnitCode = devDef.getMinUnitCode();
-                    if (devDef.getPartPercent() != null) {
-                        partPercent = devDef.getPartPercent();
-                    }
-                }
-            }
-
-            // 计算领用数量折合最小单位的值
-            BigDecimal reqQuantityInMinUnit;
-            if (unitCode != null && detail.getUnitCode().equals(unitCode)) {
-                reqQuantityInMinUnit = reqQuantity.multiply(partPercent);
-            } else {
-                reqQuantityInMinUnit = reqQuantity;
-            }
-
-            // 查询源仓库实际库存
-            List<InventoryItem> inventoryItemList = inventoryItemService.selectInventoryByItemId(
-                    itemId, lotNumber, sourceLocationId, tenantId);
-
-            // 累加总库存
-            BigDecimal totalStock = BigDecimal.ZERO;
-            for (InventoryItem inventoryItem : inventoryItemList) {
-                if (inventoryItem.getLocationId().equals(sourceLocationId)) {
-                    totalStock = totalStock.add(inventoryItem.getQuantity());
-                }
-            }
-
-            // 比较领用数量与库存
-            if (reqQuantityInMinUnit.compareTo(totalStock) > 0) {
-                throw new ServiceException("提交失败，单据中存在领用数量超过库存的明细，请核对后重新保存");
-            }
-        }
-    }
 }

openhis-server-new/openhis-application/src/main/java/com/openhis/web/inventorymanage/controller/ProductTransferController.java

@@ -93,7 +93,7 @@ public class ProductTransferController {
      * @return 操作结果
      */
     @PutMapping("/product-transfer-batch")
-    public R<?> addOrEditBatchTransferReceipt(@Validated @RequestBody List<ProductTransferDto> productTransferDtoList) {
+    public R<?> addOrEditBatchTransferReceipt(@RequestBody List<ProductTransferDto> productTransferDtoList) {
         // 批量保存按钮
         Boolean flag = true;
         return productTransferAppService.addOrEditBatchTransferReceipt(productTransferDtoList, flag);

openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/AdviceManageAppServiceImpl.java

@@ -36,8 +36,6 @@ import com.openhis.workflow.domain.ActivityDefinition;
 import com.openhis.workflow.service.IDeviceDispenseService;
 import com.openhis.workflow.service.IDeviceRequestService;
 import com.openhis.workflow.service.IServiceRequestService;
-import com.openhis.document.domain.RequestForm;
-import com.openhis.document.service.IRequestFormService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
@@ -87,9 +85,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
     @Resource
     IDeviceDispenseService iDeviceDispenseService;
 
-    @Resource
-    IRequestFormService iRequestFormService;
-
     /**
      * 查询住院患者信息
      *
@@ -271,38 +266,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
 
         log.info("开始处理删除操作，共 {} 条记录", deleteList.size());
 
-        // 🔧 手术申请单级联作废：删除手术医嘱(categoryEnum=24)时同步作废关联的手术申请单
-        Map<String, List<Long>> surgeryPrescriptionNoToRequestIds = new LinkedHashMap<>();
-        for (RegAdviceSaveDto adviceDto : deleteList) {
-            if (adviceDto.getRequestId() == null) continue;
-            ServiceRequest existing = iServiceRequestService.getById(adviceDto.getRequestId());
-            if (existing == null) continue;
-            if (existing.getCategoryEnum() != null
-                    && existing.getCategoryEnum() == 24
-                    && existing.getPrescriptionNo() != null && !existing.getPrescriptionNo().isEmpty()) {
-                surgeryPrescriptionNoToRequestIds.computeIfAbsent(existing.getPrescriptionNo(), k -> new ArrayList<>())
-                        .add(adviceDto.getRequestId());
-            }
-        }
-        for (Map.Entry<String, List<Long>> e : surgeryPrescriptionNoToRequestIds.entrySet()) {
-            String prescriptionNo = e.getKey();
-            try {
-                List<RequestForm> requestForms = iRequestFormService.list(
-                        new LambdaQueryWrapper<RequestForm>()
-                                .eq(RequestForm::getPrescriptionNo, prescriptionNo)
-                                .eq(RequestForm::getTypeCode, ActivityDefCategory.PROCEDURE.getCode())
-                                .and(w -> w.isNull(RequestForm::getDeleteFlag).or().eq(RequestForm::getDeleteFlag, "0")));
-                for (RequestForm requestForm : requestForms) {
-                    iRequestFormService.removeById(requestForm.getId());
-                }
-                if (!requestForms.isEmpty()) {
-                    log.info("级联作废手术申请单 prescriptionNo={}, 共{}条", prescriptionNo, requestForms.size());
-                }
-            } catch (Exception ex) {
-                log.warn("级联作废手术申请单失败 prescriptionNo={}", prescriptionNo, ex);
-            }
-        }
-
         for (RegAdviceSaveDto adviceDto : deleteList) {
             Integer adviceType = adviceDto.getAdviceType();
             Long requestId = adviceDto.getRequestId();

openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/RequestFormManageAppServiceImpl.java

@@ -81,7 +81,16 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
         Long requestFormId = requestFormSaveDto.getRequestFormId();
         boolean isEdit = requestFormId != null && requestFormId != 0L;
 
-        // 🔧 手术/检查申请单：优先使用前端传入的positionId（用户手动选择的发往科室），跳过执行科室配置校验
+        // 诊疗执行科室配置校验（必须在任何数据库操作之前）
+        List<ActivityOrganizationConfigDto> activityOrganizationConfig =
+            requestFormManageAppMapper.getActivityOrganizationConfig(typeCode);
+        if (activityOrganizationConfig.isEmpty()) {
+            throw new ServiceException("请先配置当前时间段的执行科室");
+        }
+
+        // 逐个校验activityList中的项目是否都配置了执行科室，并收集positionId供后续使用
+        // 必须在任何数据库操作之前完成全部校验，避免部分保存后异常导致脏数据
+        // 🔧 Bug #516: 优先使用前端传入的positionId（用户手动选择的发往科室），仅在未选择时使用配置的执行科室
         List<ActivitySaveDto> activityList = requestFormSaveDto.getActivityList();
         // 缓存校验结果，避免主循环中重复查询和可能出现的数据不一致
         java.util.Map<Long, Long> activityIdToPositionIdMap = new java.util.HashMap<>();
@@ -93,15 +102,14 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                     activityIdToPositionIdMap.put(activitySaveDto.getAdviceDefinitionId(), frontendPositionId);
                     continue;
                 }
-                // 前端未传入时，查询配置的执行科室（暂不校验，仅用于兼容无前端传入的场景）
+                // 前端未传入时，使用配置的执行科室
-                List<ActivityOrganizationConfigDto> activityOrganizationConfig =
-                    requestFormManageAppMapper.getActivityOrganizationConfig(typeCode);
                 Long configPositionId = activityOrganizationConfig.stream()
                     .filter(dto -> activitySaveDto.getAdviceDefinitionId().equals(dto.getActivityDefinitionId()))
                     .map(ActivityOrganizationConfigDto::getOrganizationId).findFirst().orElse(null);
-                if (configPositionId != null) {
+                if (configPositionId == null) {
-                    activityIdToPositionIdMap.put(activitySaveDto.getAdviceDefinitionId(), configPositionId);
+                    throw new ServiceException(activitySaveDto.getAdviceDefinitionName() + "未配置当前时间段的执行科室");
                 }
+                activityIdToPositionIdMap.put(activitySaveDto.getAdviceDefinitionId(), configPositionId);
             }
         }
 
@@ -168,77 +176,73 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
         ChargeItem chargeItem;
         log.info("保存申请单，typeCode={}, activityListSize={}, encounterId={}", typeCode, activityList != null ? activityList.size() : 0, encounterId);
 
-        // 🔧 手术申请单：跳过普通医嘱生成，只由 isProcedure 块生成手术医嘱，避免重复
+        for (ActivitySaveDto activitySaveDto : activityList) {
-        boolean isSurgeryRequest = ActivityDefCategory.PROCEDURE.getCode().equals(typeCode);
+            serviceRequest = new ServiceRequest();
-        if (!isSurgeryRequest) {
+            serviceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());
-            for (ActivitySaveDto activitySaveDto : activityList) {
+            serviceRequest.setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.SERVICE_RES_NO.getPrefix(), 4));
-                serviceRequest = new ServiceRequest();
+            serviceRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
-                serviceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());
+            serviceRequest.setPrescriptionNo(prescriptionNo);
-                serviceRequest.setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.SERVICE_RES_NO.getPrefix(), 4));
+            serviceRequest.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue());// 治疗类型
-                serviceRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
+            serviceRequest.setQuantity(activitySaveDto.getQuantity()); // 请求数量
-                serviceRequest.setPrescriptionNo(prescriptionNo);
+            serviceRequest.setUnitCode(activitySaveDto.getUnitCode()); // 请求单位编码
-                serviceRequest.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue());// 治疗类型
+            serviceRequest.setCategoryEnum(categoryEnum); // 请求类型
-                serviceRequest.setQuantity(activitySaveDto.getQuantity()); // 请求数量
+            serviceRequest.setActivityId(activitySaveDto.getAdviceDefinitionId());// 诊疗定义id
-                serviceRequest.setUnitCode(activitySaveDto.getUnitCode()); // 请求单位编码
+            serviceRequest.setPatientId(patientId); // 患者
-                serviceRequest.setCategoryEnum(categoryEnum); // 请求类型
+            serviceRequest.setRequesterId(practitionerId); // 开方医生
-                serviceRequest.setActivityId(activitySaveDto.getAdviceDefinitionId());// 诊疗定义id
+            serviceRequest.setEncounterId(encounterId); // 就诊id
-                serviceRequest.setPatientId(patientId); // 患者
+            serviceRequest.setAuthoredTime(curDate); // 请求签发时间
-                serviceRequest.setRequesterId(practitionerId); // 开方医生
-                serviceRequest.setEncounterId(encounterId); // 就诊id
-                serviceRequest.setAuthoredTime(curDate); // 请求签发时间
 
-                Long positionId = activityIdToPositionIdMap.get(activitySaveDto.getAdviceDefinitionId());
+            Long positionId = activityIdToPositionIdMap.get(activitySaveDto.getAdviceDefinitionId());
-                if (positionId == null) {
+            if (positionId == null) {
-                    throw new ServiceException(activitySaveDto.getAdviceDefinitionName() + "未配置当前时间段的执行科室");
+                throw new ServiceException(activitySaveDto.getAdviceDefinitionName() + "未配置当前时间段的执行科室");
-                }
+            }
-                serviceRequest.setOrgId(positionId); // 执行科室
+            serviceRequest.setOrgId(positionId); // 执行科室
 
-                serviceRequest.setYbClassEnum(activitySaveDto.getYbClassEnum());// 类别医保编码
+            serviceRequest.setYbClassEnum(activitySaveDto.getYbClassEnum());// 类别医保编码
-                serviceRequest.setConditionId(activitySaveDto.getConditionId()); // 诊断id
+            serviceRequest.setConditionId(activitySaveDto.getConditionId()); // 诊断id
-                serviceRequest.setEncounterDiagnosisId(activitySaveDto.getEncounterDiagnosisId()); // 就诊诊断id
+            serviceRequest.setEncounterDiagnosisId(activitySaveDto.getEncounterDiagnosisId()); // 就诊诊断id
-                iServiceRequestService.save(serviceRequest);
+            iServiceRequestService.save(serviceRequest);
 
-                chargeItem = new ChargeItem();
+            chargeItem = new ChargeItem();
-                chargeItem.setStatusEnum(ChargeItemStatus.DRAFT.getValue()); // 收费状态
+            chargeItem.setStatusEnum(ChargeItemStatus.DRAFT.getValue()); // 收费状态
-                chargeItem.setBusNo(AssignSeqEnum.CHARGE_ITEM_NO.getPrefix().concat(serviceRequest.getBusNo()));
+            chargeItem.setBusNo(AssignSeqEnum.CHARGE_ITEM_NO.getPrefix().concat(serviceRequest.getBusNo()));
-                chargeItem.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
+            chargeItem.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
-                chargeItem.setPatientId(patientId); // 患者
+            chargeItem.setPatientId(patientId); // 患者
-                chargeItem.setContextEnum(activitySaveDto.getAdviceType()); // 类型
+            chargeItem.setContextEnum(activitySaveDto.getAdviceType()); // 类型
-                chargeItem.setEncounterId(encounterId); // 就诊id
+            chargeItem.setEncounterId(encounterId); // 就诊id
-                chargeItem.setDefinitionId(activitySaveDto.getDefinitionId()); // 费用定价ID
+            chargeItem.setDefinitionId(activitySaveDto.getDefinitionId()); // 费用定价ID
-                chargeItem.setDefDetailId(activitySaveDto.getDefinitionDetailId()); // 定价子表主键
+            chargeItem.setDefDetailId(activitySaveDto.getDefinitionDetailId()); // 定价子表主键
-                chargeItem.setEntererId(practitionerId);// 开立人ID
+            chargeItem.setEntererId(practitionerId);// 开立人ID
-                chargeItem.setEnteredDate(curDate); // 开立时间
+            chargeItem.setEnteredDate(curDate); // 开立时间
-                chargeItem.setServiceTable(CommonConstants.TableName.WOR_SERVICE_REQUEST);// 医疗服务类型
+            chargeItem.setServiceTable(CommonConstants.TableName.WOR_SERVICE_REQUEST);// 医疗服务类型
-                chargeItem.setServiceId(serviceRequest.getId()); // 医疗服务ID
+            chargeItem.setServiceId(serviceRequest.getId()); // 医疗服务ID
-                chargeItem.setProductTable(CommonConstants.TableName.WOR_ACTIVITY_DEFINITION);// 产品所在表
+            chargeItem.setProductTable(CommonConstants.TableName.WOR_ACTIVITY_DEFINITION);// 产品所在表
-                chargeItem.setProductId(activitySaveDto.getAdviceDefinitionId());// 收费项id
+            chargeItem.setProductId(activitySaveDto.getAdviceDefinitionId());// 收费项id
-                chargeItem.setAccountId(activitySaveDto.getAccountId());// 关联账户ID
+            chargeItem.setAccountId(activitySaveDto.getAccountId());// 关联账户ID
-                chargeItem.setRequestingOrgId(orgId); // 开立科室
+            chargeItem.setRequestingOrgId(orgId); // 开立科室
-                chargeItem.setConditionId(activitySaveDto.getConditionId()); // 诊断id
+            chargeItem.setConditionId(activitySaveDto.getConditionId()); // 诊断id
-                chargeItem.setEncounterDiagnosisId(activitySaveDto.getEncounterDiagnosisId()); // 就诊诊断id
+            chargeItem.setEncounterDiagnosisId(activitySaveDto.getEncounterDiagnosisId()); // 就诊诊断id
-                chargeItem.setQuantityValue(activitySaveDto.getQuantity()); // 数量
+            chargeItem.setQuantityValue(activitySaveDto.getQuantity()); // 数量
-                chargeItem.setQuantityUnit(activitySaveDto.getUnitCode()); // 单位
+            chargeItem.setQuantityUnit(activitySaveDto.getUnitCode()); // 单位
-                chargeItem.setUnitPrice(activitySaveDto.getUnitPrice()); // 单价
+            chargeItem.setUnitPrice(activitySaveDto.getUnitPrice()); // 单价
-                chargeItem.setTotalPrice(activitySaveDto.getTotalPrice()); // 总价
+            chargeItem.setTotalPrice(activitySaveDto.getTotalPrice()); // 总价
-                iChargeItemService.save(chargeItem);
+            iChargeItemService.save(chargeItem);
 
-                // 处理诊疗套餐的子项信息
+            // 处理诊疗套餐的子项信息
-                ActivityDefinition activityDefinition =
+            ActivityDefinition activityDefinition =
-                    iActivityDefinitionService.getById(activitySaveDto.getAdviceDefinitionId());
+                iActivityDefinitionService.getById(activitySaveDto.getAdviceDefinitionId());
-                String childrenJson = activityDefinition.getChildrenJson();
+            String childrenJson = activityDefinition.getChildrenJson();
-                if (childrenJson != null) {
+            if (childrenJson != null) {
-                    // 诊疗子项参数类
+                // 诊疗子项参数类
-                    ActivityChildrenJsonParams activityChildrenJsonParams = new ActivityChildrenJsonParams();
+                ActivityChildrenJsonParams activityChildrenJsonParams = new ActivityChildrenJsonParams();
-                    activityChildrenJsonParams.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue()); // 治疗类型
+                activityChildrenJsonParams.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue()); // 治疗类型
-                    activityChildrenJsonParams.setPatientId(serviceRequest.getPatientId()); // 患者
+                activityChildrenJsonParams.setPatientId(serviceRequest.getPatientId()); // 患者
-                    activityChildrenJsonParams.setEncounterId(serviceRequest.getEncounterId()); // 就诊id
+                activityChildrenJsonParams.setEncounterId(serviceRequest.getEncounterId()); // 就诊id
-                    activityChildrenJsonParams.setAccountId(chargeItem.getAccountId()); // 账户id
+                activityChildrenJsonParams.setAccountId(chargeItem.getAccountId()); // 账户id
-                    activityChildrenJsonParams.setChargeItemId(chargeItem.getId()); // 费用项id
+                activityChildrenJsonParams.setChargeItemId(chargeItem.getId()); // 费用项id
-                    activityChildrenJsonParams.setParentId(serviceRequest.getId());// 子项诊疗的父id
+                activityChildrenJsonParams.setParentId(serviceRequest.getId());// 子项诊疗的父id
-                    activityChildrenJsonParams.setEncounterDiagnosisId(serviceRequest.getEncounterDiagnosisId());
+                activityChildrenJsonParams.setEncounterDiagnosisId(serviceRequest.getEncounterDiagnosisId());
-                    adviceUtils.handleActivityChild(childrenJson, organizationId, activityChildrenJsonParams);
+                adviceUtils.handleActivityChild(childrenJson, organizationId, activityChildrenJsonParams);
-                }
             }
         }
 
@@ -322,13 +326,6 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                 } else if (surgeryName != null && !surgeryName.isEmpty()) {
                     contentMap.put("surgeryName", surgeryName);
                 }
-                // 🔧 手术申请单级联删除：contentJson 中记录 requestFormId 和 prescriptionNo，删除医嘱时可定位并作废申请单
-                if (requestForm.getId() != null) {
-                    contentMap.put("requestFormId", String.valueOf(requestForm.getId()));
-                }
-                if (prescriptionNo != null && !prescriptionNo.isEmpty()) {
-                    contentMap.put("prescriptionNo", prescriptionNo);
-                }
                 if (surgeryCode != null && !surgeryCode.isEmpty()) {
                     contentMap.put("surgeryCode", surgeryCode);
                 }
@@ -371,10 +368,9 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                     surgeryChargeItem.setServiceTable(CommonConstants.TableName.WOR_SERVICE_REQUEST);
                     surgeryChargeItem.setServiceId(surgeryServiceRequest.getId());
                     surgeryChargeItem.setProductTable(CommonConstants.TableName.WOR_ACTIVITY_DEFINITION);
-                    // 优先从 activityList 获取 productId 和 definitionId
+                    // 优先从 activityList 获取 productId
                     if (activityList != null && !activityList.isEmpty()) {
                         surgeryChargeItem.setProductId(activityList.get(0).getAdviceDefinitionId());
-                        surgeryChargeItem.setDefinitionId(activityList.get(0).getDefinitionId());
                         surgeryChargeItem.setAccountId(activityList.get(0).getAccountId());
                     }
                     surgeryChargeItem.setRequestingOrgId(orgId);
@@ -413,10 +409,6 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                             anesthesiaChargeItem.setServiceTable(CommonConstants.TableName.WOR_SERVICE_REQUEST);
                             anesthesiaChargeItem.setServiceId(surgeryServiceRequest.getId());
                             anesthesiaChargeItem.setProductTable(CommonConstants.TableName.WOR_ACTIVITY_DEFINITION);
-                            // 从 activityList 获取 definitionId
-                            if (activityList != null && !activityList.isEmpty()) {
-                                anesthesiaChargeItem.setDefinitionId(activityList.get(0).getDefinitionId());
-                            }
                             anesthesiaChargeItem.setRequestingOrgId(orgId);
                             anesthesiaChargeItem.setQuantityValue(BigDecimal.valueOf(1));
                             anesthesiaChargeItem.setQuantityUnit("次");
@@ -433,18 +425,6 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                 log.error("生成手术医嘱过程中发生异常", e);
                 throw e;
             }
-            // 将手术项目名称写入申请单name字段，确保医嘱删除后申请单仍保留正确名称
-            if (activityList != null && !activityList.isEmpty()) {
-                String surgeryDisplayName = activityList.stream()
-                    .map(ActivitySaveDto::getAdviceDefinitionName)
-                    .filter(name -> name != null && !name.isEmpty())
-                    .distinct()
-                    .collect(Collectors.joining("、"));
-                if (!surgeryDisplayName.isEmpty()) {
-                    requestForm.setName(surgeryDisplayName);
-                    iRequestFormService.updateById(requestForm);
-                }
-            }
         } else {
             log.info("不是手术申请单，跳过手术医嘱生成，typeCode={}", typeCode);
         }

openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/RequestFormDetailQueryDto.java

@@ -13,11 +13,6 @@ import java.math.BigDecimal;
 @Accessors(chain = true)
 public class RequestFormDetailQueryDto {
 
-    /**
-     * 诊疗活动定义ID（wor_service_request.activity_id，与开立检验时项目字典的 id / adviceDefinitionId 一致，用于编辑回显）
-     */
-    private Long activityId;
-
     /** 医嘱名称 */
     private String adviceName;
 

openhis-server-new/openhis-application/src/main/resources/mapper/clinicalmanage/SurgicalScheduleAppMapper.xml

@@ -89,7 +89,7 @@
             cs.apply_doctor_name AS apply_doctor_name,
             drf.create_time AS apply_time,
             os.surgery_nature AS surgeryType,
-            cs.incision_level AS incisionLevel,
+            cs.incision_level AS "incisionLevel",
             os.fee_type AS feeType,
             COALESCE(pi.identifier_no, ap.bus_no, '') AS identifierNo
         FROM op_schedule os

openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml

@@ -117,7 +117,7 @@
                     )
                 </if>
                 <if test="searchKey != null and searchKey != ''">
-                    AND (t1.name ILIKE '%' || '${searchKey}' || '%' OR t1.py_str ILIKE '%' || '${searchKey}' || '%')
+                    AND (t1.name ILIKE '%' || #{searchKey} || '%' OR t1.py_str ILIKE '%' || #{searchKey} || '%')
                 </if>
                 <if test="adviceDefinitionIdParamList != null and !adviceDefinitionIdParamList.isEmpty()">
                     AND t1.id IN
@@ -181,7 +181,7 @@
                 WHERE t1.delete_flag = '0'
                 AND t1.status_enum = #{statusEnum}
                 <if test="searchKey != null and searchKey != ''">
-                    AND (t1.name ILIKE '%' || '${searchKey}' || '%' OR t1.py_str ILIKE '%' || '${searchKey}' || '%')
+                    AND (t1.name ILIKE '%' || #{searchKey} || '%' OR t1.py_str ILIKE '%' || #{searchKey} || '%')
                 </if>
                 <if test="categoryCode != null and categoryCode != ''">
                     AND t1.category_code = #{categoryCode}
@@ -278,7 +278,7 @@
                     AND T1.category_code != '手术' AND T1.category_code != '24'
                 </if>
                 <if test="searchKey != null and searchKey != ''">
-                    AND (t1.name ILIKE '%' || '${searchKey}' || '%' OR t1.py_str ILIKE '%' || '${searchKey}' || '%')
+                    AND (t1.name ILIKE '%' || #{searchKey} || '%' OR t1.py_str ILIKE '%' || #{searchKey} || '%')
                 </if>
                 <if test="categoryCode != null and categoryCode != ''">
                     AND t1.category_code = #{categoryCode}

openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationDiagnosisAppMapper.xml

@@ -135,7 +135,6 @@
                T1.onset_date AS onsetDate,
                T1.diagnosis_time AS diagnosisTime,
                T1.doctor AS diagnosisDoctor,
-               T1.long_term_flag AS longTermFlag,
                CASE WHEN EXISTS (
                    SELECT 1 FROM infectious_card T4
                    WHERE T4.diag_id = T2.id AND T4.delete_flag = '0' AND T4.status >= 1

openhis-server-new/openhis-common/src/main/java/com/openhis/common/aspectj/DictAspect.java

@@ -100,25 +100,11 @@ public class DictAspect {
                 String dictText = dictAnnotation.dictText();
                 String dictTable = dictAnnotation.dictTable();
                 String deleteFlag = dictAnnotation.deleteFlag();
-
-                // 检查 _dictText 字段是否已被手动填充（如控制器方法中预先查询设置）
-                // 如果已非空则跳过 SQL 查询，避免覆盖有效值
-                String textFieldName = field.getName() + "_dictText";
-                try {
-                    Field existingTextField = dto.getClass().getDeclaredField(textFieldName);
-                    existingTextField.setAccessible(true);
-                    Object existingValue = existingTextField.get(dto);
-                    if (existingValue != null && !existingValue.toString().isEmpty()) {
-                        continue; // _dictText 已有值，跳过
-                    }
-                } catch (NoSuchFieldException e) {
-                    // _dictText 字段不存在，继续正常流程
-                }
-
                 // 查询字典值
                 String dictLabel = queryDictLabel(dictTable, dictCode, dictText, deleteFlag, fieldValue.toString());
-                if (dictLabel != null && !dictLabel.isEmpty()) {
+                if (dictLabel != null) {
                     // 动态生成 _dictText 字段名
+                    String textFieldName = field.getName() + "_dictText";
                     try {
                         Field textField = dto.getClass().getDeclaredField(textFieldName);
                         textField.setAccessible(true);

openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/service/IOrganizationLocationService.java

@@ -36,6 +36,6 @@ public interface IOrganizationLocationService extends IService<OrganizationLocat
      * @param activityDefinitionId 诊疗定义id
      * @return 诊疗的执行科室列表
      */
-    List<OrganizationLocation> getOrgLocListByOrgIdAndActivityDefinitionId(Long organizationId, Long activityDefinitionId);
+    List<OrganizationLocation> getOrgLocListByOrgIdAndActivityDefinitionId(Long activityDefinitionId);
 
 }

openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/service/impl/OrganizationLocationServiceImpl.java

@@ -53,14 +53,12 @@ public class OrganizationLocationServiceImpl extends ServiceImpl<OrganizationLoc
     /**
      * 查询诊疗的执行科室列表
      *
-     * @param organizationId 机构id
      * @param activityDefinitionId 诊疗定义id
      * @return 诊疗的执行科室列表
      */
     @Override
-    public List<OrganizationLocation> getOrgLocListByOrgIdAndActivityDefinitionId(Long organizationId, Long activityDefinitionId) {
+    public List<OrganizationLocation> getOrgLocListByOrgIdAndActivityDefinitionId(Long activityDefinitionId) {
         return baseMapper.selectList(new LambdaQueryWrapper<OrganizationLocation>()
-            .eq(OrganizationLocation::getOrganizationId, organizationId)
             .eq(OrganizationLocation::getActivityDefinitionId, activityDefinitionId));
     }
 

openhis-ui-vue3/src/router/index.js

@@ -79,51 +79,6 @@ export const constantRoutes = [
             }
         ]
     },
-    // 住院护士站 — 快捷访问路由（与 sys_menu 中 menu_id=295 的动态路由并存，路径不同不冲突）
-    {
-        path: '/inpatientNurse',
-        component: Layout,
-        hidden: true,
-        redirect: '/inpatientNurse/inpatientNurseStation',
-        children: [
-            {
-                path: 'inpatientNurseStation',
-                component: () => import('@/views/inpatientNurse/inpatientNurseStation/index.vue'),
-                name: 'InpatientNurseStation',
-                meta: {title: '住院护士站'}
-            },
-            {
-                path: 'medicalOrderExecution',
-                component: () => import('@/views/inpatientNurse/medicalOrderExecution/index.vue'),
-                name: 'MedicalOrderExecution',
-                meta: {title: '医嘱执行'}
-            },
-            {
-                path: 'medicalOrderProofread',
-                component: () => import('@/views/inpatientNurse/medicalOrderProofread/index.vue'),
-                name: 'MedicalOrderProofread',
-                meta: {title: '医嘱校对'}
-            },
-            {
-                path: 'medicineCollect',
-                component: () => import('@/views/inpatientNurse/medicineCollect/index.vue'),
-                name: 'MedicineCollect',
-                meta: {title: '领药管理'}
-            },
-            {
-                path: 'tprsheet',
-                component: () => import('@/views/inpatientNurse/tprsheet/index.vue'),
-                name: 'TprSheet',
-                meta: {title: '体温单'}
-            },
-            {
-                path: 'nursingRecord',
-                component: () => import('@/views/inpatientNurse/nursingRecord/index.vue'),
-                name: 'NursingRecord',
-                meta: {title: '护理记录'}
-            }
-        ]
-    },
     // 添加套餐管理相关路由到公共路由，确保始终可用
     {
         path: '/maintainSystem/Inspection/PackageManagement',

openhis-ui-vue3/src/views/clinicmanagement/bargain/component/prescriptionlist.vue

@@ -461,10 +461,6 @@ watch(
     console.log(prescriptionList.value,"prescriptionList.value")
     if(newValue&&newValue.length>0){
       let saveList = prescriptionList.value.filter((item) => {
-        // 手术计费场景（generateSourceEnum=6）不限制 bizRequestFlag
-        if (isSurgeryChargeBillingContext()) {
-          return item.check && item.statusEnum == 1
-        }
         return item.check && item.statusEnum == 1&&(Number(item.bizRequestFlag)==1||!item.bizRequestFlag)
       })
        console.log(saveList,"prescriptionList.value")
@@ -877,32 +873,6 @@ function ensureOrgTreeLoaded() {
     });
 }
 
-/** 待签发且未收费（chargeStatus=5 为已收费） */
-function isPendingUnsignedAndUnpaid(item) {
-  return item.statusEnum == 1 && item.chargeStatus != 5
-}
-
-/**
- * 门诊划价：仅允许操作本人开立（bizRequestFlag==1 或空）。
- * 手术计费：列表接口需按库中 generate_source_enum 查询（当前多为 1），故子组件仍传 generateSourceEnum=1；
- * 通过 patientInfo.generateSourceEnum===6（手术计费在 chargePatientInfo 中已写入）识别场景，删除时不卡 bizRequestFlag。
- */
-function isSurgeryChargeBillingContext() {
-  const fromPatient = props.patientInfo?.generateSourceEnum
-  return fromPatient != null && Number(fromPatient) === 6
-}
-
-function isBizRequestAllowedForDelete(item) {
-  if (isSurgeryChargeBillingContext()) {
-    return true
-  }
-  const src = props.generateSourceEnum != null ? Number(props.generateSourceEnum) : NaN
-  if (src === 6) {
-    return true
-  }
-  return Number(item.bizRequestFlag) === 1 || !item.bizRequestFlag
-}
-
 function handleDelete() {
   // 🔧 修复：使用 groupIndexList 而不是 check 属性
   // 因为 watch 监听器会在数据更新时重置 check 为 false
@@ -911,93 +881,80 @@ function handleDelete() {
     return;
   }
 
-  const canDeleteRow = (item) =>
+  let deleteList = groupIndexList.value.map((index) => {
-    isPendingUnsignedAndUnpaid(item) && isBizRequestAllowedForDelete(item)
+    const item = prescriptionList.value[index];
-
+    // 只删除待签发且未收费的项目
-  const anySelectedDeletable = groupIndexList.value.some((index) =>
+    if (item.statusEnum != 1 || item.chargeStatus == 5) {
-    canDeleteRow(prescriptionList.value[index])
+      return null;
-  )
-  if (!anySelectedDeletable) {
-    proxy.$modal.msgWarning(
-      '只能删除「待签发」且「未收费」的项目；门诊划价还需为本人开立。已签发、已收费或非本人开立项不可删。'
-    )
-    return
-  }
-
-  let deleteList = groupIndexList.value
-    .map((index) => {
-      const item = prescriptionList.value[index]
-      if (!canDeleteRow(item)) {
-        return null
-      }
-      if (item.requestId == null || item.requestId === undefined || item.requestId === '') {
-        return null
-      }
-      return {
-        requestId: item.requestId,
-        dbOpType: '3',
-        adviceType: item.adviceType,
-      }
-    })
-    .filter((item) => item !== null)
-
-  // 删除逻辑：按索引从大到小排序，避免删除后索引变化
-  const sortedIndexes = [...groupIndexList.value].sort((a, b) => b - a)
-  let hasSavedItem = false
-
-  for (const index of sortedIndexes) {
-    const item = prescriptionList.value[index]
-    if (!canDeleteRow(item)) {
-      continue
     }
-
+    // 🔧 Bug #442: 非本人创建的医嘱不允许删除（与签发/签退逻辑保持一致）
+    if (Number(item.bizRequestFlag) !== 1 && item.bizRequestFlag) {
+      return null;
+    }
+    // 🔧 Bug #442: 已保存的行必须有有效的 requestId，否则跳过（避免后端删除不存在的记录）
+    if (item.requestId == null || item.requestId === undefined || item.requestId === '') {
+      return null;
+    }
+    return {
+      requestId: item.requestId,
+      dbOpType: '3',
+      adviceType: item.adviceType,
+    };
+  }).filter(item => item !== null); // 过滤掉已签发、已收费、非本人创建或无 requestId 的项目
+  
+  if (deleteList.length == 0) {
+    proxy.$modal.msgWarning('只能删除待签发且未收费的项目');
+    return;
+  }
+  
+  // 删除逻辑：按索引从大到小排序，避免删除后索引变化
+  const sortedIndexes = groupIndexList.value.sort((a, b) => b - a);
+  let hasSavedItem = false;
+  
+  for (const index of sortedIndexes) {
+    const item = prescriptionList.value[index];
+    if (item.statusEnum != 1) {
+      continue; // 跳过已签发的项目
+    }
+    
     if (!item.requestId) {
       // 新增的行（未保存到数据库），直接删除
-      prescriptionList.value.splice(index, 1)
+      prescriptionList.value.splice(index, 1);
     } else {
-      hasSavedItem = true
+      hasSavedItem = true;
     }
   }
+  
+  if (hasSavedItem) {
+    // 🔧 Bug #454: 删除前弹出确认提示，告知用户将级联删除关联检验申请单
+    const hasLabItem = deleteList.some(item => item.adviceType === 3);
+    const confirmMsg = hasLabItem
+      ? '删除此医嘱将同时删除关联的检验申请单，是否确认删除？'
+      : '确认删除选中的医嘱项目吗？';
 
-  const cleanupAfterDelete = () => {
+    proxy.$modal.confirm(confirmMsg).then(() => {
+      savePrescription({ adviceSaveList: deleteList }).then((res) => {
+        if (res.code == 200) {
+          proxy.$modal.msgSuccess('操作成功');
+          getListInfo(false);
+          expandOrder.value = [];
+          groupIndexList.value = [];
+          groupList.value = [];
+          isAdding.value = false;
+          adviceQueryParams.value.adviceType = undefined;
+        }
+      });
+    }).catch(() => {
+      // 用户取消删除
+    });
+  } else {
+    // 只有新增行，已经在前端删除完成
+    proxy.$modal.msgSuccess('操作成功');
     expandOrder.value = [];
     groupIndexList.value = [];
     groupList.value = [];
     isAdding.value = false;
     adviceQueryParams.value.adviceType = undefined;
-  };
-
-  if (hasSavedItem) {
-    if (deleteList.length === 0) {
-      proxy.$modal.msgWarning('没有可提交删除的已保存医嘱，请刷新后重试');
-      getListInfo(false);
-      cleanupAfterDelete();
-      return;
-    }
-
-    // Bug #454: 删除前确认；检验医嘱提示级联删除申请单
-    const hasLabItem = deleteList.some((item) => item.adviceType === 3);
-    const confirmMsg = hasLabItem
-      ? '删除此医嘱将同时删除关联的检验申请单，是否确认删除？'
-      : '确认删除选中的医嘱项目吗？';
-
-    proxy.$modal
-      .confirm(confirmMsg)
-      .then(() => {
-        savePrescription({ adviceSaveList: deleteList }).then((res) => {
-          if (res.code == 200) {
-            proxy.$modal.msgSuccess('操作成功');
-            getListInfo(false);
-            cleanupAfterDelete();
-          }
-        });
-      })
-      .catch(() => {
-        // 用户取消删除
-      });
-  } else {
-    proxy.$modal.msgSuccess('操作成功');
-    cleanupAfterDelete();
   }
 }
 
@@ -1029,9 +986,7 @@ function changeCheck(value,index,row){
   groupList.value.map(k=>{
     if(k.check){
       if(k.statusEnum == 1){//待签发
-        // 手术计费场景（generateSourceEnum=6）不限制 bizRequestFlag
+        if(Number(k.bizRequestFlag)==1||!k.bizRequestFlag){
-        const bizAllowed = isSurgeryChargeBillingContext() || Number(k.bizRequestFlag)==1||!k.bizRequestFlag
-        if(bizAllowed){
           if(handleSaveDisabled.value&&!handleSingOutDisabled.value&&groupList.value.length>1){
             proxy.$modal.msgWarning('请选择相同的状态的项目进行操作')
             return
@@ -1046,9 +1001,7 @@ function changeCheck(value,index,row){
         }
       }
       if(k.statusEnum == 2){ //已签发
-        // 手术计费场景（generateSourceEnum=6）不限制 bizRequestFlag
+        if(Number(k.bizRequestFlag)==1||!k.bizRequestFlag){
-        const bizAllowed = isSurgeryChargeBillingContext() || Number(k.bizRequestFlag)==1||!k.bizRequestFlag
-        if(bizAllowed){
           if(!handleSaveDisabled.value&&handleSingOutDisabled.value&&groupList.value.length>1){
             proxy.$modal.msgWarning('请选择相同的状态的项目进行操作')
             return
@@ -1075,28 +1028,28 @@ function handleSave() {
     return;
   }
   let saveList = prescriptionList.value.filter((item) => {
-    // 手术计费场景（generateSourceEnum=6）不限制 bizRequestFlag，允许任何授权用户签发
-    // 门诊划价场景保留 bizRequestFlag 限制，只能操作本人开立的医嘱
-    if (isSurgeryChargeBillingContext()) {
-      return item.check && item.statusEnum == 1
-    }
     return item.check && item.statusEnum == 1&&(Number(item.bizRequestFlag)==1||!item.bizRequestFlag)
   });
-  // 无可签发项目时提前返回，避免后端报"医嘱列表为空"
+  // let saveList = prescriptionList.value
-  if (saveList.length == 0) {
+  // .filter((item) => {
-    proxy.$modal.msgWarning('当前无可签发处方');
+  //   return item.check;
-    return;
+  // }).filter((item) => {
-  }
+  //   return item.statusEnum == 1&&item.bizRequestFlag==1
+  // })
+
+  // if (saveList.length == 0) {
+  //   proxy.$modal.msgWarning('当前无可签发处方');
+  //   return;
+  // }
   // 此处签发处方和单行保存处方传参相同，后台已经将传参存为JSON字符串，此处直接转换为JSON即可
   let list = saveList.map((item) => {
     const parsedContent = item.contentJson ? JSON.parse(item.contentJson) : {};
     return {
       ...parsedContent,
       requestId: item.requestId,
-      // 已有 requestId 的记录走 UPDATE 路径，新记录走 INSERT 路径
+      dbOpType: '1',
-      dbOpType: item.requestId ? '2' : '1',
       groupId: item.groupId,
-      // 补充顶层关键字段（这些可能不在 contentJson 中，需从 API 响应顶层提取）
+      // 🔧 Bug #443: 补充顶层关键字段（这些不在 contentJson 中，需从 API 响应顶层提取）
       encounterId: item.encounterId,
       patientId: item.patientId,
       locationId: item.positionId,
@@ -1104,14 +1057,6 @@ function handleSave() {
       adviceTableName: item.adviceTableName,
       adviceDefinitionId: item.adviceDefinitionId,
       chargeItemId: item.chargeItemId,
-      // 补充数量、单位、批号等字段（后端 handDevice 需要这些字段）
-      quantity: item.quantity,
-      unitCode: item.unitCode,
-      lotNumber: item.lotNumber,
-      categoryEnum: item.categoryEnum,
-      // 签发时显式设置手术计费关键字段，后端 generateSourceEnum 回退为默认值导致查询无法匹配
-      generateSourceEnum: props.generateSourceEnum ?? parsedContent.generateSourceEnum ?? item.generateSourceEnum,
-      sourceBillNo: props.sourceBillNo ?? parsedContent.sourceBillNo ?? item.sourceBillNo,
     };
   });
   // 确保 organizationId 不为 undefined（手术计费场景下可能缺失 orgId）
@@ -1198,10 +1143,6 @@ function handleSingOut() {
       return item.check;
     })
     .filter((item) => {
-      // 手术计费场景（generateSourceEnum=6）不限制 bizRequestFlag
-      if (isSurgeryChargeBillingContext()) {
-        return item.statusEnum == 2 && item.chargeStatus != 5
-      }
       return item.statusEnum == 2 && item.chargeStatus != 5 && (Number(item.bizRequestFlag)==1||!item.bizRequestFlag)
     })
     .map((item) => {

openhis-ui-vue3/src/views/doctorstation/components/diagnosis/diagnosis.vue

@@ -354,11 +354,6 @@ async function getList() {
         if (!item.classification) {
           item.classification = '西医';
         }
-        // 转换 longTermFlag 为字符串，以匹配 useDict 返回的字典值类型（字符串）
-        // 避免 el-select 因类型不匹配（整数 1 vs 字符串 "1"）导致下拉框清空
-        if (item.longTermFlag != null) {
-          item.longTermFlag = String(item.longTermFlag);
-        }
         // 如果ybNo（诊断编码）符合传染病编码格式，添加到selectedDiseases
         if (item.ybNo && /^(01|02|03)/.test(item.ybNo)) {
           item.selectedDiseases = [item.ybNo];

openhis-ui-vue3/src/views/doctorstation/components/diagnosis/infectiousDiseaseReportDialog.vue

@@ -41,6 +41,14 @@
           </el-col>
         </el-row>
 
+        <!-- 工作单位（学校） -->
+        <el-row :gutter="16" class="form-row">
+          <el-col :span="12" class="form-item">
+            <span class="form-label">工作单位（学校）</span>
+            <el-input v-model="form.workplace" class="underline-input" />
+          </el-col>
+        </el-row>
+
         <!-- 性别、出生日期、或实足年龄 -->
         <el-row :gutter="16" class="form-row">
           <el-col :span="7" class="form-item">
@@ -75,14 +83,6 @@
           </el-col>
         </el-row>
 
-        <!-- 工作单位（学校） -->
-        <el-row :gutter="16" class="form-row">
-          <el-col :span="12" class="form-item">
-            <span class="form-label">工作单位（学校）</span>
-            <el-input v-model="form.workplace" class="underline-input" />
-          </el-col>
-        </el-row>
-
         <!-- 联系电话、紧急联系人电话 -->
         <el-row :gutter="16" class="form-row">
           <el-col :span="12" class="form-item">
@@ -548,8 +548,6 @@ const dialogReadOnly = ref(false);
 const formRef = ref(null);
 // 保存按钮加载状态，防止重复提交
 const submitLoading = ref(false);
-// 数据加载中标志，防止 showReport 加载已有数据时 watch 清空分型字段
-const loadingData = ref(false);
 
 const props = defineProps({
   title: {
@@ -942,8 +940,7 @@ const showSubtypeSelect = computed(() => {
 // 监听疾病选择变化，自动清空分型选择
 watch(() => [form.value.selectedClassA, form.value.selectedClassB, form.value.selectedClassC], (newVal, oldVal) => {
   // 如果疾病选择发生变化，清空分型选择
-  // 数据加载中时不清空，避免 showReport 加载已有数据时被错误清空
+  if (JSON.stringify(newVal) !== JSON.stringify(oldVal)) {
-  if (JSON.stringify(newVal) !== JSON.stringify(oldVal) && !loadingData.value) {
     form.value.diseaseType = '';
   }
 }, { deep: true });
@@ -1095,9 +1092,6 @@ function showReport(reportData = {}, readOnly = true) {
   dialogVisible.value = true;
   dialogReadOnly.value = readOnly;
 
-  // 标记数据加载中，防止 watch 清空 diseaseType 分型字段
-  loadingData.value = true;
-
   resetAddressSelector();
   initProvinceOptions();
 
@@ -1155,9 +1149,6 @@ function showReport(reportData = {}, readOnly = true) {
     form.value.addressCounty,
     form.value.addressTown
   );
-
-  // 数据加载完成，恢复 watch 监听
-  loadingData.value = false;
 }
 
 /**

openhis-ui-vue3/src/views/doctorstation/components/examination/examinationApplication.vue

@@ -582,30 +582,15 @@ function handleResetSearch() {
 // 初始化默认日期范围为近一周
 handleResetSearch();
 
-// 🔧 BugFix#426/#430: 懒加载套餐明细（支持 packageName 解析）
+// 🔧 BugFix#426: 懒加载套餐明细
 async function loadPackageDetails(row, treeNode, resolve) {
-  let packageId = row.packageId;
+  if (!row.packageId) {
-  if (!packageId && row.packageName) {
-    try {
-      const pkgRes = await listCheckPackage({ packageName: row.packageName });
-      let packages = pkgRes?.data || [];
-      if (!Array.isArray(packages)) {
-        packages = packages.records || packages.data || [];
-      }
-      if (packages.length > 0) {
-        packageId = packages[0].id;
-      }
-    } catch (err) {
-      console.error('套餐名称解析失败:', err);
-    }
-  }
-  if (!packageId) {
     resolve([]);
     return;
   }
   try {
     const res = await request({
-      url: `/system/check-type/package/${packageId}/details`,
+      url: `/system/check-type/package/${row.packageId}/details`,
       method: 'get'
     });
     const list = parsePackageDetailsPayload(res);
@@ -639,9 +624,9 @@ function getPackageDetailsList(item) {
   return Array.isArray(carrier?.packageDetails) ? carrier.packageDetails : [];
 }
 
-/** 有套餐 ID 或 packageName 的已选行才展示右侧套餐区（加载中 / 空 / 明细列表） */
+/** 有套餐 ID 的已选行才展示右侧套餐区（加载中 / 空 / 明细列表） */
 function shouldShowPackageBody(item) {
-  return !!(getPackageCarrier(item)?.packageId || item.packageName || item.packageId);
+  return !!getPackageCarrier(item)?.packageId;
 }
 
 /** 金额展示：统一两位小数 */
@@ -1073,8 +1058,7 @@ const filteredCategoryList = computed(() => {
   const key = dictSearchKey.value.toLowerCase();
   return categoryList.value.map(cat => ({
     ...cat,
-    items: cat.items.filter(item => (item.name || '').toLowerCase().includes(key)),
+    items: cat.items.filter(item => (item.name || '').toLowerCase().includes(key))
-    methods: cat.methods || []
   })).filter(cat => cat.items.length > 0);
 });
 
@@ -1381,10 +1365,10 @@ async function handleMethodSelect(checked, method, cat) {
     const existingItem = selectedItems.value.find(s => s.id === targetItem.id);
     if (existingItem) {
       existingItem.selectedMethod = method;
-      // 从方法中获取套餐信息（支持 packageId 或 packageName 解析）
+      // 从方法中获取套餐信息
-      if (method.packageId || method.packageName) {
+      if (method.packageId) {
         existingItem.isPackage = true;
-        existingItem.packageId = method.packageId || existingItem.packageId;
+        existingItem.packageId = method.packageId;
         existingItem.hasChildren = true;  // #426修复
         existingItem.packageName = method.packageName || existingItem.packageName;  // #428修复: 确保 packageName 同步
         // 预加载套餐明细
@@ -1421,12 +1405,12 @@ async function handleMethodSelect(checked, method, cat) {
       isPackage: !!method.packageId || !!targetItem.packageName,
       packageId: method.packageId || targetItem.packageId || null,
       packageName: method.packageName || targetItem.packageName || null,  // #428修复: 复制 packageName，确保套餐明细可加载
-      hasChildren: !!(method.packageId || method.packageName || targetItem.packageId || targetItem.packageName)  // #426修复: 树形表格懒加载展开标记，支持 packageName 解析
+      hasChildren: !!(method.packageId || targetItem.packageId)  // #426修复: 树形表格懒加载展开标记
     };
     selectedItems.value.push(newItem);
 
     // 如果是套餐，预加载套餐明细
-    if (newItem.isPackage && (newItem.packageId || newItem.packageName)) {
+    if (newItem.isPackage && newItem.packageId) {
       loadPackageDetailsForItem(newItem);
     }
 
@@ -1564,7 +1548,7 @@ async function toggleItemExpand(item) {
 async function selectMethodCheckbox(checked, item, method) {
   if (checked) {
     item.selectedMethod = method;
-    if (item.expanded && (method.packageId || method.packageName)) {
+    if (item.expanded && method.packageId) {
       loadPackageDetailsForItem(item);
     }
     // 动态加载该方法对应的套餐明细
@@ -1629,9 +1613,8 @@ async function loadMethodPackageDetails(item, method) {
 /** 检查明细表格中切换检查方法 */
 async function onDetailMethodChange(row, val) {
   row.selectedMethod = val || null;
-  if (val?.packageId || val?.packageName) {
+  if (val?.packageId) {
-    row.packageId = val.packageId || row.packageId;
+    row.packageId = val.packageId;
-    row.packageName = val.packageName || row.packageName;
     row.isPackage = true;
     row.hasChildren = true;  // #426修复
   }

openhis-ui-vue3/src/views/doctorstation/components/prescription/prescriptionlist.vue

@@ -3801,8 +3801,6 @@ function handleSaveHistory(value) {
     uniqueKey: undefined,
     dbOpType: value.requestId ? '2' : '1',
     minUnitQuantity: value.quantity * value.partPercent,
-    // 🔧 修复：确保 categoryEnum 被传递（耗材必填字段），避免后端 NPE
-    categoryEnum: value.categoryEnum || value.categoryCode,
     conditionId: conditionId.value,
     conditionDefinitionId: conditionDefinitionId.value,
     encounterDiagnosisId: encounterDiagnosisId.value,

openhis-ui-vue3/src/views/doctorstation/components/surgery/surgeryApplication.vue

@@ -856,7 +856,6 @@ function handleDelete(row) {
     }).then(() => {
       getList()
       proxy.$modal.msgSuccess('删除成功')
-      emit('saved') // 通知父组件刷新医嘱列表
     }).catch(error => {
       console.error('删除手术失败:', error)
       proxy.$modal.msgError('删除失败')
@@ -868,7 +867,6 @@ function handleDelete(row) {
     }).then(() => {
       getList()
       proxy.$modal.msgSuccess('手术已取消')
-      emit('saved') // 通知父组件刷新医嘱列表
     }).catch(error => {
       console.error('取消手术失败:', error)
       proxy.$modal.msgError('取消失败')

openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/examineApplication.vue

@@ -179,11 +179,14 @@
 
         <div v-if="descJsonData && hasMatchedFields" class="applicationShow-container-content">
           <el-descriptions title="申请单描述" :column="2">
-            <template v-for="(value, key) in descJsonData" :key="key">
+            <el-descriptions-item
-              <el-descriptions-item v-if="isFieldMatched(key)" :label="getFieldLabel(key)">
+              v-for="key in orderedDescFieldKeys"
-                {{ transformField(key, value) || '-' }}
+              :key="key"
-              </el-descriptions-item>
+              v-if="descJsonData[key] != null && descJsonData[key] !== ''"
-            </template>
+              :label="getFieldLabel(key)"
+            >
+              {{ transformField(key, descJsonData[key]) || '-' }}
+            </el-descriptions-item>
           </el-descriptions>
         </div>
 

openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/summaryDrugApplication.vue

@@ -0,0 +1,20 @@
+<!--
+ * 住院医生站 — 汇总发药申请：复用药房「发药汇总单」能力
+ -->
+<template>
+  <div class="summary-drug-application">
+    <MedicationSummary />
+  </div>
+</template>
+
+<script setup>
+import MedicationSummary from '@/views/drug/inpatientMedicationDispensing/components/MedicationSummary.vue';
+</script>
+
+<style scoped>
+.summary-drug-application {
+  height: 100%;
+  min-height: 400px;
+  overflow: auto;
+}
+</style>

openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/surgeryApplication.vue

@@ -116,7 +116,7 @@ import {computed, getCurrentInstance, ref, watch} from 'vue';
 import {Refresh} from '@element-plus/icons-vue';
 import {patientInfo} from '../../store/patient.js';
 import {getSurgery} from './api';
-import {getDepartmentList} from '@/api/public.js';
+import {getOrgList} from '@/views/doctorstation/components/api.js';
 
 const { proxy } = getCurrentInstance();
 
@@ -182,32 +182,25 @@ const hasMatchedFields = computed(() => {
 
 /** 查询科室 */
 const getLocationInfo = async () => {
-  const res = await getDepartmentList();
+  const res = await getOrgList();
-  orgOptions.value = res.data || [];
+  orgOptions.value = res.data.records;
 };
 
 const recursionFun = (targetDepartment) => {
-  if (!targetDepartment || !orgOptions.value || orgOptions.value.length === 0) {
-    return '';
-  }
   let name = '';
-  // 统一处理：扁平列表和树形结构都适用
+  for (let index = 0; index < orgOptions.value.length; index++) {
-  const findInList = (list) => {
+    const obj = orgOptions.value[index];
-    for (const node of list) {
+    if (obj.id == targetDepartment) {
-      if (String(node.id) === String(targetDepartment)) {
+      name = obj.name;
-        name = node.name;
+    }
-        return true;
+    const subObjArray = obj['children'];
-      }
+    for (let index = 0; index < subObjArray.length; index++) {
-      // 树形结构：递归查找 children
+      const item = subObjArray[index];
-      if (node.children && node.children.length > 0) {
+      if (item.id == targetDepartment) {
-        if (findInList(node.children)) {
+        name = item.name;
-          return true;
-        }
       }
     }
-    return false;
+  }
-  };
-  findInList(orgOptions.value);
   return name;
 };
 

openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/testApplication.vue

@@ -117,9 +117,7 @@
                 <el-button link type="warning" @click="handleWithdraw(scope.row)">撤回</el-button>
               </template>
               <!-- 已校对(2)、待接收(3)、已收样(4)、已出报告(6)、已作废(7)：仅查看详情 -->
-              <template v-else>
+              <el-button link type="primary" @click="handleViewDetail(scope.row)">详情</el-button>
-                <el-button link type="primary" @click="handleViewDetail(scope.row)">详情</el-button>
-              </template>
             </template>
           </el-table-column>
         </el-table>
@@ -409,27 +407,32 @@ const hasMatchedFields = computed(() => {
 
 /** 查询科室 */
 const getLocationInfo = async () => {
-  try {
+  const res = await getDepartmentList();
-    const res = await getDepartmentList();
+  orgOptions.value = res.data || [];
-    orgOptions.value = Array.isArray(res.data) ? res.data : [];
-  } catch (e) {
-    console.warn('科室列表加载失败:', e.message);
-    orgOptions.value = [];
-  }
 };
 
 const recursionFun = (targetDepartment) => {
   if (!targetDepartment) return '';
-  const findNode = (list, id) => {
+  let name = '';
-    if (!list || list.length === 0) return '';
+  for (let index = 0; index < orgOptions.value.length; index++) {
-    for (const item of list) {
+    const obj = orgOptions.value[index];
-      if (item.id == id) return item.name;
+    if (obj.id == targetDepartment) {
-      const found = findNode(item.children, id);
+      name = obj.name;
-      if (found) return found;
+      break;
     }
-    return '';
+    const subObjArray = obj['children'];
-  };
+    if (subObjArray && subObjArray.length > 0) {
-  return findNode(orgOptions.value, targetDepartment);
+      for (let i = 0; i < subObjArray.length; i++) {
+        const item = subObjArray[i];
+        if (item.id == targetDepartment) {
+          name = item.name;
+          break;
+        }
+      }
+    }
+    if (name) break;
+  }
+  return name;
 };
 
 const handleViewDetail = async (row) => {

openhis-ui-vue3/src/views/inpatientDoctor/home/components/order/OrderForm.vue

@@ -63,7 +63,7 @@
           <span class="medicine-info"> 诊断：{{ config.diagnosisName }} </span>
           <span class="medicine-info"> 皮试：{{ row.skinTestFlag_enumText }} </span>
           <span class="medicine-info"> 注射药品：{{ row.injectFlag_enumText }} </span>
-          <span class="total-amount">
+          <span class="total-amount" v-if="row.therapyEnum == '2'">
             总金额：{{ row.totalPrice ? Number(row.totalPrice).toFixed(2) + ' 元' : '0.00 元' }}
           </span>
         </div>
@@ -83,7 +83,7 @@
                 :controls="false"
                 style="width: 70px"
                 :ref="(el) => setInputRef('doseQuantity', el)"
-                @input="() => { convertValues(); calculateTotalAmount(); }"
+                @input="convertValues"
                 @keyup.enter.prevent="handleEnter('doseQuantity')"
               />
             </el-form-item>
@@ -110,7 +110,7 @@
                 :controls="false"
                 style="width: 70px; margin-left: 32px"
                 :ref="(el) => setInputRef('dose', el)"
-                @input="() => { convertDoseValues(); calculateTotalAmount(); }"
+                @input="convertDoseValues"
                 @keyup.enter.prevent="handleEnter('dose')"
               />
             </el-form-item>
@@ -119,7 +119,7 @@
               v-model="row.doseUnitCode"
               style="width: 70px"
               placeholder=" "
-              @change="() => { convertValues(); calculateTotalAmount(); }"
+              @change="convertValues"
             >
               <el-option
                 v-for="item in row.unitCodeList"
@@ -271,17 +271,13 @@
                   controls-position="right"
                   :controls="false"
                   :ref="(el) => setInputRef('firstDose', el)"
-                  @input="calculateTotalAmount"
                   @keyup.enter.prevent="handleEnter('firstDose')"
                 />
               </el-form-item>
-              <el-select v-model="row.doseUnitCode" style="width: 70px" placeholder=" ">
+              <el-select v-model="row.unitCode" style="width: 70px" placeholder=" ">
-                <el-option
+                <template v-for="item in row.unitCodeList" :key="item.value">
-                  v-for="item in row.unitCodeList"
+                  <el-option v-if="checkUnit(item)" :value="item.value" :label="item.label" />
-                  :value="item.value"
+                </template>
-                  :label="item.label"
-                  :key="item.value"
-                />
               </el-select>
             </template>
           </div>
@@ -430,7 +426,6 @@
 
 <script setup lang="ts">
 import {computed, getCurrentInstance, nextTick, onMounted, ref, watch} from 'vue';
-import Decimal from 'decimal.js';
 
 interface Config {
   diagnosisName: string; // 仅用于显示
@@ -628,18 +623,7 @@ const orgFallbackOption = (value: any) => {
 const convertValues = () => props.handlers.convertValue('doseQuantity', props.row, props.index);
 const convertDoseValues = () => props.handlers.convertValue('dose', props.row, props.index);
 const calculateTotalPrice = () => props.handlers.calculateTotal('price', props.row, props.index);
-// 直接用 row 计算总金额：数量 * 单价，避免父组件索引不匹配的问题
+const calculateTotalAmount = () => props.handlers.calculateTotal('amount', props.row, props.index);
-const calculateTotalAmount = () => {
-  nextTick(() => {
-    const row = props.row;
-    const qty = new Decimal(row.doseQuantity || 0);
-    const isMinUnit = row.unitCode == row.minUnitCode;
-    const price = isMinUnit ? row.minUnitPrice : row.unitPrice;
-    // 四舍五入到2位再算，与页面显示的单价一致
-    const roundedPrice = new Decimal(price || 0).toDecimalPlaces(2, Decimal.ROUND_HALF_UP);
-    row.totalPrice = qty.mul(roundedPrice).toFixed(6);
-  });
-};
 const setInputRef = props.handlers.setInputRef;
 
 defineExpose({

openhis-ui-vue3/src/views/inpatientDoctor/home/components/order/applicationForm/laboratoryTests.vue

@@ -207,8 +207,6 @@ const loadAllData = async () => {
     }
     applicationListAll.value = res.data?.records || [];
     totalCount.value = res.data?.total || 0;
-    // 检验项目列表为异步加载，编辑回显必须在数据就绪后执行，否则已选区一直为空
-    applyEditTransferSelection()
   } catch (e) {
     proxy.$message.error('获取检验项目列表失败');
     applicationListAll.value = [];
@@ -345,92 +343,43 @@ watch(
   }
 );
 
-/** 编辑弹窗：根据申请单明细把右侧「已选择」与 transferValue 对齐（依赖 applicationListAll 已加载） */
+// 编辑模式下，回显已有数据
-const applyEditTransferSelection = () => {
-  const newData = props.editData
-  if (!newData?.requestFormId || !newData.requestFormDetailList?.length) {
-    return
-  }
-  if (!applicationListAll.value.length) {
-    return
-  }
-  const selectedIds = []
-  for (const detail of newData.requestFormDetailList) {
-    const idFromDetail = detail.activityId ?? detail.adviceDefinitionId
-    let matched = null
-    if (idFromDetail != null && idFromDetail !== '') {
-      matched = applicationListAll.value.find(
-        (item) => String(item.adviceDefinitionId) === String(idFromDetail)
-      )
-    }
-    if (!matched && detail.adviceName) {
-      matched = applicationListAll.value.find((item) => item.adviceName === detail.adviceName)
-    }
-    if (!matched && detail.adviceName) {
-      const norm = (s) => String(s || '').trim()
-      matched = applicationListAll.value.find(
-        (item) => norm(item.adviceName) === norm(detail.adviceName)
-      )
-    }
-    if (matched) {
-      selectedIds.push(matched.adviceDefinitionId)
-    }
-  }
-  const uniq = [...new Set(selectedIds)]
-  transferValue.value = uniq
-  if (newData.requestFormDetailList.length && uniq.length === 0) {
-    console.warn(
-      '[LaboratoryTests] 申请单明细未能在项目字典中匹配到项，请核对 activityId / 项目名称',
-      newData.requestFormDetailList
-    )
-  }
-}
-
-// 编辑模式下，回显已有数据（表单来自 descJson；项目选择在字典加载后由 applyEditTransferSelection 完成）
 watch(
   () => props.editData,
   (newData) => {
-    if (!newData || !newData.requestFormId) return
+    if (!newData || !newData.requestFormId) return;
 
+    // 解析 descJson 回填表单
     if (newData.descJson) {
       try {
-        const obj = JSON.parse(newData.descJson)
+        const obj = JSON.parse(newData.descJson);
         Object.keys(form).forEach((key) => {
           if (obj[key] !== undefined) {
-            form[key] = obj[key]
+            form[key] = obj[key];
           }
-        })
+        });
       } catch (e) {
-        console.error('解析 descJson 失败:', e)
+        console.error('解析 descJson 失败:', e);
       }
     }
 
-    applyEditTransferSelection()
+    // 回填已选项目
+    if (newData.requestFormDetailList && newData.requestFormDetailList.length > 0) {
+      // 从全部数据中匹配已选项目
+      const selectedIds = [];
+      newData.requestFormDetailList.forEach((detail) => {
+        const matched = applicationListAll.value.find(
+          (item) => item.adviceName === detail.adviceName
+        );
+        if (matched) {
+          selectedIds.push(matched.adviceDefinitionId);
+        }
+      });
+      transferValue.value = selectedIds;
+    }
   },
-  { immediate: true, deep: true }
+  { immediate: true }
-)
-
-// 编辑模式下，applicationListAll 加载完成后重新回显已选项目
-watch(
-  () => applicationListAll.value,
-  () => {
-    if (!props.editData?.requestFormId) return;
-    if (!props.editData.requestFormDetailList?.length) return;
-    if (!applicationListAll.value.length) return;
-
-    const selectedIds = [];
-    props.editData.requestFormDetailList.forEach((detail) => {
-      const matched = applicationListAll.value.find(
-        (item) => item.adviceName === detail.adviceName
-      );
-      if (matched) {
-        selectedIds.push(matched.adviceDefinitionId);
-      }
-    });
-    transferValue.value = selectedIds;
-  }
 );
-
 const submit = () => {
   if (transferValue.value.length == 0) {
     return proxy.$message.error('请选择申请单');

openhis-ui-vue3/src/views/inpatientDoctor/home/components/order/applicationForm/medicalExaminations.vue

@@ -7,6 +7,20 @@
   <div class="medicalExaminations-container">
     <!-- 主体内容 -->
     <div class="form-body">
+      <!-- 右上角：紧急程度 -->
+      <div class="urgency-bar">
+        <span class="urgency-bar-label">紧急程度：</span>
+        <el-radio-group v-model="form.urgencyLevel" @change="handleUrgencyChange" size="small">
+          <el-radio-button label="routine">普通</el-radio-button>
+          <el-radio-button label="emergency">急诊</el-radio-button>
+        </el-radio-group>
+        <transition name="el-fade-in-linear">
+          <span v-if="form.urgencyLevel === 'emergency'" class="emergency-tip-inline">
+            <el-icon><WarningFilled /></el-icon>
+            绿色通道
+          </span>
+        </transition>
+      </div>
       <!-- 选择检查项目 -->
       <div class="section-card">
         <div class="transfer-wrapper">
@@ -38,21 +52,7 @@
               />
             </el-form-item>
           </el-col>
-          <el-col :span="4">
+          <el-col :span="12">
-            <el-form-item label="紧急程度">
-              <el-radio-group v-model="form.urgencyLevel" @change="handleUrgencyChange" size="small">
-                <el-radio-button label="routine">普通</el-radio-button>
-                <el-radio-button label="emergency">急诊</el-radio-button>
-              </el-radio-group>
-              <transition name="el-fade-in-linear">
-                <span v-if="form.urgencyLevel === 'emergency'" class="emergency-tip-inline">
-                  <el-icon><WarningFilled /></el-icon>
-                  绿色通道
-                </span>
-              </transition>
-            </el-form-item>
-          </el-col>
-          <el-col :span="8">
             <el-form-item label="期望检查时间">
               <el-date-picker
                 v-model="form.expectedExaminationTime"
@@ -61,7 +61,7 @@
                 style="width: 100%"
                 value-format="YYYY-MM-DD HH:mm:ss"
                 format="YYYY-MM-DD HH:mm"
-                :disabled-date="disabledPastDate"
+                :disabled-date="disabledFutureDate"
                 :default-value="new Date()"
               />
             </el-form-item>
@@ -347,8 +347,8 @@ const rules = reactive({
   ],
 });
 
-// 禁用过去的日期（允许选择今天及以后）
+// 禁用过去的时间
-const disabledPastDate = (time) => {
+const disabledFutureDate = (time) => {
   return time.getTime() < Date.now() - 8.64e7;
 };
 
@@ -501,8 +501,8 @@ const submit = () => {
     if (res.code === 200) {
       ElMessage.success(res.msg || (props.isEditMode ? '修改成功' : '保存成功'));
       applicationList.value = [];
-      emits('submitOk');
       resetForm();
+      emits('submitOk');
     } else {
       ElMessage.error(res.msg || '保存失败');
     }
@@ -624,6 +624,23 @@ $bg-color: #f5f7fa;
     }
   }
 
+  // 紧急程度栏 - 右上角
+  .urgency-bar {
+    display: flex;
+    align-items: center;
+    justify-content: flex-end;
+    gap: 8px;
+    padding: 4px 0;
+    margin-bottom: 4px;
+  }
+
+  .urgency-bar-label {
+    font-size: 13px;
+    font-weight: 500;
+    color: $text-regular;
+    white-space: nowrap;
+  }
+
   // 卡片通用样式 - 紧凑
   .section-card {
     background: #fff;

openhis-ui-vue3/src/views/inpatientDoctor/home/components/order/applicationForm/surgery.vue

@@ -232,21 +232,64 @@ onMounted(() => {
  * type(1：watch监听类型 2:点击保存类型)
  * selectProjectIds(选中项目的id数组)
  * */
-const projectWithDepartment = (selectProjectIds) => {
+const projectWithDepartment = (selectProjectIds, type) => {
-  if (!selectProjectIds || selectProjectIds.length === 0) {
+  //1.获取选中的项目 2.判断项目的执行科室是否相同 3.判断执行科室是否配置 4.将项目的执行科室复值到执行科室下拉选位置
-    form.targetDepartment = '';
+  let isRelease = true;
+  // 选中项目的数组
+  const arr = [];
+  // 根据选中的项目id查找对应的项目
+  selectProjectIds.forEach((element) => {
+    const searchData = applicationList.value.find((item) => {
+      return element == item.adviceDefinitionId;
+    });
+    arr.push(searchData);
+  });
+  // 清空科室
+  form.targetDepartment = '';
+  if (arr.length > 0) {
+    const obj = arr[0];
+    // 判断科室是否相同
+    const isCompare = arr.every((item) => {
+      return item.orgId == obj.orgId;
+    });
+    if (!isCompare) {
+      ElMessage({
+        type: 'error',
+        message: '执行科室不同',
+      });
+      isRelease = false;
+    }
+    // 选中项目中的执行科室id与全部科室数据做匹配
+    const findItem = findTreeItem(orgOptions.value, obj.orgId);
+
+    if (!findItem) {
+      isRelease = false;
+      ElMessage({
+        type: 'error',
+        message: '未找到项目执行的科室',
+      });
+    }
+    if (type == 1) {
+      if (isRelease) {
+        form.targetDepartment = findItem.id;
+      }
+    }
   }
+  return isRelease;
 };
 // 监听选择项目变化
-watch(() => transferValue.value, (newValue) => {
+watch(
-  projectWithDepartment(newValue);
+  () => transferValue.value,
-});
+  (newValue) => {
+    projectWithDepartment(newValue, 1);
+  }
+);
 const submit = () => {
   if (transferValue.value.length == 0) {
-    return proxy.$message.error('请选择手术项目');
+    return proxy.$message.error('请选择申请单');
   }
-  if (!form.targetDepartment) {
+  if (!projectWithDepartment(transferValue.value, 2)) {
-    return proxy.$message.error('请选择发往科室');
+    return;
   }
   let applicationListAllFilter = applicationListAll.value.filter((item) => {
     return transferValue.value.includes(item.adviceDefinitionId);
@@ -259,7 +302,7 @@ const submit = () => {
       unitCode: item.unitCode,
       unitPrice: item.price,
       totalPrice: item.price,
-      positionId: form.targetDepartment || item.positionId, // 用户手动选择的发往科室优先于项目默认执行科室
+      positionId: item.positionId,
       definitionId: item.chargeItemDefinitionId,
       accountId: patientInfo.value.accountId,
     };

openhis-ui-vue3/src/views/inpatientDoctor/home/components/order/index.vue

@@ -605,26 +605,13 @@ function getListInfo(addNewRow) {
       prescriptionList.value = res.data
         .map((item) => {
           const parsedContent = JSON.parse(item.contentJson);
-          // 构造 unitCodeList，确保编辑时下拉框有正确的选项
-          console.log('【DEBUG】unitCode:', parsedContent?.unitCode, typeof parsedContent?.unitCode, 'unitCodeList:', JSON.stringify(parsedContent?.unitCodeList));
-          const unitCodeListData = parsedContent?.unitCodeList || [
-            { value: String(parsedContent?.unitCode ?? item.unitCode ?? ''), label: parsedContent?.unitCode_dictText ?? item.unitCode_dictText ?? '', type: 'unit' },
-            { value: String(parsedContent?.doseUnitCode ?? ''), label: parsedContent?.doseUnitCode_dictText ?? '', type: 'dose' },
-            { value: String(parsedContent?.minUnitCode ?? ''), label: parsedContent?.minUnitCode_dictText ?? '', type: 'minUnit' },
-          ];
           return {
             ...parsedContent,
             ...item,
-            // 🔧 修复：contentJson 中的 totalPrice 优先于 charge_item 表的 totalPrice
-            // charge_item.totalPrice 可能为 0 或 null（新建医嘱时），导致总金额显示为 "-"
-            totalPrice: parsedContent?.totalPrice || item.totalPrice,
             isEdit: false,
             showPopover: false,
             doseQuantity: parsedContent?.doseQuantity,
             doseUnitCode_dictText: parsedContent?.doseUnitCode_dictText,
-            // 确保 unitCode 为字符串类型，与 unitCodeList 的 option value 类型一致
-            unitCode: String(parsedContent?.unitCode ?? item.unitCode ?? ''),
-            unitCodeList: unitCodeListData,
             // 确保 therapyEnum 被正确设置，优先使用 contentJson 中的值
             therapyEnum: String(parsedContent?.therapyEnum ?? item.therapyEnum ?? '1'),
             // 🔧 修复：确保 orgId 为 String 类型，与 organization 树的 id 类型一致
@@ -804,7 +791,7 @@ function checkUnit(item, row) {
   }
 }
 
-// 行双击打开编辑块，"待保存"和"待签发"均可编辑
+// 行双击打开编辑块，仅待发送的可编辑
 function clickRowDb(row, column, event) {
   // 检查点击的是否是复选框
   if (event && event.target.closest('.el-checkbox')) {
@@ -815,8 +802,8 @@ function clickRowDb(row, column, event) {
     return;
   }
   row.showPopover = false;
-  // statusEnum == 1 包含"待保存(无requestId)"和"待签发(有requestId)"，均允许编辑
+  // “待签发(已保存 requestId存在)”不允许再编辑；仅“待保存(无requestId)”允许编辑
-  if (row.statusEnum == 1) {
+  if (row.statusEnum == 1 && !row.requestId) {
     // 确保治疗类型为字符串，方便与单选框 label 对齐，默认为长期医嘱('1')
     row.therapyEnum = String(row.therapyEnum ?? '1');
     row.isEdit = true;
@@ -1195,7 +1182,7 @@ function handleSave() {
     // 此处签发处方和单行保存处方传参相同，后台已经将传参存为JSON字符串，此处直接转换为JSON即可
     loading.value = true;
     let list = saveList.map((item) => {
-      const parsedContent = item.contentJson ? JSON.parse(item.contentJson) : {};
+      const parsedContent = JSON.parse(item.contentJson);
       return {
         ...parsedContent,
         adviceType: item.adviceType,
@@ -1454,14 +1441,14 @@ function handleSaveBatch() {
 function setValue(row) {
   // 构造单位列表
   unitCodeList.value = [
-    { value: String(row.unitCode), label: row.unitCode_dictText, type: 'unit' },
+    { value: row.unitCode, label: row.unitCode_dictText, type: 'unit' },
     {
-      value: String(row.doseUnitCode),
+      value: row.doseUnitCode,
       label: row.doseUnitCode_dictText,
       type: 'dose',
     },
     {
-      value: String(row.minUnitCode),
+      value: row.minUnitCode,
       label: row.minUnitCode_dictText,
       type: 'minUnit',
     },
@@ -1527,8 +1514,8 @@ function setValue(row) {
     // dose: undefined, Removed to preserve dose value from group package
     unitCodeList: unitCodeList.value,
     doseUnitCode: row.doseUnitCode,
-    minUnitCode: String(row.minUnitCode),
+    minUnitCode: row.minUnitCode,
-    unitCode: row.partAttributeEnum == 1 ? String(row.minUnitCode) : String(row.unitCode),
+    unitCode: row.partAttributeEnum == 1 ? row.minUnitCode : row.unitCode,
     categoryEnum: row.categoryCode,
     definitionId: row.chargeItemDefinitionId,
     executeNum: 1,
@@ -1544,13 +1531,6 @@ function setValue(row) {
             ? new Decimal(selectedStock.price).div(row.partPercent).toFixed(6)
             : prevRow.minUnitPrice,
           positionName: selectedStock?.locationName,
-          totalPrice: row.quantity
-            ? (String(row.unitCode) == String(row.minUnitCode)
-              ? (row.quantity * (selectedStock
-                  ? new Decimal(selectedStock.price).div(row.partPercent).toFixed(6)
-                  : prevRow.minUnitPrice)).toFixed(6)
-              : (row.quantity * (selectedStock?.price ?? 0)).toFixed(6))
-            : undefined,
         }
       : {
           quantity: 1,
@@ -1601,10 +1581,10 @@ function handleSaveGroup(orderGroupList) {
       therapyEnum: item.orderDetailInfos?.therapyEnum || '1',
     };
 
-    // 预初始化空行（组套项带预填值，设为 false 让明细字段在表格中直接展示）
+    // 预初始化空行
     prescriptionList.value[rowIndex.value] = {
       uniqueKey: nextId.value++,
-      isEdit: false,
+      isEdit: true,
       statusEnum: 1,
     };
 
@@ -1635,10 +1615,7 @@ function handleSaveGroup(orderGroupList) {
       conditionId: conditionId.value,
       conditionDefinitionId: conditionDefinitionId.value,
       encounterDiagnosisId: encounterDiagnosisId.value,
-      diagnosisName: diagnosisName.value,
       therapyEnum: prescriptionList.value[rowIndex.value]?.therapyEnum || mergedDetail.therapyEnum || '1',
-      // 🔧 修复：确保组套医嘱的 categoryEnum 被正确映射，防止后端 NPE
-      categoryEnum: mergedDetail?.categoryEnum || mergedDetail?.categoryCode || item?.categoryCode,
     };
 
     // 计算价格和总量
@@ -1679,8 +1656,6 @@ function handleSaveHistory(value) {
     encounterDiagnosisId: encounterDiagnosisId.value,
     // 确保 therapyEnum 被正确传递，默认为长期医嘱('1')
     therapyEnum: value.therapyEnum || '1',
-    // 🔧 修复：历史医嘱的 categoryCode(String) 映射为后端 categoryEnum(Integer)，防止 NPE
-    categoryEnum: value.categoryEnum || value.categoryCode,
     contentJson: JSON.stringify({
       ...value,
       therapyEnum: value.therapyEnum || '1',

openhis-ui-vue3/src/views/inpatientDoctor/home/index.vue

@@ -22,6 +22,9 @@
             <el-tab-pane label="检查申请" name="examine">
               <ExamineApplication ref="examineApplicationRef" />
             </el-tab-pane>
+            <!-- <el-tab-pane label="汇总发药申请" name="summaryDrug">
+              <SummaryDrugApplication ref="summaryDrugApplicationRef" />
+            </el-tab-pane> -->
             <el-tab-pane label="手术申请" name="surgery">
               <SurgeryApplication ref="surgeryApplicationRef" />
             </el-tab-pane>

openhis-ui-vue3/src/views/inpatientNurse/InpatientBilling/components/FeeDialog.vue

@@ -354,7 +354,7 @@ const adviceTypeList = computed(() => {
   }
   // 默认值
   return [
-    { label: '耗材', value: 2 },
+    { label: '耗材', value: 4 },
     { label: '诊疗', value: 3 },
     { label: '全部', value: '' },
   ];
@@ -373,8 +373,7 @@ const filterKeywords = ref({});
 const queryParams = ref({
   pageSize: 100,
   pageNum: 1,
-  // 默认加载全部类型（药品1+耗材2+诊疗3）
+  adviceTypes: '2,3',
-  adviceTypes: [1, 2, 3],
 });
 /**
  * 医嘱提交数据模型
@@ -556,26 +555,12 @@ function loadDepartmentOptions() {
 function getAdviceBaseInfos() {
   adviceLoading.value = true;
   queryParams.value.searchKey = searchText.value;
-  // 字典值(3=诊疗,4=耗材)映射为后端adviceType(2=耗材,3=诊疗)
+  queryParams.value.adviceType = adviceType.value;
-  if (adviceType.value === 4) {
-    queryParams.value.adviceTypes = [2];
-  } else if (adviceType.value === 3) {
-    queryParams.value.adviceTypes = [3];
-  } else {
-    queryParams.value.adviceTypes = [1, 2, 3];
-  }
   queryParams.value.organizationId = orgId.value;
   queryParams.value.pricingFlag = 1; // 划价标记
   getAdviceBaseInfo(queryParams.value)
     .then((res) => {
-      const list = res.data?.records || [];
+      AdviceBaseInfoList.value = res.data?.records || [];
-      // 药品(1)和耗材(2)必须有库存才能展示，诊疗(3)无库存概念不过滤
-      AdviceBaseInfoList.value = list.filter(item => {
-        if (item.adviceType === 1 || item.adviceType === 2) {
-          return item.inventoryList && item.inventoryList.length > 0;
-        }
-        return true;
-      });
     })
     .finally(() => {
       adviceLoading.value = false;

openhis-ui-vue3/src/views/inpatientNurse/constants/navigation.js

@@ -29,6 +29,12 @@ export const inpatientNurseNavs = [
     icon: 'EditPen',
     accent: '#ff7a45',
   },
+  {
+    label: '汇总发药申请',
+    path: '/inHospital/statistics/drugDistribution',
+    icon: 'Collection',
+    accent: '#597ef7',
+  },
   {
     label: '住院记账',
     path: '/inHospital/statistics/InpatientBilling',

openhis-ui-vue3/src/views/inpatientNurse/drugDistribution/components/prescriptionList.vue

@@ -166,7 +166,7 @@
 import {getPrescriptionList, medicineSummary} from './api';
 import {patientInfoList} from '../../components/store/patient.js';
 import {formatDateStr} from '@/utils/index';
-import {getCurrentInstance, ref} from 'vue';
+import {getCurrentInstance, ref, watch} from 'vue';
 import useUserStore from '@/store/modules/user';
 
 const activeNames = ref([]);
@@ -273,6 +273,11 @@ function handleGetPrescription() {
   }
 }
 
+// 监听医嘱类型筛选条件变化，自动刷新列表
+watch(() => props.therapyEnum, () => {
+  handleGetPrescription();
+});
+
 function handleMedicineSummary() {
   let paramList = getSelectRows();
   if (!paramList || paramList.length === 0) {

openhis-ui-vue3/src/views/inpatientNurse/drugDistribution/components/summaryMedicineList.vue

@@ -50,7 +50,7 @@
 <script setup>
 import {getMedicineSummary, getMedicineSummaryDetail} from './api';
 import {patientInfoList} from '../../components/store/patient.js';
-import {getCurrentInstance, ref} from 'vue';
+import {getCurrentInstance, ref, watch} from 'vue';
 
 const medicineSummaryFormList = ref([]);
 const medicineSummaryFormDetails = ref([]);
@@ -86,6 +86,11 @@ function handleGetPrescription() {
   });
 }
 
+// 监听医嘱类型筛选条件变化，自动刷新列表
+watch(() => props.therapyEnum, () => {
+  handleGetPrescription();
+});
+
 // 获取发药单详情
 function getDetail(row) {
   getMedicineSummaryDetail({ summaryNo: row.busNo }).then((res) => {

openhis-ui-vue3/src/views/inpatientNurse/drugDistribution/index.vue

@@ -106,7 +106,7 @@
 </template>
 
 <script setup>
-import {getCurrentInstance, nextTick, ref} from 'vue';
+import {getCurrentInstance, ref} from 'vue';
 import {useRouter} from 'vue-router';
 import PatientList from '../components/patientList.vue';
 import PrescriptionList from './components/prescriptionList.vue';
@@ -173,29 +173,15 @@ function handleGetPrescription() {
   }
 }
 
-async function handelSwicthChange(value) {
+function handelSwicthChange(value) {
-  if (isDetails.value == '1') {
+  if (!prescriptionRefs.value) {
-    if (!prescriptionRefs.value) {
+    chooseAll.value = false;
-      chooseAll.value = false;
+    return;
-      return;
+  }
-    }
+  if (value) {
-    await nextTick();
+    prescriptionRefs.value.selectAllRows();
-    if (value) {
-      prescriptionRefs.value.selectAllRows();
-    } else {
-      prescriptionRefs.value.clearSelection();
-    }
   } else {
-    if (!summaryMedicineRefs.value) {
+    prescriptionRefs.value.clearSelection();
-      chooseAll.value = false;
-      return;
-    }
-    await nextTick();
-    if (value) {
-      summaryMedicineRefs.value.selectAllRows();
-    } else {
-      summaryMedicineRefs.value.clearSelection();
-    }
   }
 }
 
@@ -212,11 +198,7 @@ function handleTherapyChange() {
 }
 
 function handleExecute() {
-  if (isDetails.value == '1') {
+  proxy.$refs['prescriptionRefs'].handleMedicineSummary();
-    prescriptionRefs.value?.handleMedicineSummary();
-  } else {
-    summaryMedicineRefs.value?.handleExecute();
-  }
 }
 
 function handleBack() {
@@ -224,11 +206,7 @@ function handleBack() {
 }
 
 provide('handleGetPrescription', (value) => {
-  if (isDetails.value == '1') {
+  prescriptionRefs.value.handleGetPrescription();
-    prescriptionRefs.value?.handleGetPrescription();
-  } else {
-    summaryMedicineRefs.value?.handleGetPrescription();
-  }
 });
 </script>
 

openhis-ui-vue3/src/views/inpatientNurse/medicalOrderProofread/components/prescriptionList.vue

@@ -182,16 +182,8 @@ function handleRadioChange() {
 
 function handleGetPrescription() {
   if (patientInfoList.value.length > 0) {
-    // 过滤掉 encounterId 无效的患者节点，防止后端 SQL 解析异常
-    const validEncounterIds = patientInfoList.value
-      .map((i) => i.encounterId)
-      .filter((id) => id !== undefined && id !== null && id !== '');
-    if (validEncounterIds.length === 0) {
-      proxy.$message.warning('请选择有效的患者');
-      return;
-    }
     loading.value = true;
-    let encounterIds = validEncounterIds.join(',');
+    let encounterIds = patientInfoList.value.map((i) => i.encounterId).join(',');
     getPrescriptionList({
       encounterIds: encounterIds,
       requestStatus: props.requestStatus,

openhis-ui-vue3/src/views/inpatientNurse/tprChart/components/addTprDialog.vue

@@ -777,9 +777,6 @@ const InputOptions = ref([
 // 日期范围 - 体征信息搜索时间
 const receptionTime = ref(null);
 
-// 按钮禁用状态（保存按钮依赖）
-const buttonDisabled = ref(false);
-
 // 表单数据 - 体征录入
 const formData = ref({
   recordingDate: '',
@@ -850,10 +847,26 @@ function getPatientList() {
       patientId: props.patientId
     }
   }).then((res) => {
-    if (res.code === 200 && res.data) {
+
-      patientList.value = Array.isArray(res.data) ? res.data : (res.data.data || []);
+    // 判断返回的数据结构
+    let data = res.data;
+    if (res.data && res.data.data && typeof res.data.data === 'object') {
+      // 如果是嵌套结构 {data: {data: Array(3)}}
+      data = res.data.data;
+    } else if (res.data && typeof res.data === 'object' && res.data.data !== undefined) {
+      // 如果是 {code: 200, msg: '操作成功', data: Array(3)}
+      data = res.data.data;
+    }
+
+    console.log('=== data 长度 ===', data?.length);
+
+    if (res.code === 200 && data) {
+      console.log('=== 准备赋值 patientList.value ===');
+      patientList.value = data;
+      console.log('=== patientList.value 赋值后 ===', patientList.value);
+      console.log('=== patientList.value 长度 ===', patientList.value?.length);
     } else {
-      patientList.value = [];
+      console.error('=== 查询失败或无数据 ===');
     }
   }).catch(err => {
     console.error('=== 查询报错 ===', err);
@@ -872,22 +885,8 @@ function getPatientDetial() {
   queryParams.value.patientId = props.patientId;
   // 默认查询今天的数据
   const today = moment().format('YYYY-MM-DD');
-  const now = moment();
   receptionTime.value = [today, today];
   formData.value.recordingDate = today;
-  // 自动填充最近的整点时间点（2/6/10/14/18/22点）
-  const hour = now.hour();
-  const timePoints = [2, 6, 10, 14, 18, 22];
-  let nearestHour = timePoints[0];
-  let minDiff = Math.abs(hour - nearestHour);
-  for (const tp of timePoints) {
-    const diff = Math.abs(hour - tp);
-    if (diff < minDiff) {
-      minDiff = diff;
-      nearestHour = tp;
-    }
-  }
-  formData.value.timePoint = String(nearestHour).padStart(2, '0') + '00';
   // 自动加载数据
   getPatientList();
   listPatient(queryParams.value).then((res) => {
@@ -968,29 +967,6 @@ function confirmCharge() {
     encounterId: props.patientInfo.encounterId,
   };
 
-  // 自动获取当前日期和时间
-  const now = moment();
-  if (!params.recordingDate) {
-    params.recordingDate = now.format('YYYY-MM-DD');
-    formData.value.recordingDate = params.recordingDate;
-  }
-  if (!params.timePoint) {
-    // 取最近的整点时间点（2/6/10/14/18/22点）
-    const hour = now.hour();
-    const timePoints = [2, 6, 10, 14, 18, 22];
-    let nearestHour = timePoints[0];
-    let minDiff = Math.abs(hour - nearestHour);
-    for (const tp of timePoints) {
-      const diff = Math.abs(hour - tp);
-      if (diff < minDiff) {
-        minDiff = diff;
-        nearestHour = tp;
-      }
-    }
-    params.timePoint = String(nearestHour).padStart(2, '0') + '00';
-    formData.value.timePoint = params.timePoint;
-  }
-
   // 收集所有录入的体征数据
   const vitalSignsCode = [];
   const vitalSignsValues = [];
@@ -1076,18 +1052,13 @@ function confirmCharge() {
     vitalSignsValues.push(params.stoolVolume);
   }
 
-  // 校验：没有录入任何体征数据时提示用户
-  if (vitalSignsCode.length === 0) {
-    proxy.$modal.msgWarning('请录入患者体征信息');
-    return;
-  }
-
   params.vitalSignsCode = vitalSignsCode;
   params.vitalSignsValues = vitalSignsValues;
+  params.recordingDate = formData.value.recordingDate || moment(new Date()).format('YYYY-MM-DD');
 
   addVitalSigns(params).then(res => {
     if (res.code === 200) {
-      proxy.$modal.msgSuccess('保存成功');
+      proxy.msgSuccess('保存成功');
       // 保存成功后刷新列表
       getPatientList();
       // 清空表单
@@ -1117,9 +1088,6 @@ function confirmCharge() {
         stoolVolume: '',
       };
     }
-  }).catch(err => {
-    console.error('保存体征数据失败:', err);
-    proxy.$modal.msgError('保存失败，请重试');
   });
 }
 /** 重置操作表单 */

openhis-ui-vue3/src/views/medicationmanagement/requisitionManagement/requisitionManagement/index.vue

@@ -982,16 +982,6 @@ function handleSubmitApproval() {
   } else if (!form.purchaseinventoryList[length - 1].isSave) {
     proxy.$modal.msgWarning('第' + length + '行单据未保存，请先保存');
   } else {
-    // 提交审批前逐行校验库存，防止超库存单据进入审批
-    for (let i = 0; i < form.purchaseinventoryList.length; i++) {
-      const line = form.purchaseinventoryList[i];
-      if (!line) continue;
-      const err = validateRequisitionQtyVsStock(line, i + 1);
-      if (err) {
-        proxy.$modal.msgWarning(err);
-        return;
-      }
-    }
     submitApproval(receiptHeaderForm.busNo).then((response) => {
       if (response.code == 200) {
         proxy.$modal.msgSuccess('提交审批成功');
@@ -1141,7 +1131,8 @@ function handleLocationClick(item, row, index) {
     .then((res) => {
       const list = res.data || [];
       const d = pickBestOrgQuantityRow(list);
-      if (d) {
+      const strictOk = d && Number(d.orgQuantity ?? 0) > 0;
+      if (strictOk) {
         applyFromDto(d, false);
         if (Number(r.totalQuantity) <= 0) {
           proxy.$message.warning('仓库数量为0，无法调用！');
@@ -1153,15 +1144,11 @@ function handleLocationClick(item, row, index) {
         return runGet(false).then((res2) => {
           const list2 = res2.data || [];
           const d2 = pickBestOrgQuantityRow(list2);
-          if (d2) {
+          if (d2 && Number(d2.orgQuantity ?? 0) > 0) {
             applyFromDto(d2, true);
-            if (Number(r.totalQuantity) <= 0) {
+            proxy.$message.info(
-              proxy.$message.warning('仓库数量为0，无法调用！');
+              '所选批号在本仓库无对应库存或批号不一致，已按仓库实物回显批号与可领数量，请核对。'
-            } else {
+            );
-              proxy.$message.info(
-                '所选批号在本仓库无对应库存或批号不一致，已按仓库实物回显批号与可领数量，请核对。'
-              );
-            }
           } else {
             r.totalQuantity = 0;
             r.price = 0;

openhis-ui-vue3/src/views/medicationmanagement/transferManagent/batchTransfer/index.vue

@@ -739,25 +739,15 @@ function handleSubmitApproval() {
   let length = totalIncentoryInfoList.value.length;
   if (length < 1) {
     proxy.$modal.msgWarning('请先添加单据');
-    return;
+  } else if (data.isEdit) {
-  }
-  // 校验调拨数量：必须 > 0
-  const invalidQtyRow = totalIncentoryInfoList.value.find(
-    (row) => !row.itemQuantity || row.itemQuantity <= 0
-  );
-  if (invalidQtyRow) {
-    proxy.$modal.msgWarning('存在调拨数量为0或无效的明细，请检查后提交');
-    return;
-  }
-  if (data.isEdit) {
     proxy.$modal.msgWarning('单据未保存');
-    return;
+  } else {
+    submitApproval(receiptHeaderForm.busNo).then((response) => {
+      proxy.$modal.msgSuccess('提交审批成功');
+      tagsViewStore.delView(router.currentRoute.value);
+      router.replace({ path: 'transferManagentList' });
+    });
   }
-  submitApproval(receiptHeaderForm.busNo).then((response) => {
-    proxy.$modal.msgSuccess('提交审批成功');
-    tagsViewStore.delView(router.currentRoute.value);
-    router.replace({ path: 'transferManagentList' });
-  });
 }
 
 // 切换仓库类型获取药房/药库列表   目的仓库切换
@@ -917,22 +907,6 @@ function remakeBlur(row, index) {
   editBatchTransfer(index);
 }
 function handleSave() {
-  // 校验调拨数量：必须 > 0
-  const invalidQtyRow = totalIncentoryInfoList.value.find(
-    (row) => !row.itemQuantity || row.itemQuantity <= 0
-  );
-  if (invalidQtyRow) {
-    proxy.$modal.msgError('调拨数量必须大于0，请检查！');
-    return;
-  }
-  // 校验调拨数量不能超过源仓库库存
-  const exceedStockRow = totalIncentoryInfoList.value.find(
-    (row) => row.itemQuantity > row.totalSourceQuantity
-  );
-  if (exceedStockRow) {
-    proxy.$modal.msgError('调拨数量不可超出源库存数量，请检查！');
-    return;
-  }
   // 校验单价
   const invalidPriceRow = totalIncentoryInfoList.value.find(
     (row) => !row.price || row.price <= 0

openhis-ui-vue3/src/views/medicationmanagement/transferManagent/transferManagent/index.vue

@@ -386,7 +386,7 @@
                       :disabled="viewStatus == 'view'"
                       v-model="scope.row.itemQuantityDisplay"
                       placeholder=""
-                      @input="(value) => handleItemQuantityChange(scope.row, value)"
+                      @change="(value) => handleItemQuantityChange(scope.row, value)"
                       :class="{ 'error-border': scope.row.error }"
                     />
                   </div>
@@ -971,10 +971,6 @@ function handleItemQuantityChange(row, value) {
     quantityTemp = value;
   }
   row.totalPrice = ((row.price * quantityTemp) / row.partPercent).toFixed(2);
-  // 数量变更后重置保存标记，允许重新提交
-  row.isSave = false;
-  // 同步更新底部合计金额
-  handleTotalAmount();
 }
 
 function handelApply() {
@@ -1266,108 +1262,128 @@ function editBatchTransfer(index) {
 }
 
 function handleSave(row, index) {
-  // 过滤出未保存的行，已保存的行不重复提交
+  rowList.value = [];
-  const listToCheck = route.query.supplyBusNo
+  if (route.query.supplyBusNo) {
-    ? forms.purchaseinventoryList
+    // 编辑
-    : form.purchaseinventoryList;
+    forms.purchaseinventoryList.map((row, index) => {
-  const unsavedList = listToCheck.filter(item => !item.isSave);
+      if (row) {
-  if (unsavedList.length === 0) {
+        proxy.$refs['receiptHeaderRef'].validate((valid) => {
-    proxy.$modal.msgWarning('所有行均已保存，无需重复提交');
+          if (valid) {
-    return;
+            proxy.$refs['formRef'].validate((valid) => {
+              if (valid) {
+                if (row.unitCode == row.unitList.minUnitCode) {
+                  row.itemQuantity = forms.purchaseinventoryList[index].olditemQuantity
+                    ? forms.purchaseinventoryList[index].olditemQuantity
+                    : forms.purchaseinventoryList[index].itemQuantity;
+                } else {
+                  row.itemQuantity = forms.purchaseinventoryList[index].itemMaxQuantity
+                    ? forms.purchaseinventoryList[index].itemMaxQuantity
+                    : forms.purchaseinventoryList[index].itemQuantity;
+                }
+                // let rows = JSON.parse(JSON.stringify(row))
+                // delete rows.itemMaxQuantity
+
+                if (row.unitCode == row.unitCode_dictText) {
+                  if (row.unitCode_dictText == row.unitList.minUnitCode_dictText) {
+                    row.unitCode = row.unitList.minUnitCode;
+                  } else {
+                    row.unitCode = row.unitList.unitCode;
+                    row.unitCode_dictText = row.unitList.unitCode_dictText;
+                  }
+                }
+                if (row.unitCode == row.unitList.unitCode) {
+                  row.unitCode_dictText = row.unitList.unitCode_dictText;
+                } else if (row.unitCode == row.unitList.minUnitCode) {
+                  row.unitCode_dictText = row.unitList.minUnitCode_dictText;
+                }
+                if (!forms.purchaseinventoryList[index].price || forms.purchaseinventoryList[index].price <= 0) {
+                  proxy.$message.warning('调拨单价不能为空或为0，请检查！');
+                  return;
+                }
+                forms.purchaseinventoryList[index].totalPrice =
+                  forms.purchaseinventoryList[index].price * forms.purchaseinventoryList[index].itemQuantity;
+                rowList.value.push(JSON.parse(JSON.stringify(row)));
+                if (
+                  rowList._rawValue &&
+                  rowList._rawValue.length == forms.purchaseinventoryList.length
+                ) {
+                  addTransferProducts(rowList._rawValue);
+                }
+              }
+            });
+          }
+        });
+      }
+    });
+  } else {
+    //新增
+    form.purchaseinventoryList.map((row, index) => {
+      if (row) {
+        proxy.$refs['receiptHeaderRef'].validate((valid) => {
+          if (valid) {
+            proxy.$refs['formRef'].validate((valid) => {
+              if (valid) {
+                let rows = JSON.parse(JSON.stringify(row));
+                delete rows.itemMaxQuantity;
+                if (rows.unitCode == rows.unitList.minUnitCode) {
+                  rows.itemQuantity = form.purchaseinventoryList[index].olditemQuantity
+                    ? form.purchaseinventoryList[index].olditemQuantity
+                    : form.purchaseinventoryList[index].itemQuantity;
+                } else {
+                  rows.itemQuantity = form.purchaseinventoryList[index].itemMaxQuantity
+                    ? form.purchaseinventoryList[index].itemMaxQuantity
+                    : form.purchaseinventoryList[index].itemQuantity;
+                }
+                if (rows.unitCode == rows.unitCode_dictText) {
+                  if (rows.unitCode_dictText == rows.unitList.minUnitCode_dictText) {
+                    rows.unitCode = rows.unitList.minUnitCode;
+                  } else {
+                    rows.unitCode = rows.unitList.unitCode;
+                    rows.unitCode_dictText = rows.unitList.unitCode_dictText;
+                  }
+                }
+                if (rows.unitCode == rows.unitList.unitCode) {
+                  rows.unitCode_dictText = rows.unitList.unitCode_dictText;
+                } else if (rows.unitCode == rows.unitList.minUnitCode) {
+                  rows.unitCode_dictText = rows.unitList.minUnitCode_dictText;
+                }
+                if (!form.purchaseinventoryList[index].price || form.purchaseinventoryList[index].price <= 0) {
+                  proxy.$message.warning('调拨单价不能为空或为0，请检查！');
+                  return;
+                }
+                form.purchaseinventoryList[index].totalPrice =
+                  form.purchaseinventoryList[index].price * form.purchaseinventoryList[index].itemQuantity;
+                rowList.value.push(JSON.parse(JSON.stringify(rows)));
+                if (
+                  rowList._rawValue &&
+                  rowList._rawValue.length == form.purchaseinventoryList.length
+                ) {
+                  addTransferProducts(rowList._rawValue);
+                }
+              }
+            });
+          }
+        });
+      }
+    });
   }
-
-  // 先校验表头
-  proxy.$refs['receiptHeaderRef'].validate((headerValid) => {
-    if (!headerValid) return;
-
-    // 逐行校验（避免异步回调导致重复提交）
-    const rowsToSave = [];
-    for (let i = 0; i < form.purchaseinventoryList.length; i++) {
-      const r = form.purchaseinventoryList[i];
-      if (!r) continue;
-
-      // 跳过已保存的行，避免重复提交导致预扣减库存叠加
-      if (r.isSave) continue;
-
-      // 校验当前行的必填字段
-      let rowValid = true;
-      for (const prop of ['name', 'unitCode']) {
-        const formRef = proxy.$refs['formRef'];
-        if (formRef && formRef.validateField) {
-          formRef.validateField(`purchaseinventoryList.${i}.${prop}`, (valid) => {
-            if (valid) rowValid = false;
-          });
-        }
-      }
-      if (!rowValid) {
-        proxy.$modal.msgWarning('第' + (i + 1) + '行数据不完整，请检查');
-        return;
-      }
-
-      // 单价校验
-      if (!r.price || r.price <= 0) {
-        proxy.$modal.msgWarning('第' + (i + 1) + '行调拨单价不能为空或为0');
-        return;
-      }
-
-      // 单位处理
-      const rowData = route.query.supplyBusNo
-        ? JSON.parse(JSON.stringify(forms.purchaseinventoryList[i]))
-        : JSON.parse(JSON.stringify(r));
-      delete rowData.itemMaxQuantity;
-
-      if (rowData.unitCode == rowData.unitList?.minUnitCode) {
-        rowData.itemQuantity = r.olditemQuantity || r.itemQuantity;
-      } else {
-        rowData.itemQuantity = r.itemMaxQuantity || r.itemQuantity;
-      }
-
-      if (rowData.unitCode == rowData.unitCode_dictText) {
-        if (rowData.unitCode_dictText == rowData.unitList?.minUnitCode_dictText) {
-          rowData.unitCode = rowData.unitList.minUnitCode;
-        } else {
-          rowData.unitCode = rowData.unitList.unitCode;
-          rowData.unitCode_dictText = rowData.unitList.unitCode_dictText;
-        }
-      }
-      if (rowData.unitCode == rowData.unitList?.unitCode) {
-        rowData.unitCode_dictText = rowData.unitList.unitCode_dictText;
-      } else if (rowData.unitCode == rowData.unitList?.minUnitCode) {
-        rowData.unitCode_dictText = rowData.unitList.minUnitCode_dictText;
-      }
-
-      // 计算总价
-      r.totalPrice = r.price * rowData.itemQuantity;
-      rowsToSave.push(rowData);
-    }
-
-    // 所有行校验通过，一次性提交
-    if (rowsToSave.length > 0) {
-      addTransferProducts(rowsToSave);
-    }
-  });
 }
 function addTransferProducts(rowList) {
   addTransferProduct(JSON.parse(JSON.stringify(rowList))).then((res) => {
+    // 当前行没有id视为首次新增
+    // if (!row.id) {
+    //   data.isAdding = false; // 允许新增下一行
+    // }
     if (res.data) {
       proxy.$message.success('保存成功！');
-      let newIdIndex = 0;
       form.purchaseinventoryList.map((row, index) => {
-        // 只有未保存的行才会拿到新 id（和提交顺序一致）
+        form.purchaseinventoryList[index].id = res.data[index];
-        if (!row.isSave && res.data[newIdIndex]) {
-          form.purchaseinventoryList[index].id = res.data[newIdIndex];
-          newIdIndex++;
-        }
         form.purchaseinventoryList[index].isSave = true;
       });
       if (route.query.supplyBusNo) {
         // 编辑
-        let newIdIdx = 0;
         forms.purchaseinventoryList.map((row, index) => {
-          if (!row.isSave && res.data[newIdIdx]) {
+          forms.purchaseinventoryList[index].id = res.data[index];
-            forms.purchaseinventoryList[index].id = res.data[newIdIdx];
-            newIdIdx++;
-          }
           forms.purchaseinventoryList[index].isSave = true;
         });
       }

openhis-ui-vue3/src/views/surgicalschedule/index.vue

@@ -781,7 +781,7 @@
       </el-table>
 
       <!-- 底部分页区 -->
-      <div class="pagination-container apply-pagination">
+      <div class="pagination-container apply-pagination" style="margin-top: 10px; padding-bottom: 20px">
         <pagination
           v-show="applyTotal > 0"
           :total="applyTotal"
@@ -792,9 +792,12 @@
           @pagination="getSurgicalScheduleList"
         />
       </div>
+      <!-- 分页与底部操作区之间的间隔 -->
+      <div style="height: 48px"></div>
+
       <!-- 底部操作区 -->
       <template #footer>
-        <div class="dialog-footer" style="padding-top: 12px; border-top: 1px solid #ebeef5">
+        <div class="dialog-footer" style="margin-top: 24px; padding-top: 12px; border-top: 1px solid #ebeef5">
           <el-button @click="cancelApplyDialog">取消</el-button>
           <el-button type="primary" @click="confirmApply">确认</el-button>
         </div>
@@ -829,7 +832,7 @@
           </div>
           <div style="padding: 10px">
             <prescriptionlist :patientInfo="chargePatientInfo" ref="prescriptionRef"
-              :generateSourceEnum="chargePatientInfo.generateSourceEnum"
+              :generateSourceEnum="1"
               :sourceBillNo="chargePatientInfo.sourceBillNo" />
             <div class="overlay" v-if="disabled"></div>
           </div>
@@ -1565,7 +1568,7 @@ function handleMedicalAdvice(row) {
   temporaryMedicalLoading.value = true // 🔧 新增：开始加载
 
   // 调用计费接口获取数据
-  getPrescriptionList(row.visitId, 6, row.operCode).then((res) => {
+  getPrescriptionList(row.visitId).then((res) => {
     console.log('=== 拉取计费数据返回结果 ===', res)
     if (res.code === 200 && res.data) {
       // 🔧 修复：显示所有药品请求数据，不管有没有计费项目
@@ -1576,18 +1579,12 @@ function handleMedicalAdvice(row) {
       const filteredItems = res.data.filter(item => {
         // 匹配 encounterId
         if (item.encounterId !== row.visitId) return false;
-        // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3/6)
+        // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3)
-        // 🔧 修复 Bug #444: 使用 Number() 显式转换，避免字符串 "1" 被 !== 1 放行
+        if (item.adviceType !== 1) return false;
-        const at = Number(item.adviceType ?? item.advice_type);
-        if (at !== 1) return false;
         // 过滤掉名称为空的项目
         const medicineName = item.adviceName || item.advice_name;
         if (!medicineName || medicineName.trim() === '') return false;
-        // 🔧 修复 Bug #444: 二次过滤，排除名称中包含手术/检查/诊疗关键词的非药品项目
+        // 🔧 修复 Bug #445: 过滤掉已生成医嘱的项目（已有 requestId 的不应出现在"待生成"列表）
-        // 某些计费项目可能在 adm_charge_item 中被错误标注为 adviceType=1
-        const excludedKeywords = ['术', '超声', '多普勒', '检查', '检验', '彩超', 'X线', 'CT', 'MRI', '扫描', '造影'];
-        if (excludedKeywords.some(kw => medicineName.includes(kw))) return false;
-        // 🔧 修复 Bug #445: 过滤掉已生成医嘱的项目（已有 requestId 的不应出现在"待生成"列表中）
         if (item.requestId) return false;
         // 根据药品请求ID去重，避免重复显示
         const itemId = item.requestId || item.id;
@@ -1708,14 +1705,9 @@ function handleMedicalAdvice(row) {
         usageLabel: usageLabel, // 🔧 新增：保存显示名称
         frequency: '临时',
         executeTime: new Date().toLocaleString('zh-CN'),
-        // 🔧 关键修复：确保 originalMedicine 中包含 encounterId 和匹配字段
+        // 🔧 关键修复：确保 originalMedicine 中包含 encounterId，以便后续判断是否为同一患者
-        // medicineName/specification/quantity 用于 handleTemporaryMedicalSubmit 中的
-        // 已提交项目匹配过滤（Bug #445），缺少这些字段会导致过滤失效
         originalMedicine: {
           ...medicine,
-          medicineName: medicine.medicineName,
-          specification: medicine.specification,
-          quantity: medicine.quantity,
           encounterId: row.visitId // 添加 encounterId 字段
         }
       }
@@ -1854,21 +1846,6 @@ function handleTemporaryMedicalRefresh() {
 function handleQuoteBilling() {
   // 重新拉取计费药品数据
   if (temporaryPatientInfo.value.visitId) {
-    // 🔧 修复 Bug #445: 在清空之前提取已提交项目的复合匹配键
-    // 原因：后续的 ID 匹配过滤依赖 temporaryAdvices，但 temporaryAdvices 会被先清空
-    // 新医嘱没有 requestId/chargeItemId，需用名称+规格+数量的复合键匹配
-    const submittedKeys = new Set(
-      (temporaryAdvices.value || [])
-        .map(a => {
-          const om = a.originalMedicine || {}
-          const name = om.medicineName || om.adviceName || a.adviceName || ''
-          const spec = om.specification || om.volume || ''
-          const qty = om.quantity ?? 0
-          return `${name}|||${spec}|||${qty}`
-        })
-        .filter(k => k !== '|||0')
-    )
-
     temporaryMedicalLoading.value = true // 🔧 新增：开始加载
     getPrescriptionList(temporaryPatientInfo.value.visitId, 6, temporaryPatientInfo.value.operCode).then((res) => {
             if (res.code === 200 && res.data) {
@@ -1876,21 +1853,16 @@ function handleQuoteBilling() {
               temporaryBillingMedicines.value = []
               temporaryAdvices.value = []
     
-              // 🔧 修复 Bug #445: 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3/6)
+              // 🔧 修复 Bug #445: 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3)
               // 同时过滤掉已有 requestId 的项目（已生成医嘱的不需要再次显示在"待生成"列表中）
               const filteredItems = res.data.filter(item => {
                 // 匹配 encounterId
                 if (item.encounterId !== temporaryPatientInfo.value.visitId) return false;
-                // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3/6)
+                // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3)
-                // 🔧 修复 Bug #444: 使用 Number() 显式转换 + snake_case 回退，避免字符串 "1" 匹配失败
+                if (item.adviceType !== 1) return false;
-                const at = Number(item.adviceType ?? item.advice_type);
-                if (at !== 1) return false;
                 // 过滤掉名称为空的项目
                 const medicineName = item.adviceName || item.advice_name;
                 if (!medicineName || medicineName.trim() === '') return false;
-                // 🔧 修复 Bug #444: 二次过滤，排除名称中包含手术/检查/诊疗关键词的非药品项目
-                const excludedKeywords = ['术', '超声', '多普勒', '检查', '检验', '彩超', 'X线', 'CT', 'MRI', '扫描', '造影'];
-                if (excludedKeywords.some(kw => medicineName.includes(kw))) return false;
                 // 🔧 修复 Bug #445: 过滤掉已生成医嘱的项目（已有 requestId）
                 if (item.requestId) return false;
                 return true;
@@ -1994,70 +1966,36 @@ function handleQuoteBilling() {
             usageLabel: usageLabel, // 🔧 新增：保存显示名称
             frequency: '临时',
             executeTime: new Date().toLocaleString('zh-CN'),
-            // 🔧 关键修复：确保 originalMedicine 中包含 encounterId 和匹配字段
+            // 🔧 关键修复：确保 originalMedicine 中包含 encounterId，以便后续判断是否为同一患者
-            // medicineName/specification/quantity 用于已提交项目匹配过滤（Bug #445）
             originalMedicine: {
               ...medicine,
-              medicineName: medicine.medicineName,
-              specification: medicine.specification,
-              quantity: medicine.quantity,
               encounterId: temporaryPatientInfo.value.visitId // 添加 encounterId 字段
             }
           }
         })
 
         // 🔧 修复 Bug #445: 过滤掉已生成医嘱的项目，避免"引用计费"后已提交项目重新出现在"待生成"列表
-        // 使用清空前提取的 submittedKeys（名称|||规格|||数量复合键）进行匹配
+        // 原因：后端返回的计费数据中，已生成医嘱的项目可能没有 requestId 字段
-        if (submittedKeys.size > 0) {
+        // 方案：用 chargeItemId/requestId/id 与已有的 temporaryAdvices 做匹配，排除已生成项目
-          temporaryBillingMedicines.value = temporaryBillingMedicines.value.filter(m => {
+        if (temporaryAdvices.value.length > 0) {
-            const key = `${m.medicineName || ''}|||${m.specification || ''}|||${m.quantity ?? 0}`
+          const existingAdviceIds = new Set()
-            return !submittedKeys.has(key)
+          temporaryAdvices.value.forEach(a => {
-          })
+            const om = a.originalMedicine || {}
-          // 同步更新 temporaryAdvices，保持两份数据一致
+            if (om.requestId) existingAdviceIds.add(String(om.requestId))
-          temporaryAdvices.value = temporaryBillingMedicines.value.map((medicine, index) => {
+            if (om.chargeItemId) existingAdviceIds.add(String(om.chargeItemId))
-            const specMatch = medicine.specification ? medicine.specification.match(/(\d+)(\D+)/) : null
+            if (om.id) existingAdviceIds.add(String(om.id))
-            const specValue = specMatch ? parseInt(specMatch[1]) : 1
-            const specUnit = specMatch ? specMatch[2] : 'ml'
-            const dosage = specValue * (medicine.quantity || 1)
-            let usageCode = 'iv'
-            let usageLabel = '静脉注射'
-            try {
-              const jsonContent = medicine.contentJson || medicine.content_json;
-              if (jsonContent) {
-                const contentData = JSON.parse(jsonContent);
-                if (contentData.methodCode) {
-                  usageCode = contentData.methodCode;
-                  usageLabel = getUsageLabel(contentData.methodCode);
-                }
-              }
-            } catch (e) {}
-            if (!usageCode || usageCode === 'iv') {
-              if (medicine.medicineName && medicine.medicineName.includes('注射液')) {
-                usageCode = 'iv'; usageLabel = '静脉注射';
-              } else if (medicine.medicineName && medicine.medicineName.includes('片')) {
-                usageCode = 'po'; usageLabel = '口服';
-              } else if (medicine.medicineName && medicine.medicineName.includes('胶囊')) {
-                usageCode = 'po'; usageLabel = '口服';
-              }
-            }
-            return {
-              id: index + 1,
-              adviceName: medicine.medicineName || '',
-              dosage,
-              unit: specUnit,
-              usage: usageCode,
-              usageLabel,
-              frequency: '临时',
-              executeTime: new Date().toLocaleString('zh-CN'),
-              originalMedicine: {
-                ...medicine,
-                medicineName: medicine.medicineName,
-                specification: medicine.specification,
-                quantity: medicine.quantity,
-                encounterId: temporaryPatientInfo.value.visitId
-              }
-            }
           })
+          if (existingAdviceIds.size > 0) {
+            temporaryBillingMedicines.value = temporaryBillingMedicines.value.filter(m => {
+              const mRequestId = m.requestId != null ? String(m.requestId) : null
+              const mChargeItemId = m.chargeItemId != null ? String(m.chargeItemId) : null
+              const mId = m.id != null ? String(m.id) : null
+              if (mRequestId && existingAdviceIds.has(mRequestId)) return false
+              if (mChargeItemId && existingAdviceIds.has(mChargeItemId)) return false
+              if (mId && existingAdviceIds.has(mId)) return false
+              return true
+            })
+          }
         }
 
         temporaryMedicalLoading.value = false // 🔧 新增：加载完成
@@ -2470,14 +2408,15 @@ function getRowClassName({ row, rowIndex }) {
 
 /* 手术申请查询弹窗 — 分页与footer间距 */
 .surgery-apply-dialog :deep(.el-dialog__body) {
-  padding-bottom: 16px;
+  padding-bottom: 32px;
 }
 .surgery-apply-dialog :deep(.el-dialog__footer) {
-  padding-top: 8px;
+  padding-top: 0;
 }
 .surgery-apply-dialog :deep(.apply-pagination) {
-  padding-top: 12px;
+  padding-bottom: 24px;
-  padding-bottom: 16px;
+  margin-bottom: 16px;
+  border-bottom: 1px solid #ebeef5;
 }
 .surgery-apply-dialog :deep(.apply-pagination .el-pagination) {
   margin-right: 80px;
@@ -2497,16 +2436,17 @@ function getRowClassName({ row, rowIndex }) {
 <style>
 /* 手术申请查询弹窗 — 非 scoped 确保穿透 teleport */
 .surgery-apply-dialog .apply-pagination {
-  padding-top: 12px !important;
+  padding-bottom: 24px !important;
-  padding-bottom: 16px !important;
+  margin-bottom: 16px !important;
+  border-bottom: 1px solid #ebeef5 !important;
 }
 .surgery-apply-dialog .apply-pagination .el-pagination {
   margin-right: 80px !important;
 }
 .surgery-apply-dialog .el-dialog__body {
-  padding-bottom: 16px !important;
+  padding-bottom: 32px !important;
 }
 .surgery-apply-dialog .el-dialog__footer {
-  padding-top: 8px !important;
+  padding-top: 0 !important;
 }
 </style>