Fix Bug #552: 双击待保存医嘱编辑保存后不应自动添加空医嘱 — 根因：handleSaveSign 中自动添加空行的条件缺少 isAdding.value 判断，导致双击编辑已有待保存医嘱也会触发 handleAddPrescription()

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

.agentforge/analysis/bug545_analysis.md

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,79 @@
+# 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）

analysis_469.md

@@ -0,0 +1,42 @@
+# 分析报告 — Bug #469
+
+## 问题描述
+检验申请列表的【操作】列仅显示固定的"打印"和"删除"按钮，未根据申请单状态动态切换操作权限。
+
+## 根因分析
+文件 `openhis-ui-vue3/src/views/doctorstation/components/inspection/inspectionApplication.vue` 第97-104行：
+- 操作列模板中固定渲染"打印"和"删除"按钮，没有任何状态判断逻辑
+- 缺少"修改"和"撤回"按钮
+
+## 状态机设计
+| 状态 | 条件 | 允许的操作 |
+|------|------|-----------|
+| 待开立 | applyStatus == 0 | 修改、删除 |
+| 已开立 | applyStatus == 1 && needExecute != true | 撤回 |
+| 已执行 | applyStatus == 1 && needExecute == true | 无（仅打印） |
+
+## 修复方案
+1. **前端 Vue**: 操作列改为 `v-if` 条件渲染按钮（修改/删除/撤回/打印）
+2. **前端 API**: 新增撤回接口 `withdrawInspectionApplication(applyNo)`
+3. **后端 Controller**: 新增 `POST /withdraw/{applyNo}` 端点
+4. **后端 Service**: 新增 `withdrawInspectionLabApply` 方法，将 applyStatus 置回 0，needRefund/needExecute 置回 false
+
+## 修复结果
+✅ 成功，共14行改动（2个commit完成）
+
+### 修复详情
+1. **commit c643a78b** - 初始修复：将操作列从静态"打印/删除"改为基于状态的动态按钮（修改/删除/撤回/详情），10行改动
+2. **commit f369ea41** - 跟进修复：将"详情"按钮包裹在 `<template v-else>` 中，避免对所有状态始终渲染，4行改动
+
+### 状态机实现
+| 状态 | 条件 | 显示按钮 |
+|------|------|---------|
+| 待签发 | billStatus == '0' | 修改 + 删除 |
+| 已签发 | billStatus == '1' | 撤回 |
+| 其他状态 | 已采证/已送检/报告已出/已作废 | 详情 |
+
+### 涉及文件
+- `openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/testApplication.vue` - 前端操作列动态按钮
+- `openhis-ui-vue3/src/views/inpatientDoctor/home/components/applicationShow/api.js` - 前端API（deleteRequestForm, withdrawRequestForm）
+- `openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/controller/RequestFormManageController.java` - 后端Controller（/delete, /withdraw 端点）
+- `openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/RequestFormManageAppServiceImpl.java` - 后端Service实现

bug547_analysis.md

@@ -0,0 +1,41 @@
+# Bug #547 分析报告
+
+## Bug 描述
+在"系统管理-执行科室配置"页面，选择科室（如检验科）后添加新项目并保存，显示"与未知科室时间冲突"错误。
+
+## 根因定位
+
+**核心问题在 `OrganizationLocationAppServiceImpl.java:161-174`**
+
+时间冲突检测的查询逻辑存在两个缺陷：
+
+### 缺陷1：查询范围过窄
+```java
+// 只查同一科室 + 同一诊疗的记录
+getOrgLocListByOrgIdAndActivityDefinitionId(orgLoc.getOrganizationId(), orgLoc.getActivityDefinitionId());
+```
+只查询**同一科室**的记录。如果同一诊疗项目在其他科室已有配置且时间重叠，不会被当前查询检测到。但系统本应阻止同一诊疗在多个科室同时段执行。
+
+### 缺陷2："未知科室"错误提示
+当冲突记录关联的科室被软删除（`delete_flag='1'`）时，`organizationService.getById()` 受 `@TableLogic` 注解影响查不到该科室，返回 null，错误提示变成"与未知科室时间冲突"。
+
+数据库验证发现确实存在软删除科室的组织位置记录（内科门诊、上海学校医院、信息科等，共9条）。
+
+### 数据流
+
+1. 前端选择科室 → 点击"添加新项目" → 填写诊疗和时间 → 点击"保存"
+2. 后端 `addOrEditOrgLoc()` 接收请求
+3. 查询现有冲突记录（**当前只查同科室**）
+4. 对冲突记录检查时间重叠
+5. 查找冲突科室名称 → 若科室被软删除则返回 null → "未知科室"
+
+## 修复方案
+
+1. **修改冲突检测范围**：查询同一 `activityDefinitionId` 的所有记录（跨科室检测），而非仅限当前科室
+2. **优雅处理"未知科室"**：当 `getById` 返回 null 时，使用 "已删除科室( ID )" 替代 "未知科室"，提供更有用的信息
+3. **新增 Service 方法**：`getOrgLocListByActivityDefinitionId(Long activityDefinitionId)` 用于按诊疗定义查询所有记录
+
+## 涉及文件
+- `openhis-server-new/openhis-application/src/main/java/com/openhis/web/basedatamanage/appservice/impl/OrganizationLocationAppServiceImpl.java`
+- `openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/service/IOrganizationLocationService.java`
+- `openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/service/impl/OrganizationLocationServiceImpl.java`

md/bug-analysis/bug444-analysis.md

@@ -0,0 +1,30 @@
+# 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

@@ -132,7 +132,22 @@ temporaryAdvices.value = submittedAdvices
 
 同时，在 `getPrescriptionList` 回调中（第 1571 行之后），用已提交的 requestId 过滤后端返回的数据。
 
-## 总结
+## 修复结果
 
-- **根因**：`handleMedicalAdvice` 每次打开都清空 `temporaryAdvices`，然后从后端重新拉取数据。但后端返回的新创建医嘱项可能没有 `requestId`，导致无法过滤。
+### 实际根因
-- **修复**：保留已提交（有 requestId）的医嘱数据，不清空；同时用这些 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）

openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/impl/DoctorScheduleAppServiceImpl.java

@@ -4,7 +4,7 @@ import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.core.common.core.domain.R;
 import com.core.common.utils.SecurityUtils;
-import com.openhis.common.constant.CommonConstants;
+import com.openhis.common.enums.SlotStatus;
 import com.openhis.appointmentmanage.domain.DoctorSchedule;
 import com.openhis.appointmentmanage.domain.DoctorScheduleWithDateDto;
 import com.openhis.appointmentmanage.domain.SchedulePool;
@@ -502,8 +502,8 @@ public class DoctorScheduleAppServiceImpl implements IDoctorScheduleAppService {
             // 该排班下存在有效患者预约（号源槽：已预约/已锁定/已取号）则禁止删除；已退号、仅可用/已取消槽位不计入
             long appointmentCount = scheduleSlotService.count(new QueryWrapper<ScheduleSlot>()
                     .in("pool_id", poolIds)
-                    .in("status", CommonConstants.SlotStatus.BOOKED, CommonConstants.SlotStatus.LOCKED,
+                    .in("status", SlotStatus.BOOKED.getValue(), SlotStatus.LOCKED.getValue(),
-                            CommonConstants.SlotStatus.CHECKED_IN));
+                            SlotStatus.CHECKED_IN.getValue()));
             if (appointmentCount > 0) {
                 return R.fail("该排班已有患者预约，禁止删除！如需取消请先处理患者退预约或使用'停诊'功能。");
             }

openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/impl/TicketAppServiceImpl.java

@@ -9,7 +9,7 @@ import com.openhis.clinical.domain.Ticket;
 import com.openhis.clinical.service.ITicketService;
 import com.openhis.web.appointmentmanage.appservice.ITicketAppService;
 import com.openhis.web.appointmentmanage.dto.TicketDto;
-import com.openhis.common.constant.CommonConstants.SlotStatus;
+import com.openhis.common.enums.SlotStatus;
 import com.openhis.common.enums.OrderStatus;
 import org.springframework.stereotype.Service;
 
@@ -193,25 +193,24 @@ public class TicketAppServiceImpl implements ITicketAppService {
                 if (Boolean.TRUE.equals(raw.getIsStopped())) {
                     dto.setStatus("已停诊");
                 } else {
-                    Integer slotStatus = raw.getSlotStatus();
+                    SlotStatus status = SlotStatus.getByValue(raw.getSlotStatus());
-                    if (slotStatus != null) {
+                    if (status != null) {
-                        if (SlotStatus.CHECKED_IN.equals(slotStatus)) {
+                        if (status == SlotStatus.LOCKED) {
-                            dto.setStatus("已取号");
-                        } else if (SlotStatus.BOOKED.equals(slotStatus)) {
-                            // order_main.status: 0=患者取消(已退号) 2=系统取消 其余=已预约
                             if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
                                 dto.setStatus("已退号");
-                            } else if (OrderStatus.SYSTEM_CANCELLED.getValue().equals(raw.getOrderStatus())) {
-                                dto.setStatus("系统取消");
                             } else {
-                                dto.setStatus("已预约");
+                                dto.setStatus("已锁定");
                             }
-                        } else if (SlotStatus.RETURNED.equals(slotStatus)) {
+                        } else if (status == SlotStatus.BOOKED) {
-                            dto.setStatus("已退号");
+                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
-                        } else if (SlotStatus.CANCELLED.equals(slotStatus)) {
+                                dto.setStatus("已退号");
+                            } else {
+                                dto.setStatus("已取号");
+                            }
+                        } else if (status == SlotStatus.CANCELLED) {
                             dto.setStatus("已停诊");
-                        } else if (SlotStatus.LOCKED.equals(slotStatus)) {
+                        } else if (status == SlotStatus.RETURNED) {
-                            dto.setStatus("已锁定");
+                            dto.setStatus("已退号");
                         } else {
                             dto.setStatus("未预约");
                         }
@@ -237,6 +236,10 @@ public class TicketAppServiceImpl implements ITicketAppService {
     /**
      * 统一状态入参，避免前端状态值大小写/中文/数字差异导致 SQL 条件失效后回全量数据
      */
+    /**
+     * 规范前端传入的状态查询参数，映射到 SQL 的 slotStatusNormExpr 值。
+     * 数值映射: 0=待约 1=已约(签到后) 2=锁定(预约后) 3=已签到 4=已停诊 5=已退号
+     */
     private void normalizeQueryStatus(com.openhis.appointmentmanage.dto.TicketQueryDTO query) {
         String rawStatus = query.getStatus();
         if (rawStatus == null) {
@@ -263,28 +266,31 @@ public class TicketAppServiceImpl implements ITicketAppService {
             case "已预约":
                 query.setStatus("booked");
                 break;
+            case "locked":
+            case "2":
+            case "已锁定":
+                query.setStatus("locked");
+                break;
             case "checked":
             case "checkin":
             case "checkedin":
-            case "2":
+            case "3":
             case "已取号":
                 query.setStatus("checked");
                 break;
             case "cancelled":
             case "canceled":
-            case "3":
+            case "4":
             case "已停诊":
             case "已取消":
                 query.setStatus("cancelled");
                 break;
             case "returned":
-            case "4":
             case "5":
             case "已退号":
                 query.setStatus("returned");
                 break;
             default:
-                // 设置为 impossible 值，配合 mapper 的 otherwise 分支直接返回空
                 query.setStatus("__invalid__");
                 break;
         }
@@ -367,26 +373,25 @@ public class TicketAppServiceImpl implements ITicketAppService {
                 if (Boolean.TRUE.equals(raw.getIsStopped())) {
                     dto.setStatus("已停诊");
                 } else {
-                    // 第二关：看独立的细分槽位状态 (0: 可用, 1: 已预约, 2: 已取消...)
+                    // 第二关：看独立的细分槽位状态 (0: 可用, 1: 已预约, 2: 已锁定...)
-                    Integer slotStatus = raw.getSlotStatus();
+                    SlotStatus status = SlotStatus.getByValue(raw.getSlotStatus());
-                    if (slotStatus != null) {
+                    if (status != null) {
-                        if (SlotStatus.CHECKED_IN.equals(slotStatus)) {
+                        if (status == SlotStatus.LOCKED) {
-                            dto.setStatus("已取号");
-                        } else if (SlotStatus.BOOKED.equals(slotStatus)) {
-                            // order_main.status: 0=患者取消(已退号) 2=系统取消 其余=已预约
                             if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
                                 dto.setStatus("已退号");
-                            } else if (OrderStatus.SYSTEM_CANCELLED.getValue().equals(raw.getOrderStatus())) {
-                                dto.setStatus("系统取消");
                             } else {
-                                dto.setStatus("已预约");
+                                dto.setStatus("已锁定");
                             }
-                        } else if (SlotStatus.RETURNED.equals(slotStatus)) {
+                        } else if (status == SlotStatus.BOOKED) {
-                            dto.setStatus("已退号");
+                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
-                        } else if (SlotStatus.CANCELLED.equals(slotStatus)) {
+                                dto.setStatus("已退号");
+                            } else {
+                                dto.setStatus("已取号");
+                            }
+                        } else if (status == SlotStatus.CANCELLED) {
                             dto.setStatus("已停诊");
-                        } else if (SlotStatus.LOCKED.equals(slotStatus)) {
+                        } else if (status == SlotStatus.RETURNED) {
-                            dto.setStatus("已锁定");
+                            dto.setStatus("已退号");
                         } else {
                             dto.setStatus("未预约");
                         }

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.getActivityDefinitionId());
+            organizationLocationService.getOrgLocListByActivityDefinitionId(orgLoc.getActivityDefinitionId());
         organizationLocationList = (orgLoc.getId() != null)
             ? organizationLocationList.stream().filter(item -> !orgLoc.getId().equals(item.getId())).toList()
             : organizationLocationList;
@@ -169,7 +169,7 @@ public class OrganizationLocationAppServiceImpl implements IOrganizationLocation
                 if (DateTimeUtils.isOverlap(organizationLocation.getStartTime(), organizationLocation.getEndTime(),
                     orgLoc.getStartTime(), orgLoc.getEndTime())) {
                     Organization org = organizationService.getById(organizationLocation.getOrganizationId());
-                    String organizationName = org != null ? org.getName() : "未知科室";
+                    String organizationName = org != null ? org.getName() : "已删除科室(ID:" + organizationLocation.getOrganizationId() + ")";
                     return R.fail("当前诊疗：" + activityName + CommonConstants.Common.DASH + orgLoc.getStartTime()
                         + CommonConstants.Common.DASH + orgLoc.getEndTime() + "与" + organizationName + "时间冲突");
                 }

openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientRegistrationAppServiceImpl.java

@@ -18,6 +18,7 @@ import com.openhis.administration.mapper.PatientMapper;
 import com.openhis.administration.service.*;
 import com.openhis.common.constant.CommonConstants;
 import com.openhis.common.constant.PromptMsgConstant;
+import com.openhis.common.enums.SlotStatus;
 import com.openhis.common.enums.*;
 import com.openhis.common.enums.ybenums.YbPayment;
 import com.openhis.common.utils.EnumUtils;
@@ -643,8 +644,7 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
                     .set(Order::getStatus, OrderStatus.PATIENT_CANCELLED.getValue())
                     .set(Order::getPayStatus, PaymentStatus.REFUND_ALL.getValue())
                     .set(Order::getCancelTime, new Date())
-                    .set(Order::getCancelReason,
+                    .set(Order::getCancelReason, "诊前退号")
-                        StringUtils.isNotEmpty(reason) ? reason : "诊前退号")
                     .set(Order::getUpdateTime, new Date())
                     .setSql("version = version + 1")
                     .eq(Order::getId, appointmentOrder.getId())
@@ -660,17 +660,27 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
                 return appointmentOrder.getId();
             }
 
-            int slotRows = scheduleSlotMapper.updateSlotStatus(slotId, CommonConstants.SlotStatus.AVAILABLE);
+            // 只有已预约(1)的号源才能退号，对应签到后的 BOOKED 状态
-            if (slotRows > 0) {
+            ScheduleSlot slot = scheduleSlotMapper.selectById(slotId);
-                Long poolId = scheduleSlotMapper.selectPoolIdBySlotId(slotId);
+            if (slot == null || !SlotStatus.BOOKED.getValue().equals(slot.getStatus())) {
-                if (poolId != null) {
+                log.warn("退号跳过：槽位非已预约状态, slotId={}, status={}", slotId,
-                    schedulePoolMapper.refreshPoolStats(poolId);
+                    slot != null ? slot.getStatus() : null);
-                    schedulePoolMapper.update(null,
+                return appointmentOrder.getId();
-                        new LambdaUpdateWrapper<SchedulePool>()
+            }
-                            .setSql("version = version + 1")
+
-                            .set(SchedulePool::getUpdateTime, new Date())
+            int slotRows = scheduleSlotMapper.updateSlotStatus(slotId, SlotStatus.AVAILABLE.getValue());
-                            .eq(SchedulePool::getId, poolId));
+            if (slotRows == 0) {
-                }
+                log.warn("退号时更新槽位状态未影响任何行, slotId={}", slotId);
+                return appointmentOrder.getId();
+            }
+
+            Long poolId = scheduleSlotMapper.selectPoolIdBySlotId(slotId);
+            if (poolId != null) {
+                schedulePoolMapper.update(null,
+                    new LambdaUpdateWrapper<SchedulePool>()
+                        .setSql("booked_num = booked_num - 1, version = version + 1")
+                        .set(SchedulePool::getUpdateTime, new Date())
+                        .eq(SchedulePool::getId, poolId));
             }
             return appointmentOrder.getId();
         } catch (Exception e) {

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

@@ -35,6 +35,9 @@ 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;
@@ -51,6 +54,7 @@ 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;
@@ -69,6 +73,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
     private static final Pattern INSPECTION_APPLY_NO_JSON =
         Pattern.compile("\"applyNo\"\\s*:\\s*\"([^\"]+)\"");
 
+    
     @Resource
     AssignSeqUtil assignSeqUtil;
 
@@ -132,6 +137,20 @@ 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:";
     // 缓存过期时间（小时）
@@ -1750,6 +1769,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
         return StringUtils.isBlank(applyNo) ? null : applyNo;
     }
 
+    
     /**
      * 处理诊疗
      */
@@ -1798,31 +1818,50 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                 }
             }
         }
-        // 检验申请单在医嘱 contentJson 中写入 applyNo；从医嘱删除时需先级联作废检验单，避免检验页签仍显示孤儿申请
+        // 🔧 级联作废：在删除 ServiceRequest 之前，先读取所有待删除记录的级联信息
+        // 检验申请单：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;
             }
-            iServiceRequestService.removeById(requestId);// 删除诊疗
+            ServiceRequest existing = iServiceRequestService.getById(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(adviceSaveDto.getRequestId());
+                    .add(requestId);
+            }
+            // 手术申请单级联（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)) {
-                labCascadeSkippedRequestIds.addAll(e.getValue());
+                cascadeSkippedRequestIds.addAll(e.getValue());
                 log.info("handService - 级联作废检验申请单 applyNo={}，已跳过重复删除的医嘱 requestIds={}",
                     e.getKey(), e.getValue());
             } else {
@@ -1831,8 +1870,41 @@ 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 (labCascadeSkippedRequestIds.contains(adviceSaveDto.getRequestId())) {
+            if (cascadeSkippedRequestIds.contains(adviceSaveDto.getRequestId())) {
                 continue;
             }
             Long requestId = adviceSaveDto.getRequestId();
@@ -1842,7 +1914,6 @@ 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);
         }
@@ -2481,21 +2552,17 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
             }
         }
 
-        // 使用直接 LIMIT 查询，不触发 MyBatis Plus 的 COUNT 开销
+        // 使用 MyBatis Plus 分页查询
-        List<SurgeryItemDto> records = doctorStationAdviceAppMapper.getSurgeryPage(
+        IPage<SurgeryItemDto> result = doctorStationAdviceAppMapper.getSurgeryPage(
                 new Page<>(pageNo, pageSize),
                 PublicationStatus.ACTIVE.getValue(),
                 organizationId,
                 searchKey);
 
-        // 手动构造 Page 对象，total 设为 records.size()（前端 el-transfer 不需要精确的 total 总数）
-        IPage<SurgeryItemDto> result = new com.baomidou.mybatisplus.extension.plugins.pagination.Page<>(pageNo, pageSize);
-        result.setRecords(records);
-        result.setTotal(records.size());
         log.info("getSurgeryPage 完成: {}ms, total={}, records={}", System.currentTimeMillis() - start, result.getTotal(), result.getRecords().size());
 
         // 无搜索时将结果写入缓存
-        if (useCache) {
+        if (useCache && result instanceof com.baomidou.mybatisplus.extension.plugins.pagination.Page) {
             redisCache.setCacheObject(cacheKey, result, (int) CACHE_EXPIRE_HOURS, java.util.concurrent.TimeUnit.HOURS);
             log.info("缓存手术项目, key: {}, 过期时间: {} 小时", cacheKey, CACHE_EXPIRE_HOURS);
         }

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

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

@@ -195,7 +195,7 @@ public interface DoctorStationAdviceAppMapper {
      * @param searchKey 模糊查询关键字（可选）
      * @return 手术项目分页数据
      */
-    List<SurgeryItemDto> getSurgeryPage(@Param("page") Page<SurgeryItemDto> page,
+    IPage<SurgeryItemDto> getSurgeryPage(@Param("page") Page<SurgeryItemDto> page,
             @Param("statusEnum") Integer statusEnum,
             @Param("organizationId") Long organizationId,
             @Param("searchKey") String searchKey);

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

@@ -32,6 +32,7 @@ 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;
@@ -202,62 +203,70 @@ public class ProductTransferAppServiceImpl implements IProductTransferAppService
     @Override
     public R<?> addOrEditBatchTransferReceipt(List<ProductTransferDto> productTransferDtoList, Boolean flag) {
 
-        // 校验调拨数量：必须 > 0 且不超过源库存数量（从数据库查实时库存）
         Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
-        for (ProductTransferDto dto : productTransferDtoList) {
+        Date now = DateUtils.getNowDate();
-            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> requestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
+            List<SupplyRequest> oldRequestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
-            if (!requestList.isEmpty()) {
+            if (!oldRequestList.isEmpty()) {
-                List<Long> requestIdList = requestList.stream().map(SupplyRequest::getId).collect(Collectors.toList());
+                // 恢复旧记录已预划扣的库存
-                // 单据信息删除
+                for (SupplyRequest oldReq : oldRequestList) {
-                supplyRequestService.removeByIds(requestIdList);
+                    if (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);
+                        }
+                    }
+                }
+                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());
@@ -265,33 +274,58 @@ 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);
     }
 
@@ -332,33 +366,63 @@ public class ProductTransferAppServiceImpl implements IProductTransferAppService
     @Override
     public R<?> addOrEditTransferReceipt(List<ProductTransferDto> productTransferDtoList) {
 
-        // 校验调拨数量：必须 > 0 且不超过源库存数量（从数据库查实时库存）
         Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
-        for (ProductTransferDto dto : productTransferDtoList) {
+        Date now = DateUtils.getNowDate();
-            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> requestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
+        List<SupplyRequest> oldRequestList = supplyRequestService.getSupplyByBusNo(busNoList.get(0));
-        if (!requestList.isEmpty()) {
+        Map<String, BigDecimal> oldDeductionMap = new HashMap<>();
-            // 请求id取得
+        if (!oldRequestList.isEmpty()) {
-            List<Long> requestIdList = requestList.stream().map(SupplyRequest::getId).collect(Collectors.toList());
+            for (SupplyRequest oldReq : oldRequestList) {
-            // 单据信息删除
+                if (oldReq.getItemId() != null && oldReq.getLotNumber() != null && oldReq.getSourceLocationId() != null
-            supplyRequestService.removeByIds(requestIdList);
+                        && oldReq.getItemQuantity() != null) {
+                    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<>();
@@ -405,6 +469,22 @@ 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,58 +519,8 @@ public class ReceiptApprovalAppServiceImpl implements IReceiptApprovalAppService
             // 暂时先取出全部的库存，循环查库存同一会有问题，后续优化
             List<InventoryItem> inventoryItems = inventoryItemService.selectAllInventory();
             for (SupplyItemDetailDto supplyItemDetailDto : supplyItemDetailList) {
-                // 根据项目id,产品批号，源仓库id 查询源仓库库存表信息
+                // 🔧 源仓库库存已在保存时预划扣，审批通过时不再重复扣减
-                // List<InventoryItem> inventoryItemSourceList = inventoryItemService.selectInventoryByItemId(
+                outList.add(supplyItemDetailDto);
-                // 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/patientmanage/appservice/impl/PatientInformationServiceImpl.java

@@ -269,7 +269,7 @@ public class PatientInformationServiceImpl implements IPatientInformationService
 //        log.debug("添加病人信息,patientInfoDto:{}", patientBaseInfoDto);
         // 如果患者没有输入身份证号则根据年龄自动生成
         String idCard = patientBaseInfoDto.getIdCard();
-        if (idCard == null || CommonConstants.Common.AREA_CODE.equals(idCard.substring(0, 6))) {
+        if (idCard == null || idCard.length() < 6 || CommonConstants.Common.AREA_CODE.equals(idCard.substring(0, 6))) {
             if (patientBaseInfoDto.getAge() != null) {
                 idCard = IdCardUtil.generateIdByAge(patientBaseInfoDto.getAge());
                 patientBaseInfoDto.setIdCard(idCard);

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

@@ -36,6 +36,8 @@ 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;
 
@@ -85,6 +87,9 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
     @Resource
     IDeviceDispenseService iDeviceDispenseService;
 
+    @Resource
+    IRequestFormService iRequestFormService;
+
     /**
      * 查询住院患者信息
      *
@@ -266,6 +271,38 @@ 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,16 +81,7 @@ 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<>();
@@ -102,14 +93,15 @@ 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) {
-                    throw new ServiceException(activitySaveDto.getAdviceDefinitionName() + "未配置当前时间段的执行科室");
+                    activityIdToPositionIdMap.put(activitySaveDto.getAdviceDefinitionId(), configPositionId);
                 }
-                activityIdToPositionIdMap.put(activitySaveDto.getAdviceDefinitionId(), configPositionId);
             }
         }
 
@@ -176,73 +168,77 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
         ChargeItem chargeItem;
         log.info("保存申请单，typeCode={}, activityListSize={}, encounterId={}", typeCode, activityList != null ? activityList.size() : 0, encounterId);
 
-        for (ActivitySaveDto activitySaveDto : activityList) {
+        // 🔧 手术申请单：跳过普通医嘱生成，只由 isProcedure 块生成手术医嘱，避免重复
-            serviceRequest = new ServiceRequest();
+        boolean isSurgeryRequest = ActivityDefCategory.PROCEDURE.getCode().equals(typeCode);
-            serviceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());
+        if (!isSurgeryRequest) {
-            serviceRequest.setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.SERVICE_RES_NO.getPrefix(), 4));
+            for (ActivitySaveDto activitySaveDto : activityList) {
-            serviceRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
+                serviceRequest = new ServiceRequest();
-            serviceRequest.setPrescriptionNo(prescriptionNo);
+                serviceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());
-            serviceRequest.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue());// 治疗类型
+                serviceRequest.setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.SERVICE_RES_NO.getPrefix(), 4));
-            serviceRequest.setQuantity(activitySaveDto.getQuantity()); // 请求数量
+                serviceRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
-            serviceRequest.setUnitCode(activitySaveDto.getUnitCode()); // 请求单位编码
+                serviceRequest.setPrescriptionNo(prescriptionNo);
-            serviceRequest.setCategoryEnum(categoryEnum); // 请求类型
+                serviceRequest.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue());// 治疗类型
-            serviceRequest.setActivityId(activitySaveDto.getAdviceDefinitionId());// 诊疗定义id
+                serviceRequest.setQuantity(activitySaveDto.getQuantity()); // 请求数量
-            serviceRequest.setPatientId(patientId); // 患者
+                serviceRequest.setUnitCode(activitySaveDto.getUnitCode()); // 请求单位编码
-            serviceRequest.setRequesterId(practitionerId); // 开方医生
+                serviceRequest.setCategoryEnum(categoryEnum); // 请求类型
-            serviceRequest.setEncounterId(encounterId); // 就诊id
+                serviceRequest.setActivityId(activitySaveDto.getAdviceDefinitionId());// 诊疗定义id
-            serviceRequest.setAuthoredTime(curDate); // 请求签发时间
+                serviceRequest.setPatientId(patientId); // 患者
+                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);
+                }
             }
         }
 
@@ -326,6 +322,13 @@ 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);
                 }
@@ -368,9 +371,10 @@ 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
+                    // 优先从 activityList 获取 productId 和 definitionId
                     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);
@@ -409,6 +413,10 @@ 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("次");
@@ -425,6 +433,18 @@ 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,6 +13,11 @@ 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/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}
@@ -893,7 +893,6 @@
               AND (t1.name ILIKE '%' || #{searchKey} || '%' OR t1.py_str ILIKE '%' || #{searchKey} || '%')
           </if>
         ORDER BY t1.ID, t1.name ASC, t2.ID ASC
-        LIMIT #{page.size} OFFSET ${(page.current - 1) * page.size}
     </select>
 
     <!-- 检查项目专用分页查询：仅查检查(23) + 定价，无库存/草稿库存/取药科室等无关逻辑 -->

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

@@ -135,6 +135,7 @@
                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/constant/CommonConstants.java

@@ -768,36 +768,4 @@ public class CommonConstants {
         Integer ACCOUNT_DEVICE_TYPE = 6;
     }
 
-    /**
-     * 号源槽位状态 (adm_schedule_slot.status)
-     */
-    public interface SlotStatus {
-        /** 可用 / 待预约 */
-        Integer AVAILABLE = 0;
-        /** 已预约 */
-        Integer BOOKED = 1;
-        /** 已取消 / 已停诊 */
-        Integer CANCELLED = 2;
-        /** 已签到 / 已取号 */
-        Integer CHECKED_IN = 3;
-        /** 已锁定 */
-        Integer LOCKED = 4;
-        /** 已退号 */
-        Integer RETURNED = 5;
-    }
-
-    /**
-     * 预约订单状态 (order_main.status)
-     */
-    public interface AppointmentOrderStatus {
-        /** 已预约 (待就诊) */
-        Integer BOOKED = 1;
-        /** 已取号 (已就诊) */
-        Integer CHECKED_IN = 2;
-        /** 已取消 */
-        Integer CANCELLED = 3;
-        /** 已退号 */
-        Integer RETURNED = 4;
-    }
-
 }

openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SlotStatus.java

@@ -0,0 +1,57 @@
+package com.openhis.common.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 号源槽位状态 (adm_schedule_slot.status)
+ *
+ * <pre>
+ * 状态流转:
+ *   预约     → 0→2 (锁定), locked_num+1
+ *   取消预约 → 2→0 (释放), locked_num-1
+ *   签到     → 2→1 (已约), locked_num-1, booked_num+1
+ *   退号     → 1→0 (释放), booked_num-1
+ *   停诊     → 任意→4 (已取消)
+ * </pre>
+ *
+ * @author system
+ */
+@Getter
+@AllArgsConstructor
+public enum SlotStatus implements HisEnumInterface {
+
+    /** 可用 / 待预约 */
+    AVAILABLE(0, "available", "可用"),
+
+    /** 已预约 */
+    BOOKED(1, "booked", "已预约"),
+
+    /** 已锁定 (约而不付：预约后锁定号源) */
+    LOCKED(2, "locked", "已锁定"),
+
+    /** 已签到 / 已取号 */
+    CHECKED_IN(3, "checked_in", "已签到"),
+
+    /** 已取消 / 已停诊 */
+    CANCELLED(4, "cancelled", "已取消"),
+
+    /** 已退号 */
+    RETURNED(5, "returned", "已退号");
+
+    private final Integer value;
+    private final String code;
+    private final String info;
+
+    public static SlotStatus getByValue(Integer value) {
+        if (value == null) {
+            return null;
+        }
+        for (SlotStatus val : values()) {
+            if (val.getValue().equals(value)) {
+                return val;
+            }
+        }
+        return null;
+    }
+}

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

@@ -36,6 +36,14 @@ public interface IOrganizationLocationService extends IService<OrganizationLocat
      * @param activityDefinitionId 诊疗定义id
      * @return 诊疗的执行科室列表
      */
-    List<OrganizationLocation> getOrgLocListByOrgIdAndActivityDefinitionId(Long activityDefinitionId);
+    List<OrganizationLocation> getOrgLocListByOrgIdAndActivityDefinitionId(Long organizationId, Long activityDefinitionId);
+
+    /**
+     * 根据诊疗定义id查询所有执行科室列表（跨科室）
+     *
+     * @param activityDefinitionId 诊疗定义id
+     * @return 执行科室列表
+     */
+    List<OrganizationLocation> getOrgLocListByActivityDefinitionId(Long activityDefinitionId);
 
 }

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

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

openhis-server-new/openhis-domain/src/main/java/com/openhis/appointmentmanage/mapper/SchedulePoolMapper.java

@@ -10,10 +10,11 @@ import org.springframework.stereotype.Repository;
 public interface SchedulePoolMapper extends BaseMapper<SchedulePool> {
 
     /**
-     * 按号源池实时重算统计值，避免并发场景下计数漂移。
+     * 按号源池实时重算统计值。
      *
-     * 说明：available_num 在当前项目中可能为数据库生成列，因此这里仅维护
+     * @param poolId       号源池ID
-     * booked_num / locked_num，剩余号由数据库或查询逻辑计算。
+     * @param bookedStatus 已约状态值，由 SlotStatus.BOOKED.getValue() 传入
+     * @param lockedStatus 锁定状态值，由 SlotStatus.LOCKED.getValue() 传入
      */
     @Update("""
             UPDATE adm_schedule_pool p
@@ -23,20 +24,22 @@ public interface SchedulePoolMapper extends BaseMapper<SchedulePool> {
                     FROM adm_schedule_slot s
                     WHERE s.pool_id = p.id
                       AND s.delete_flag = '0'
-                      AND s.status = 1
+                      AND s.status = #{bookedStatus}
                 ), 0),
                 locked_num = COALESCE((
                     SELECT COUNT(1)
                     FROM adm_schedule_slot s
                     WHERE s.pool_id = p.id
                       AND s.delete_flag = '0'
-                      AND s.status = 3
+                      AND s.status = #{lockedStatus}
                 ), 0),
                 update_time = now()
             WHERE p.id = #{poolId}
               AND p.delete_flag = '0'
             """)
-    int refreshPoolStats(@Param("poolId") Long poolId);
+    int refreshPoolStats(@Param("poolId") Long poolId,
+                         @Param("bookedStatus") Integer bookedStatus,
+                         @Param("lockedStatus") Integer lockedStatus);
 
     /**
      * 签到时更新号源池统计：锁定数-1，已预约数+1

openhis-server-new/openhis-domain/src/main/java/com/openhis/appointmentmanage/mapper/ScheduleSlotMapper.java

@@ -22,9 +22,12 @@ public interface ScheduleSlotMapper extends BaseMapper<ScheduleSlot> {
     TicketSlotDTO selectTicketSlotById(@Param("id") Long id);
 
     /**
-     * 原子抢占槽位：仅当当前状态=0(可用)时，更新为1(已预约)。
+     * 原子抢占槽位：仅当当前状态=0(待约)时，更新为目标锁定状态。
+     *
+     * @param slotId       槽位ID
+     * @param lockedStatus 锁定状态值，由 SlotStatus.LOCKED.getValue() 传入
      */
-    int lockSlotForBooking(@Param("slotId") Long slotId);
+    int lockSlotForBooking(@Param("slotId") Long slotId, @Param("lockedStatus") Integer lockedStatus);
 
     /**
      * 按主键更新槽位状态。
@@ -34,12 +37,16 @@ public interface ScheduleSlotMapper extends BaseMapper<ScheduleSlot> {
     /**
      * 更新槽位状态并记录签到时间
      *
-     * @param slotId      槽位ID
+     * @param slotId         槽位ID
-     * @param status      状态
+     * @param status         目标状态，由 SlotStatus.BOOKED.getValue() 传入
-     * @param checkInTime 签到时间
+     * @param checkInTime    签到时间
+     * @param requiredStatus 前置状态，由 SlotStatus.LOCKED.getValue() 传入
      * @return 结果
      */
-    int updateSlotStatusAndCheckInTime(@Param("slotId") Long slotId, @Param("status") Integer status, @Param("checkInTime") Date checkInTime);
+    int updateSlotStatusAndCheckInTime(@Param("slotId") Long slotId,
+                                       @Param("status") Integer status,
+                                       @Param("checkInTime") Date checkInTime,
+                                       @Param("requiredStatus") Integer requiredStatus);
 
     /**
      * 根据槽位ID查询所属号源池ID。

openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/impl/TicketServiceImpl.java

@@ -1,10 +1,12 @@
 package com.openhis.clinical.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.openhis.appointmentmanage.domain.AppointmentConfig;
 import com.openhis.appointmentmanage.service.IAppointmentConfigService;
 import com.openhis.appointmentmanage.domain.TicketSlotDTO;
+import com.openhis.appointmentmanage.domain.SchedulePool;
 import com.openhis.appointmentmanage.domain.ScheduleSlot;
 import com.openhis.appointmentmanage.mapper.SchedulePoolMapper;
 import com.openhis.appointmentmanage.mapper.ScheduleSlotMapper;
@@ -13,7 +15,7 @@ import com.openhis.clinical.domain.Ticket;
 import com.openhis.clinical.mapper.TicketMapper;
 import com.openhis.clinical.service.IOrderService;
 import com.openhis.clinical.service.ITicketService;
-import com.openhis.common.constant.CommonConstants.SlotStatus;
+import com.openhis.common.enums.SlotStatus;
 import com.openhis.common.enums.OrderStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -177,7 +179,7 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
             logger.error("安全拦截：号源底库核对失败，slotId: {}", slotId);
             throw new RuntimeException("号源数据不存在");
         }
-        if (slot.getSlotStatus() != null && !SlotStatus.AVAILABLE.equals(slot.getSlotStatus())) {
+        if (slot.getSlotStatus() != null && SlotStatus.getByValue(slot.getSlotStatus()) != SlotStatus.AVAILABLE) {
             throw new RuntimeException("手慢了！该号源已刚刚被他人抢占");
         }
         if (Boolean.TRUE.equals(slot.getIsStopped())) {
@@ -205,7 +207,7 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
         }
 
         // 原子抢占：避免并发下同一槽位被重复预约
-        int lockRows = scheduleSlotMapper.lockSlotForBooking(slotId);
+        int lockRows = scheduleSlotMapper.lockSlotForBooking(slotId, SlotStatus.LOCKED.getValue());
         if (lockRows <= 0) {
             throw new RuntimeException("手慢了！该号源已刚刚被他人抢占");
         }
@@ -260,7 +262,15 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
             throw new RuntimeException("预约成功但号源回填订单失败，请重试");
         }
 
-        refreshPoolStatsBySlotId(slotId);
+        // 6. 预约成功后 locked_num+1（原子递增替代全量 recount，避免并发计数漂移）
+        Long poolId = scheduleSlotMapper.selectPoolIdBySlotId(slotId);
+        if (poolId != null) {
+            schedulePoolMapper.update(null,
+                new LambdaUpdateWrapper<SchedulePool>()
+                    .setSql("locked_num = locked_num + 1, version = version + 1")
+                    .set(SchedulePool::getUpdateTime, new Date())
+                    .eq(SchedulePool::getId, poolId));
+        }
         return 1;
     }
 
@@ -277,7 +287,8 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
         if (slot == null) {
             throw new RuntimeException("号源槽位不存在");
         }
-        if (slot.getSlotStatus() == null || !SlotStatus.BOOKED.equals(slot.getSlotStatus())) {
+        // 只有锁定态(2)的号源可以取消预约
+        if (slot.getSlotStatus() == null || SlotStatus.getByValue(slot.getSlotStatus()) != SlotStatus.LOCKED) {
             throw new RuntimeException("号源不可取消预约");
         }
 
@@ -292,7 +303,7 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
             orderService.cancelAppointmentOrder(order.getId(), "患者取消预约");
         }
 
-        int updated = scheduleSlotMapper.updateSlotStatus(slotId, SlotStatus.AVAILABLE);
+        int updated = scheduleSlotMapper.updateSlotStatus(slotId, SlotStatus.AVAILABLE.getValue());
         if (updated > 0) {
             refreshPoolStatsBySlotId(slotId);
         }
@@ -318,11 +329,14 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
         orderService.updateOrderStatusById(latestOrder.getId(), OrderStatus.ACTIVE.getValue());
         orderMapper.updatePayStatus(latestOrder.getId(), 1, new Date());
 
-        // 2. 查询号源槽位信息
+        // 2. 只有锁定态(2)的号源才能签到，签到时 2→1(LOCKED→BOOKED)
         ScheduleSlot slot = scheduleSlotMapper.selectById(slotId);
+        if (slot == null || !SlotStatus.LOCKED.getValue().equals(slot.getStatus())) {
+            throw new RuntimeException("号源状态异常，无法签到");
+        }
 
-        // 3. 更新号源槽位状态为已签到，记录签到时间
+        // 3. 更新号源槽位状态 2→1（LOCKED→BOOKED，已预约=已签到）
-        scheduleSlotMapper.updateSlotStatusAndCheckInTime(slotId, SlotStatus.CHECKED_IN, new Date());
+        scheduleSlotMapper.updateSlotStatusAndCheckInTime(slotId, SlotStatus.BOOKED.getValue(), new Date(), SlotStatus.LOCKED.getValue());
 
         // 4. 更新号源池统计：锁定数-1，已预约数+1
         if (slot != null && slot.getPoolId() != null) {
@@ -351,7 +365,7 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
             orderService.cancelAppointmentOrder(order.getId(), "医生停诊");
         }
 
-        int updated = scheduleSlotMapper.updateSlotStatus(slotId, SlotStatus.CANCELLED);
+        int updated = scheduleSlotMapper.updateSlotStatus(slotId, SlotStatus.CANCELLED.getValue());
         if (updated > 0) {
             refreshPoolStatsBySlotId(slotId);
         }
@@ -364,7 +378,7 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
     private void refreshPoolStatsBySlotId(Long slotId) {
         Long poolId = scheduleSlotMapper.selectPoolIdBySlotId(slotId);
         if (poolId != null) {
-            schedulePoolMapper.refreshPoolStats(poolId);
+            schedulePoolMapper.refreshPoolStats(poolId, SlotStatus.BOOKED.getValue(), SlotStatus.LOCKED.getValue());
         }
     }
 

openhis-server-new/openhis-domain/src/main/resources/mapper/administration/ScheduleSlotMapper.xml

@@ -4,14 +4,17 @@
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.openhis.appointmentmanage.mapper.ScheduleSlotMapper">
 
-    <!-- 统一状态值（兼容数字/英文字符串存储），输出 Integer，避免 resultType 映射 NumberFormatException -->
+    <!--
+      统一状态值映射: DB 数值 → 规范化输出
+      0=待约 1=已约(签到后) 2=锁定(预约后) 3=已签到 4=已停诊 5=已退号
+    -->
     <sql id="slotStatusNormExpr">
         CASE
             WHEN LOWER(CONCAT('', s.status)) IN ('0', 'unbooked', 'available') THEN 0
             WHEN LOWER(CONCAT('', s.status)) IN ('1', 'booked') THEN 1
-            WHEN LOWER(CONCAT('', s.status)) IN ('2', 'cancelled', 'canceled', 'stopped') THEN 2
+            WHEN LOWER(CONCAT('', s.status)) IN ('2', 'locked') THEN 2
             WHEN LOWER(CONCAT('', s.status)) IN ('3', 'checked', 'checked_in', 'checkin') THEN 3
-            WHEN LOWER(CONCAT('', s.status)) IN ('4', 'locked') THEN 4
+            WHEN LOWER(CONCAT('', s.status)) IN ('4', 'cancelled', 'canceled', 'stopped') THEN 4
             WHEN LOWER(CONCAT('', s.status)) IN ('5', 'returned') THEN 5
             ELSE NULL
         END
@@ -31,9 +34,9 @@
         CASE
             WHEN LOWER(CONCAT('', p.status)) IN ('0', 'unbooked', 'available') THEN 0
             WHEN LOWER(CONCAT('', p.status)) IN ('1', 'booked') THEN 1
-            WHEN LOWER(CONCAT('', p.status)) IN ('2', 'cancelled', 'canceled', 'stopped') THEN 2
+            WHEN LOWER(CONCAT('', p.status)) IN ('2', 'locked') THEN 2
             WHEN LOWER(CONCAT('', p.status)) IN ('3', 'checked', 'checked_in', 'checkin') THEN 3
-            WHEN LOWER(CONCAT('', p.status)) IN ('4', 'locked') THEN 4
+            WHEN LOWER(CONCAT('', p.status)) IN ('4', 'cancelled', 'canceled', 'stopped') THEN 4
             WHEN LOWER(CONCAT('', p.status)) IN ('5', 'returned') THEN 5
             ELSE NULL
         END
@@ -149,10 +152,11 @@
             s.id = #{id}
     </select>
 
+    <!-- 预约锁定: 0→#{lockedStatus} (AVAILABLE→LOCKED)，由枚举传入 -->
     <update id="lockSlotForBooking">
         UPDATE adm_schedule_slot
         SET
-            status = 1,
+            status = #{lockedStatus},
             update_time = now()
         WHERE
             id = #{slotId}
@@ -174,6 +178,7 @@
             AND delete_flag = '0'
     </update>
 
+    <!-- 签到: #{requiredStatus}→#{status} (LOCKED→BOOKED)，前置条件由枚举传入 -->
     <update id="updateSlotStatusAndCheckInTime">
         UPDATE adm_schedule_slot
         SET
@@ -182,6 +187,7 @@
             update_time = NOW()
         WHERE
             id = #{slotId}
+            AND status = #{requiredStatus}
             AND delete_flag = '0'
     </update>
 
@@ -202,7 +208,7 @@
             update_time = now()
         WHERE
             id = #{slotId}
-            AND status = 1
+            AND status = 2
             AND delete_flag = '0'
     </update>
 
@@ -299,15 +305,16 @@
             <if test="query.phone != null and query.phone != ''">
                 AND o.phone LIKE CONCAT('%', #{query.phone}, '%')
             </if>
-            <!-- 5. 按系统时间过滤（Bug #398 #399 修复：仅未预约受时间过滤，已预约/已取号/已退号不受影响） -->
+            <!-- 5. 时间过滤: 仅待约(0)受时间限制，已锁定(2)/已约(1)/已签到(3)/已退号(5)不受影响 -->
             AND (
                 (<include refid="slotStatusNormExpr" /> = 0 AND (p.schedule_date > CURRENT_DATE OR (p.schedule_date = CURRENT_DATE AND (CAST(p.schedule_date AS TIMESTAMP) + CAST(s.expect_time AS TIME)) >= NOW())))
                 OR <include refid="slotStatusNormExpr" /> = 1
+                OR <include refid="slotStatusNormExpr" /> = 2
                 OR <include refid="slotStatusNormExpr" /> = 3
                 OR <include refid="slotStatusNormExpr" /> = 5
                 OR <include refid="orderStatusNormExpr" /> = 4
             )
-            <!-- 6. 状态过滤 -->
+            <!-- 6. 状态筛选: unbooked(0) locked(2) booked(2) checked(1) cancelled(4) returned(5) -->
             <if test="query.status != null and query.status != '' and query.status != 'all'">
                 <choose>
                     <when test="'unbooked'.equals(query.status) or '未预约'.equals(query.status)">
@@ -318,7 +325,15 @@
                         )
                     </when>
                     <when test="'booked'.equals(query.status) or '已预约'.equals(query.status)">
-                        AND <include refid="slotStatusNormExpr" /> = 1
+                        AND <include refid="slotStatusNormExpr" /> = 2
+                        AND <include refid="orderStatusNormExpr" /> = 1
+                        AND (
+                            d.is_stopped IS NULL
+                            OR d.is_stopped = FALSE
+                        )
+                    </when>
+                    <when test="'locked'.equals(query.status) or '已锁定'.equals(query.status)">
+                        AND <include refid="slotStatusNormExpr" /> = 2
                         AND <include refid="orderStatusNormExpr" /> = 1
                         AND (
                             d.is_stopped IS NULL
@@ -326,13 +341,7 @@
                         )
                     </when>
                     <when test="'checked'.equals(query.status) or '已取号'.equals(query.status)">
-                        AND (
+                        AND <include refid="slotStatusNormExpr" /> = 1
-                            <include refid="slotStatusNormExpr" /> = 3
-                            OR (
-                                <include refid="slotStatusNormExpr" /> = 1
-                                AND <include refid="orderStatusNormExpr" /> = 2
-                            )
-                        )
                         AND (
                             d.is_stopped IS NULL
                             OR d.is_stopped = FALSE
@@ -340,7 +349,7 @@
                     </when>
                     <when test="'cancelled'.equals(query.status) or '已停诊'.equals(query.status) or '已取消'.equals(query.status)">
                         AND (
-                            <include refid="slotStatusNormExpr" /> = 2
+                            <include refid="slotStatusNormExpr" /> = 4
                             OR d.is_stopped = TRUE
                         )
                     </when>

openhis-ui-vue3/src/utils/medicalConstants.js

@@ -172,12 +172,12 @@ export const SlotStatus = {
   AVAILABLE: 0,
   /** 已预约 */
   BOOKED: 1,
-  /** 已取消 / 已停诊 */
+  /** 已锁定 */
-  CANCELLED: 2,
+  LOCKED: 2,
   /** 已签到 / 已取号 */
   CHECKED_IN: 3,
-  /** 已锁定 */
+  /** 已取消 / 已停诊 */
-  LOCKED: 4,
+  CANCELLED: 4,
 };
 
 /**
@@ -185,10 +185,10 @@ export const SlotStatus = {
  */
 export const SlotStatusDescriptions = {
   0: '未预约',
-  1: '已预约',
+  1: '已取号',
-  2: '已停诊',
+  2: '已锁定',
   3: '已取号',
-  4: '已锁定',
+  4: '已停诊',
 };
 
 /**

openhis-ui-vue3/src/views/appoinmentmanage/outpatientAppointment/index.vue

@@ -34,6 +34,7 @@
           <select id="status-select" class="search-select" v-model="selectedStatus" @change="onSearch">
             <option value="all">全部</option>
             <option value="unbooked">未预约</option>
+            <option value="locked">已锁定</option>
             <option value="booked">已预约</option>
             <option value="checked">已取号</option>
             <option value="cancelled">已停诊</option>
@@ -253,6 +254,7 @@ import useUserStore from '@/store/modules/user';
 
 const STATUS_CLASS_MAP = {
   '未预约': 'status-unbooked',
+  '已锁定': 'status-locked',
   '已预约': 'status-booked',
   '已取号': 'status-checked',
   '已退号': 'status-returned',
@@ -774,6 +776,7 @@ export default {
       // 🔧 BugFix#399: 确保已取号状态正确匹配
       const statusMap = {
         unbooked: ['未预约'],
+        locked: ['已锁定'],
         booked: ['已预约'],
         checked: ['已取号', '已签到'],
         cancelled: ['已停诊', '已取消'],

openhis-ui-vue3/src/views/charge/outpatientregistration/index.vue

@@ -1685,7 +1685,7 @@ function loadCheckInPatientList() {
   const today = formatDateStr(new Date(), 'YYYY-MM-DD');
   listTicket({
     date: today,
-    status: 'booked',
+    status: 'locked',
     name: checkInSearchKey.value, // 支持姓名等模糊查询，后端需适配
     page: checkInPage.value,
     limit: checkInLimit.value

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

@@ -461,6 +461,10 @@ 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")
@@ -1025,7 +1029,9 @@ function changeCheck(value,index,row){
   groupList.value.map(k=>{
     if(k.check){
       if(k.statusEnum == 1){//待签发
-        if(Number(k.bizRequestFlag)==1||!k.bizRequestFlag){
+        // 手术计费场景（generateSourceEnum=6）不限制 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
@@ -1040,7 +1046,9 @@ function changeCheck(value,index,row){
         }
       }
       if(k.statusEnum == 2){ //已签发
-        if(Number(k.bizRequestFlag)==1||!k.bizRequestFlag){
+        // 手术计费场景（generateSourceEnum=6）不限制 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
@@ -1067,28 +1075,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
+  // 无可签发项目时提前返回，避免后端报"医嘱列表为空"
-  // .filter((item) => {
+  if (saveList.length == 0) {
-  //   return item.check;
+    proxy.$modal.msgWarning('当前无可签发处方');
-  // }).filter((item) => {
+    return;
-  //   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,
-      dbOpType: '1',
+      // 已有 requestId 的记录走 UPDATE 路径，新记录走 INSERT 路径
+      dbOpType: item.requestId ? '2' : '1',
       groupId: item.groupId,
-      // 🔧 Bug #443: 补充顶层关键字段（这些不在 contentJson 中，需从 API 响应顶层提取）
+      // 补充顶层关键字段（这些可能不在 contentJson 中，需从 API 响应顶层提取）
       encounterId: item.encounterId,
       patientId: item.patientId,
       locationId: item.positionId,
@@ -1096,9 +1104,14 @@ function handleSave() {
       adviceTableName: item.adviceTableName,
       adviceDefinitionId: item.adviceDefinitionId,
       chargeItemId: item.chargeItemId,
-      // 🔧 Bug Fix: 签发时显式设置手术计费关键字段，避免后端 prescription_no / generateSourceEnum 回退为默认值导致查询无法匹配
+      // 补充数量、单位、批号等字段（后端 handDevice 需要这些字段）
-      generateSourceEnum: props.generateSourceEnum ?? parsedContent.generateSourceEnum,
+      quantity: item.quantity,
-      sourceBillNo: props.sourceBillNo ?? parsedContent.sourceBillNo,
+      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）
@@ -1185,6 +1198,10 @@ 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,6 +354,11 @@ 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/inpatientDoctor/home/components/applicationShow/examineApplication.vue

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

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

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

@@ -41,7 +41,9 @@
               <el-option label="全部" value="" />
               <el-option label="待签发" value="0" />
               <el-option label="已签发" value="1" />
-              <el-option label="已出报告" value="6" />
+              <el-option label="已采证" value="4" />
+              <el-option label="已送检" value="5" />
+              <el-option label="报告已出" value="6" />
               <el-option label="已作废" value="7" />
             </el-select>
           </el-form-item>
@@ -91,7 +93,15 @@
           <el-table-column prop="prescriptionNo" label="申请单号" width="140" />
           <el-table-column label="单据状态" width="100" align="center">
             <template #default="scope">
-              <span>{{ parseBillStatus(scope.row.billStatus ?? scope.row.status) }}</span>
+              <el-tag
+                :type="getBillStatusTagType(scope.row)"
+                effect="plain"
+                round
+                :class="{ 'report-status-tag': isReportStatus(scope.row) }"
+                @click="handleStatusClick(scope.row)"
+              >
+                {{ parseBillStatus(getBillStatus(scope.row)) }}
+              </el-tag>
             </template>
           </el-table-column>
           <el-table-column label="申请类型" width="100" align="center">
@@ -107,16 +117,16 @@
           <el-table-column prop="requesterId_dictText" label="申请者" width="120" />
           <el-table-column label="操作" align="center" fixed="right" width="220">
             <template #default="scope">
-              <!-- 待签发（status=0或null/undefined）：可修改、删除 -->
+              <!-- 待签发：可修改、删除 -->
-              <template v-if="!scope.row.status || scope.row.status == 0">
+              <template v-if="isPendingStatus(scope.row)">
                 <el-button link type="primary" @click="handleEdit(scope.row)">修改</el-button>
                 <el-button link type="danger" @click="handleDelete(scope.row)">删除</el-button>
               </template>
-              <!-- 已签发（status=1）：可撤回 -->
+              <!-- 已签发：可撤回 -->
-              <template v-else-if="scope.row.status == 1">
+              <template v-else-if="isIssuedStatus(scope.row)">
                 <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>
               </template>
@@ -212,10 +222,10 @@
 </template>
 
 <script setup>
-import {computed, getCurrentInstance, ref, watch} from 'vue';
+import {computed, getCurrentInstance, nextTick, ref, watch} from 'vue';
 import {Refresh, Search} from '@element-plus/icons-vue';
 import {patientInfo} from '../../store/patient.js';
-import {getInspection, deleteRequestForm, withdrawRequestForm} from './api';
+import {getInspection, deleteRequestForm, withdrawRequestForm, getProofResult} from './api';
 import {getDepartmentList} from '@/api/public.js';
 import LaboratoryTests from '../order/applicationForm/laboratoryTests.vue';
 import {saveInspection} from '../order/applicationForm/api.js';
@@ -270,7 +280,7 @@ const fetchData = async () => {
     if (res.code === 200 && res.data) {
       const raw = res.data?.records || res.data;
       const list = Array.isArray(raw) ? raw : [raw];
-      tableData.value = list.filter(Boolean);
+      tableData.value = list.filter(Boolean).sort(sortByCreateTimeDesc);
     } else {
       tableData.value = [];
     }
@@ -329,19 +339,95 @@ const labelMap = {
  * @param {string|number} status - 状态码
  * @returns {string} 状态文本
  */
+const getBillStatus = (row) => {
+  return row?.billStatus ?? row?.status ?? row?.statusEnum ?? row?.applyStatus;
+};
+
 const parseBillStatus = (status) => {
   const statusMap = {
     '0': '待签发',
     '1': '已签发',
-    '2': '已校对',
+    '2': '已采证',
-    '3': '待接收',
+    '3': '已送检',
-    '4': '已收样',
+    '4': '已采证',
-    '6': '已出报告',
+    '5': '已送检',
+    '6': '报告已出',
+    '8': '报告已出',
     '7': '已作废',
   };
   return statusMap[String(status)] || '-';
 };
 
+const getBillStatusTagType = (row) => {
+  const typeMap = {
+    '0': 'info',
+    '1': 'primary',
+    '2': 'primary',
+    '3': 'warning',
+    '4': 'primary',
+    '5': 'warning',
+    '6': 'success',
+    '7': 'danger',
+    '8': 'success',
+  };
+  return typeMap[String(getBillStatus(row))] || 'info';
+};
+
+const isPendingStatus = (row) => {
+  const status = getBillStatus(row);
+  return status === undefined || status === null || status === '' || String(status) === '0';
+};
+
+const isIssuedStatus = (row) => String(getBillStatus(row)) === '1';
+
+const isReportStatus = (row) => ['6', '8'].includes(String(getBillStatus(row)));
+
+const sortByCreateTimeDesc = (a, b) => {
+  const aTime = a?.createTime ? new Date(a.createTime).getTime() : 0;
+  const bTime = b?.createTime ? new Date(b.createTime).getTime() : 0;
+  return bTime - aTime;
+};
+
+const handleStatusClick = (row) => {
+  if (isReportStatus(row)) {
+    handleViewReport(row);
+  }
+};
+
+const pickReportUrl = (data, row) => {
+  if (!data) return '';
+  if (typeof data === 'string') return data;
+
+  const raw = data.records || data;
+  const list = Array.isArray(raw) ? raw : [raw];
+  const matched =
+    list.find((item) => {
+      const reportNo = item.busNo || item.reportNo || item.applyNo || item.prescriptionNo;
+      return reportNo && row.prescriptionNo && String(reportNo) === String(row.prescriptionNo);
+    }) || list[0];
+
+  return matched?.requestUrl || matched?.pdfUrl || matched?.reportUrl || matched?.url || '';
+};
+
+const handleViewReport = async (row) => {
+  try {
+    const res = await getProofResult({
+      encounterId: row.encounterId || patientInfo.value?.encounterId,
+      prescriptionNo: row.prescriptionNo,
+    });
+    if (res?.code === 200) {
+      const url = pickReportUrl(res.data, row);
+      if (url) {
+        window.open(url, '_blank');
+        return;
+      }
+    }
+    proxy.$modal?.msgWarning?.('暂未获取到检验报告链接');
+  } catch (e) {
+    proxy.$modal?.msgError?.(e.message || '获取检验报告失败');
+  }
+};
+
 /**
  * 解析申请类型（优先级代码）
  * @param {string} descJson - JSON字符串
@@ -462,12 +548,12 @@ const handleViewDetail = async (row) => {
  * 修改检验申请单（待签发状态）
  */
 const handleEdit = async (row) => {
-  // 确保科室数据已加载
-  if (!orgOptions.value || orgOptions.value.length === 0) {
-    await getLocationInfo();
-  }
   editRowData.value = row;
   editDialogVisible.value = true;
+  await nextTick();
+  editFormRef.value?.getList?.();
+  editFormRef.value?.getLocationInfo?.();
+  editFormRef.value?.getDiagnosisList?.();
 };
 
 /**
@@ -646,6 +732,10 @@ defineExpose({
   animation: rotating 2s linear infinite;
 }
 
+.report-status-tag {
+  cursor: pointer;
+}
+
 @keyframes rotating {
   0% {
     transform: rotate(0deg);

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

@@ -134,10 +134,10 @@
   </div>
 </template>
 <script setup name="LaboratoryTests">
-import {getCurrentInstance, onMounted, reactive, ref, watch, computed} from 'vue';
+import {getCurrentInstance, nextTick, onMounted, reactive, ref, watch, computed} from 'vue';
 import {patientInfo} from '../../../store/patient.js';
 import {getApplicationList, saveInspection} from './api';
-import {getOrgList} from '@/views/doctorstation/components/api.js';
+import {getDepartmentList} from '@/api/public.js';
 import {getEncounterDiagnosis} from '../../api.js';
 import {ElMessage} from 'element-plus';
 
@@ -168,6 +168,7 @@ const loading = ref(false);
 const orgOptions = ref([]);
 const searchKey = ref('');
 const totalCount = ref(0);
+const skipDeptAutoFill = ref(false);
 
 // 将已加载的全部数据转为 transfer 组件所需的格式
 const buildTransferData = (records) => {
@@ -207,6 +208,8 @@ const loadAllData = async () => {
     }
     applicationListAll.value = res.data?.records || [];
     totalCount.value = res.data?.total || 0;
+    // 检验项目列表为异步加载，编辑回显必须在数据就绪后执行，否则已选区一直为空
+    applyEditTransferSelection()
   } catch (e) {
     proxy.$message.error('获取检验项目列表失败');
     applicationListAll.value = [];
@@ -242,6 +245,8 @@ const getList = async () => {
 const handleSearch = () => {
   // 搜索时保持已选中的项目不受影响
 };
+// 编辑初始化标志：避免 applyEditTransferSelection 设置 transferValue 时触发 projectWithDepartment 覆盖 descJson 中的科室值
+const isInitializing = ref(false);
 const transferValue = ref([]);
 const form = reactive({
   // categoryType: '', // 项目类别
@@ -259,7 +264,31 @@ const form = reactive({
   otherDiagnosisList: [], //其他断目录
 });
 const rules = reactive({});
+
+const normalizeOrgTreeIds = (nodes) => {
+  if (!Array.isArray(nodes)) return [];
+  return nodes.map((node) => ({
+    ...node,
+    id: node.id != null ? String(node.id) : node.id,
+    children: node.children?.length ? normalizeOrgTreeIds(node.children) : undefined,
+  }));
+};
+
+const resolveTargetDepartmentId = (rawId) => {
+  if (rawId == null || rawId === '') return '';
+  const node = findTreeItem(orgOptions.value, rawId);
+  return node ? String(node.id) : String(rawId);
+};
+
+const applyTargetDepartmentEcho = () => {
+  if (form.targetDepartment) {
+    form.targetDepartment = resolveTargetDepartmentId(form.targetDepartment);
+  }
+};
+
 onMounted(() => {
+  getLocationInfo();
+  getDiagnosisList();
   getList();
 });
 /**
@@ -288,8 +317,9 @@ const projectWithDepartment = (selectProjectIds, type) => {
       });
     }
   });
-  // 保存用户手动选择的发往科室（提交时需要保留）
+  // 保存用户手动选择/回显的发往科室（提交、编辑回显时需要保留）
-  const manualDept = type === 2 ? form.targetDepartment : '';
+  const manualDept =
+    type === 2 || (isEditMode.value && form.targetDepartment) ? form.targetDepartment : '';
   // 清空科室
   form.targetDepartment = '';
   if (arr.length > 0) {
@@ -309,8 +339,8 @@ const projectWithDepartment = (selectProjectIds, type) => {
     const findItem = findTreeItem(orgOptions.value, obj.orgId);
     if (!findItem) {
       // type=2(提交)时，若用户已手动选择发往科室，则允许提交
-      if (type === 2 && manualDept) {
+      if ((type === 2 || isEditMode.value) && manualDept) {
-        form.targetDepartment = manualDept;
+        form.targetDepartment = resolveTargetDepartmentId(manualDept);
         isRelease = true;
       } else if (type === 2 && !manualDept) {
         // 提交时用户未手动选择科室，才提示错误
@@ -326,10 +356,10 @@ const projectWithDepartment = (selectProjectIds, type) => {
     }
     if (findItem && isRelease) {
       // 提交时若用户已选「发往科室」，不得用项目默认执行科室覆盖
-      if (type === 2 && manualDept) {
+      if ((type === 2 || isEditMode.value) && manualDept) {
-        form.targetDepartment = manualDept;
+        form.targetDepartment = resolveTargetDepartmentId(manualDept);
       } else {
-        form.targetDepartment = findItem.id;
+        form.targetDepartment = String(findItem.id);
       }
     }
   }
@@ -339,49 +369,93 @@ const projectWithDepartment = (selectProjectIds, type) => {
 watch(
   () => transferValue.value,
   (newValue) => {
+    if (skipDeptAutoFill.value) return;
+    if (isInitializing.value) return;
     projectWithDepartment(newValue, 1);
   }
 );
 
-// 编辑模式下，回显已有数据
+/** 编辑弹窗：根据申请单明细把右侧「已选择」与 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 变化触发 projectWithDepartment 覆盖 descJson 中的科室值
+  isInitializing.value = true
+  skipDeptAutoFill.value = true
+  transferValue.value = uniq
+  nextTick(() => {
+    skipDeptAutoFill.value = false
+  })
+  isInitializing.value = false
+  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]
           }
-        });
+        })
+        applyTargetDepartmentEcho()
       } 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 }
+  { immediate: true, deep: true }
-);
+)
 
-// 编辑模式下，applicationListAll 加载完成后重新回显已选项目
+watch(
+  () => orgOptions.value,
+  () => {
+    applyTargetDepartmentEcho()
+  }
+)
+
+// 编辑模式下，项目字典加载完成后重新回显已选项目
 watch(
   () => applicationListAll.value,
   () => {
@@ -398,7 +472,10 @@ watch(
         selectedIds.push(matched.adviceDefinitionId);
       }
     });
+    isInitializing.value = true;
     transferValue.value = selectedIds;
+    isInitializing.value = false;
+    applyEditTransferSelection();
   }
 );
 
@@ -451,9 +528,9 @@ const submit = () => {
 };
 /** 查询科室 */
 const getLocationInfo = () => {
-  getOrgList().then((res) => {
+  return getDepartmentList().then((res) => {
-    orgOptions.value = res.data.records;
+    orgOptions.value = normalizeOrgTreeIds(res.data || []);
-    console.log('科室========>', JSON.stringify(orgOptions.value));
+    applyTargetDepartmentEcho();
   });
 };
 // 获取诊断目录

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

@@ -232,64 +232,21 @@ onMounted(() => {
  * type(1：watch监听类型 2:点击保存类型)
  * selectProjectIds(选中项目的id数组)
  * */
-const projectWithDepartment = (selectProjectIds, type) => {
+const projectWithDepartment = (selectProjectIds) => {
-  //1.获取选中的项目 2.判断项目的执行科室是否相同 3.判断执行科室是否配置 4.将项目的执行科室复值到执行科室下拉选位置
+  if (!selectProjectIds || selectProjectIds.length === 0) {
-  let isRelease = true;
+    form.targetDepartment = '';
-  // 选中项目的数组
-  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(
+watch(() => transferValue.value, (newValue) => {
-  () => transferValue.value,
+  projectWithDepartment(newValue);
-  (newValue) => {
+});
-    projectWithDepartment(newValue, 1);
-  }
-);
 const submit = () => {
   if (transferValue.value.length == 0) {
-    return proxy.$message.error('请选择申请单');
+    return proxy.$message.error('请选择手术项目');
   }
-  if (!projectWithDepartment(transferValue.value, 2)) {
+  if (!form.targetDepartment) {
-    return;
+    return proxy.$message.error('请选择发往科室');
   }
   let applicationListAllFilter = applicationListAll.value.filter((item) => {
     return transferValue.value.includes(item.adviceDefinitionId);
@@ -302,7 +259,7 @@ const submit = () => {
       unitCode: item.unitCode,
       unitPrice: item.price,
       totalPrice: item.price,
-      positionId: item.positionId,
+      positionId: form.targetDepartment || item.positionId, // 用户手动选择的发往科室优先于项目默认执行科室
       definitionId: item.chargeItemDefinitionId,
       accountId: patientInfo.value.accountId,
     };

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

@@ -804,7 +804,7 @@ function checkUnit(item, row) {
   }
 }
 
-// 行双击打开编辑块，仅待发送的可编辑
+// 行双击打开编辑块：待保存、待签发医嘱均可编辑；已签发/已完成/停止不允许编辑
 function clickRowDb(row, column, event) {
   // 检查点击的是否是复选框
   if (event && event.target.closest('.el-checkbox')) {
@@ -815,14 +815,18 @@ function clickRowDb(row, column, event) {
     return;
   }
   row.showPopover = false;
-  // “待签发(已保存 requestId存在)”不允许再编辑；仅“待保存(无requestId)”允许编辑
+  if (row.statusEnum == 1) {
-  if (row.statusEnum == 1 && !row.requestId) {
     // 确保治疗类型为字符串，方便与单选框 label 对齐，默认为长期医嘱('1')
     row.therapyEnum = String(row.therapyEnum ?? '1');
     row.isEdit = true;
     const index = prescriptionList.value.findIndex((item) => item.uniqueKey === row.uniqueKey);
-    prescriptionList.value[index] = row;
+    rowIndex.value = index;
+    if (index !== -1) {
+      prescriptionList.value[index] = row;
+    }
     expandOrder.value = [row.uniqueKey];
+  } else {
+    proxy.$modal.msgWarning('仅待保存或待签发医嘱允许编辑');
   }
 }
 
@@ -1195,7 +1199,7 @@ function handleSave() {
     // 此处签发处方和单行保存处方传参相同，后台已经将传参存为JSON字符串，此处直接转换为JSON即可
     loading.value = true;
     let list = saveList.map((item) => {
-      const parsedContent = JSON.parse(item.contentJson);
+      const parsedContent = item.contentJson ? JSON.parse(item.contentJson) : {};
       return {
         ...parsedContent,
         adviceType: item.adviceType,
@@ -1393,7 +1397,9 @@ function handleSaveSign(row, index) {
       }
     });
   } else {
-    if (prescriptionList.value[0].adviceName) {
+    // 仅通过【新增】按钮创建的医嘱保存后才自动添加下一行空医嘱
+    // 双击编辑已有"待保存"医嘱保存时，不应自动添加空行
+    if (isAdding.value && prescriptionList.value[0].adviceName) {
       handleAddPrescription();
     }
   }

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

@@ -348,13 +348,14 @@ const adviceTypeList = computed(() => {
       return val === 3 || val === 4;
     }).map(item => ({
       label: item.label,
-      value: parseInt(item.value)
+      // drord_doctor_type 中耗材是 4，但 /advice-base-info 后端耗材类型是 2
+      value: parseInt(item.value) === 4 ? 2 : parseInt(item.value)
     }));
     return [...filtered, { label: '全部', value: '' }];
   }
   // 默认值
   return [
-    { label: '耗材', value: 4 },
+    { label: '耗材', value: 2 },
     { label: '诊疗', value: 3 },
     { label: '全部', value: '' },
   ];
@@ -373,7 +374,8 @@ const filterKeywords = ref({});
 const queryParams = ref({
   pageSize: 100,
   pageNum: 1,
-  adviceTypes: '2,3',
+  // 默认加载全部类型（药品1+耗材2+诊疗3）
+  adviceTypes: [1, 2, 3],
 });
 /**
  * 医嘱提交数据模型
@@ -482,8 +484,9 @@ watch(
   (visible) => {
     if (visible) {
       executeTime.value = formatDateStr(new Date(), 'YYYY-MM-DD HH:mm:ss');
-      // 弹窗打开时重新加载科室和位置选项，确保数据最新
+      // 弹窗打开时按当前患者科室重新加载，避免复用上一次患者/登录科室的结果
       loadDepartmentOptions();
+      getAdviceBaseInfos();
       getDiseaseInitLoc(16);
     } else {
       resetData();
@@ -555,12 +558,28 @@ function loadDepartmentOptions() {
 function getAdviceBaseInfos() {
   adviceLoading.value = true;
   queryParams.value.searchKey = searchText.value;
-  queryParams.value.adviceType = adviceType.value;
+  // 字典值(3=诊疗,4=耗材)映射为后端adviceType(2=耗材,3=诊疗)
+  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.adviceTypes = normalizeAdviceTypesForQuery(adviceType.value);
+  queryParams.value.organizationId = props.patientInfo.organizationId || orgId.value;
   queryParams.value.pricingFlag = 1; // 划价标记
   getAdviceBaseInfo(queryParams.value)
     .then((res) => {
-      AdviceBaseInfoList.value = res.data?.records || [];
+      const list = 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;
@@ -605,6 +624,12 @@ function getItemType_Text(type) {
   const map = { 2: '耗材', 3: '诊疗' };
   return map[type] || '其他';
 }
+function normalizeAdviceTypesForQuery(type) {
+  if (type === '' || type === undefined || type === null) {
+    return '2,3';
+  }
+  return Number(type) === 4 ? 2 : type;
+}
 function getUnitCodeOptions(row) {
   const unitCodes = [];
   // 大单位：优先用 code，code 缺失时用字典文本兜底

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

@@ -262,7 +262,7 @@
 </template>
 
 <script setup>
-import {computed, nextTick, onMounted, ref, watch} from 'vue';
+import {nextTick, onMounted, ref} from 'vue';
 import {ElMessage, ElMessageBox} from 'element-plus';
 // Element Plus 图标导入
 import {User} from '@element-plus/icons-vue';
@@ -366,9 +366,9 @@ const rawPrescriptionList = ref([]); // 原始未分组数据
 const groupedPrescriptionList = ref([]); // 按encounterId分组后的数据
 const activeCollapseNames = ref([]); // Collapse激活状态
 const selectedRows = ref({}); // 选中的行数据
-const totalItemsCount = ref(0); // 总医嘱项数
-const totalAmount = ref(0); // 总金额（保留4位小数）
 const dialogVisible = ref(false);
+/** Tab 切换同步日期时跳过 date-picker change，避免与 v-model 循环触发 */
+const syncingDateFromTab = ref(false);
 const selectedFeeItems = ref([]);
 const currentPatientInfo = ref(null);
 const queryParams = ref({
@@ -381,24 +381,6 @@ const userStore = useUserStore();
 const userId = ref(safeGet(userStore, 'id', ''));
 const orgId = ref(safeGet(userStore, 'orgId', ''));
 
-// ========== 计算属性 ==========
-// 计算总统计信息（总项数、总金额）
-const calculateTotalStats = computed(() => {
-  let itemsCount = 0;
-  let amount = 0;
-
-  safeArray(groupedPrescriptionList.value).forEach((patientGroup) => {
-    safeArray(patientGroup).forEach((item) => {
-      itemsCount++;
-      // 累加单价，保留4位小数精度
-      amount = Math.round((amount + Number(safeGet(item, 'unitPrice', 0))) * 10000) / 10000;
-    });
-  });
-
-  totalItemsCount.value = itemsCount;
-  totalAmount.value = amount;
-});
-
 // ========== 方法 ==========
 /**
  * 计算单个患者的总金额（保留4位小数）
@@ -447,16 +429,19 @@ const handleTableSelectionChange = (index, val) => {
 };
 
 /**
- * 日期Tab切换
+ * 按 Tab 同步日期范围（避免 date-picker @change 与 Tab v-model 互相覆盖）
- * @param {Object} tab - 标签页
+ * @param {string} rangeType - today | yesterday | custom
  */
-const handleDateTabClick = (tab) => {
+const applyDateRangeByTab = (rangeType) => {
   const today = new Date();
   const yesterday = new Date(today);
   yesterday.setDate(today.getDate() - 1);
   const format = (date) => formatDateStr(date, 'YYYY-MM-DD');
 
-  switch (safeGet(tab, 'paneName')) {
+  syncingDateFromTab.value = true;
+  dateRange.value = rangeType;
+
+  switch (rangeType) {
     case 'today':
       dateRangeValue.value = [format(today), format(today)];
       break;
@@ -464,27 +449,54 @@ const handleDateTabClick = (tab) => {
       dateRangeValue.value = [format(yesterday), format(yesterday)];
       break;
     case 'custom':
-      if (!dateRangeValue.value.length) {
+      if (safeArray(dateRangeValue.value).length < 2) {
         dateRangeValue.value = [format(today), format(today)];
       }
       break;
+    default:
+      break;
   }
+
+  nextTick(() => {
+    syncingDateFromTab.value = false;
+  });
 };
 
 /**
- * 日期选择器变化
+ * 日期Tab切换
+ * @param {Object} tab - 标签页
+ */
+const handleDateTabClick = (tab) => {
+  const rangeType = tab?.paneName ?? tab?.props?.name;
+  if (!rangeType) return;
+  applyDateRangeByTab(rangeType);
+  handleQuery();
+};
+
+/**
+ * 日期选择器变化（仅用户手动改日期时切到「自定义」）
  * @param {Array} val - 选中日期
  */
 const handleDatePickerChange = (val) => {
+  if (syncingDateFromTab.value) return;
+
   const dateVal = safeArray(val);
-  if (dateVal.length === 2) {
+  if (dateVal.length !== 2) return;
+
+  const start = new Date(dateVal[0]);
+  const end = new Date(dateVal[1]);
+  if (start > end) {
+    ElMessage.warning('开始日期不能晚于结束日期');
+    syncingDateFromTab.value = true;
+    dateRangeValue.value = [dateVal[1], dateVal[0]];
+    nextTick(() => {
+      syncingDateFromTab.value = false;
+    });
+    return;
+  }
+
+  if (dateRange.value !== 'custom') {
     dateRange.value = 'custom';
-    const start = new Date(dateVal[0]);
-    const end = new Date(dateVal[1]);
-    if (start > end) {
-      ElMessage.warning('开始日期不能晚于结束日期');
-      dateRangeValue.value = [dateVal[1], dateVal[0]];
-    }
   }
 };
 
@@ -714,24 +726,7 @@ const handleSingleDelete = (row) => {
 };
 // ========== 初始化 ==========
 onMounted(() => {
-  // 设置默认日期
+  applyDateRangeByTab('today');
-  const today = new Date();
-  const defaultDate = formatDateStr(today, 'YYYY-MM-DD');
-  dateRangeValue.value = [defaultDate, defaultDate];
-
-  // 监听日期变化自动查询
-  watch(
-    [dateRange, dateRangeValue],
-    ([newRange, newVal], [oldRange, oldVal]) => {
-      if (oldRange !== undefined && safeArray(newVal).length === 2) {
-        handleQuery();
-      }
-    },
-    { deep: true }
-  );
-
-  // 初始化统计信息
-  calculateTotalStats.value;
 });
 </script>
 

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

@@ -386,7 +386,7 @@
                       :disabled="viewStatus == 'view'"
                       v-model="scope.row.itemQuantityDisplay"
                       placeholder=""
-                      @change="(value) => handleItemQuantityChange(scope.row, value)"
+                      @input="(value) => handleItemQuantityChange(scope.row, value)"
                       :class="{ 'error-border': scope.row.error }"
                     />
                   </div>
@@ -971,6 +971,10 @@ function handleItemQuantityChange(row, value) {
     quantityTemp = value;
   }
   row.totalPrice = ((row.price * quantityTemp) / row.partPercent).toFixed(2);
+  // 数量变更后重置保存标记，允许重新提交
+  row.isSave = false;
+  // 同步更新底部合计金额
+  handleTotalAmount();
 }
 
 function handelApply() {
@@ -1262,128 +1266,108 @@ function editBatchTransfer(index) {
 }
 
 function handleSave(row, index) {
-  rowList.value = [];
+  // 过滤出未保存的行，已保存的行不重复提交
-  if (route.query.supplyBusNo) {
+  const listToCheck = route.query.supplyBusNo
-    // 编辑
+    ? forms.purchaseinventoryList
-    forms.purchaseinventoryList.map((row, index) => {
+    : form.purchaseinventoryList;
-      if (row) {
+  const unsavedList = listToCheck.filter(item => !item.isSave);
-        proxy.$refs['receiptHeaderRef'].validate((valid) => {
+  if (unsavedList.length === 0) {
-          if (valid) {
+    proxy.$modal.msgWarning('所有行均已保存，无需重复提交');
-            proxy.$refs['formRef'].validate((valid) => {
+    return;
-              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) => {
-        form.purchaseinventoryList[index].id = res.data[index];
+        // 只有未保存的行才会拿到新 id（和提交顺序一致）
+        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) => {
-          forms.purchaseinventoryList[index].id = res.data[index];
+          if (!row.isSave && res.data[newIdIdx]) {
+            forms.purchaseinventoryList[index].id = res.data[newIdIdx];
+            newIdIdx++;
+          }
           forms.purchaseinventoryList[index].isSave = true;
         });
       }

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

@@ -1565,7 +1565,7 @@ function handleMedicalAdvice(row) {
   temporaryMedicalLoading.value = true // 🔧 新增：开始加载
 
   // 调用计费接口获取数据
-  getPrescriptionList(row.visitId).then((res) => {
+  getPrescriptionList(row.visitId, 6, row.operCode).then((res) => {
     console.log('=== 拉取计费数据返回结果 ===', res)
     if (res.code === 200 && res.data) {
       // 🔧 修复：显示所有药品请求数据，不管有没有计费项目
@@ -1576,12 +1576,18 @@ function handleMedicalAdvice(row) {
       const filteredItems = res.data.filter(item => {
         // 匹配 encounterId
         if (item.encounterId !== row.visitId) return false;
-        // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3)
+        // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3/6)
-        if (item.adviceType !== 1) return false;
+        // 🔧 修复 Bug #444: 使用 Number() 显式转换，避免字符串 "1" 被 !== 1 放行
+        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 #445: 过滤掉已生成医嘱的项目（已有 requestId 的不应出现在"待生成"列表）
+        // 🔧 修复 Bug #444: 二次过滤，排除名称中包含手术/检查/诊疗关键词的非药品项目
+        // 某些计费项目可能在 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;
@@ -1702,9 +1708,14 @@ 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 字段
         }
       }
@@ -1843,6 +1854,21 @@ 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) {
@@ -1850,16 +1876,21 @@ function handleQuoteBilling() {
               temporaryBillingMedicines.value = []
               temporaryAdvices.value = []
     
-              // 🔧 修复 Bug #445: 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3)
+              // 🔧 修复 Bug #445: 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3/6)
               // 同时过滤掉已有 requestId 的项目（已生成医嘱的不需要再次显示在"待生成"列表中）
               const filteredItems = res.data.filter(item => {
                 // 匹配 encounterId
                 if (item.encounterId !== temporaryPatientInfo.value.visitId) return false;
-                // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3)
+                // 只保留药品类型（adviceType=1），过滤掉耗材(2)和诊疗项目(3/6)
-                if (item.adviceType !== 1) return false;
+                // 🔧 修复 Bug #444: 使用 Number() 显式转换 + snake_case 回退，避免字符串 "1" 匹配失败
+                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;
@@ -1963,36 +1994,70 @@ 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: 过滤掉已生成医嘱的项目，避免"引用计费"后已提交项目重新出现在"待生成"列表
-        // 原因：后端返回的计费数据中，已生成医嘱的项目可能没有 requestId 字段
+        // 使用清空前提取的 submittedKeys（名称|||规格|||数量复合键）进行匹配
-        // 方案：用 chargeItemId/requestId/id 与已有的 temporaryAdvices 做匹配，排除已生成项目
+        if (submittedKeys.size > 0) {
-        if (temporaryAdvices.value.length > 0) {
+          temporaryBillingMedicines.value = temporaryBillingMedicines.value.filter(m => {
-          const existingAdviceIds = new Set()
+            const key = `${m.medicineName || ''}|||${m.specification || ''}|||${m.quantity ?? 0}`
-          temporaryAdvices.value.forEach(a => {
+            return !submittedKeys.has(key)
-            const om = a.originalMedicine || {}
+          })
-            if (om.requestId) existingAdviceIds.add(String(om.requestId))
+          // 同步更新 temporaryAdvices，保持两份数据一致
-            if (om.chargeItemId) existingAdviceIds.add(String(om.chargeItemId))
+          temporaryAdvices.value = temporaryBillingMedicines.value.map((medicine, index) => {
-            if (om.id) existingAdviceIds.add(String(om.id))
+            const specMatch = medicine.specification ? medicine.specification.match(/(\d+)(\D+)/) : null
+            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 // 🔧 新增：加载完成

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

@@ -150,7 +150,7 @@
           :disabled="allItemsSubmitted"
           @click="handleSignAndSubmit"
         >
-          {{ allItemsSubmitted ? '已签发' : (isSigned ? '提交医嘱' : '一键签名并生成医嘱') }}
+          {{ allItemsSubmitted ? '已签发' : '一键签名并生成医嘱' }}
         </el-button>
       </div>
     </div>