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

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-19 14:05:56 +08:00
716 changed files with 50051 additions and 101318 deletions
--- a/.agentforge/analysis/556.md
+++ b/.agentforge/analysis/556.md
@@ -1,27 +0,0 @@
-# Bug #556 Analysis
-
-## Title
-【门诊医生站-检验】新增检验申请单时就诊卡号/执行时间未自动回显，且项目列表冗余显示"套餐"文字
-
-## Root Cause Analysis
-
-### Issue 1: 就诊卡号未自动回显
- **Code**: `inspectionApplication.vue:886` - `formData.medicalrecordNumber = props.patientInfo.identifierNo || ''`
- **Root Cause**: Logic is correct but depends on `props.patientInfo.identifierNo` being populated. The watch on `props.patientInfo` (line 2074) triggers `initData()`. The card number field itself is correctly bound. This is likely a timing issue where the patient data loads before `identifierNo` is available, but the core code path is correct — no code change needed here beyond ensuring executeTime default doesn't block form rendering.
-
-### Issue 2: 执行时间未默认填充当前系统时间
- **Code**: `inspectionApplication.vue:978` - `executeTime: null`
- **Root Cause**: In `initData()` (line 879-921), only `applyTime` is set via `startApplyTimeTimer()`. `formData.executeTime` is never assigned a default value. Similarly in `resetForm()` (line 1550), `executeTime` remains `null`.
- **Fix**: Add `formData.executeTime = formatDateTime(new Date())` in `initData()` and change `resetForm()` to use `executeTime: formatDateTime(new Date())`.
-
-### Issue 3: 项目列表冗余显示"套餐"文字
- **Code**: `inspectionApplication.vue:1190` - Already fixed with `packageName` check. But `inspectionApplication.vue:2000` in `loadApplicationToForm()` still uses loose check: `item.feePackageId != null || item.itemName?.includes('套餐')`.
- **Fix**: Update `loadApplicationToForm()` line 2000 to match the stricter check: `item.feePackageId != null && item.feePackageId !== '' && item.feePackageId !== 'null' && item.packageName`.
-
-## Files to Modify
- `openhis-ui-vue3/src/views/doctorstation/components/inspection/inspectionApplication.vue`
-
-## Changes
-1. `initData()`: Add `formData.executeTime = formatDateTime(new Date())` after line 899
-2. `resetForm()`: Change `executeTime: null` to `executeTime: formatDateTime(new Date())` at line 1550
-3. `loadApplicationToForm()`: Fix `isPackage` logic at line 2000
--- a/.agentforge/bugs/556-analysis.md
+++ b/.agentforge/bugs/556-analysis.md
@@ -1,53 +0,0 @@
-# Bug #556 分析报告
-
-## 问题描述
-【门诊医生站-检验】新增检验申请单时：
-1. 就诊卡号字段为空，未自动带出患者就诊卡号
-2. 执行时间字段未自动填充，仅显示占位提示
-3. 检验项目列表每条记录前均带"套餐"文字标签（冗余显示）
-
-## 根因分析
-
-### 问题1：就诊卡号未自动回显
- 代码路径：`initData()` 中 `formData.medicalrecordNumber = props.patientInfo.identifierNo || ''`
- 数据绑定：`v-model="formData.medicalrecordNumber"`
- `props.patientInfo` 由父组件传入，字段 `identifierNo` 来自后端患者信息
- 当前逻辑本身正确，但需要增加兜底回读机制（已有 #406 的同步逻辑在 handleSave 中，initData 也应覆盖）
- **结论**：代码路径正确，如果 identifierNo 为空则是父组件传参问题；已在 handleSave 中有同步逻辑，initData 中已有逻辑。无需额外修复。
-
-### 问题2：执行时间未自动填充
- 根因：`formData.executeTime` 在 `formData` 初始化时（line 978）设为 `null`
- `initData()` 函数没有为 executeTime 设置默认值
- `resetForm()` 函数（line 1550）也将 executeTime 重置为 `null`
- 前端 datetime picker 在 `v-model` 为 `null` 时显示占位符 "选择执行时间"
- **修复方案**：在 `initData()` 中设置 `formData.executeTime = formatDateTime(new Date())`；在 `resetForm()` 中也同样设置默认值为当前时间
-
-### 问题3：项目列表冗余显示"套餐"文字
- 根因：`isPackage` 判定条件不一致
-  - `loadCategoryItems()` (line 1190): 使用 `item.feePackageId != null && ... && item.packageName` — ✅ 正确（同时检查 feePackageId 有效 + packageName 非空）
-  - `loadApplicationToForm()` (line 2000): 使用 `item.feePackageId != null || item.itemName?.includes('套餐')` — ❌ 错误
-    - `feePackageId != null` 单独判断会导致普通项目因 feePackageId 有值被误标为套餐
-    - `item.itemName?.includes('套餐')` 更是直接按名称文字判断，极不准确
- 影响位置：
-  - 检验项目选择区（line 566）：`<el-tag v-if="item.isPackage">套餐</el-tag>`
-  - 已选项目列表（line 617）：`<el-tag v-if="item.isPackage">套餐</el-tag>`
-  - 检验信息详情表格（line 448）：`<el-tag v-if="scope.row.isPackage">套餐</el-tag>`
- **修复方案**：将 `loadApplicationToForm()` 中的 `isPackage` 判定统一为与 `loadCategoryItems()` 一致的逻辑
-
-## 修复方案
-
-### 修复1：执行时间默认填充
- 文件：`inspectionApplication.vue`
- 位置：`initData()` 函数，在已有患者信息赋值后添加 `formData.executeTime = formatDateTime(new Date())`
- 位置：`resetForm()` 函数，将 `executeTime: null` 改为使用当前时间
-
-### 修复2：isPackage 判定统一
- 文件：`inspectionApplication.vue`
- 位置：`loadApplicationToForm()` 函数 line 2000
- 旧代码：`const isPackage = item.feePackageId != null || item.itemName?.includes('套餐')`
- 新代码：`const isPackage = item.feePackageId != null && item.feePackageId !== '' && item.feePackageId !== 'null' && item.packageName`
-
-## 验收标准
-1. 新增检验申请单时，执行时间字段自动填充当前系统时间（YYYY-MM-DD HH:mm:ss 格式）
-2. 检验项目列表中，只有真正的套餐项目前显示"套餐"标签，普通项目不显示
-3. 就诊卡号在有患者信息时正常显示
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,68 @@
+# 忽略所有编译器、IDE相关的文件
+**/.idea/
+**/.vscode/
+**/*.swp
+**/*.swo
+**/*.bak
+**/*.tmp
+**/.vs/
+
+# 忽略 Java 项目编译文件
+**/*.class
+**/*.jar
+**/*.war
+**/*.ear
+**/target/
+**/bin/
+
+# 忽略 Maven、Gradle、Ant 相关文件
+**/.mvn/
+**/.gradle/
+**/build/
+**/out/
+
+# 忽略 Eclipse、IntelliJ IDEA 和 NetBeans 临时文件
+**/*.log
+**/*.project
+**/*.classpath
+
+# 忽略 Java 配置文件
+**/*.iml
+
+# 忽略 Node.js 和 Vue 项目相关文件
+**/node_modules/
+**/npm-debug.log
+**/yarn-error.log
+**/yarn-debug.log
+**/dist/
+**/*.lock
+**/*.tgz
+
+# 忽略 Vue 项目相关构建文件
+**/.vuepress/dist/
+
+# 忽略 IDE 配置文件
+**/*.launch
+**/*.settings/
+
+# 忽略操作系统生成的文件
+**/.DS_Store
+**/Thumbs.db
+**/Desktop.ini
+
+
+
+/openhis-miniapp/unpackage
+
+# 忽略设计书
+PostgreSQL/openHis_DB设计书.xlsx
+
+public.sql
+发版记录/2025-11-12/~$发版日志.docx
+发版记录/2025-11-12/~$S-管理系统-调价管理.docx
+发版记录/2025-11-12/发版日志.docx
+.gitignore
+openhis-server-new/openhis-application/src/main/resources/application-dev.yml
+.env.test.local
+playwright-report/
+test-results/
--- a/.harness/PROGRESS.md
+++ b/.harness/PROGRESS.md
@@ -1,39 +0,0 @@
-# 进度日志
-
-## 当前已验证状态
-
- 仓库根目录：`/root/.openclaw/workspace/his-repo`
- 分支：`develop`
- 标准启动路径：`cd openhis-server-new && mvn compile -pl openhis-application -am`
- 标准验证路径：`bash .harness/check.sh`（一键全部门禁）
- 标准初始化：`bash .harness/init.sh`
- 标准作业流程：`.harness/STANDARD_OPERATING_PROCEDURE.md`
- 当前最高优先级未完成功能：`harness-003` — 持续完善 check.sh
- 当前 blocker：无
-
-## 会话记录
-
-### Session 001 (2026-05-28) — 基础设施 v1
- 已完成：AGENTS.md 重构、5 技能创建、通用模板、插件安装
-
-### Session 002 (2026-05-28) — WalkingLabs 整合
- 已完成：walkinglabs-harness 技能、.harness/ 模板、AGENTS.md v2、check.sh
-
-### Session 003 (2026-05-28) ← 当前
- 目标：用 Harness 方法论验证 Bug #597 + 定义标准化开发流程
- 已完成：
-  - Bug #597 全链路 6 环验证通过（所有环节 ✅）
-  - 创建 .harness/STANDARD_OPERATING_PROCEDURE.md（196 行）
-  - 格式化的 Harness 工作循环：Init→Plan→Implement→Verify→Cleanup→Review
- 运行过的验证：mvn compile ✅ | check.sh 7/7 ✅ | 全链路 6/6 ✅
- 提交记录：
- 已知风险或未解决问题：
- 下一步最佳动作：无 — 所有基础设施已完成
-
-## 当前功能状态
-
-| ID | 功能 | 状态 |
-|---|---|---|
-| harness-001 | 基础设施 v1（24 篇博客） | done ✅ |
-| harness-002 | WalkingLabs 实战模式整合 | done ✅ |
-| harness-003 | 质量门禁自动化检查脚本 | in_progress 🔄 |
--- a/.harness/STANDARD_OPERATING_PROCEDURE.md
+++ b/.harness/STANDARD_OPERATING_PROCEDURE.md
@@ -1,196 +0,0 @@
-# Harness 标准作业程序 (SOP)
-
-> 所有开发任务、Bug 修复、重构，必须遵循此流程。
-
-## 流程全景
-
-```
-Init → Plan → Implement → Verify → Cleanup → Review
- │        │        │           │         │         │
- └─ 环境  └─ 全链路 └─ 约束内   └─ 门禁    └─ 状态   └─ 评分
-    就绪    分析     修改        检查       更新     评审
-```
-
---
-
-## 步骤详解
-
-### Step 1: Init — 环境就绪
-
-```bash
-# 1. 确认在正确的目录
-pwd
-
-# 2. 运行初始化
-bash .harness/init.sh
-
-# 3. 读取当前进度
-cat .harness/PROGRESS.md
-cat .harness/feature_list.json
-
-# 4. 查看最近变更
-git log --oneline -5
-git status --short
-```
-
-**检查项：**
- [ ] 编译通过 (`mvn compile`)
- [ ] 了解当前进行中的功能
- [ ] 了解最近提交
-
---
-
-### Step 2: Plan — 全链路分析
-
-**对于每个字段/功能的新增或修改，先画出完整数据流：**
-
-```
-录入 → 保存 → 查询 → 修改 → 删除 → 关联
- │       │      │      │      │      │
- └前端    └API   └Mapper └回显   └软删除 └上下游
-          └Ctrl  └DTO    └再保存         └计费
-          └Svc   └前端                     └打印
-          └Entity                          └报表
-          └DB
-```
-
-**检查清单（6 环）：**
-1. **录入** — 前端有输入入口？（弹窗、行编辑、表单）
-2. **保存** — 前端→API→Controller→Service→Entity→DB，每个入口都传了吗？（注意多个 Service 实现类）
-3. **查询** — DB→Mapper XML（UNION ALL 子查询统一加）→DTO→前端展示
-4. **修改** — 编辑回显→修改保存→正确更新？
-5. **删除/停止** — 状态变更会丢失该字段吗？
-6. **关联** — 上下游（护士站、药房、计费、打印、报表）需要同步改吗？
-
-**输出：** `update_plan` 分解步骤 + 风险评估
-
---
-
-### Step 3: Implement — 约束内修改
-
-**约束铁律：**
- 一次只做一个功能（`single_active_feature = true`）
- 只动必要文件，禁止"顺便改进"无关代码
- 遵循 AGENTS.md 中的代码风格规范
- 涉及 Mapper XML 时，UNION ALL 所有子查询统一修改
-
-**修改原则：**
- 安全 > 架构 > 质量 > 性能
- 增量修改，每步可回滚
- 每个检查点保存进度（`update_plan`）
-
---
-
-### Step 4: Verify — 门禁检查
-
-```bash
-# L1: 编译检查
-cd openhis-server-new && mvn compile -pl openhis-application -am
-
-# L2: 全链路门禁
-bash .harness/check.sh
-
-# L3: 人工审查（输出变更摘要）
-```
-
-**输出变更摘要：**
-```
-修改文件: N 个
-新增行数: N
-删除行数: N
-影响模块: [模块列表]
-风险等级: 低/中/高
-变更摘要: [一句话描述做了什么]
-```
-
---
-
-### Step 5: Cleanup — 状态更新
-
-```bash
-# 1. 更新进度
-vim .harness/PROGRESS.md
-# 添加新会话记录，更新完成状态
-
-# 2. 更新功能清单
-vim .harness/feature_list.json
-# 标记完成/更新状态
-
-# 3. 运行干净状态检查
-cat .harness/clean-state-checklist.md
-# 逐项确认
-
-# 4. 提交
-git add -A
-git commit -m "type(scope): description"
-git push origin develop
-```
-
-**提交信息格式：**
-```
-<type>(<scope>): <description>
-
-type: feat | fix | refactor | docs | test | chore
-scope: 模块名（如 mapper, service, harness）
-```
-
---
-
-### Step 6: Review — 评审评分
-
-对照 `.harness/evaluator-rubric.md` 逐项评分：
-
-| 维度 | 满分 | 自评 |
-|---|---|---|
-| 正确性 | 2 | 行为是否符合目标 |
-| 验证 | 2 | 门禁是否全部通过 |
-| 范围纪律 | 2 | 是否超出任务边界 |
-| 可靠性 | 2 | 能否重复执行 |
-| 可维护性 | 2 | 代码是否规范 |
-| 交接准备度 | 2 | 下一轮能否继续 |
-
-**结论：** Accept / Revise / Block
-
---
-
-## 异常处理
-
-### 编译失败
-```
-失败 → 分析错误 → git restore 撤销 → 从检查点重试
-持续失败（3次） → 上报人类
-```
-
-### 全链路不完整
-```
-发现缺环 → 记录到 PROGRESS.md blocker → 补充修复
-```
-
-### 范围蔓延
-```
-发现超出任务 → 创建新 feature → 当前任务先完成
-```
-
---
-
-## 速查命令
-
-```bash
-# 诊断
-pwd                           # 确认目录
-git status --short            # 查看变更
-git log --oneline -5          # 查看历史
-git diff --stat HEAD          # 变更统计
-
-# 回滚
-git checkout -- <file>        # 撤销单个文件
-git reset HEAD~1              # 撤销上次提交（保留修改）
-
-# 验证
-bash .harness/init.sh         # 初始化
-bash .harness/check.sh        # 全部门禁
-
-# 状态
-cat .harness/PROGRESS.md      # 进度
-cat .harness/feature_list.json # 功能清单
-```
--- a/.harness/check.sh
+++ b/.harness/check.sh
@@ -1,82 +0,0 @@
-#!/usr/bin/env bash
-# =============================================
-# Harness Quality Gates — 一键运行所有门禁
-# 源自 $closed-loop-testing skill
-# =============================================
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT_DIR"
-
-PASS=0
-FAIL=0
-RESULTS=()
-
-check() {
-    local level="$1" name="$2" cmd="$3"
-    cd "$ROOT_DIR"
-    echo ""
-    echo "━━━ [${level}] ${name} ━━━"
-    if eval "$cmd" 2>&1; then
-        echo "  ✅ ${name} 通过"
-        PASS=$((PASS + 1))
-        RESULTS+=("✅|${level}|${name}")
-    else
-        echo "  ❌ ${name} 失败"
-        FAIL=$((FAIL + 1))
-        RESULTS+=("❌|${level}|${name}")
-    fi
-}
-
-echo ""
-echo "╔══════════════════════════════════════╗"
-echo "║   Harness Quality Gates              ║"
-echo "║   $(date '+%Y-%m-%d %H:%M')              ║"
-echo "╚══════════════════════════════════════╝"
-
-# ── L1: 编译检查 ──
-echo ""
-echo "╔══ L1 编译检查 ══════════════════════╗"
-check "L1" "后端编译" "cd '$ROOT_DIR/openhis-server-new' && mvn compile -pl openhis-application -am -q"
-
-# ── L2: 全链路检查 ──
-echo ""
-echo "╔══ L2 全链路数据流验证 ══════════════╗"
-
-# L2-1: 文件存在性检查
-check "L2" "AGENTS.md 存在" "test -f '$ROOT_DIR/AGENTS.md'"
-check "L2" "init.sh 可执行" "test -x '$ROOT_DIR/.harness/init.sh'"
-check "L2" "PROGRESS.md 存在" "test -f '$ROOT_DIR/.harness/PROGRESS.md'"
-check "L2" "feature_list.json 有效" "python3 -c 'import json; json.load(open(\"$ROOT_DIR/.harness/feature_list.json\"))'"
-
-# L2-2: Mapper XML 结构检查
-check "L2" "Mapper XML 行数一致性" "find '$ROOT_DIR/openhis-server-new' -path '*/mapper/*.xml' -exec wc -l {} + 2>/dev/null | tail -1 | awk '{print \$1}' | xargs test 0 -lt"
-
-# ── L3: 约束合规检查 ──
-echo ""
-echo "╔══ L3 约束合规检查 ══════════════════╗"
-
-# L3-1: 无硬编码密钥
-check "L3" "无硬编码密钥" "! grep -r 'password=.*[a-zA-Z0-9]\{8,\}' --include='*.java' --include='*.yml' --include='*.xml' --include='*.py' '$ROOT_DIR' 2>/dev/null | grep -v 'test\|example\|sample\|template\|localhost\|jchl' | head -5 | grep . && false || true"
-
-# ── 汇总 ──
-echo ""
-echo "╔══════════════════════════════════════╗"
-echo "║   质量门禁结果汇总                    ║"
-echo "╚══════════════════════════════════════╝"
-echo ""
-for r in "${RESULTS[@]}"; do
-    IFS='|' read -r status level name <<< "$r"
-    echo "  $status [$level] $name"
-done
-echo ""
-echo "  总计: $((PASS + FAIL)) | ✅ $PASS 通过 | ❌ $FAIL 失败"
-echo ""
-
-if [ "$FAIL" -gt 0 ]; then
-    echo "  ⚠️  有 $FAIL 项未通过"
-    echo "  提示：新增/修改文件后记得 git add 后再检查"
-    exit 1
-else
-    echo "  🎉 所有门禁通过！"
-fi
--- a/.harness/clean-state-checklist.md
+++ b/.harness/clean-state-checklist.md
@@ -1,13 +0,0 @@
-# 干净状态检查清单
-
-会话结束前逐项检查：
-
- [ ] 标准启动路径仍然可用（mvn compile 通过）
- [ ] 标准验证路径仍然可运行
- [ ] 当前进度已记录到 PROGRESS.md
- [ ] 功能状态真实反映 passing 和未验证的边界
- [ ] feature_list.json 已更新
- [ ] 没有任何半成品步骤处于未记录状态
- [ ] 临时文件和调试代码已清理
- [ ] 提交信息清晰描述了变更内容
- [ ] 下一轮会话无需人工修复即可继续
--- a/.harness/evaluator-rubric.md
+++ b/.harness/evaluator-rubric.md
@@ -1,22 +0,0 @@
-# 评审评分表
-
-| 维度 | 问题 | 0-2分 | 备注 |
-|---|---|---|---|
-| 正确性 | 实现的行为是否符合目标功能？ | | |
-| 验证 | 编译检查是否通过？数据流是否完整？ | | |
-| 范围纪律 | 是否保持在选定功能范围内？ | | |
-| 可靠性 | 结果能否在重启后继续工作？ | | |
-| 可维护性 | 代码是否遵循项目规范？ | | |
-| 交接准备度 | 下一轮能否只靠仓库内文件继续推进？ | | |
-
-## 结论
-
- [ ] Accept
- [ ] Revise
- [ ] Block
-
-## 后续动作
-
- 缺失的证据：
- 必须补的修复：
- 下次复审触发条件：
--- a/.harness/feature_list.json
+++ b/.harness/feature_list.json
@@ -1,72 +0,0 @@
-{
-  "project": "OpenHIS",
-  "last_updated": "2026-05-28",
-  "rules": {
-    "single_active_feature": true,
-    "passing_requires_evidence": true,
-    "do_not_skip_verification": true
-  },
-  "status_legend": {
-    "not_started": "功能还没开始做",
-    "in_progress": "当前唯一正在进行的任务",
-    "blocked": "有已记录的阻塞问题",
-    "passing": "验证已通过，证据已记录",
-    "done": "已完成并合入主干"
-  },
-  "features": [
-    {
-      "id": "harness-001",
-      "priority": 1,
-      "area": "infrastructure",
-      "title": "Harness Engineering 基础设施搭建",
-      "user_visible_behavior": "Codex 具备完整的约束/反馈/控制/持久执行能力",
-      "status": "done",
-      "verification": [
-        "AGENTS.md 包含四大核心组件",
-        "5 个技能安装到 Codex 环境",
-        "harness-engineering 插件注册到 marketplace",
-        "通用 AGENTS.md 模板可用"
-      ],
-      "evidence": ["AGENTS.md restructured", "skills created", "plugin validated"],
-      "notes": "v1: 24 篇博客方法整合完成"
-    },
-    {
-      "id": "harness-002",
-      "priority": 2,
-      "area": "infrastructure",
-      "title": "WalkingLabs 实战模式整合",
-      "user_visible_behavior": "项目具备完整的 5 子系统 Harness（指令/工具/环境/状态/反馈）",
-      "status": "done",
-      "verification": [
-        ".harness/ 目录包含所有模板文件",
-        "init.sh 可正常运行",
-        "PROGRESS.md 记录当前状态",
-        "feature_list.json 跟踪所有功能",
-        "walkinglabs-harness 技能已安装"
-      ],
-      "evidence": [
-        "init.sh verified (compile OK)",
-        "6 templates installed in .harness/",
-        "AGENTS.md updated with 5-subsystem model",
-        "walkinglabs-harness skill created (142 lines)"
-      ],
-      "notes": "v2: walkinglabs 5 子系统整合完成"
-    },
-    {
-      "id": "harness-003",
-      "priority": 3,
-      "area": "infrastructure",
-      "title": "建立质量门禁自动化检查脚本",
-      "user_visible_behavior": "运行一条命令即可完成 L1-L3 质量门禁检查",
-      "status": "not_started",
-      "verification": [
-        "创建 .harness/check.sh — 一键运行所有门禁",
-        "L1: mvn compile 编译检查",
-        "L2: Mapper XML 全链路字段一致性检查",
-        "L3: 生成变更摘要供人工审查"
-      ],
-      "evidence": [],
-      "notes": ""
-    }
-  ]
-}
--- a/.harness/init.sh
+++ b/.harness/init.sh
@@ -1,43 +0,0 @@
-#!/usr/bin/env bash
-# Harness Init — 统一启动与验证入口
-# 每次新会话开始前运行
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT_DIR"
-
-echo "==> 当前目录: $PWD"
-echo "==> Git 状态"
-git status --short 2>/dev/null || true
-git log --oneline -3 2>/dev/null || true
-
-echo ""
-echo "==> 编译检查"
-cd openhis-server-new
-mvn compile -pl openhis-application -am -q 2>/dev/null && echo "    ✅ 编译通过" || echo "    ❌ 编译失败"
-
-echo ""
-echo "==> 读取进度"
-if [ -f .harness/PROGRESS.md ]; then
-    head -20 .harness/PROGRESS.md
-else
-    echo "    (无进度文件)"
-fi
-
-echo ""
-echo "==> 读取功能清单"
-if [ -f .harness/feature_list.json ]; then
-    python3 -c "
-import json
-with open('.harness/feature_list.json') as f:
-    data = json.load(f)
-features = [f for f in data.get('features', []) if f.get('status') == 'in_progress']
-if features:
-    print(f\"    当前进行中: {features[0].get('title', 'unknown')}\")
-else:
-    print('    当前无进行中的功能')
-" 2>/dev/null || echo "    (无法解析)"
-fi
-
-echo ""
-echo "==> 环境就绪 ✅"
--- a/.harness/session-handoff.md
+++ b/.harness/session-handoff.md
@@ -1,29 +0,0 @@
-# 会话交接
-
-## 当前已验证
-
- 现在明确可用的部分：
- 本轮实际跑过的验证：
-
-## 本轮改动
-
- 新增了哪些代码或行为：
- Harness 发生了哪些变化：
-
-## 仍损坏或未验证
-
- 已知缺陷：
- 未验证路径：
- 下一轮需要注意的风险：
-
-## 下一步最佳动作
-
- 最高优先级未完成功能：
- 为什么它是下一步：
- 什么结果才算 passing：
-
-## 命令速查
-
- 编译：`cd openhis-server-new && mvn compile -pl openhis-application -am`
- 打包：`mvn clean package -DskipTests`
- 启动：`mvn spring-boot:run`
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,308 +1,188 @@
-# OpenHIS — Harness Engineering 开发指南
+# OpenHIS - AI Agent Development Guide

-> **模型决定上限，Harness 决定底线。**
-> 本文件是 OpenHIS 项目的 Harness Engineering 落地。整合了 OpenAI/Anthropic Harness Engineering 方法论与 walkinglabs 实战模式。
+## 项目概览
+OpenHIS 是一个医院管理系统，采用 Java 17 + Spring Boot 后端和 Vue 3 + Vite 前端架构。

-> **🔴 铁律统一文件**: `/root/.codex/rules/IRON_LAWS.md` — 所有智能体必须遵守，运行时自动加载。
-> **📦 技能包安装**: https://github.com/paskaa/agentforge-harness-skill — 其他电脑一键安装所有铁律和技能。
-
---
-
-## 📋 项目信息
-
-OpenHIS 医院管理系统 | Java 17 + Spring Boot + MyBatis Plus | Vue 3 + Element Plus | PostgreSQL
-
-### 构建和运行
+## 构建和运行命令

+### 后端（Java/Spring Boot）
 ```bash
-cd /root/.openclaw/workspace/his-repo
-
-# 初始化（每次新会话先运行）
-bash .harness/init.sh
-
-# 后端编译
-cd openhis-server-new && mvn compile -pl openhis-application -am
-
-# 后端打包
+# 构建整个项目
+cd openhis-server-new
 mvn clean package -DskipTests

-# 后端运行
-cd openhis-application && mvn spring-boot:run
+# 运行后端（开发模式）
+cd openhis-server-new/openhis-application
+mvn spring-boot:run

-# 前端
-cd openhis-ui-vue3 && npm install && npm run dev
+# 运行特定模块
+cd openhis-server-new/[module-name]
+mvn spring-boot:run
 ```

-### 关键路径
+### 前端（Vue 3 + Vite）
+```bash
+# 安装依赖
+cd openhis-ui-vue3
+npm install

-```
-后端代码:    openhis-server-new/openhis-application/src/main/java/com/
-后端配置:    openhis-server-new/openhis-application/src/main/resources/
-Mapper XML:  .../mapper/ (regdoctorstation/, doctorstation/, ...)
-前端代码:    openhis-ui-vue3/src/
-Harness:     .harness/ (init.sh, PROGRESS.md, feature_list.json, ...)
+# 开发服务器
+npm run dev
+
+# 生产构建
+npm run build:prod
+
+# 测试环境构建
+npm run build:test
+
+# 预览构建结果
+npm run preview
 ```

---
+### 测试
+项目当前没有配置正式的测试框架。如需添加测试：
+- 后端：考虑使用 JUnit 5 + Mockito
+- 前端：考虑使用 Vitest + Vue Test Utils

-## 🔧 5 子系统模型（WalkingLabs）
+## 代码风格规范

-> 源自：[Learn Harness Engineering](https://walkinglabs.github.io/learn-harness-engineering/zh/)
+### Java 后端规范
+- **Java 版本**: 17
+- **框架**: Spring Boot 2.5.15
+- **ORM**: MyBatis Plus 3.5.5
+- **数据库**: PostgreSQL
+- **包结构**:
+  - `com.openhis` - 业务逻辑
+  - `com.core` - 核心框架
+- **命名约定**:
+  - 类名：PascalCase（如 `UserController`）
+  - 方法名：camelCase（如 `getUserList`）
+  - 常量：SCREAMING_SNAKE_CASE
+  - 配置文件：kebab-case
+- **注解使用**:
+  - 使用 `@Slf4j` 替代手动声明 logger
+  - 使用 `@Data` 在实体类中
+  - 使用 `@Service/@Controller/@Repository` 等 Spring 注解
+- **异常处理**:
+  - 使用统一的异常处理机制
+  - 自定义业务异常继承 `RuntimeException`

-### 1. 指令子系统（Instruction）
-
-| 文件 | 用途 |
-|---|---|
-| **AGENTS.md**（本文件） | 项目规则、约束、工作流程 |
-| `.harness/feature_list.json` | 机器可读的功能状态追踪 |
-| `.harness/PROGRESS.md` | 会话进度和已验证状态 |
-| `.harness/session-handoff.md` | 跨会话交接摘要 |
-
-### 2. 工具子系统（Tools）
-
-| 工具 | 用途 |
-|---|---|
-| `mvn compile` | 编译验证 |
-| `git` | 版本控制 + 回滚 |
-| `pwd` | 确认当前目录 |
-| shell | 文件操作、命令执行 |
-
-### 3. 环境子系统（Environment）
-
-| 组件 | 状态 |
-|---|---|
-| Java 17 | ✅ `pom.xml` 锁定 |
-| Maven | ✅ `mvn-wrapper` |
-| PostgreSQL | ✅ 192.168.110.252:15432 |
-| Node.js | ✅ `package.json` 锁定 |
-
-### 4. 状态子系统（State）
-
-| 机制 | 用途 |
-|---|---|
-| `update_plan` | 当前步骤检查点 |
-| `.harness/PROGRESS.md` | 跨会话进度记录 |
-| `.harness/feature_list.json` | 功能状态跟踪 |
-| `git log` | 变更历史追溯 |
-
-### 5. 反馈子系统（Feedback）
-
-| 层级 | 命令 | 时间 |
-|---|---|---|
-| L1 编译 | `mvn compile -pl openhis-application -am` | <30 秒 |
-| L2 全链路 | 六环检查清单（见下文） | <5 分钟 |
-| L3 审查 | 你人工审查 diff | 10-30 分钟 |
-
---
-
-## 📋 标准工作循环
-
-```
-开始会话
-  │
-  ├→ 1. Init
-  │   ├── bash .harness/init.sh
-  │   ├── 读取 PROGRESS.md / feature_list.json
-  │   ├── git log --oneline -5
-  │   └── 确认编译通过
-  │
-  ├→ 2. Plan
-  │   ├── update_plan / checklist_write 分解步骤
-  │   ├── 评估复杂度/风险
-  │   └── 设定检查点
-  │
-  ├→ 3. Implement
-  │   ├── 一次只做一个功能
-  │   ├── 全链路检查清单核对
-  │   └── 增量修改，只动必要文件
-  │
-  ├→ 4. Verify
-  │   ├── L1: mvn compile
-  │   ├── L2: 全链路数据流验证
-  │   └── 生成变更摘要
-  │
-  └→ 5. Cleanup
-      ├── 运行 clean-state-checklist.md
-      ├── 更新 PROGRESS.md + feature_list.json
-      ├── git add + commit + push
-      └── init.sh 确认干净状态
-```
-
---
-
-## 🔗 全链路修复原则
-
-修 Bug 时，不得"就事论事"，必须走通完整的**数据流全链路**：
-
-### 六环检查清单
-
-```
-1. 录入   → 前端有无输入入口？（弹窗、行编辑、表单...）
-2. 保存   → 前端 → API → Controller → Service → Entity → DB，
-             每个保存入口都传了该字段吗？
-3. 查询   → DB → Mapper XML（UNION ALL 子查询统一加）→ DTO → 前端展示
-4. 修改   → 编辑回显 → 修改保存 → 正确更新？
-5. 删除   → 状态变更会丢失该字段吗？
-6. 关联   → 上下游（护士站、计费、打印、报表）需要同步改吗？
-```
-
-### 常见陷阱
-
-| 陷阱 | 解决 |
-|---|---|
-| 只修主入口，批量保存/签发保存漏了 | 检查所有 Service 实现类 |
-| 前端加了后端没传 | 逐个入口确认 |
-| UNION ALL 只改一半 | 所有子查询统一加 |
-| DTO 继承链没检查 | 检查父类/子类字段一致性 |
-| 只测新增没测编辑 | 新增和编辑都要测 |
-
---
-
-
-## 🚨 铁律（不可违反 — 来自实际 Bug 教训）
-
-### 状态值一致性
-涉及状态流转的 Bug，修改前**必须**列出完整链路并逐项检查：
-1. 枚举定义（如 `SlotStatus`、`OrderStatus`）的数值
-2. Service 层设置的状态值是否与枚举一致
-3. 查询/列表接口的状态映射是否覆盖所有枚举值
-4. 前端 `STATUS_CLASS_MAP` 是否包含新状态
-5. 前端过滤条件（`v-if`、`v-for`）是否兼容新状态
-6. 池/统计表的聚合 SQL 是否包含新状态值
-
-**禁止**：只改一端不检查其他端。必须全链路对齐。
-
-### 禁止删除源文件
- **绝对禁止**删除项目中已有的 Java/Vue/SQL 源文件
- 编译错误 → 修复错误，不删除文件
- 重复文件 → 重构合并，不删除文件
- AI 幻觉文件 → 检查 `git ls-tree baseline -- <file>` 确认后再删除
- **唯一例外**：人类明确确认删除
-
-### 全链路验证（状态流转 Bug 必做）
-修复后按以下顺序验证，**编译通过不等于修复完成**：
-```
-① 数据库：SELECT status FROM table WHERE id = ?  → 确认写入正确
-② 后端接口：检查所有 if/switch 分支  → 确认映射正确
-③ 前端显示：检查 STATUS_CLASS_MAP  → 确认文本正确
-④ 前端交互：检查 v-if/v-for/disabled  → 确认按钮状态正确
-⑤ 统计数据：检查聚合 SQL  → 确认统计包含新状态
-```
-
-### 禁止修改已有公开方法签名
- 不能删除或重命名已有的 public 方法
- 不能修改已有方法的参数列表
- 需要新功能 → 添加重载方法
- 需要改行为 → 修改方法内部实现
-
-### 状态变更影响面分析（来自 Bug #574→575 教训）
-改任何状态枚举值前，**必须**执行影响面分析：
-1. `rg "原状态枚举名" --type java` 列出所有引用文件
-2. 逐个检查：设置值？查询过滤？显示映射？统计聚合？
-3. 检查逆向流程：退号、取消、停诊是否兼容新状态
-4. 检查 XML mapper 中所有查询过滤条件
-5. 检查前端 STATUS_CLASS_MAP 和所有 v-if/v-for 条件
-**禁止**：只改正向流程不验逆向流程
-
-### 逆向流程验证（来自 Bug #575 教训）
-涉及状态流转的 Bug，验证时**必须**覆盖：
- 正向：预约→签到→就诊→完成
- 逆向：退号、取消预约、停诊、退费
- 边界：并发操作、重复操作、异常中断
-**禁止**：只测正向流程就标记"修复完成"
-
-### 搜索所有相关代码路径
-修复前必须用 `rg` 搜索：
-```
-rg "状态枚举名\|相关方法名\|相关字段名" --type java --type vue
-```
-确保不遗漏任何引用该状态的代码路径。
-
-## 📐 代码风格规范
-
-### Java 后端
-
-| 项目 | 规范 |
-|---|---|
-| 包结构 | `com.openhis`（业务）、`com.core`（核心） |
-| 命名 | 类 PascalCase、方法 camelCase、常量 SCREAMING_SNAKE_CASE |
-| 注解 | `@Slf4j`、`@Data`、`@Service/@Controller/@Repository` |
-| 异常 | 统一异常处理，业务异常继承 `RuntimeException` |
-| 缩进 | 4 空格，行 120 字符 |
-
-### Vue 前端
-
-| 项目 | 规范 |
-|---|---|
-| 框架 | Vue 3 + Composition API + Element Plus + Pinia |
-| 命名 | 组件 PascalCase、文件 kebab-case、变量 camelCase |
-| 缩进 | 2 空格，单引号，行 100 字符 |
+### Vue 前端规范
+- **框架**: Vue 3 + Composition API
+- **UI 库**: Element Plus
+- **状态管理**: Pinia
+- **路由**: Vue Router 4
+- **构建工具**: Vite 5
+- **组件命名**: PascalCase
+- **文件命名**: kebab-case
+- **变量命名**: camelCase
+- **常量命名**: SCREAMING_SNAKE_CASE
+- **函数命名**:
+  - 事件处理：`handle` 前缀
+  - 数据获取：`get`/`load` 前缀
+  - 提交操作：`submit` 前缀

 ### 导入顺序
+#### Java
+1. `java.*`
+2. `javax.*`
+3. 第三方库
+4. `com.core.*`
+5. `com.openhis.*`
+6. `*.*`（其他包）

-**Java：** `java.*` → `javax.*` → 第三方 → `com.core.*` → `com.openhis.*`
-**Vue：** `vue` 相关 → 第三方 → `@/` 别名 → 相对路径
+#### JavaScript/Vue
+1. `vue` 相关
+2. 第三方库
+3. `@/` 别名导入
+4. 相对路径导入

---
+### 代码格式
+#### Java
+- 缩进：4个空格
+- 行长度：120字符
+- 左大括号不换行

-## 🏗️ 开发约定
+#### Vue/JavaScript
+- 缩进：2个空格
+- 字符串：优先使用单引号
+- 行长度：100字符

-| 领域 | 约定 |
-|---|---|
-| API | RESTful，统一响应格式，Swagger 文档 |
-| 数据库 | snake_case 命名，主键 `id`，软删除 `valid_flag` |
-| 安全 | 所有 API 需权限验证，SQL 注入/XSS 防护 |
-| 性能 | Druid 连接池，路由懒加载，虚拟滚动 |
+## 关键配置文件

---
+### 后端配置
+- 主配置：`openhis-server-new/openhis-application/src/main/resources/application.yml`
+- 环境配置：`application-{profile}.yml`
+- Maven 父 POM：`openhis-server-new/pom.xml`

-## ⚙️ 关键配置
+### 前端配置
+- Vite 配置：`openhis-ui-vue3/vite.config.js`
+- 环境变量：`.env.*` 文件
+- 路由配置：`openhis-ui-vue3/src/router/index.js`

-| 项目 | 值 |
-|---|---|
-| 后端端口 | 18080 |
-| 前端端口 | 81 |
-| API 前缀 | `/openhis` |
-| Swagger | `/openhis/swagger-ui/index.html` |
-| 后端配置 | `application.yml` / `application-{profile}.yml` |
-| 前端配置 | `vite.config.js` / `.env.*` |
+## 开发约定

---
+### API 设计
+- RESTful API 风格
+- 统一响应格式
+- 使用 Swagger 文档
+- 错误码统一管理

-## 📈 过往 Bug 教训
+### 数据库
+- 表名：snake_case
+- 字段名：snake_case
+- 主键：使用 `id`
+- 软删除：使用 `valid_flag` 字段

-| Bug | 教训 |
-|---|---|
-| #574 | `checkInTicket()` 状态值写错（BOOKED→应为CHECKED_IN），前端映射缺失，池统计漏计。根因：没走完整状态链路 |
-| #574 | AI 智能体看到编译错误直接删文件，没检查 git baseline。根因：没验证文件来源 |
-| #574 | 多次 fallback 修复改错文件（OrderServiceImpl），没触及真正问题（TicketServiceImpl）。根因：没用 rg 搜索所有引用 |
+### 前端组件
+- 单一职责原则
+- Props 使用 camelCase
+- Events 使用 kebab-case
+- 使用 Composition API
+- 组件文档使用 JSDoc

-## 📈 成熟度追踪
+### 状态管理
+- 模块化设计
+- 异步操作使用 actions
+- 避免在组件中直接修改状态

-| 等级 | 特征 | 本项目 |
-|---|---|---|
-| **L1 初始** | 零星使用 AI 工具 | ✅ 已超越 |
-| **L2 管理** | 基础约束 + 反馈 + 控制 | ✅ **当前** |
-| **L3 定义** | 标准化、可复用 | 🔄 walkinglabs 5 子系统整合 |
-| **L4 量化** | 数据驱动优化 | ⏳ |
-| **L5 优化** | AI 自主优化 Harness | ⏳ |
+## 环境变量

---
+### 前端
+- `VITE_APP_BASE_API`: API 基础路径
+- `VITE_APP_ENV`: 环境标识

-## 📚 技能索引（Codex 内置）
+### 后端
+- `spring.profiles.active`: 激活的配置文件
+- `core.name`: 应用名称
+- `core.version`: 应用版本

-| 技能 | 用途 |
-|---|---|
-| `$harness-engineering` | 主方法论 — 约束 + 反馈 + 控制 + 持久 |
-| `$walkinglabs-harness` | 实战模式 — 5 子系统 + 模板 + 会话持续 |
-| `$durable-execution` | 检查点、幂等性、事件溯源 |
-| `$closed-loop-testing` | 质量门禁、测试策略、反馈循环 |
-| `$constraint-design` | DSL 设计、策略模式、约束编排 |
-| `$review-audit` | 审查工作流、审计追踪、合规检查 |
-| `$full-chain-fix` | 全链路数据流修复 |
-| `$karpathy-guidelines` | 减少 LLM 编码常见错误 |
+## 安全规范
+- 所有 API 接口需要权限验证
+- 敏感信息使用环境变量
+- SQL 注入防护
+- XSS 攻击防护

---
+## 性能优化
+- 后端使用连接池（Druid）
+- 前端使用路由懒加载
+- 图片使用 WebP 格式
+- 大列表使用虚拟滚动

-> **总纲：** 你负责"做什么"和"为什么"，Agent 负责"怎么做"和"做多好"
-> **工作循环：** Init → Plan → Implement → Verify → Cleanup
+## 常用工具类
+- 后端：`com.core.common.utils.*`
+- 前端：`@/utils/*`
+
+## 注意事项
+1. 修改数据库结构需要同步 SQL 脚本
+2. 新增功能需要添加权限配置
+3. 前端路由需要在权限系统中注册
+4. 接口变更需要更新 Swagger 文档
+5. 遵循现有代码风格，避免不必要的变化
+
+## 故障排除
+- 后端端口：18080
+- 前端端口：81
+- API 前缀：`/openhis`
+- Swagger UI：`/openhis/swagger-ui/index.html`
+- Druid 监控：`/openhis/druid/login.html`
--- a/deploy/deploy-frontend.ps1
+++ b/deploy/deploy-frontend.ps1
@@ -1,62 +0,0 @@
-# ============================================================
-# OpenHIS 前端部署脚本 (Windows PowerShell)
-# 用法: .\deploy-frontend.ps1 [-Env prod|test|staging|dev]
-# ============================================================
-param(
-    [ValidateSet("prod","test","staging","dev")]
-    [string]$Env = "prod"
-)
-
-$ErrorActionPreference = "Stop"
-$ProjectDir = Split-Path -Parent (Split-Path -Parent $MyInvocation.MyCommand.Path)
-$UiDir = "$ProjectDir\openhis-ui-vue3"
-$DistDir = "$UiDir\dist"
-
-Write-Host "==========================================" -ForegroundColor Cyan
-Write-Host " OpenHIS 前端部署" -ForegroundColor Cyan
-Write-Host " 环境: $Env" -ForegroundColor Cyan
-Write-Host " 目录: $UiDir" -ForegroundColor Cyan
-Write-Host "==========================================" -ForegroundColor Cyan
-
-# ---------- 1. 环境检查 ----------
-Write-Host "`n[1/5] 环境检查..." -ForegroundColor Yellow
-
-try { $nodeVer = node -v } catch { Write-Host "错误: 未找到 node" -ForegroundColor Red; exit 1 }
-try { $npmVer = npm -v } catch { Write-Host "错误: 未找到 npm" -ForegroundColor Red; exit 1 }
-
-$nodeMajor = [int]($nodeVer -replace 'v','' -split '\.')[0]
-if ($nodeMajor -lt 18) {
-    Write-Host "错误: Node.js >= 18，当前 $nodeVer" -ForegroundColor Red
-    exit 1
-}
-Write-Host "  Node.js: $nodeVer ✓"
-Write-Host "  npm:     $npmVer ✓"
-
-# ---------- 2. 安装依赖 ----------
-Write-Host "`n[2/5] 安装依赖..." -ForegroundColor Yellow
-Set-Location $UiDir
-npm install --legacy-peer-deps
-Write-Host "  依赖安装完成 ✓" -ForegroundColor Green
-
-# ---------- 3. 构建 ----------
-Write-Host "`n[3/5] 构建 ($Env)..." -ForegroundColor Yellow
-npm run "build:$Env"
-Write-Host "  构建完成 ✓" -ForegroundColor Green
-
-# ---------- 4. 产物信息 ----------
-Write-Host "`n[4/5] 构建产物:" -ForegroundColor Yellow
-$totalSize = (Get-ChildItem $DistDir -Recurse -File | Measure-Object -Property Length -Sum).Sum
-$fileCount = (Get-ChildItem $DistDir -Recurse -File).Count
-Write-Host "  路径: $DistDir"
-Write-Host "  大小: $([math]::Round($totalSize/1MB, 2)) MB"
-Write-Host "  文件: $fileCount 个"
-
-# ---------- 5. 部署提示 ----------
-Write-Host "`n[5/5] 后续操作:" -ForegroundColor Yellow
-Write-Host ""
-Write-Host "  将 $DistDir 目录内容上传到服务器 Nginx 根目录"
-Write-Host "  然后在服务器执行: nginx -s reload"
-Write-Host ""
-Write-Host "==========================================" -ForegroundColor Cyan
-Write-Host " 构建完成!" -ForegroundColor Green
-Write-Host "==========================================" -ForegroundColor Cyan
--- a/deploy/deploy-frontend.sh
+++ b/deploy/deploy-frontend.sh
@@ -1,84 +0,0 @@
-#!/bin/bash
-# ============================================================
-# OpenHIS 前端部署脚本
-# 用法: bash deploy-frontend.sh [prod|test|staging|dev]
-# 默认: prod
-# ============================================================
-set -e
-
-MODE=${1:-prod}
-PROJECT_DIR=$(cd "$(dirname "$0")/.." && pwd)
-UI_DIR="$PROJECT_DIR/openhis-ui-vue3"
-DIST_DIR="$UI_DIR/dist"
-
-echo "=========================================="
-echo " OpenHIS 前端部署"
-echo " 环境: $MODE"
-echo " 目录: $UI_DIR"
-echo "=========================================="
-
-# ---------- 1. 环境检查 ----------
-echo ""
-echo "[1/5] 环境检查..."
-
-check_cmd() {
-  if ! command -v "$1" &> /dev/null; then
-    echo "错误: 未找到 $1，请先安装"
-    exit 1
-  fi
-}
-
-check_cmd node
-check_cmd npm
-
-NODE_VER=$(node -v | sed 's/v//' | cut -d. -f1)
-if [ "$NODE_VER" -lt 18 ]; then
-  echo "错误: Node.js 版本需要 >= 18，当前: $(node -v)"
-  exit 1
-fi
-
-echo "  Node.js: $(node -v) ✓"
-echo "  npm:     $(npm -v) ✓"
-
-# ---------- 2. 安装依赖 ----------
-echo ""
-echo "[2/5] 安装依赖..."
-cd "$UI_DIR"
-
-# 清理旧的 node_modules（可选，取消注释启用）
-# echo "  清理旧依赖..."
-# rm -rf node_modules package-lock.json
-
-npm install --production=false --legacy-peer-deps
-echo "  依赖安装完成 ✓"
-
-# ---------- 3. 构建 ----------
-echo ""
-echo "[3/5] 构建 ($MODE)..."
-npm run "build:$MODE"
-echo "  构建完成 ✓"
-
-# ---------- 4. 产物信息 ----------
-echo ""
-echo "[4/5] 构建产物:"
-TOTAL_SIZE=$(du -sh "$DIST_DIR" 2>/dev/null | cut -f1)
-FILE_COUNT=$(find "$DIST_DIR" -type f | wc -l)
-echo "  路径: $DIST_DIR"
-echo "  大小: $TOTAL_SIZE"
-echo "  文件: $FILE_COUNT 个"
-
-# ---------- 5. 部署提示 ----------
-echo ""
-echo "[5/5] 部署方式:"
-echo ""
-echo "  方式一: 复制到 Nginx"
-echo "    cp -r $DIST_DIR/* /usr/share/nginx/html/openhis/"
-echo "    nginx -s reload"
-echo ""
-echo "  方式二: 软链接（推荐，方便更新）"
-echo "    ln -sfn $DIST_DIR /usr/share/nginx/html/openhis"
-echo "    nginx -s reload"
-echo ""
-echo "=========================================="
-echo " 部署完成!"
-echo "=========================================="
--- a/deploy/fix-deps.sh
+++ b/deploy/fix-deps.sh
@@ -1,81 +0,0 @@
-# ============================================================
-# OpenHIS 前端依赖问题排查与修复脚本
-# 用法: bash fix-deps.sh
-# ============================================================
-set -e
-
-PROJECT_DIR=$(cd "$(dirname "$0")/.." && pwd)
-UI_DIR="$PROJECT_DIR/openhis-ui-vue3"
-
-cd "$UI_DIR"
-
-echo "=========================================="
-echo " OpenHIS 前端依赖诊断"
-echo "=========================================="
-echo ""
-
-# 检查 node_modules 是否存在
-if [ ! -d "node_modules" ]; then
-  echo "[!] node_modules 不存在，执行 npm install..."
-  npm install --legacy-peer-deps
-  exit 0
-fi
-
-# 检查 package-lock.json 是否存在
-if [ ! -f "package-lock.json" ]; then
-  echo "[!] package-lock.json 缺失，重新生成..."
-  npm install --legacy-peer-deps
-fi
-
-# 检查关键依赖
-echo "检查关键依赖:"
-DEPS=("vue" "vite" "vxe-table" "element-plus" "pinia" "vue-router" "axios" "dayjs")
-for dep in "${DEPS[@]}"; do
-  if [ -d "node_modules/$dep" ]; then
-    VER=$(node -p "require('./node_modules/$dep/package.json').version" 2>/dev/null || echo "未知")
-    echo "  ✓ $dep@$VER"
-  else
-    echo "  ✗ $dep 缺失!"
-  fi
-done
-
-echo ""
-
-# 检查过时依赖
-echo "检查过时依赖 (可选升级):"
-npm outdated 2>/dev/null || true
-
-echo ""
-
-# 常见问题修复菜单
-echo "=========================================="
-echo " 修复选项:"
-echo "  1) 重新安装依赖 (rm node_modules + npm install)"
-echo "  2) 清理缓存并重装 (npm cache clean + 重装)"
-echo "  3) 修复 peer 依赖冲突 (npm install --legacy-peer-deps)"
-echo "  4) 退出"
-echo "=========================================="
-read -p "选择 [1-4]: " choice
-
-case $choice in
-  1)
-    echo "清理 node_modules..."
-    rm -rf node_modules package-lock.json
-    npm install --legacy-peer-deps
-    ;;
-  2)
-    echo "清理缓存..."
-    npm cache clean --force
-    rm -rf node_modules package-lock.json
-    npm install --legacy-peer-deps
-    ;;
-  3)
-    npm install --legacy-peer-deps
-    ;;
-  *)
-    echo "退出"
-    ;;
-esac
-
-echo ""
-echo "完成 ✓"
--- a/deploy/nginx-openhis.conf
+++ b/deploy/nginx-openhis.conf
@@ -1,48 +0,0 @@
-# ============================================================
-# OpenHIS 前端 Nginx 配置
-# 放到 /etc/nginx/conf.d/openhis.conf 或 include 到 nginx.conf
-# ============================================================
-
-server {
-    listen       80;
-    server_name  openhis.local;  # 改成实际域名或 IP
-
-    # 前端静态文件
-    location / {
-        root   /usr/share/nginx/html/openhis;
-        index  index.html;
-        try_files $uri $uri/ /index.html;  # SPA 路由回退
-    }
-
-    # 后端 API 代理
-    location /prd-api/ {
-        proxy_pass http://127.0.0.1:18080/openhis/;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_connect_timeout 300;
-        proxy_read_timeout    300;
-        client_max_body_size  50m;
-    }
-
-    # gzip 压缩（Vite 构建已生成 .gz 文件，Nginx 直接发送）
-    gzip on;
-    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript image/svg+xml;
-    gzip_min_length 1024;
-    gzip_comp_level 6;
-    gzip_vary on;
-
-    # 静态资源缓存（带 hash 的文件长期缓存）
-    location ~* /assets/.*\.(js|css|woff2?|ttf|eot|png|jpg|jpeg|gif|svg|ico)$ {
-        root /usr/share/nginx/html/openhis;
-        expires 365d;
-        add_header Cache-Control "public, immutable";
-    }
-
-    # index.html 不缓存（保证更新及时生效）
-    location = /index.html {
-        root /usr/share/nginx/html/openhis;
-        add_header Cache-Control "no-cache, no-store, must-revalidate";
-    }
-}
--- a/docs/bug-fixes/bug-632.md
+++ b/docs/bug-fixes/bug-632.md
@@ -1,33 +0,0 @@
-# Bug #632 修复报告
-
-## 基本信息
- **标题**: Bug #632 测试完成，请验收。提出人: chenxj。
- **严重程度**: 待查
- **提出人**: chenxj
- **修复时间**: 15:49:42 ~ 16:01:30
- **修复耗时**: 662.1s
- **Commit**: `213568233222`
-
-## 根因分析
-Bug #632 修复完成。核心问题是 JavaScript `&&` 运算符的经典陷阱——当所有条件为 truthy 时，`&&` 返回最后一个操作数（`item.packageName` 字符串 `"肝功能12项"`），而非 `true`。两处 `Boolean()` 强制转换确保 `isPackage` 始终为布尔值。
-  |  #
-
-## 修复文件
- .../src/main/java/com/openhis/lab/domain/InspectionPackage.java        | 3 +++
- .../src/main/java/com/openhis/lab/domain/InspectionPackageDetail.java  | 3 +++
-
-## 流程时间线
-| 时间 | 智能体 | 事件 | 状态 | 耗时 |
-|------|--------|------|------|------|
-| 15:49:42 | guanyu | fix_start | ⏳ | 0.0s |
-| 16:01:30 | guanyu | fix_done | ✅ | 662.1s |
-| 16:01:36 | zhugeliang | analyze_done | ✅ | 0.0s |
-|------|--------|------|------|------|
-| 16:01:38 | chenlin | doc_done | ✅ | <1s |
-
-## 测试结果
- **结果**: ❌ FAIL
- **输出**: 
-
-## 全流程完成
-诸葛亮分析 → guanyu 修复 → 张飞测试 → 华佗验收 → 陈琳归档
--- a/docs/bug-fixes/bug-634.md
+++ b/docs/bug-fixes/bug-634.md
@@ -1,35 +0,0 @@
-# Bug #634 修复报告
-
-## 基本信息
- **标题**: [系统维护-检验套餐] 保存套餐失败，报 JSON 反序列化日期解析异常 (LocalDateTime)
- **严重程度**: 致命
- **提出人**: chenxj
- **修复时间**: 15:21:28 ~ 15:27:25
- **修复耗时**: 357.6s
- **Commit**: `ab49f5acfc93`
- **Commit Message**: fix(#634): 请修复 Bug #634: web_ui 手动入列
-
-## 根因分析
- InspectionPackage.java 和 InspectionPackageDetail.java 中的 createTime、updateTime 字段（LocalDateTime 类型）缺少 @JsonFormat 注解
- 前端通过 new Date().toISOString() 发送 ISO 8601 格式日期字符串（含毫秒 + Z 时区后缀），Jackson 反序列化失败
-
-## 修复文件
- .../core/framework/config/ApplicationConfig.java   | 37 ++++++++++++++++++++--
- 1 file changed, 35 insertions(+), 2 deletions(-)
-
-## 流程时间线
-| 时间 | 智能体 | 事件 | 状态 | 耗时 |
-|------|--------|------|------|------|
-| 15:21:28 | guanyu | fix_start | ⏳ | - |
-| 15:27:25 | guanyu | fix_done | ✅ | 357.6s |
-| 15:27:28 | zhugeliang | analyze_done | ✅ | 0.0s |
-| 15:27:31 | zhangfei | test_done | ✅ | 0.0s |
-| 15:27:33 | huatuo | verify_done | ✅ | 0.0s |
-| 15:27:33 | chenlin | doc_done | ✅ | 0.0s |
-
-## 测试结果
- **结果**: ✅ PASS
- **Playwright**: @bug634 无头浏览器测试通过
-
-## 全流程完成
-诸葛亮分析 → guanyu 修复 → 张飞测试 → 华佗验收 → 陈琳归档
--- a/docs/bug-fixes/bug-644.md
+++ b/docs/bug-fixes/bug-644.md
@@ -1,32 +0,0 @@
-# Bug #644 修复报告
-
-## 基本信息
- **标题**: Bug #644 测试完成，请验收。提出人: chenxj。
- **提出人**: chenxj
- **修复时间**: 00:24:37 ~ 00:32:06
- **修复耗时**: 347.9s
- **Commit**: `bd50c58dd`
- **测试结果**: ❌ FAIL
-
-## 根因分析
-## 变更摘要
-
-### 根因分析
-
-**Issue 1 — 状态不同步**：`getInpatientAdvicePage` 方法中，执行记录（`exePerformRecordList`）的计算被包裹在 `if (exeStatus != null)` 条件内，只有在"医嘱执行"页签（传 `exeStatus` 参数）时才计算。"已校对"页签不传 `exeStatus`，因此执行记录永远不会被
-
-## 修复文件
- .../impl/AdviceProcessAppServiceImpl.java          | 89 +++++++++++++++-------
- .../dto/InpatientAdviceDto.java                    |  3 +
-
-## 流程时间线
-| 时间 | 智能体 | 事件 | 状态 | 耗时 |
-|------|--------|------|------|------|
-| 00:24:37 | guanyu | fix_start | ⏳ | 0.0s |
-| 00:25:39 | guanyu | fix_retry | ❓ | 0.0s |
-| 00:32:06 | guanyu | fix_done | ✅ | 347.9s |
-| 00:32:09 | zhugeliang | analyze_done | ✅ | 0.0s |
-| 00:32:11 | chenlin | doc_done | ✅ | <1s |
-
-## 全流程
-诸葛亮分析 → guanyu 修复 → 张飞测试 → 华佗验收 → 陈琳归档
--- a/2
+++ b/2
--- a/openhis-server-new/core-framework/src/main/java/com/core/framework/config/ApplicationConfig.java
+++ b/openhis-server-new/core-framework/src/main/java/com/core/framework/config/ApplicationConfig.java
@@ -1,8 +1,5 @@
 package com.core.framework.config;

-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import org.mybatis.spring.annotation.MapperScan;
@@ -11,7 +8,6 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;

-import java.io.IOException;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.TimeZone;
@@ -27,36 +23,6 @@ import java.util.TimeZone;
 // 指定要扫描的Mapper类的包的路径
@MapperScan({"com.core.**.mapper", "com.openhis.**.mapper"})
 public class ApplicationConfig {
-
-    /** 支持多种日期格式的反序列化器 */
-    private static final JsonDeserializer<LocalDateTime> LOCAL_DATE_TIME_DESERIALIZER = new JsonDeserializer<LocalDateTime>() {
-        private static final DateTimeFormatter ISO_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
-        private static final DateTimeFormatter SIMPLE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-        private static final DateTimeFormatter SLASH_FORMATTER = DateTimeFormatter.ofPattern("yyyy/M/d HH:mm:ss");
-
-        @Override
-        public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
-            String text = p.getText();
-            if (text == null || text.isEmpty()) {
-                return null;
-            }
-            // 去除时区后缀 Z/z 和偏移量 +HH:MM/+HHMM（LocalDateTime 不含时区信息）
-            String cleaned = text.replaceAll("[Zz]$", "").replaceAll("[+-]\\d{2}:?\\d{2}$", "");
-            // 尝试 ISO 8601 格式（yyyy-MM-ddTHH:mm:ss.SSS）
-            try {
-                return LocalDateTime.parse(cleaned, ISO_FORMATTER);
-            } catch (Exception ignored) {
-            }
-            // 尝试简单格式（yyyy-MM-dd HH:mm:ss）
-            try {
-                return LocalDateTime.parse(cleaned, SIMPLE_FORMATTER);
-            } catch (Exception ignored) {
-            }
-            // 尝试斜杠格式（yyyy/M/d HH:mm:ss）
-            return LocalDateTime.parse(cleaned, SLASH_FORMATTER);
-        }
-    };
-
    /**
     * 时区配置
     */
@@ -68,9 +34,7 @@ public class ApplicationConfig {
            // 设置日期格式为 yyyy/M/d HH:mm:ss，支持多种格式反序列化
            builder.simpleDateFormat("yyyy/M/d HH:mm:ss");
            // 添加JavaTimeModule支持，用于LocalDateTime
-            JavaTimeModule javaTimeModule = new JavaTimeModule();
-            javaTimeModule.addDeserializer(LocalDateTime.class, LOCAL_DATE_TIME_DESERIALIZER);
-            builder.modules(javaTimeModule);
+            builder.modules(new JavaTimeModule());
            builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy/M/d HH:mm:ss")));
        };
    }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/Inspection/dto/InstrumentManageInitDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/Inspection/dto/InstrumentManageInitDto.java
@@ -1,7 +1,7 @@
 package com.openhis.web.Inspection.dto;

-import lombok.Getter;
-import lombok.Setter;
+import lombok.Data;
+import lombok.experimental.Accessors;

 import java.util.List;

@@ -11,17 +11,30 @@ import java.util.List;
 * @author
 * @date
 */
-@Getter
-@Setter
+@Data
+@Accessors(chain = true)
 public class InstrumentManageInitDto {
    private List<statusEnumOption> statusFlagOptions;
-    private List<InstrumentType> instrumentTypeList;
-    private List<InstrumentStatusEnumOption> instrumentStatusEnumList;
+    private List<InstrumentType> InstrumentTypeList;
+    private List<InstrumentStatusEnumOption> InstrumentStatusEnumList;
+
+    // 手动添加 setter 方法
+    public void setStatusFlagOptions(List<statusEnumOption> statusFlagOptions) {
+        this.statusFlagOptions = statusFlagOptions;
+    }
+
+    public void setInstrumentTypeList(List<InstrumentType> InstrumentTypeList) {
+        this.InstrumentTypeList = InstrumentTypeList;
+    }
+
+    public void setInstrumentStatusEnumList(List<InstrumentStatusEnumOption> InstrumentStatusEnumList) {
+        this.InstrumentStatusEnumList = InstrumentStatusEnumList;
+    }

    /**
     * 状态
     */
-    @Getter
+    @Data
    public static class statusEnumOption {
        private Integer value;
        private String info;
@@ -31,7 +44,7 @@ public class InstrumentManageInitDto {
        }
    }

-    @Getter
+    @Data
    public static class InstrumentStatusEnumOption {
        private Integer value;
        private String info;
@@ -41,7 +54,7 @@ public class InstrumentManageInitDto {
        }
    }

-    @Getter
+    @Data
    public static class InstrumentType {
        private Integer value;
        private String info;
@@ -50,4 +63,6 @@ public class InstrumentManageInitDto {
            this.info = info;
        }
    }
+
+
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/impl/TicketAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/impl/TicketAppServiceImpl.java
@@ -199,7 +199,7 @@ public class TicketAppServiceImpl implements ITicketAppService {
                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
                                dto.setStatus("已退号");
                            } else {
-                                dto.setStatus("已预约");
+                                dto.setStatus("已锁定");
                            }
                        } else if (status == SlotStatus.BOOKED) {
                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
@@ -207,12 +207,6 @@ public class TicketAppServiceImpl implements ITicketAppService {
                            } else {
                                dto.setStatus("已取号");
                            }
-                        } else if (status == SlotStatus.CHECKED_IN) {
-                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
-                                dto.setStatus("已退号");
-                            } else {
-                                dto.setStatus("已签到");
-                            }
                        } else if (status == SlotStatus.CANCELLED) {
                            dto.setStatus("已停诊");
                        } else if (status == SlotStatus.RETURNED) {
@@ -386,7 +380,7 @@ public class TicketAppServiceImpl implements ITicketAppService {
                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
                                dto.setStatus("已退号");
                            } else {
-                                dto.setStatus("已预约");
+                                dto.setStatus("已锁定");
                            }
                        } else if (status == SlotStatus.BOOKED) {
                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
@@ -394,12 +388,6 @@ public class TicketAppServiceImpl implements ITicketAppService {
                            } else {
                                dto.setStatus("已取号");
                            }
-                        } else if (status == SlotStatus.CHECKED_IN) {
-                            if (OrderStatus.PATIENT_CANCELLED.getValue().equals(raw.getOrderStatus())) {
-                                dto.setStatus("已退号");
-                            } else {
-                                dto.setStatus("已签到");
-                            }
                        } else if (status == SlotStatus.CANCELLED) {
                            dto.setStatus("已停诊");
                        } else if (status == SlotStatus.RETURNED) {
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/basedatamanage/appservice/impl/OrganizationLocationAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/basedatamanage/appservice/impl/OrganizationLocationAppServiceImpl.java
@@ -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() : ("科室[" + organizationLocation.getOrganizationId() + "]已删除");
+                    String organizationName = org != null ? org.getName() : "已删除科室(ID:" + organizationLocation.getOrganizationId() + ")";
                    return R.fail("当前诊疗：" + activityName + CommonConstants.Common.DASH + orgLoc.getStartTime()
                        + CommonConstants.Common.DASH + orgLoc.getEndTime() + "与" + organizationName + "时间冲突");
                }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/basedatamanage/dto/OrgLocQueryParam.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/basedatamanage/dto/OrgLocQueryParam.java
@@ -31,9 +31,4 @@ public class OrgLocQueryParam implements Serializable {
    /** 发放类别 */
    private String distributionCategoryCode;

-    /**
-     * 项目编码 | 药品:1 耗材:2
-     */
-    private String itemCode;
-
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/IOutpatientRegistrationAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/IOutpatientRegistrationAppService.java
@@ -48,11 +48,6 @@ public interface IOutpatientRegistrationAppService {
    IPage<PractitionerMetadata> getPractitionerMetadataByLocationId(Long orgId, String searchKey, Integer pageNo,
        Integer pageSize);

-    /**
-     * 查询全院医生（不限科室），按角色过滤
-     */
-    IPage<PractitionerMetadata> getAllDoctors(String searchKey, Integer pageNo, Integer pageSize);
-
    /**
     * 根据机构id筛选服务项目
     *
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientRegistrationAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientRegistrationAppServiceImpl.java
@@ -243,22 +243,6 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
        return practitionerMetadataPage;
    }

-    /**
-     * 查询全院医生（不限科室），按角色过滤
-     */
-    @Override
-    public IPage<PractitionerMetadata> getAllDoctors(String searchKey, Integer pageNo, Integer pageSize) {
-        QueryWrapper<PractitionerMetadata> queryWrapper = HisQueryUtils.buildQueryWrapper(null, searchKey,
-            new HashSet<>(Arrays.asList("name", "py_str", "wb_str")), null);
-        IPage<PractitionerMetadata> page =
-            outpatientRegistrationAppMapper.getAllDoctorPage(new Page<>(pageNo, pageSize),
-                PractitionerRoles.DOCTOR.getCode(), queryWrapper);
-        page.getRecords().forEach(e -> {
-            e.setGenderEnum_enumText(EnumUtils.getInfoByValue(AdministrativeGender.class, e.getGenderEnum()));
-        });
-        return page;
-    }
-
    /**
     * 根据机构id筛选服务项目
     *
@@ -676,12 +660,10 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
                return appointmentOrder.getId();
            }

-            // 已预约(1)或已签到(3)的号源都能退号
+            // 只有已预约(1)的号源才能退号，对应签到后的 BOOKED 状态
            ScheduleSlot slot = scheduleSlotMapper.selectById(slotId);
-            if (slot == null || 
-                (!SlotStatus.BOOKED.getValue().equals(slot.getStatus()) && 
-                 !SlotStatus.CHECKED_IN.getValue().equals(slot.getStatus()))) {
-                log.warn("退号跳过：槽位状态不允许退号, slotId={}, status={}", slotId,
+            if (slot == null || !SlotStatus.BOOKED.getValue().equals(slot.getStatus())) {
+                log.warn("退号跳过：槽位非已预约状态, slotId={}, status={}", slotId,
                    slot != null ? slot.getStatus() : null);
                return appointmentOrder.getId();
            }
@@ -694,8 +676,11 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra

            Long poolId = scheduleSlotMapper.selectPoolIdBySlotId(slotId);
            if (poolId != null) {
-                // 退号时刷新池统计（兼容 BOOKED 和 CHECKED_IN 状态）
-                schedulePoolMapper.refreshPoolStats(poolId, SlotStatus.BOOKED.getValue(), SlotStatus.LOCKED.getValue());
+                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) {
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/controller/OutpatientRegistrationController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/controller/OutpatientRegistrationController.java
@@ -87,17 +87,6 @@ public class OutpatientRegistrationController {
            iOutpatientRegistrationAppService.getPractitionerMetadataByLocationId(orgId, searchKey, pageNo, pageSize));
    }

-    /**
-     * 查询全院医生（不限科室），用于手术申请等需跨科室选择医生的场景
-     */
-    @GetMapping(value = "/all-doctors")
-    public R<?> getAllDoctors(
-        @RequestParam(value = "searchKey", defaultValue = "") String searchKey,
-        @RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
-        @RequestParam(value = "pageSize", defaultValue = "20") Integer pageSize) {
-        return R.ok(iOutpatientRegistrationAppService.getAllDoctors(searchKey, pageNo, pageSize));
-    }
-
    /**
     * 根据机构id筛选服务项目
     */
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/mapper/OutpatientRegistrationAppMapper.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/mapper/OutpatientRegistrationAppMapper.java
@@ -24,13 +24,6 @@ public interface OutpatientRegistrationAppMapper {
        @Param("orgId") Long orgId, @Param("RoleCode") String RoleCode,
        @Param(Constants.WRAPPER) QueryWrapper<PractitionerMetadata> queryWrapper);

-    /**
-     * 查询全院医生（不限科室），按角色过滤
-     */
-    IPage<PractitionerMetadata> getAllDoctorPage(@Param("page") Page<PractitionerMetadata> page,
-        @Param("RoleCode") String RoleCode,
-        @Param(Constants.WRAPPER) QueryWrapper<PractitionerMetadata> queryWrapper);
-
    /**
     * 根据病人id和科室id查询当日挂号次数
     */
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/appservice/impl/SurgeryAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/appservice/impl/SurgeryAppServiceImpl.java
@@ -39,7 +39,6 @@ import com.openhis.web.clinicalmanage.appservice.ISurgeryAppService;
 import com.openhis.web.clinicalmanage.dto.SurgeryDto;
 import com.openhis.web.clinicalmanage.mapper.SurgeryAppMapper;
 import com.openhis.workflow.domain.ServiceRequest;
-import com.openhis.workflow.domain.ActivityDefinition;
 import com.openhis.workflow.service.IActivityDefinitionService;
 import com.openhis.workflow.service.IServiceRequestService;
 import org.springframework.beans.BeanUtils;
@@ -366,21 +365,7 @@ public class SurgeryAppServiceImpl implements ISurgeryAppService {
        serviceRequest.setPrescriptionNo(prescriptionNo);
        serviceRequest.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue());// 治疗类型
        serviceRequest.setQuantity(BigDecimal.valueOf(1)); // 请求数量
-        // 从诊疗目录获取使用单位，避免硬编码
-        String unitCode = "次"; // 默认值
-        String surgeryCode = surgeryDto.getSurgeryCode();
-        if (surgeryCode != null && !surgeryCode.isEmpty()) {
-            ActivityDefinition activityDef = activityDefinitionService.getOne(
-                new LambdaQueryWrapper<ActivityDefinition>()
-                    .eq(ActivityDefinition::getBusNo, surgeryCode)
-                    .eq(ActivityDefinition::getCategoryCode, "24")
-            );
-            if (activityDef != null && activityDef.getPermittedUnitCode() != null
-                && !activityDef.getPermittedUnitCode().isEmpty()) {
-                unitCode = activityDef.getPermittedUnitCode();
-            }
-        }
-        serviceRequest.setUnitCode(unitCode); // 请求单位编码
+        serviceRequest.setUnitCode("次"); // 请求单位编码
        serviceRequest.setCategoryEnum(24); // 请求类型：24-手术（新值域，避开 adviceType 碰撞）
        serviceRequest.setActivityId(surgeryId); // 手术ID作为诊疗定义id
        serviceRequest.setPatientId(surgeryDto.getPatientId()); // 患者
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/appservice/impl/SurgicalScheduleAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/appservice/impl/SurgicalScheduleAppServiceImpl.java
@@ -215,9 +215,6 @@ public class SurgicalScheduleAppServiceImpl implements ISurgicalScheduleAppServi
                if (surgery != null) {
                    surgery.setStatusEnum(1); // 1 = 已排期
                    surgery.setUpdateTime(new Date());
-                    // Bug #558: 手术安排时同步写入手术室确认时间和确认人
-                    surgery.setOperatingRoomConfirmTime(new Date());
-                    surgery.setOperatingRoomConfirmUser(loginUser.getUsername());
                    
                    // 填充缺失的申请科室和主刀医生名称
                    fillSurgeryMissingNames(surgery);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/common/dto/PerformInfoDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/common/dto/PerformInfoDto.java
@@ -36,7 +36,4 @@ public class PerformInfoDto {
    /** 分组id */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long groupId;
-
-    /** 退回原因 */
-    private String backReason;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/IDoctorStationAdviceAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/IDoctorStationAdviceAppService.java
@@ -147,6 +147,6 @@ public interface IDoctorStationAdviceAppService {
     */
    IPage<SurgeryItemDto> getSurgeryPage(Long organizationId, Integer pageNo, Integer pageSize, String searchKey);

-    IPage<SurgeryItemDto> getExaminationPage(Long organizationId, Integer pageNo, Integer pageSize, String searchKey, String categoryCode);
+    IPage<SurgeryItemDto> getExaminationPage(Long organizationId, Integer pageNo, Integer pageSize, String searchKey);

 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/IDoctorStationEmrAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/IDoctorStationEmrAppService.java
@@ -63,21 +63,17 @@ public interface IDoctorStationEmrAppService {
     * 获取待写病历列表
     *
     * @param doctorId 医生ID
-     * @param pageNo 当前页码
-     * @param pageSize 每页条数
-     * @param patientName 患者姓名（可选）
-     * @return 待写病历分页数据
+     * @return 待写病历列表
     */
-    R<?> getPendingEmrList(Long doctorId, Integer pageNo, Integer pageSize, String patientName);
+    R<?> getPendingEmrList(Long doctorId);

    /**
     * 获取待写病历数量
     *
     * @param doctorId 医生ID
-     * @param patientName 患者姓名（可选）
     * @return 待写病历数量
     */
-    R<?> getPendingEmrCount(Long doctorId, String patientName);
+    R<?> getPendingEmrCount(Long doctorId);

    /**
     * 检查患者是否需要写病历
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java
@@ -14,7 +14,6 @@ import com.core.common.exception.ServiceException;
 import com.core.common.utils.AssignSeqUtil;
 import com.core.common.utils.MessageUtils;
 import com.core.common.utils.SecurityUtils;
-import com.core.common.utils.DictUtils;
 import com.core.common.utils.StringUtils;
 import com.core.web.util.TenantOptionUtil;
 import com.openhis.administration.domain.Account;
@@ -49,9 +48,6 @@ import com.openhis.web.personalization.dto.ActivityDeviceDto;
 import com.openhis.workflow.domain.ActivityDefinition;
 import com.openhis.workflow.domain.DeviceRequest;
 import com.openhis.workflow.domain.InventoryItem;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.openhis.workflow.domain.ServiceRequest;
 import com.openhis.workflow.service.*;
 import lombok.extern.slf4j.Slf4j;
@@ -950,27 +946,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
    /**
     * 处理药品
     */
-
-    /**
-     * 将 remark 合并到 contentJson 中，确保 Mapper 能从 content_json 提取 remark
-     */
-    private String injectRemarkIntoContentJson(String contentJson, String remark) {
-        if (remark == null || remark.isEmpty() || contentJson == null || contentJson.isEmpty()) {
-            return contentJson;
-        }
-        try {
-            ObjectMapper mapper = new ObjectMapper();
-            JsonNode node = mapper.readTree(contentJson);
-            if (node instanceof ObjectNode) {
-                ((ObjectNode) node).put("remark", remark);
-                return mapper.writeValueAsString(node);
-            }
-        } catch (Exception e) {
-            log.warn("Failed to inject remark into contentJson: {}", e.getMessage());
-        }
-        return contentJson;
-    }
-
    private List<String> handMedication(List<AdviceSaveDto> medicineList, Date curDate, String adviceOpType,
            Long organizationId, String signCode) {
        // 当前登录账号的科室id
@@ -1187,10 +1162,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
            if (medicationRequest.getId() == null) {
                firstTimeSave = true;
            }
-            // 确保 contentJson 包含 remark
-            if (adviceSaveDto.getRemark() != null && !adviceSaveDto.getRemark().isEmpty()) {
-                medicationRequest.setContentJson(injectRemarkIntoContentJson(medicationRequest.getContentJson(), adviceSaveDto.getRemark()));
-            }
            iMedicationRequestService.saveOrUpdate(medicationRequest);
            if (firstTimeSave) {
                medRequestIdList.add(medicationRequest.getId().toString());
@@ -1651,10 +1622,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
            deviceRequest.setConditionId(adviceSaveDto.getConditionId()); // 诊断id
            deviceRequest.setEncounterDiagnosisId(adviceSaveDto.getEncounterDiagnosisId()); // 就诊诊断id

-            // 确保 contentJson 包含 remark
-            if (adviceSaveDto.getRemark() != null && !adviceSaveDto.getRemark().isEmpty()) {
-                deviceRequest.setContentJson(injectRemarkIntoContentJson(deviceRequest.getContentJson(), adviceSaveDto.getRemark()));
-            }
            iDeviceRequestService.saveOrUpdate(deviceRequest);
            if (is_save) {
                // 处理耗材发放
@@ -1921,7 +1888,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                    Surgery surgery = iSurgeryService.getOne(
                        new LambdaQueryWrapper<Surgery>()
                            .eq(Surgery::getSurgeryNo, prescriptionNo)
-                            .and(w -> w.isNull(Surgery::getDeleteFlag).or().eq(Surgery::getDeleteFlag, "0")).last("LIMIT 1"));
+                            .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());
@@ -2066,9 +2033,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                serviceRequest.setBasedOnTable(CommonConstants.TableName.MED_MEDICATION_REQUEST);
            }

-            // 备注
-            serviceRequest.setRemark(adviceSaveDto.getRemark());
-
            iServiceRequestService.saveOrUpdate(serviceRequest);

            // 保存时保存诊疗费用项
@@ -2187,7 +2151,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                            .eq(ChargeItem::getServiceId, adviceSaveDto.getRequestId())
                            .eq(ChargeItem::getServiceTable, CommonConstants.TableName.WOR_SERVICE_REQUEST)
                            .eq(ChargeItem::getDeleteFlag, DelFlag.NO.getCode())
-                    .last("LIMIT 1"));
+                    );
                    log.info("BugFix#328: 通过requestId查询费用项，requestId={}, chargeItem={}", 
                            adviceSaveDto.getRequestId(), existingChargeItem != null ? existingChargeItem.getId() : "null");
                }
@@ -2228,6 +2192,11 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                CommonConstants.TableName.MED_MEDICATION_REQUEST, CommonConstants.TableName.WOR_DEVICE_REQUEST,
                CommonConstants.TableName.WOR_SERVICE_REQUEST, practitionerId, Whether.NO.getCode(),
                sourceEnum, sourceBillNo);
+        // 手术计费场景：sourceBillNo 不为空时，过滤掉药品（1），保留耗材（2）和诊疗（3/6）
+        if (sourceBillNo != null && !sourceBillNo.isEmpty()) {
+            requestBaseInfo.removeIf(dto -> dto.getAdviceType() != null
+                    && dto.getAdviceType() == 1);
+        }
        for (RequestBaseDto requestBaseDto : requestBaseInfo) {
            // 请求状态
            requestBaseDto
@@ -2241,15 +2210,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
            // 收费状态
            requestBaseDto.setChargeStatus_enumText(
                    EnumUtils.getInfoByValue(ChargeItemStatus.class, requestBaseDto.getChargeStatus()));
-            // 单位字典翻译：优先通过 unit_code 字典翻译编码值，失败时回退使用原始值
-            if (StringUtils.isNotBlank(requestBaseDto.getUnitCode()) && StringUtils.isBlank(requestBaseDto.getUnitCode_dictText())) {
-                String dictLabel = DictUtils.getDictLabel("unit_code", requestBaseDto.getUnitCode());
-                if (StringUtils.isNotBlank(dictLabel)) {
-                    requestBaseDto.setUnitCode_dictText(dictLabel);
-                } else {
-                    requestBaseDto.setUnitCode_dictText(requestBaseDto.getUnitCode());
-                }
-            }
        }
        return R.ok(requestBaseInfo);
    }
@@ -2301,7 +2261,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                        new LambdaQueryWrapper<InventoryItem>()
                            .eq(InventoryItem::getItemId, dispense.getMedicationId())
                            .eq(InventoryItem::getLotNumber, dispense.getLotNumber())
-                    .last("LIMIT 1"));
+                    );
                    
                    if (inventoryItem != null) {
                        // 计算回滚后的数量（加上已发放的数量）
@@ -2331,7 +2291,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
        log.info("BugFix: signOffAdvice - 签退所有请求，状态改为待签发, requestIdList={}", requestIdList);
        
        // 尝试签退药品请求（只有存在的才会更新）
-        iMedicationRequestService.updateDraftStatusBatch(requestIdList, null, null, null);
+        iMedicationRequestService.updateDraftStatusBatch(requestIdList, null, null);
        // 尝试签退耗材请求（只有存在的才会更新）
        iDeviceRequestService.updateDraftStatusBatch(requestIdList);
        // 尝试签退诊疗请求（只有存在的才会更新）
@@ -2388,52 +2348,21 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                .map(UpdateGroupDto::getRequestId).collect(Collectors.toList());

        if (!idsToSetNull.isEmpty()) {
-            // 对三个表都执行 group_id/group_no 置空（哪个表有该 id 就更新哪个）
-            UpdateWrapper<MedicationRequest> medUpdateWrapper = new UpdateWrapper<>();
-            medUpdateWrapper.set("group_id", null).in("id", idsToSetNull);
-            iMedicationRequestService.update(medUpdateWrapper);
+            // 创建更新条件
+            UpdateWrapper<MedicationRequest> updateWrapper = new UpdateWrapper<>();
+            updateWrapper.set("group_id", null).in("id", idsToSetNull);

-            UpdateWrapper<ServiceRequest> srvUpdateWrapper = new UpdateWrapper<>();
-            srvUpdateWrapper.set("group_id", null).in("id", idsToSetNull);
-            iServiceRequestService.update(srvUpdateWrapper);
-
-            // DeviceRequest 使用 group_no（String 类型）
-            UpdateWrapper<DeviceRequest> devUpdateWrapper = new UpdateWrapper<>();
-            devUpdateWrapper.set("group_no", null).in("id", idsToSetNull);
-            iDeviceRequestService.update(devUpdateWrapper);
+            // 执行更新
+            iMedicationRequestService.update(updateWrapper);
        }

-        // 处理 groupId 非 null 的情况：按实际所属表分别更新
-        List<UpdateGroupDto> nonNullGroupList = groupList.stream()
-                .filter(dto -> dto.getGroupId() != null).collect(Collectors.toList());
-        if (!nonNullGroupList.isEmpty()) {
-            for (UpdateGroupDto dto : nonNullGroupList) {
-                Long reqId = dto.getRequestId();
-                Long grpId = dto.getGroupId();
-                // 先尝试药品表（med_medication_request → group_id）
-                MedicationRequest medReq = iMedicationRequestService.getById(reqId);
-                if (medReq != null) {
-                    UpdateWrapper<MedicationRequest> uw = new UpdateWrapper<>();
-                    uw.set("group_id", grpId).eq("id", reqId);
-                    iMedicationRequestService.update(uw);
-                    continue;
-                }
-                // 再尝试诊疗表（wor_service_request → group_id）
-                ServiceRequest srvReq = iServiceRequestService.getById(reqId);
-                if (srvReq != null) {
-                    UpdateWrapper<ServiceRequest> uw = new UpdateWrapper<>();
-                    uw.set("group_id", grpId).eq("id", reqId);
-                    iServiceRequestService.update(uw);
-                    continue;
-                }
-                // 最后尝试耗材表（wor_device_request → group_no, String 类型）
-                DeviceRequest devReq = iDeviceRequestService.getById(reqId);
-                if (devReq != null) {
-                    UpdateWrapper<DeviceRequest> uw = new UpdateWrapper<>();
-                    uw.set("group_no", grpId != null ? grpId.toString() : null).eq("id", reqId);
-                    iDeviceRequestService.update(uw);
-                }
-            }
+        // 处理非null的情况
+        List<MedicationRequest> medicationRequestList = groupList.stream().filter(dto -> dto.getGroupId() != null)
+                .map(dto -> new MedicationRequest().setId(dto.getRequestId()).setGroupId(dto.getGroupId()))
+                .collect(Collectors.toList());
+
+        if (!medicationRequestList.isEmpty()) {
+            iMedicationRequestService.saveOrUpdateBatch(medicationRequestList);
        }
    }

@@ -2642,13 +2571,12 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
    }

    @Override
-    public IPage<SurgeryItemDto> getExaminationPage(Long organizationId, Integer pageNo, Integer pageSize, String searchKey, String categoryCode) {
+    public IPage<SurgeryItemDto> getExaminationPage(Long organizationId, Integer pageNo, Integer pageSize, String searchKey) {
        IPage<SurgeryItemDto> result = doctorStationAdviceAppMapper.getExaminationPage(
                new Page<>(pageNo, pageSize),
                PublicationStatus.ACTIVE.getValue(),
                organizationId,
-                searchKey,
-                categoryCode);
+                searchKey);
        return result;
    }

--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationEmrAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationEmrAppServiceImpl.java
@@ -29,7 +29,6 @@ import com.openhis.document.service.IEmrTemplateService;
 import com.openhis.web.doctorstation.appservice.IDoctorStationEmrAppService;
 import com.openhis.web.doctorstation.dto.EmrTemplateDto;
 import com.openhis.web.doctorstation.dto.PatientEmrDto;
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;

@@ -42,7 +41,6 @@ import java.util.stream.Collectors;
 /**
 * 医生站-电子病历 应用实现类
 */
-@Slf4j
@Service
 public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppService {

@@ -62,7 +60,13 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
    IDocRecordService docRecordService;

    @Resource
-    private com.openhis.web.doctorstation.mapper.DoctorStationEmrAppMapper doctorStationEmrAppMapper;
+    private EncounterMapper encounterMapper;
+
+    @Resource
+    private PatientMapper patientMapper;
+
+    @Resource
+    private com.openhis.administration.mapper.EncounterParticipantMapper encounterParticipantMapper;

    /**
     * 添加病人病历信息
@@ -75,7 +79,7 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
        Emr emr = new Emr();
        BeanUtils.copyProperties(patientEmrDto, emr);
        String contextStr = patientEmrDto.getContextJson().toString();
-        Emr patientEmr = emrService.getOne(new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, emr.getEncounterId()).orderByDesc(Emr::getCreateTime).last("LIMIT 1"), false);
+        Emr patientEmr = emrService.getOne(new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, emr.getEncounterId()));
        boolean saveSuccess;
        // 如果已经保存病历，再次保存走更新
        if (patientEmr != null) {
@@ -122,10 +126,6 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
     */
    @Override
    public R<?> getPatientEmrHistory(PatientEmrDto patientEmrDto, Integer pageNo, Integer pageSize) {
-        // 校验参数
-        if (patientEmrDto.getPatientId() == null) {
-            return R.ok(new Page<>(pageNo, pageSize));
-        }
        Page<Emr> page = emrService.page(new Page<>(pageNo, pageSize),
            new LambdaQueryWrapper<Emr>().eq(Emr::getPatientId, patientEmrDto.getPatientId()));
        return R.ok(page);
@@ -140,12 +140,8 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
     */
    @Override
    public R<?> getEmrDetail(Long encounterId) {
-        // 校验参数
-        if (encounterId == null) {
-            return R.ok(null);
-        }
        // 先查询门诊病历(emr表)
-        Emr emrDetail = emrService.getOne(new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, encounterId).orderByDesc(Emr::getCreateTime).last("LIMIT 1"), false);
+        Emr emrDetail = emrService.getOne(new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, encounterId));
        if (emrDetail != null) {
            return R.ok(emrDetail);
        }
@@ -155,8 +151,7 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
            new LambdaQueryWrapper<DocRecord>()
                .eq(DocRecord::getEncounterId, encounterId)
                .orderByDesc(DocRecord::getCreateTime)
-                .last("LIMIT 1"),
-            false
+                .last("LIMIT 1")
        );
        if (docRecord != null) {
            // 住院病历存在，也返回数据
@@ -228,29 +223,52 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
     * @return 待写病历列表
     */
    @Override
-    public R<?> getPendingEmrList(Long doctorId, Integer pageNo, Integer pageSize, String patientName) {
-        // 先查询总数
-        Long total = doctorStationEmrAppMapper.getPendingEmrCount(doctorId, patientName);
+    public R<?> getPendingEmrList(Long doctorId) {
+        // 由于Encounter实体中没有jzPractitionerUserId字段，我们需要通过关联查询来获取相关信息
+        // 使用医生工作站的mapper来查询相关数据
+        // 这里我们直接使用医生工作站的查询逻辑

-        // 计算分页偏移量，再查询分页数据
-        int offset = (pageNo - 1) * pageSize;
-        List<Map<String, Object>> pageRows = doctorStationEmrAppMapper.getPendingEmrList(doctorId, patientName, pageSize, offset);
+        // 查询当前医生负责的、状态为"就诊中"但还没有写病历的患者
+        // 需要通过EncounterParticipant表来关联医生信息
+        List<Encounter> encounters = encounterMapper.selectList(
+            new LambdaQueryWrapper<Encounter>()
+                .eq(Encounter::getStatusEnum, EncounterStatus.IN_PROGRESS.getValue())
+        );

-        // 计算年龄列
-        for (Map<String, Object> row : pageRows) {
-            Object birthDate = row.get("birthDate");
-            if (birthDate instanceof Date) {
-                row.put("age", calculateAge((Date) birthDate));
-            } else {
-                row.put("age", null);
+        // 过滤出由指定医生负责且还没有写病历的就诊记录
+        List<Map<String, Object>> pendingEmrs = new ArrayList<>();
+        for (Encounter encounter : encounters) {
+            // 检查该就诊记录是否已经有病历
+            Emr existingEmr = emrService.getOne(
+                new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, encounter.getId())
+            );
+
+            // 检查该就诊是否由指定医生负责
+            boolean isAssignedToDoctor = isEncounterAssignedToDoctor(encounter.getId(), doctorId);
+
+            if (existingEmr == null && isAssignedToDoctor) {
+                // 如果没有病历且由该医生负责，则添加到待写病历列表
+                Map<String, Object> pendingEmr = new java.util.HashMap<>();
+
+                // 获取患者信息
+                Patient patient = patientMapper.selectById(encounter.getPatientId());
+
+                pendingEmr.put("encounterId", encounter.getId());
+                pendingEmr.put("patientId", encounter.getPatientId());
+                pendingEmr.put("patientName", patient != null ? patient.getName() : "未知");
+                pendingEmr.put("gender", patient != null ? patient.getGenderEnum() : null);
+                // 使用出生日期计算年龄
+                pendingEmr.put("age", patient != null && patient.getBirthDate() != null ?
+                    calculateAge(patient.getBirthDate()) : null);
+                // 使用创建时间作为挂号时间
+                pendingEmr.put("registerTime", encounter.getCreateTime());
+                pendingEmr.put("busNo", encounter.getBusNo()); // 病历号
+
+                pendingEmrs.add(pendingEmr);
            }
-            row.remove("birthDate");
        }

-        Map<String, Object> result = new java.util.HashMap<>();
-        result.put("rows", pageRows);
-        result.put("total", total != null ? total : 0L);
-        return R.ok(result);
+        return R.ok(pendingEmrs);
    }

    /**
@@ -260,9 +278,14 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
     * @return 待写病历数量
     */
    @Override
-    public R<?> getPendingEmrCount(Long doctorId, String patientName) {
-        Long count = doctorStationEmrAppMapper.getPendingEmrCount(doctorId, patientName);
-        return R.ok(count != null ? count.intValue() : 0);
+    public R<?> getPendingEmrCount(Long doctorId) {
+        // 获取待写病历列表，然后返回数量
+        R<?> result = getPendingEmrList(doctorId);
+        if (result.getCode() == 200) {
+            List<?> pendingEmrs = (List<?>) result.getData();
+            return R.ok(pendingEmrs.size());
+        }
+        return R.ok(0);
    }

    /**
@@ -275,7 +298,7 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
    public R<?> checkNeedWriteEmr(Long encounterId) {
        // 检查该就诊记录是否已经有病历
        Emr existingEmr = emrService.getOne(
-            new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, encounterId).orderByDesc(Emr::getCreateTime).last("LIMIT 1"), false
+            new LambdaQueryWrapper<Emr>().eq(Emr::getEncounterId, encounterId)
        );

        // 如果没有病历，则需要写病历
@@ -283,6 +306,24 @@ public class DoctorStationEmrAppServiceImpl implements IDoctorStationEmrAppServi
        return R.ok(needWrite);
    }

+    /**
+     * 检查就诊是否分配给指定医生
+     *
+     * @param encounterId 就诊ID
+     * @param doctorId 医生ID
+     * @return 是否分配给指定医生
+     */
+    private boolean isEncounterAssignedToDoctor(Long encounterId, Long doctorId) {
+        // 查询就诊参与者表，检查是否有指定医生的接诊记录
+        com.openhis.administration.domain.EncounterParticipant participant =
+            encounterParticipantMapper.selectOne(
+                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<com.openhis.administration.domain.EncounterParticipant>()
+                    .eq(com.openhis.administration.domain.EncounterParticipant::getEncounterId, encounterId)
+                    .eq(com.openhis.administration.domain.EncounterParticipant::getPractitionerId, doctorId)
+            );
+
+        return participant != null;
+    }

    /**
     * 根据出生日期计算年龄
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationLabApplyServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationLabApplyServiceImpl.java
@@ -274,7 +274,7 @@ public class DoctorStationLabApplyServiceImpl implements IDoctorStationInspectio
                    new QueryWrapper<Organization>()
                        .eq("bus_no", performDeptCode)
                        .eq("delete_flag", "0")
-                .last("LIMIT 1"));
+                );
                if (organization != null) {
                    positionId = organization.getId();
                } else {
@@ -410,7 +410,7 @@ public class DoctorStationLabApplyServiceImpl implements IDoctorStationInspectio
            new QueryWrapper<InspectionLabApply>()
                .eq("apply_no", applyNo)
                .eq("delete_flag", DelFlag.NO.getCode())
-                .last("LIMIT 1"));
+        );

        if (mainEntity == null) {
            return null;
@@ -532,7 +532,7 @@ public class DoctorStationLabApplyServiceImpl implements IDoctorStationInspectio
            // 1. 根据申请单号查询检验申请单信息
            InspectionLabApply inspectionLabApply = inspectionLabApplyService.getOne(
                new QueryWrapper<InspectionLabApply>().eq("apply_no", applyNo)
-                .last("LIMIT 1"));
+            );

            if (inspectionLabApply == null) {
                log.warn("未找到申请单号为 [{}] 的检验申请单", applyNo);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationMainAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationMainAppServiceImpl.java
@@ -215,7 +215,7 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
                    // 限定当天日期，避免复诊患者匹配到历史队列记录
                    .eq(TriageQueueItem::getQueueDate, LocalDate.now())
                    .eq(TriageQueueItem::getDeleteFlag, "0")
-            .last("LIMIT 1"));
+            );
            if (queueItem != null) {
                // 使用 TriageQueueStatus 枚举替代原有硬编码数字 20，保证状态值一致性
                queueItem.setStatus(TriageQueueStatus.IN_CLINIC.getValue());
@@ -282,7 +282,7 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
                .eq(TriageQueueItem::getEncounterId, encounterId)
                .eq(TriageQueueItem::getQueueDate, LocalDate.now())
                .eq(TriageQueueItem::getDeleteFlag, "0")
-        .last("LIMIT 1"));
+        );

        // 当天未找到时回退：不限日期查最近一条（防止跨日就诊队列项遗漏更新）
        if (queueItem == null) {
@@ -292,8 +292,8 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
                    .eq(TriageQueueItem::getEncounterId, encounterId)
                    .eq(TriageQueueItem::getDeleteFlag, "0")
                    .orderByDesc(TriageQueueItem::getQueueDate)
-                    .last("LIMIT 1"));
-
+                    .last("LIMIT 1")
+            );
            if (queueItem != null) {
                log.warn("完诊：当天队列项未找到，回退使用最近队列记录 queueDate={}, id={}",
                    queueItem.getQueueDate(), queueItem.getId());
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationAdviceController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationAdviceController.java
@@ -77,10 +77,8 @@ public class DoctorStationAdviceController {
     */
    @PostMapping(value = "/save-advice")
    @RepeatSubmit(interval = 5000, message = "请勿重复提交医嘱，请稍候再试")
-    public R<?> saveAdvice(@RequestBody AdviceSaveParam adviceSaveParam,
-                           @RequestParam(required = false, defaultValue = "1") String adviceOpType) {
-        // 🔧 Bug #445 修复：使用前端传入的 adviceOpType 参数（1=保存草稿，2=签发），而非硬编码
-        return iDoctorStationAdviceAppService.saveAdvice(adviceSaveParam, adviceOpType);
+    public R<?> saveAdvice(@RequestBody AdviceSaveParam adviceSaveParam) {
+        return iDoctorStationAdviceAppService.saveAdvice(adviceSaveParam, AdviceOpType.SAVE_ADVICE.getCode());
    }

    /**
@@ -228,9 +226,8 @@ public class DoctorStationAdviceController {
            @RequestParam(value = "organizationId", required = false) Long organizationId,
            @RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
            @RequestParam(value = "pageSize", defaultValue = "500") Integer pageSize,
-            @RequestParam(value = "searchKey", defaultValue = "") String searchKey,
-            @RequestParam(value = "categoryCode", defaultValue = "23") String categoryCode) {
-        return R.ok(iDoctorStationAdviceAppService.getExaminationPage(organizationId, pageNo, pageSize, searchKey, categoryCode));
+            @RequestParam(value = "searchKey", defaultValue = "") String searchKey) {
+        return R.ok(iDoctorStationAdviceAppService.getExaminationPage(organizationId, pageNo, pageSize, searchKey));
    }

 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/PendingEmrController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/PendingEmrController.java
@@ -26,36 +26,34 @@ public class PendingEmrController {
     * 获取待写病历列表
     *
     * @param doctorId 医生ID
-     * @param pageNo 当前页码
-     * @param pageSize 每页条数
-     * @param patientName 患者姓名（可选）
-     * @return 待写病历分页数据
+     * @return 待写病历列表
     */
    @GetMapping("/pending-list")
-    public R<?> getPendingEmrList(@RequestParam(required = false) Long doctorId,
-                                   @RequestParam(defaultValue = "1") Integer pageNum,
-                                   @RequestParam(defaultValue = "10") Integer pageSize,
-                                   @RequestParam(required = false) String patientName) {
+    public R<?> getPendingEmrList(@RequestParam(required = false) Long doctorId) {
+        // 如果没有传递医生ID，则使用当前登录用户ID
        if (doctorId == null) {
-            doctorId = com.core.common.utils.SecurityUtils.getLoginUser().getPractitionerId();
+            doctorId = com.core.common.utils.SecurityUtils.getLoginUser().getUserId();
        }
-        return iDoctorStationEmrAppService.getPendingEmrList(doctorId, pageNum, pageSize, patientName);
+
+        // 调用服务获取待写病历列表
+        return iDoctorStationEmrAppService.getPendingEmrList(doctorId);
    }

    /**
     * 获取待写病历数量
     * 
     * @param doctorId 医生ID
-     * @param patientName 患者姓名（可选）
     * @return 待写病历数量
     */
    @GetMapping("/pending-count")
-    public R<?> getPendingEmrCount(@RequestParam(required = false) Long doctorId,
-                                    @RequestParam(required = false) String patientName) {
+    public R<?> getPendingEmrCount(@RequestParam(required = false) Long doctorId) {
+        // 如果没有传递医生ID，则使用当前登录用户ID
        if (doctorId == null) {
-            doctorId = com.core.common.utils.SecurityUtils.getLoginUser().getPractitionerId();
+            doctorId = com.core.common.utils.SecurityUtils.getLoginUser().getUserId();
        }
-        return iDoctorStationEmrAppService.getPendingEmrCount(doctorId, patientName);
+        
+        // 调用服务获取待写病历数量
+        return iDoctorStationEmrAppService.getPendingEmrCount(doctorId);
    }

    /**
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/AdviceBaseDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/AdviceBaseDto.java
@@ -198,10 +198,8 @@ public class AdviceBaseDto {
    /**
     * 所属科室
     */
-    @Dict(dictTable = "adm_organization", dictCode = "id", dictText = "name")
    @JsonSerialize(using = ToStringSerializer.class)
    private Long orgId;
-    private String orgId_dictText;

    /**
     * 所在位置
@@ -250,9 +248,4 @@ public class AdviceBaseDto {
     * 是否缺少取药科室配置（仅药品类型使用）
     */
    private Boolean pharmacyConfigMissing;
-
-    /**
-     * 备注（最长50字）
-     */
-    private String remark;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/AdviceSaveDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/AdviceSaveDto.java
@@ -8,10 +8,6 @@ import lombok.Data;
 import lombok.experimental.Accessors;

 import java.math.BigDecimal;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import org.springframework.format.annotation.DateTimeFormat;
-
-import java.util.Date;
 import com.fasterxml.jackson.annotation.JsonSetter;
 import com.fasterxml.jackson.annotation.Nulls;

@@ -30,14 +26,6 @@ public class AdviceSaveDto {
    /** 医嘱类型 */
    private Integer adviceType; // 1:药品 , 2: 耗材 , 3:项目

-    /**
-     * 医嘱开始时间
-     */
-    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private Date startTime;
-
-
    /**
     * 请求id
     */
@@ -282,11 +270,6 @@ public class AdviceSaveDto {
     */
    private String sourceBillNo;

-    /**
-     * 备注（最长50字）
-     */
-    private String remark;
-
    /**
     * 设置默认值
     */
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/PatientDetailsDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/PatientDetailsDto.java
@@ -63,18 +63,6 @@ public class PatientDetailsDto {
     */
    private String address;

-    /** 地址省 */
-    private String addressProvince;
-
-    /** 地址市 */
-    private String addressCity;
-
-    /** 地址区 */
-    private String addressDistrict;
-
-    /** 地址街道 */
-    private String addressStreet;
-
    /**
     * 工作单位
     */
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/RequestBaseDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/RequestBaseDto.java
@@ -22,12 +22,6 @@ public class RequestBaseDto {
     */
    private Integer adviceType; // 1:药品 , 2: 耗材 , 3:项目

-        /**
-     * 医嘱开始时间
-     */
-    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
-    private Date startTime;
-
    /**
     * 唯一标识
     */
@@ -127,11 +121,6 @@ public class RequestBaseDto {
     * 请求状态
     */
    private Integer statusEnum;
-
-    /**
-     * 退回原因
-     */
-    private String reasonText;
    private String statusEnum_enumText;

    /**
@@ -249,15 +238,4 @@ public class RequestBaseDto {
    @JsonSerialize(using = ToStringSerializer.class)
    private Long patientId;

-    /**
-     * 停嘱医生
-     */
-    private String stopUserName;
-
-    /**
-     * 停嘱时间
-     */
-    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
-    private Date stopTime;
-
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/SurgeryItemDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/SurgeryItemDto.java
@@ -2,7 +2,6 @@ package com.openhis.web.doctorstation.dto;

 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
-import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;

 import java.math.BigDecimal;
@@ -24,9 +23,6 @@ public class SurgeryItemDto {
    @JsonSerialize(using = ToStringSerializer.class)
    private Long orgId;

-    /** 所属科室名称 */
-    private String orgName;
-
    /** 执行科室ID */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long positionId;
@@ -41,10 +37,6 @@ public class SurgeryItemDto {
    /** 单位编码 */
    private String unitCode;

-    /** 单位编码字典文本（前端用于显示单位，输出为 unitCode_dictText 以下划线格式匹配前端） */
-    @JsonProperty("unitCode_dictText")
+    /** 单位编码字典文本（前端用于显示单位） */
    private String unitCodeDictText;
-
-    /** 所需标本编码（来自诊疗目录配置，对应字典 specimen_code 的 dictValue） */
-    private String specimenCode;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/mapper/DoctorStationAdviceAppMapper.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/mapper/DoctorStationAdviceAppMapper.java
@@ -203,7 +203,6 @@ public interface DoctorStationAdviceAppMapper {
    IPage<SurgeryItemDto> getExaminationPage(@Param("page") Page<SurgeryItemDto> page,
            @Param("statusEnum") Integer statusEnum,
            @Param("organizationId") Long organizationId,
-            @Param("searchKey") String searchKey,
-            @Param("categoryCode") String categoryCode);
+            @Param("searchKey") String searchKey);

 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/mapper/DoctorStationEmrAppMapper.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/mapper/DoctorStationEmrAppMapper.java
@@ -1,22 +1,11 @@
 package com.openhis.web.doctorstation.mapper;

-import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Repository;

-import java.util.List;
-import java.util.Map;
-
 /**
 * 医生站-电子病历 应用Mapper
 */
@Repository
 public interface DoctorStationEmrAppMapper {

-    List<Map<String, Object>> getPendingEmrList(@Param("doctorId") Long doctorId,
-                                                 @Param("patientName") String patientName,
-                                                 @Param("pageSize") Integer pageSize,
-                                                 @Param("offset") Integer offset);
-
-    Long getPendingEmrCount(@Param("doctorId") Long doctorId,
-                            @Param("patientName") String patientName);
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/dto/HomeStatisticsDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/dto/HomeStatisticsDto.java
@@ -40,16 +40,6 @@ public class HomeStatisticsDto {
     */
    private Double revenueTrend;
    
-    /**
-     * 今日收入金额（数值，单位：元）
-     */
-    private java.math.BigDecimal todayRevenueAmount;
-
-    /**
-     * 昨日收入金额（数值，单位：元）
-     */
-    private java.math.BigDecimal yesterdayRevenueAmount;
-    
    /**
     * 今日预约数量
     */
@@ -79,19 +69,4 @@ public class HomeStatisticsDto {
     * 待写病历数量
     */
    private Integer pendingEmr;
-
-    /**
-     * 今日处方数量
-     */
-    private Integer todayPrescriptions;
-
-    /**
-     * 昨日处方数量
-     */
-    private Integer yesterdayPrescriptions;
-
-    /**
-     * 处方相对前日变化百分比
-     */
-    private Double prescriptionTrend;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/AdviceProcessAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/AdviceProcessAppServiceImpl.java
@@ -58,7 +58,6 @@ import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
 import java.util.*;
-import java.util.Objects;
 import java.util.stream.Collectors;

 /**
@@ -179,25 +178,11 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
        inpatientAdviceParam.setEncounterIds(null);
        Integer exeStatus = inpatientAdviceParam.getExeStatus();
        inpatientAdviceParam.setExeStatus(null);
-        // 提取requestStatus手动处理，支持COMPLETED(3)和CHECK_VERIFIED(10)同时查询
-        Integer requestStatus = inpatientAdviceParam.getRequestStatus();
-        inpatientAdviceParam.setRequestStatus(null);
+        // requestStatus由前端tab传入，通过QueryWrapper自动添加到SQL外层WHERE过滤
        // 构建查询条件
        QueryWrapper<InpatientAdviceParam> queryWrapper
                = HisQueryUtils.buildQueryWrapper(inpatientAdviceParam, null, null, null);

-        // 手动拼接requestStatus条件：COMPLETED(3)时同时包含CHECK_VERIFIED(10)和PENDING_RECEIVE(11)
-        // UNION查询外层列名为request_status（T1.status_enum AS request_status），不是status_enum
-        if (requestStatus != null) {
-            if (RequestStatus.COMPLETED.getValue().equals(requestStatus)) {
-                queryWrapper.in("request_status",
-                        RequestStatus.COMPLETED.getValue(), RequestStatus.CHECK_VERIFIED.getValue(),
-                        RequestStatus.PENDING_RECEIVE.getValue());
-            } else {
-                queryWrapper.eq("request_status", requestStatus);
-            }
-        }
-
        // 手动拼接住院患者id条件
        if (encounterIds != null && !encounterIds.isEmpty()) {
            List<Long> encounterIdList
@@ -330,29 +315,19 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
        Long practitionerId = SecurityUtils.getLoginUser().getPractitionerId();
        Date checkDate = new Date();
        if (!serviceRequestList.isEmpty()) {
-            List<Long> serviceReqIds = serviceRequestList.stream().map(PerformInfoDto::getRequestId).toList();
-            // 先查询服务请求，按 categoryEnum 分流：检查类(23)走 CHECK_VERIFIED，其余走 COMPLETED
-            List<ServiceRequest> allServiceRequests = serviceRequestService.listByIds(serviceReqIds);
-            List<Long> checkReqIds = allServiceRequests.stream()
-                    .filter(sr -> ActivityDefCategory.TEST.getValue().equals(sr.getCategoryEnum()))
-                    .map(ServiceRequest::getId).toList();
-            List<Long> otherReqIds = allServiceRequests.stream()
-                    .filter(sr -> !ActivityDefCategory.TEST.getValue().equals(sr.getCategoryEnum()))
-                    .map(ServiceRequest::getId).toList();
-            // 检查类 → 已校对（CHECK_VERIFIED=10）
-            if (!checkReqIds.isEmpty()) {
-                serviceRequestService.updateCheckVerifiedStatus(checkReqIds, practitionerId, checkDate);
-            }
-            // 其他类 → 已完成（COMPLETED=3）
-            if (!otherReqIds.isEmpty()) {
-                serviceRequestService.updateCompleteRequestStatus(otherReqIds, practitionerId, checkDate);
-            }
-            // 处理转科/出院等特殊医嘱
-            for (ServiceRequest serviceRequest : allServiceRequests) {
+            // 更新服务请求状态已完成
+            serviceRequestService.updateCompleteRequestStatus(
+                    serviceRequestList.stream().map(PerformInfoDto::getRequestId).toList(), practitionerId, checkDate);
+            List<ServiceRequest> serviceRequests = serviceRequestService
+                    .listByIds(serviceRequestList.stream().map(PerformInfoDto::getRequestId).collect(Collectors.toList()));
+            for (ServiceRequest serviceRequest : serviceRequests) {
+                // 判断医嘱类型
                if (ActivityDefCategory.TRANSFER.getValue().equals(serviceRequest.getCategoryEnum())) {
+                    // 更新患者状态 待转科
                    encounterService.updateEncounterStatus(serviceRequest.getEncounterId(),
                            EncounterZyStatus.PENDING_TRANSFER.getValue());
                } else if (ActivityDefCategory.DISCHARGE.getValue().equals(serviceRequest.getCategoryEnum())) {
+                    // 更新患者状态 待出院
                    encounterService.updateEncounterStatus(serviceRequest.getEncounterId(),
                            EncounterZyStatus.AWAITING_DISCHARGE.getValue());
                }
@@ -384,24 +359,6 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
                medRequestList.add(item);
            }
        }
-        // 校验医嘱是否已执行，已执行的医嘱需要先取消执行后才能退回
-        List<Long> allRequestIds = performInfoList.stream().map(PerformInfoDto::getRequestId).toList();
-        List<Procedure> allProcedures = procedureService.list(
-                new LambdaQueryWrapper<Procedure>()
-                        .in(Procedure::getRequestId, allRequestIds)
-                        .eq(Procedure::getDeleteFlag, "0"));
-        Set<Long> executedIds = allProcedures.stream()
-                .filter(p -> EventStatus.COMPLETED.getValue().equals(p.getStatusEnum()))
-                .map(Procedure::getId)
-                .collect(Collectors.toSet());
-        Set<Long> cancelledRefundIds = allProcedures.stream()
-                .filter(p -> EventStatus.CANCEL.getValue().equals(p.getStatusEnum()) && p.getRefundId() != null)
-                .map(Procedure::getRefundId)
-                .collect(Collectors.toSet());
-        executedIds.removeAll(cancelledRefundIds);
-        if (!executedIds.isEmpty()) {
-            return R.fail("该医嘱已执行，请先取消执行后再退回");
-        }
        // 校验药品医嘱是否已发药，已发药的医嘱不允许退回
        if (!medRequestList.isEmpty()) {
            List<Long> medReqIds = medRequestList.stream().map(PerformInfoDto::getRequestId).toList();
@@ -415,21 +372,15 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
        }
        Long practitionerId = SecurityUtils.getLoginUser().getPractitionerId();
        Date checkDate = new Date();
-        // 从请求中提取退回原因（所有项目共享同一原因）
-        String backReason = performInfoList.stream()
-                .map(PerformInfoDto::getBackReason)
-                .filter(Objects::nonNull)
-                .findFirst()
-                .orElse(null);
        if (!serviceRequestList.isEmpty()) {
            // 更新服务请求状态待发送
            serviceRequestService.updateDraftStatus(
-                    serviceRequestList.stream().map(PerformInfoDto::getRequestId).toList(), practitionerId, checkDate, backReason);
+                    serviceRequestList.stream().map(PerformInfoDto::getRequestId).toList(), practitionerId, checkDate);
        }
        if (!medRequestList.isEmpty()) {
            // 更新药品请求状态待发送
            medicationRequestService.updateDraftStatusBatch(
-                    medRequestList.stream().map(PerformInfoDto::getRequestId).toList(), practitionerId, checkDate, backReason);
+                    medRequestList.stream().map(PerformInfoDto::getRequestId).toList(), practitionerId, checkDate);
        }
        return R.ok(null, "退回成功");
    }
@@ -473,22 +424,6 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
            List<ServiceRequestUseExe> actUseExeList = this.assemblyActivity(activityList);
            // 处理诊疗执行
            this.exeActivity(actUseExeList, exeDate);
-            // 检查类医嘱执行后，状态改为"待接收"（PENDING_RECEIVE=11）
-            List<Long> actReqIds = activityList.stream().map(AdviceExecuteDetailParam::getRequestId).toList();
-            List<ServiceRequest> executedReqs = serviceRequestService.listByIds(actReqIds);
-            List<Long> checkReqIds = executedReqs.stream()
-                    .filter(sr -> ActivityDefCategory.TEST.getValue().equals(sr.getCategoryEnum()))
-                    .map(ServiceRequest::getId).toList();
-            if (!checkReqIds.isEmpty()) {
-                serviceRequestService.updatePendingReceiveStatus(checkReqIds);
-            }
-            // 手术类医嘱执行后，状态改为"已执行"（SurgeryAppStatusEnum.EXECUTED=4）
-            List<Long> surgeryReqIds = executedReqs.stream()
-                    .filter(sr -> ActivityDefCategory.PROCEDURE.getValue().equals(sr.getCategoryEnum()))
-                    .map(ServiceRequest::getId).toList();
-            if (!surgeryReqIds.isEmpty()) {
-                serviceRequestService.updateSurgeryAppStatus(surgeryReqIds, SurgeryAppStatusEnum.EXECUTED.getCode());
-            }
        }

        return R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, new Object[]{"医嘱执行"}));
@@ -589,10 +524,7 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
        // 处理长期已发放的药品
        if (!longMedDispensedList.isEmpty()) {
            // 生成退药单
-            this.creatRefundMedicationList(longMedDispensedList, procedureIdMap);
-            // 药品退药请求状态变更(待退药)
-            medicationRequestService.updateCancelledStatusBatch(
-                    longMedDispensedList.stream().map(MedicationDispense::getMedReqId).toList(), null, null);
+            this.creatRefundMedicationList(tempMedDispensedList, procedureIdMap);
        }
        // 处理临时已发放药品
        if (!tempMedDispensedList.isEmpty()) {
@@ -733,24 +665,6 @@ public class AdviceProcessAppServiceImpl implements IAdviceProcessAppService {
            deviceDispenseService.removeByIds(deviceDispenseList.stream().map(DeviceDispense::getId).toList());
            deviceRequestService.removeByIds(deviceDispenseList.stream().map(DeviceDispense::getDeviceReqId).toList());
        }
-        // 手术类医嘱取消执行后，状态回退为"已校对"（SurgeryAppStatusEnum.VERIFIED=3）
-        List<Long> surgeryCancelReqIds = adviceExecuteParam.getAdviceExecuteDetailList().stream()
-                .filter(e -> CommonConstants.TableName.WOR_SERVICE_REQUEST.equals(e.getAdviceTable()))
-                .map(AdviceExecuteDetailParam::getRequestId)
-                .filter(Objects::nonNull)
-                .distinct()
-                .toList();
-        if (!surgeryCancelReqIds.isEmpty()) {
-            List<ServiceRequest> surgeryRequests = serviceRequestService.list(
-                    new LambdaQueryWrapper<ServiceRequest>()
-                            .in(ServiceRequest::getId, surgeryCancelReqIds)
-                            .eq(ServiceRequest::getCategoryEnum, ActivityDefCategory.PROCEDURE.getValue()));
-            if (!surgeryRequests.isEmpty()) {
-                serviceRequestService.updateSurgeryAppStatus(
-                        surgeryRequests.stream().map(ServiceRequest::getId).toList(),
-                        SurgeryAppStatusEnum.VERIFIED.getCode());
-            }
-        }
        return R.ok("取消执行成功,相关汇总领药单已重新生成");
    }

--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/MedicineSummaryAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/MedicineSummaryAppServiceImpl.java
@@ -78,10 +78,12 @@ public class MedicineSummaryAppServiceImpl implements IMedicineSummaryAppService
                        .map(notPerformedReason -> new DispenseInitDto.NotPerformedReasonOption(notPerformedReason.getValue(),
                        notPerformedReason.getInfo()))
                        .collect(Collectors.toList());
-        // 发药状态（汇总单：待配药→已提交，已发放→已发药）
+        // 发药状态
        List<DispenseStatusOption> dispenseStatusOptions = new ArrayList<>();
-        dispenseStatusOptions.add(new DispenseStatusOption(DispenseStatus.PREPARATION.getValue(), "已提交"));
-        dispenseStatusOptions.add(new DispenseStatusOption(DispenseStatus.COMPLETED.getValue(), "已发药"));
+        dispenseStatusOptions.add(new DispenseStatusOption(DispenseStatus.PREPARATION.getValue(),
+                DispenseStatus.PREPARATION.getInfo()));
+        dispenseStatusOptions.add(new DispenseStatusOption(DispenseStatus.COMPLETED.getValue(),
+                DispenseStatus.COMPLETED.getInfo()));

        initDto.setNotPerformedReasonOptions(notPerformedReasonOptions).setDispenseStatusOptions(dispenseStatusOptions);
        return R.ok(initDto);
@@ -159,8 +161,8 @@ public class MedicineSummaryAppServiceImpl implements IMedicineSummaryAppService
                new Page<>(pageNo, pageSize), queryWrapper, DispenseStatus.COMPLETED.getValue(),
                DispenseStatus.PREPARATION.getValue(), SupplyType.SUMMARY_DISPENSE.getValue());
        medicineSummaryFormPage.getRecords().forEach(e -> {
-            // 发药状态（汇总单展示文案）
-            e.setStatusEnum_enumText(getSummaryFormStatusText(e.getStatusEnum()));
+            // 发药状态
+            e.setStatusEnum_enumText(EnumUtils.getInfoByValue(DispenseStatus.class, e.getStatusEnum()));
        });
        return R.ok(medicineSummaryFormPage);
    }
@@ -290,17 +292,4 @@ public class MedicineSummaryAppServiceImpl implements IMedicineSummaryAppService
        }
        return R.ok(MessageUtils.createMessage(PromptMsgConstant.Common.M00004, new Object[]{"取消"}));
    }
-
-    /**
-     * 汇总发药单状态展示文案（药品医嘱状态映射表：汇总申请→已提交，发药→已发药）
-     */
-    private String getSummaryFormStatusText(Integer statusEnum) {
-        if (DispenseStatus.PREPARATION.getValue().equals(statusEnum)) {
-            return "已提交";
-        }
-        if (DispenseStatus.COMPLETED.getValue().equals(statusEnum)) {
-            return "已发药";
-        }
-        return EnumUtils.getInfoByValue(DispenseStatus.class, statusEnum);
-    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/outpatientmanage/appservice/impl/OutpatientInfusionAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/outpatientmanage/appservice/impl/OutpatientInfusionAppServiceImpl.java
@@ -256,7 +256,7 @@ public class OutpatientInfusionAppServiceImpl implements IOutpatientInfusionAppS
            }
            boolean result = serviceRequestService.updateCancelledStatus(serviceReqId, now, practitionerId, orgId);
            // 更新主服务请求状态为待执行
-            serviceRequestService.updateDraftStatus(List.of(serviceRequest.getBasedOnId()), null, null, null);
+            serviceRequestService.updateDraftStatus(List.of(serviceRequest.getBasedOnId()), null, null);
            if (result) {
                // 判断是否全部取消执行
                boolean exists = serviceRequestMapper.exists(new LambdaQueryWrapper<ServiceRequest>()
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/patientmanage/appservice/impl/OutpatientRecordServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/patientmanage/appservice/impl/OutpatientRecordServiceImpl.java
@@ -86,13 +86,8 @@ public class OutpatientRecordServiceImpl implements IOutpatientRecordService {
            
            // 处理就诊对象状态筛选
            if (outpatientRecordSearchParam.getSubjectStatusEnum() != null) {
-                if (outpatientRecordSearchParam.getSubjectStatusEnum() == 0) {
-                    // 前端选择"无状态"(0)时，过滤 status_enum IS NULL 的记录
-                    queryWrapper.isNull("enc.status_enum");
-                } else {
                queryWrapper.eq("enc.status_enum", outpatientRecordSearchParam.getSubjectStatusEnum());
            }
-            }
            
            // 处理医生姓名查询（支持模糊查询）
            if (outpatientRecordSearchParam.getDoctorName() != null && !outpatientRecordSearchParam.getDoctorName().isEmpty()) {
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/patientmanage/appservice/impl/PatientInformationServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/patientmanage/appservice/impl/PatientInformationServiceImpl.java
@@ -133,13 +133,47 @@ public class PatientInformationServiceImpl implements IPatientInformationService
    @Override
    public IPage<PatientBaseInfoDto> getPatientInfo(PatientBaseInfoDto patientBaseInfoDto, String searchKey,
            Integer pageNo, Integer pageSize, HttpServletRequest request) {
-        // 构建基础查询条件
+        // 获取登录者信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
+        Long userId = loginUser.getUserId();
+        Integer tenantId = loginUser.getTenantId().intValue();
+        
+        // 先构建基础查询条件
        QueryWrapper<PatientBaseInfoDto> queryWrapper = HisQueryUtils.buildQueryWrapper(
                patientBaseInfoDto, searchKey, new HashSet<>(Arrays.asList(CommonConstants.FieldName.Name,
                        CommonConstants.FieldName.BusNo, CommonConstants.FieldName.PyStr, CommonConstants.FieldName.WbStr)),
                request);
        
+        // 检查是否是精确ID查询（从门诊挂号页面跳转时使用）
+        boolean hasExactIdQuery = (patientBaseInfoDto.getId() != null);
+        
+        // 只有非精确ID查询时，才添加医生患者过滤条件
+        if (!hasExactIdQuery) {
+            // 查询当前用户对应的医生信息
+            LambdaQueryWrapper<com.openhis.administration.domain.Practitioner> practitionerQuery = new LambdaQueryWrapper<>();
+            practitionerQuery.eq(com.openhis.administration.domain.Practitioner::getUserId, userId);
+            // 使用list()避免TooManyResultsException异常，然后取第一个记录
+            List<com.openhis.administration.domain.Practitioner> practitionerList = practitionerService.list(practitionerQuery);
+            com.openhis.administration.domain.Practitioner practitioner = practitionerList != null && !practitionerList.isEmpty() ? practitionerList.get(0) : null;
+            
+            // 如果当前用户是医生，添加医生患者过滤条件
+            if (practitioner != null) {
+                // 查询该医生作为接诊医生（ADMITTER, code="1"）和挂号医生（REGISTRATION_DOCTOR, code="12"）的所有就诊记录的患者ID
+                List<Long> doctorPatientIds = patientManageMapper.getPatientIdsByPractitionerId(
+                        practitioner.getId(),
+                        Arrays.asList(ParticipantType.ADMITTER.getCode(), ParticipantType.REGISTRATION_DOCTOR.getCode()),
+                        tenantId);
+                
+                if (doctorPatientIds != null && !doctorPatientIds.isEmpty()) {
+                    // 添加患者ID过滤条件 - 注意：这里使用列名而不是表别名
+                    queryWrapper.in("id", doctorPatientIds);
+                } else {
+                    // 如果没有相关患者，返回空结果
+                    queryWrapper.eq("id", -1); // 设置一个不存在的ID
+                }
+            }
+            // 如果不是医生，查询所有患者
+        }
        
        IPage<PatientBaseInfoDto> patientInformationPage
                = patientManageMapper.getPatientPage(new Page<>(pageNo, pageSize), queryWrapper);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/PendingMedicationDetailsAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/PendingMedicationDetailsAppServiceImpl.java
@@ -52,8 +52,7 @@ public class PendingMedicationDetailsAppServiceImpl implements IPendingMedicatio
        Page<PendingMedicationPageDto> pendingMedicationPage = pendingMedicationDetailsMapper
            .selectPendingMedicationDetailsPage(new Page<>(pageNo, pageSize), queryWrapper,
                DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.PREPARATION.getValue(),
-                DispenseStatus.PREPARED.getValue(), DispenseStatus.SUMMARIZED.getValue(),
-                EncounterClass.AMB.getValue(), EncounterClass.IMP.getValue());
+                DispenseStatus.PREPARED.getValue(), EncounterClass.AMB.getValue(), EncounterClass.IMP.getValue());

        pendingMedicationPage.getRecords().forEach(e -> {
            // 发药类型
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/WesternMedicineDispenseAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/WesternMedicineDispenseAppServiceImpl.java
@@ -191,8 +191,7 @@ public class WesternMedicineDispenseAppServiceImpl implements IWesternMedicineDi
        Page<EncounterInfoDto> encounterInfoPage
                = westernMedicineDispenseMapper.selectEncounterInfoListPage(new Page<>(pageNo, pageSize), queryWrapper,
                        statusEnum, DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
-                        DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue(),
-                        DispenseStatus.SUMMARIZED.getValue());
+                        DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue());
        encounterInfoPage.getRecords().forEach(encounterInfo -> {
            // 性别
            encounterInfo.setGenderEnum_enumText(
@@ -230,7 +229,7 @@ public class WesternMedicineDispenseAppServiceImpl implements IWesternMedicineDi
                = westernMedicineDispenseMapper.selectMedicineDispenseOrderPage(new Page<>(pageNo, pageSize), queryWrapper,
                        DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
                        DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue(), dispenseStatus,
-                        PublicationStatus.ACTIVE.getValue(), DispenseStatus.SUMMARIZED.getValue());
+                        PublicationStatus.ACTIVE.getValue());
        medicineDispenseOrderPage.getRecords().forEach(medicineDispenseOrder -> {
            // 发药状态
            medicineDispenseOrder.setStatusEnum_enumText(
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/PendingMedicationDetailsMapper.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/PendingMedicationDetailsMapper.java
@@ -22,7 +22,6 @@ public interface PendingMedicationDetailsMapper {
     * @param inProgress 发药类型：待发药
     * @param preparation 发药类型：待配药
     * @param prepared 发药类型：已配药
-     * @param summarized 发药类型：已汇总
     * @param amb 门诊类型
     * @param imp 住院类型
     * @return 待发药明细
@@ -33,7 +32,6 @@ public interface PendingMedicationDetailsMapper {
        @Param("inProgress") Integer inProgress,
        @Param("preparation") Integer preparation,
        @Param("prepared") Integer prepared,
-        @Param("summarized") Integer summarized,
        @Param("amb") Integer amb,
        @Param("imp") Integer imp);

--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/WesternMedicineDispenseMapper.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/WesternMedicineDispenseMapper.java
@@ -35,7 +35,7 @@ public interface WesternMedicineDispenseMapper {
        @Param(Constants.WRAPPER) QueryWrapper<EncounterInfoSearchParam> queryWrapper,
        @Param("statusEnum") Integer statusEnum, @Param("inProgress") Integer inProgress,
        @Param("completed") Integer completed, @Param("preparation") Integer preparation,
-        @Param("prepared") Integer prepared, @Param("summarized") Integer summarized);
+        @Param("prepared") Integer prepared);

    /**
     * 发药单查询
@@ -54,8 +54,7 @@ public interface WesternMedicineDispenseMapper {
        @Param(Constants.WRAPPER) QueryWrapper<ItemDispenseOrderDto> queryWrapper,
        @Param("inProgress") Integer inProgress, @Param("completed") Integer completed,
        @Param("preparation") Integer preparation, @Param("prepared") Integer prepared,
-        @Param("dispenseStatus") Integer dispenseStatus, @Param("active") Integer active,
-        @Param("summarized") Integer summarized);
+        @Param("dispenseStatus") Integer dispenseStatus, @Param("active") Integer active);

    /**
     * 获取配药人下拉选列表
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/IAdviceManageAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/IAdviceManageAppService.java
@@ -69,12 +69,4 @@ public interface IAdviceManageAppService {
     */
    R<?> stopRegAdvice(List<AdviceBatchOpParam> paramList);

-    /**
-     * 住院医嘱取消停嘱（恢复）
-     *
-     * @param paramList 恢复参数
-     * @return 结果
-     */
-    R<?> cancelStopRegAdvice(List<AdviceBatchOpParam> paramList);
-
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/AdviceManageAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/AdviceManageAppServiceImpl.java
@@ -18,7 +18,6 @@ import com.openhis.common.constant.PromptMsgConstant;
 import com.openhis.common.enums.*;
 import com.openhis.common.utils.EnumUtils;
 import com.openhis.common.utils.HisQueryUtils;
-import com.openhis.medication.domain.MedicationDispense;
 import com.openhis.medication.domain.MedicationRequest;
 import com.openhis.medication.service.IMedicationDispenseService;
 import com.openhis.medication.service.IMedicationRequestService;
@@ -31,9 +30,6 @@ import com.openhis.web.regdoctorstation.dto.*;
 import com.openhis.web.regdoctorstation.mapper.AdviceManageAppMapper;
 import com.openhis.web.regdoctorstation.utils.RegPrescriptionUtils;
 import com.openhis.workflow.domain.DeviceRequest;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.openhis.workflow.domain.ServiceRequest;
 import com.openhis.workflow.service.IActivityDefinitionService;
 import com.openhis.workflow.domain.ActivityDefinition;
@@ -192,10 +188,9 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
        // 药品
        List<RegAdviceSaveDto> medicineList = regAdviceSaveList.stream()
                .filter(e -> ItemType.MEDICINE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
-        // 诊疗活动（包含护理adviceType=26、手术adviceType=6）
+        // 诊疗活动（包含护理adviceType=26）
        List<RegAdviceSaveDto> activityList = regAdviceSaveList.stream()
                .filter(e -> ItemType.ACTIVITY.getValue().equals(e.getAdviceType())
-                        || ItemType.SURGERY.getValue().equals(e.getAdviceType())
                        || (e.getAdviceType() != null && e.getAdviceType() == 26))
                .collect(Collectors.toList());
        // 耗材 🔧 Bug #147 修复
@@ -356,27 +351,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
    /**
     * 处理药品
     */
-
-    /**
-     * 将 remark 合并到 contentJson 中，确保 Mapper 能从 content_json 提取 remark
-     */
-    private String injectRemarkIntoContentJson(String contentJson, String remark) {
-        if (remark == null || remark.isEmpty() || contentJson == null || contentJson.isEmpty()) {
-            return contentJson;
-        }
-        try {
-            ObjectMapper mapper = new ObjectMapper();
-            JsonNode node = mapper.readTree(contentJson);
-            if (node instanceof ObjectNode) {
-                ((ObjectNode) node).put("remark", remark);
-                return mapper.writeValueAsString(node);
-            }
-        } catch (Exception e) {
-            log.warn("Failed to inject remark into contentJson: {}", e.getMessage());
-        }
-        return contentJson;
-    }
-
    private List<String> handMedication(List<RegAdviceSaveDto> medicineList, Date startTime, Date authoredTime,
            Date curDate, String adviceOpType, Long organizationId, String signCode) {
        // 当前登录账号的科室id
@@ -441,7 +415,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            }
            // 保存时处理的字段属性
            if (is_save) {
-                longMedicationRequest.setEffectiveDoseStart(regAdviceSaveDto.getStartTime() != null ? regAdviceSaveDto.getStartTime() : startTime); // 医嘱开始时间
+                longMedicationRequest.setEffectiveDoseStart(startTime); // 医嘱开始时间
                longMedicationRequest
                        .setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.MEDICATION_RES_NO.getPrefix(), 4));
                longMedicationRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
@@ -475,10 +449,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            if (longMedicationRequest.getId() == null) {
                firstTimeSave = true;
            }
-            // 确保 contentJson 包含 remark
-            if (regAdviceSaveDto.getRemark() != null && !regAdviceSaveDto.getRemark().isEmpty()) {
-                longMedicationRequest.setContentJson(injectRemarkIntoContentJson(longMedicationRequest.getContentJson(), regAdviceSaveDto.getRemark()));
-            }
            iMedicationRequestService.saveOrUpdate(longMedicationRequest);
            if (firstTimeSave) {
                medRequestIdList.add(longMedicationRequest.getId().toString());
@@ -533,7 +503,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            }
            // 保存时处理的字段属性
            if (is_save) {
-                tempMedicationRequest.setEffectiveDoseStart(regAdviceSaveDto.getStartTime() != null ? regAdviceSaveDto.getStartTime() : startTime); // 医嘱开始时间
+                tempMedicationRequest.setEffectiveDoseStart(startTime); // 医嘱开始时间
                tempMedicationRequest
                        .setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.MEDICATION_RES_NO.getPrefix(), 4));
                tempMedicationRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
@@ -566,10 +536,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            if (tempMedicationRequest.getId() == null) {
                firstTimeSave = true;
            }
-            // 确保 contentJson 包含 remark
-            if (regAdviceSaveDto.getRemark() != null && !regAdviceSaveDto.getRemark().isEmpty()) {
-                tempMedicationRequest.setContentJson(injectRemarkIntoContentJson(tempMedicationRequest.getContentJson(), regAdviceSaveDto.getRemark()));
-            }
            iMedicationRequestService.saveOrUpdate(tempMedicationRequest);
            if (firstTimeSave) {
                medRequestIdList.add(tempMedicationRequest.getId().toString());
@@ -649,7 +615,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            }
            // 保存时处理的字段属性
            if (is_save) {
-                longServiceRequest.setOccurrenceStartTime(regAdviceSaveDto.getStartTime() != null ? regAdviceSaveDto.getStartTime() : startTime); // 医嘱开始时间
+                longServiceRequest.setOccurrenceStartTime(startTime); // 医嘱开始时间
                longServiceRequest.setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.SERVICE_RES_NO.getPrefix(), 4));
                longServiceRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
                longServiceRequest.setQuantity(new BigDecimal("1")); // 请求数量 | 诊疗的长期医嘱数量都是1
@@ -661,7 +627,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                longServiceRequest.setPatientId(regAdviceSaveDto.getPatientId()); // 患者
                longServiceRequest.setRequesterId(regAdviceSaveDto.getPractitionerId()); // 开方医生
                longServiceRequest.setEncounterId(regAdviceSaveDto.getEncounterId()); // 就诊id
-                longServiceRequest.setOrgId(regAdviceSaveDto.getEffectiveOrgId()); // 执行科室
+                longServiceRequest.setOrgId(regAdviceSaveDto.getPositionId()); // 执行科室
                longServiceRequest.setContentJson(regAdviceSaveDto.getContentJson()); // 请求内容json
                longServiceRequest.setYbClassEnum(regAdviceSaveDto.getYbClassEnum());// 类别医保编码
                longServiceRequest.setConditionId(regAdviceSaveDto.getConditionId()); // 诊断id
@@ -673,7 +639,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                    longServiceRequest.setBasedOnTable(CommonConstants.TableName.MED_MEDICATION_REQUEST);
                }
            }
-            longServiceRequest.setRemark(regAdviceSaveDto.getRemark());
            iServiceRequestService.saveOrUpdate(longServiceRequest);
            if (longServiceRequest.getId() != null) {
                processedRequestIds.add(longServiceRequest.getId());
@@ -701,7 +666,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            }
            // 保存时处理的字段属性
            if (is_save) {
-                tempServiceRequest.setOccurrenceStartTime(regAdviceSaveDto.getStartTime() != null ? regAdviceSaveDto.getStartTime() : startTime); // 医嘱开始时间
+                tempServiceRequest.setOccurrenceStartTime(startTime); // 医嘱开始时间
                tempServiceRequest.setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.SERVICE_RES_NO.getPrefix(), 4));
                tempServiceRequest.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
                tempServiceRequest.setQuantity(regAdviceSaveDto.getQuantity()); // 请求数量
@@ -713,7 +678,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                tempServiceRequest.setRequesterId(regAdviceSaveDto.getPractitionerId()); // 开方医生
                tempServiceRequest.setEncounterId(regAdviceSaveDto.getEncounterId()); // 就诊id
                tempServiceRequest.setAuthoredTime(curDate); // 请求签发时间
-                tempServiceRequest.setOrgId(regAdviceSaveDto.getEffectiveOrgId()); // 执行科室
+                tempServiceRequest.setOrgId(regAdviceSaveDto.getPositionId()); // 执行科室
                tempServiceRequest.setContentJson(regAdviceSaveDto.getContentJson()); // 请求内容json
                tempServiceRequest.setYbClassEnum(regAdviceSaveDto.getYbClassEnum());// 类别医保编码
                tempServiceRequest.setConditionId(regAdviceSaveDto.getConditionId()); // 诊断id
@@ -725,7 +690,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                    tempServiceRequest.setBasedOnTable(CommonConstants.TableName.MED_MEDICATION_REQUEST);
                }
            }
-            tempServiceRequest.setRemark(regAdviceSaveDto.getRemark());
            iServiceRequestService.saveOrUpdate(tempServiceRequest);
            if (tempServiceRequest.getId() != null) {
                processedRequestIds.add(tempServiceRequest.getId());
@@ -848,7 +812,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                deviceRequest.setPatientId(regAdviceSaveDto.getPatientId()); // 患者
                deviceRequest.setRequesterId(regAdviceSaveDto.getPractitionerId()); // 开方医生
                deviceRequest.setOrgId(regAdviceSaveDto.getFounderOrgId()); // 开方人科室
-                deviceRequest.setReqAuthoredTime(regAdviceSaveDto.getStartTime() != null ? regAdviceSaveDto.getStartTime() : startTime); // 医嘱开始时间
+                deviceRequest.setReqAuthoredTime(startTime); // 医嘱开始时间
                deviceRequest.setPerformLocation(regAdviceSaveDto.getLocationId()); // 发放科室
                deviceRequest.setEncounterId(regAdviceSaveDto.getEncounterId()); // 就诊id
                deviceRequest.setPackageId(regAdviceSaveDto.getPackageId()); // 组套id
@@ -857,10 +821,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                deviceRequest.setConditionId(regAdviceSaveDto.getConditionId()); // 诊断id
                deviceRequest.setEncounterDiagnosisId(regAdviceSaveDto.getEncounterDiagnosisId()); // 就诊诊断id
            }
-            // 确保 contentJson 包含 remark
-            if (regAdviceSaveDto.getRemark() != null && !regAdviceSaveDto.getRemark().isEmpty()) {
-                deviceRequest.setContentJson(injectRemarkIntoContentJson(deviceRequest.getContentJson(), regAdviceSaveDto.getRemark()));
-            }
            iDeviceRequestService.saveOrUpdate(deviceRequest);
        }

@@ -891,7 +851,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                deviceRequest.setPatientId(regAdviceSaveDto.getPatientId()); // 患者
                deviceRequest.setRequesterId(regAdviceSaveDto.getPractitionerId()); // 开方医生
                deviceRequest.setOrgId(regAdviceSaveDto.getFounderOrgId()); // 开方人科室
-                deviceRequest.setReqAuthoredTime(regAdviceSaveDto.getStartTime() != null ? regAdviceSaveDto.getStartTime() : startTime); // 医嘱开始时间
+                deviceRequest.setReqAuthoredTime(startTime); // 医嘱开始时间
                deviceRequest.setPerformLocation(regAdviceSaveDto.getLocationId()); // 发放科室
                deviceRequest.setEncounterId(regAdviceSaveDto.getEncounterId()); // 就诊id
                deviceRequest.setPackageId(regAdviceSaveDto.getPackageId()); // 组套id
@@ -900,10 +860,6 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                deviceRequest.setConditionId(regAdviceSaveDto.getConditionId()); // 诊断id
                deviceRequest.setEncounterDiagnosisId(regAdviceSaveDto.getEncounterDiagnosisId()); // 就诊诊断id
            }
-            // 确保 contentJson 包含 remark
-            if (regAdviceSaveDto.getRemark() != null && !regAdviceSaveDto.getRemark().isEmpty()) {
-                deviceRequest.setContentJson(injectRemarkIntoContentJson(deviceRequest.getContentJson(), regAdviceSaveDto.getRemark()));
-            }
            iDeviceRequestService.saveOrUpdate(deviceRequest);

            // 保存时,保存耗材费用项
@@ -1060,7 +1016,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
        }
        if (!medicineRequestIds.isEmpty()) {
            // 根据请求id更新请求状态
-            iMedicationRequestService.updateDraftStatusBatch(medicineRequestIds, null, null, null);
+            iMedicationRequestService.updateDraftStatusBatch(medicineRequestIds, null, null);
        }
        if (!activityRequestIds.isEmpty()) {
            // 根据请求id更新请求状态
@@ -1087,14 +1043,8 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
     */
    @Override
    public R<?> stopRegAdvice(List<AdviceBatchOpParam> paramList) {
-        // 获取停嘱时间：优先从前端传入的 stopTime，否则用当前时间
-        Date stopTime = paramList.stream()
-                .map(AdviceBatchOpParam::getStopTime)
-                .filter(Objects::nonNull)
-                .findFirst()
-                .orElse(new Date());
-        // 获取当前操作用户昵称作为停嘱医生
-        String stopUserName = SecurityUtils.getNickName();
+        // 当前时间
+        Date date = new Date();
        // 药品
        List<AdviceBatchOpParam> medicineList = paramList.stream()
                .filter(e -> ItemType.MEDICINE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
@@ -1109,112 +1059,15 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                = activityList.stream().map(AdviceBatchOpParam::getRequestId).collect(Collectors.toList());
        if (!medicineRequestIds.isEmpty()) {
            iMedicationRequestService.update(new LambdaUpdateWrapper<MedicationRequest>()
-                    .in(MedicationRequest::getId, medicineRequestIds)
-                    .set(MedicationRequest::getEffectiveDoseEnd, stopTime)
-                    .set(MedicationRequest::getStatusEnum, RequestStatus.STOPPED.getValue())
-                    .set(MedicationRequest::getUpdateBy, stopUserName));
+                    .in(MedicationRequest::getId, medicineRequestIds).set(MedicationRequest::getEffectiveDoseEnd, date)
+                    .set(MedicationRequest::getStatusEnum, RequestStatus.STOPPED.getValue()));
        }
        if (!activityRequestIds.isEmpty()) {
            iServiceRequestService.update(new LambdaUpdateWrapper<ServiceRequest>()
-                    .in(ServiceRequest::getId, activityRequestIds)
-                    .set(ServiceRequest::getOccurrenceEndTime, stopTime)
-                    .set(ServiceRequest::getStatusEnum, RequestStatus.STOPPED.getValue())
-                    .set(ServiceRequest::getUpdateBy, stopUserName));
+                    .in(ServiceRequest::getId, activityRequestIds).set(ServiceRequest::getOccurrenceEndTime, date)
+                    .set(ServiceRequest::getStatusEnum, RequestStatus.STOPPED.getValue()));
        }
        return R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, new Object[]{"医嘱停止"}));
-
-    }
-
-    /**
-     * 住院医嘱取消停嘱（恢复）
-     * 
-     * 核心业务逻辑：
-     * 1. 护士站校验：护士站尚未对该医嘱的停止进行"停止核对/确认"（即 dispense 状态未进入已发药/完成状态）
-     * 2. 药房端校验：药房尚未对该停嘱单进行退药接收/退费入库确认
-     * 3. 若校验通过，将医嘱状态复原为"已签发"；清空停嘱时间与停嘱医生字段；
-     *    同时自动作废已生成的待发药退回/退药申请
-     *
-     * @param paramList 恢复参数
-     * @return 结果
-     */
-    @Override
-    public R<?> cancelStopRegAdvice(List<AdviceBatchOpParam> paramList) {
-        // 药品
-        List<AdviceBatchOpParam> medicineList = paramList.stream()
-                .filter(e -> ItemType.MEDICINE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
-        List<Long> medicineRequestIds
-                = medicineList.stream().map(AdviceBatchOpParam::getRequestId).collect(Collectors.toList());
-        // 诊疗（包含护理adviceType=26）
-        List<AdviceBatchOpParam> activityList = paramList.stream()
-                .filter(e -> ItemType.ACTIVITY.getValue().equals(e.getAdviceType())
-                        || (e.getAdviceType() != null && e.getAdviceType() == 26))
-                .collect(Collectors.toList());
-        List<Long> activityRequestIds
-                = activityList.stream().map(AdviceBatchOpParam::getRequestId).collect(Collectors.toList());
-
-        // ============ 前置校验 ============
-        // 1. 护士站校验：查询药品发放记录，确认护士站是否已执行停止核对（发药）
-        if (!medicineRequestIds.isEmpty()) {
-            List<MedicationDispense> dispenseList = iMedicationDispenseService.selectByRequestIdList(medicineRequestIds);
-            for (MedicationDispense dispense : dispenseList) {
-                // 如果发放状态 >= COMPLETED(4)，说明护士站已发药/已确认停止
-                if (dispense.getStatusEnum() != null && dispense.getStatusEnum() >= DispenseStatus.COMPLETED.getValue()
-                        && !DispenseStatus.ON_HOLD.getValue().equals(dispense.getStatusEnum())
-                        && !DispenseStatus.STOPPED.getValue().equals(dispense.getStatusEnum())
-                        && !DispenseStatus.CANCELLED.getValue().equals(dispense.getStatusEnum())) {
-                    throw new ServiceException("护士站已确认停止该医嘱，无法取消停嘱！");
-                }
-                // 2. 药房端校验：如果已有退药/退费记录，说明药房已处理
-                if (DispenseStatus.RETURNED.getValue().equals(dispense.getStatusEnum())
-                        || DispenseStatus.REFUNDED.getValue().equals(dispense.getStatusEnum())
-                        || DispenseStatus.PART_REFUND.getValue().equals(dispense.getStatusEnum())) {
-                    throw new ServiceException("药房已完成退药处理，无法取消停嘱！");
-                }
-            }
-        }
-
-        // ============ 执行恢复 ============
-        if (!medicineRequestIds.isEmpty()) {
-            // 恢复药品请求状态为"已发送"(ACTIVE=2)，清空停嘱时间和更新人
-            iMedicationRequestService.update(new LambdaUpdateWrapper<MedicationRequest>()
-                    .in(MedicationRequest::getId, medicineRequestIds)
-                    .set(MedicationRequest::getStatusEnum, RequestStatus.ACTIVE.getValue())
-                    .set(MedicationRequest::getEffectiveDoseEnd, null)
-                    .set(MedicationRequest::getUpdateBy, null));
-            
-            // 作废/删除与这些药品请求相关的待退药发放记录
-            List<MedicationDispense> relatedDispenseList = iMedicationDispenseService.selectByRequestIdList(medicineRequestIds);
-            for (MedicationDispense dispense : relatedDispenseList) {
-                if (DispenseStatus.PENDING_REFUND.getValue().equals(dispense.getStatusEnum())
-                        || DispenseStatus.CANCELLED.getValue().equals(dispense.getStatusEnum())
-                        || DispenseStatus.ON_HOLD.getValue().equals(dispense.getStatusEnum())) {
-                    // 将待退药/暂停/撤回的记录标记为草稿，或删除
-                    iMedicationDispenseService.update(new LambdaUpdateWrapper<MedicationDispense>()
-                            .eq(MedicationDispense::getId, dispense.getId())
-                            .set(MedicationDispense::getStatusEnum, DispenseStatus.DRAFT.getValue())
-                            .set(MedicationDispense::getStatusChangedTime, new Date()));
-                }
-                // 如果 dispense 已处于 STOPPED(6) 状态，也恢复为草稿以重新触发配药流程
-                if (DispenseStatus.STOPPED.getValue().equals(dispense.getStatusEnum())) {
-                    iMedicationDispenseService.update(new LambdaUpdateWrapper<MedicationDispense>()
-                            .eq(MedicationDispense::getId, dispense.getId())
-                            .set(MedicationDispense::getStatusEnum, DispenseStatus.PREPARATION.getValue())
-                            .set(MedicationDispense::getStatusChangedTime, new Date()));
-                }
-            }
-        }
-
-        if (!activityRequestIds.isEmpty()) {
-            // 恢复诊疗请求状态为"已发送"(ACTIVE=2)，清空停嘱时间和更新人
-            iServiceRequestService.update(new LambdaUpdateWrapper<ServiceRequest>()
-                    .in(ServiceRequest::getId, activityRequestIds)
-                    .set(ServiceRequest::getStatusEnum, RequestStatus.ACTIVE.getValue())
-                    .set(ServiceRequest::getOccurrenceEndTime, null)
-                    .set(ServiceRequest::getUpdateBy, null));
-        }
-
-        return R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, new Object[]{"医嘱恢复"}));
-
    }

 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/RequestFormManageAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/RequestFormManageAppServiceImpl.java
@@ -5,7 +5,6 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.core.common.core.domain.R;
-import com.core.common.enums.DelFlag;
 import com.core.common.exception.ServiceException;
 import com.core.common.utils.AssignSeqUtil;
 import com.core.common.utils.MessageUtils;
@@ -18,8 +17,6 @@ import com.openhis.common.constant.PromptMsgConstant;
 import com.openhis.common.enums.*;
 import com.openhis.document.domain.RequestForm;
 import com.openhis.document.service.IRequestFormService;
-import com.openhis.lab.domain.Specimen;
-import com.openhis.lab.service.ISpecimenService;
 import com.openhis.web.doctorstation.dto.ActivityChildrenJsonParams;
 import com.openhis.web.doctorstation.utils.AdviceUtils;
 import com.openhis.web.regdoctorstation.appservice.IRequestFormManageAppService;
@@ -70,39 +67,6 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
    @Resource
    IActivityDefinitionService iActivityDefinitionService;

-    @Resource
-    ISpecimenService iSpecimenService;
-
-    /**
-     * 校验当前用户是否有权操作该申请单（申请者本人或管理员）
-     */
-    private R<?> validateRequestFormPermission(RequestForm requestForm) {
-        if (SecurityUtils.isAdmin(SecurityUtils.getUserId())) {
-            return null;
-        }
-        Long currentPractitionerId = SecurityUtils.getLoginUser().getPractitionerId();
-        Long requesterId = requestForm.getRequesterId();
-        if (currentPractitionerId == null || requesterId == null
-            || !currentPractitionerId.equals(requesterId)) {
-            return R.fail("无操作权限，仅申请开立者或管理员可操作");
-        }
-        return null;
-    }
-
-    /**
-     * 校验关联医嘱是否已采证（存在已采集/已接收标本则不可撤回）
-     */
-    private boolean hasCollectedSpecimen(List<Long> serviceRequestIds) {
-        if (serviceRequestIds == null || serviceRequestIds.isEmpty()) {
-            return false;
-        }
-        long count = iSpecimenService.count(
-            new LambdaQueryWrapper<Specimen>()
-                .in(Specimen::getServiceId, serviceRequestIds)
-                .ge(Specimen::getCollectionStatusEnum, SpecCollectStatus.COLLECTED.getValue()));
-        return count > 0;
-    }
-
    /**
     * 保存申请单
     *
@@ -155,18 +119,10 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                return R.fail("无待签发的医嘱,该申请单不可编辑");
            }
        } else {
-            // 根据申请单类型生成不同前缀的单号
+            // 检查申请单号：JC（检查）+ Z（住院标识）+ yyMMdd（日期）+ 5位顺序号
            String dateStr = new java.text.SimpleDateFormat("yyMMdd").format(new Date());
-            AssignSeqEnum seqEnum;
-            if (ActivityDefCategory.PROCEDURE.getCode().equals(typeCode)) {
-                seqEnum = AssignSeqEnum.SURGERY_APPLY_NO;
-            } else if (ActivityDefCategory.PROOF.getCode().equals(typeCode)) {
-                seqEnum = AssignSeqEnum.LAB_APPLY_NO;
-            } else {
-                seqEnum = AssignSeqEnum.CHECK_APPLY_NO;
-            }
-            int seq = assignSeqUtil.getSeqNoByDay(seqEnum.getPrefix());
-            prescriptionNo = seqEnum.getPrefix() + dateStr + String.format("%05d", seq);
+            int seq = assignSeqUtil.getSeqNoByDay(AssignSeqEnum.CHECK_APPLY_NO.getPrefix());
+            prescriptionNo = "JCZ" + dateStr + String.format("%05d", seq);
        }

        // 当前时间
@@ -342,25 +298,7 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
                surgeryServiceRequest.setPrescriptionNo(prescriptionNo);
                surgeryServiceRequest.setTherapyEnum(TherapyTimeType.TEMPORARY.getValue());
                surgeryServiceRequest.setQuantity(BigDecimal.valueOf(1));
-                // 从诊疗目录获取使用单位，避免硬编码
-                String unitCode = "次"; // 默认值
-                if (activityList != null && !activityList.isEmpty()) {
-                    String dtoUnitCode = activityList.get(0).getUnitCode();
-                    if (dtoUnitCode != null && !dtoUnitCode.isEmpty()) {
-                        unitCode = dtoUnitCode;
-                    } else {
-                        // 从 ActivityDefinition 查询使用单位
-                        Long activityId = activityList.get(0).getAdviceDefinitionId();
-                        if (activityId != null) {
-                            ActivityDefinition activityDef = iActivityDefinitionService.getById(activityId);
-                            if (activityDef != null && activityDef.getPermittedUnitCode() != null
-                                && !activityDef.getPermittedUnitCode().isEmpty()) {
-                                unitCode = activityDef.getPermittedUnitCode();
-                            }
-                        }
-                    }
-                }
-                surgeryServiceRequest.setUnitCode(unitCode);
+                surgeryServiceRequest.setUnitCode("次");
                surgeryServiceRequest.setCategoryEnum(24); // 24-手术（新值域，避开 adviceType 碰撞）
                // 优先从 activityList 获取手术 ID
                if (activityList != null && !activityList.isEmpty()) {
@@ -590,17 +528,12 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
        if (requestForm == null) {
            return R.fail("申请单不存在");
        }
-        R<?> permissionResult = validateRequestFormPermission(requestForm);
-        if (permissionResult != null) {
-            return permissionResult;
-        }
        String prescriptionNo = requestForm.getPrescriptionNo();

        // 查询该申请单下所有 ServiceRequest（含子项）
        List<ServiceRequest> serviceRequests = iServiceRequestService.list(
            new LambdaQueryWrapper<ServiceRequest>()
-                .eq(ServiceRequest::getPrescriptionNo, prescriptionNo)
-                .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
+                .eq(ServiceRequest::getPrescriptionNo, prescriptionNo));
        if (serviceRequests == null || serviceRequests.isEmpty()) {
            return R.fail("未找到关联的诊疗医嘱");
        }
@@ -630,7 +563,7 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
        // 4. 删除申请单
        iRequestFormService.removeById(requestFormId);

-        log.info("检验申请单删除成功，requestFormId={}, prescriptionNo={}", requestFormId, prescriptionNo);
+        log.info("检查申请单删除成功，requestFormId={}, prescriptionNo={}", requestFormId, prescriptionNo);
        return R.ok("删除成功");
    }

@@ -643,47 +576,32 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
        if (requestForm == null) {
            return R.fail("申请单不存在");
        }
-        R<?> permissionResult = validateRequestFormPermission(requestForm);
-        if (permissionResult != null) {
-            return permissionResult;
-        }
        String prescriptionNo = requestForm.getPrescriptionNo();

        // 查询该申请单下所有 ServiceRequest
        List<ServiceRequest> serviceRequests = iServiceRequestService.list(
            new LambdaQueryWrapper<ServiceRequest>()
-                .eq(ServiceRequest::getPrescriptionNo, prescriptionNo)
-                .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
+                .eq(ServiceRequest::getPrescriptionNo, prescriptionNo));
        if (serviceRequests == null || serviceRequests.isEmpty()) {
            return R.fail("未找到关联的诊疗医嘱");
        }

+        // 校验：只有已签发(status=2)的申请单可撤回
+        boolean allActive = serviceRequests.stream()
+            .allMatch(sr -> RequestStatus.ACTIVE.getValue().equals(sr.getStatusEnum()));
+        if (!allActive) {
+            return R.fail("只有已签发状态的申请单可撤回");
+        }
+
+        // 将所有 ServiceRequest 状态改回待签发(DRAFT=0)
        List<Long> serviceRequestIds = serviceRequests.stream()
            .map(ServiceRequest::getId).collect(Collectors.toList());
-
-        // 校验：标本已采集则不可撤回
-        if (hasCollectedSpecimen(serviceRequestIds)) {
-            return R.fail("标本已采集，无法撤回");
-        }
-
-        // 校验：任一ServiceRequest为ACTIVE(status=2)即可撤回，与SQL的EXISTS逻辑一致
-        boolean hasActive = serviceRequests.stream()
-            .anyMatch(sr -> RequestStatus.ACTIVE.getValue().equals(sr.getStatusEnum()));
-        if (!hasActive) {
-            return R.fail("只有已签发且未采证的申请单可撤回");
-        }
-
-        // 将所有已签发的 ServiceRequest 状态改回待签发，与申请单展示状态同步
-        boolean updated = iServiceRequestService.update(
+        iServiceRequestService.update(
            new ServiceRequest().setStatusEnum(RequestStatus.DRAFT.getValue()),
            new LambdaUpdateWrapper<ServiceRequest>()
-                .in(ServiceRequest::getId, serviceRequestIds)
-                .eq(ServiceRequest::getStatusEnum, RequestStatus.ACTIVE.getValue()));
-        if (!updated) {
-            return R.fail("撤回失败，医嘱状态已变更，请刷新后重试");
-        }
+                .in(ServiceRequest::getId, serviceRequestIds));

-        log.info("检验申请单撤回成功，requestFormId={}, prescriptionNo={}", requestFormId, prescriptionNo);
+        log.info("检查申请单撤回成功，requestFormId={}, prescriptionNo={}", requestFormId, prescriptionNo);
        return R.ok("撤回成功");
    }

--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/SpecialAdviceAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/appservice/impl/SpecialAdviceAppServiceImpl.java
@@ -28,7 +28,6 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
-import org.springframework.util.CollectionUtils;
 import java.util.stream.Collectors;

 /**
@@ -162,7 +161,7 @@ public class SpecialAdviceAppServiceImpl implements ISpecialAdviceAppService {
                    adviceBaseDto.setAdviceDefinitionId(definitionId); // 医嘱定义id
                    // 对应的诊疗医嘱信息
                    activityAdviceBaseDto = iDoctorStationAdviceAppService.getAdviceBaseInfo(adviceBaseDto, null, null,
-                            null, null, 1, 1, null, List.of(3), null, null).getRecords().get(0);
+                            null, null, 1, 1, Whether.NO.getValue(), List.of(3), null, null).getRecords().get(0);
                    // 逻辑1---------------------直接新增
                    longServiceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());// 请求状态
                    longServiceRequest.setOccurrenceStartTime(startTime); // 医嘱开始时间
@@ -209,7 +208,7 @@ public class SpecialAdviceAppServiceImpl implements ISpecialAdviceAppService {
            adviceBaseDto.setAdviceDefinitionId(definitionId); // 医嘱定义id
            // 对应的诊疗医嘱信息
            activityAdviceBaseDto = iDoctorStationAdviceAppService
-                    .getAdviceBaseInfo(adviceBaseDto, null, null, null, null, 1, 1, null, List.of(3), null, null)
+                    .getAdviceBaseInfo(adviceBaseDto, null, null, null, null, 1, 1, Whether.NO.getValue(), List.of(3), null, null)
                    .getRecords().get(0);

            longServiceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());// 请求状态
@@ -349,7 +348,7 @@ public class SpecialAdviceAppServiceImpl implements ISpecialAdviceAppService {
        adviceBaseDto.setAdviceDefinitionId(transferOrganizationDefinitionId); // 医嘱定义id
        // 转科的医嘱信息
        AdviceBaseDto activityAdviceBaseDto = iDoctorStationAdviceAppService
-                .getAdviceBaseInfo(adviceBaseDto, null, null, null, null, 1, 1, null, List.of(3), null, null)
+                .getAdviceBaseInfo(adviceBaseDto, null, null, null, null, 1, 1, Whether.NO.getValue(), List.of(3), null, null)
                .getRecords().get(0);
        // 保存转科医嘱请求
        ServiceRequest serviceRequest = new ServiceRequest();
@@ -401,7 +400,7 @@ public class SpecialAdviceAppServiceImpl implements ISpecialAdviceAppService {
        // 计划出院时间
        Date endTime = leaveHospitalParam.getEndTime();
        if (endTime == null) {
-            endTime = new Date();
+            endTime = endTime;
        }
        // 就诊id
        Long encounterId = leaveHospitalParam.getEncounterId();
@@ -430,12 +429,9 @@ public class SpecialAdviceAppServiceImpl implements ISpecialAdviceAppService {
        }

        // 出院的医嘱信息
-        List<AdviceBaseDto> adviceList = iDoctorStationAdviceAppService.getAdviceBaseInfo(null, null, null,
-                List.of(transferOrganizationDefinitionId), null, 1, 1, null, List.of(3), null, null).getRecords();
-        if (CollectionUtils.isEmpty(adviceList)) {
-            return R.fail("未找到出院医嘱定义数据，请确认诊疗目录中已配置出院医嘱");
-        }
-        AdviceBaseDto activityAdviceBaseDto = adviceList.get(0);
+        AdviceBaseDto activityAdviceBaseDto = iDoctorStationAdviceAppService.getAdviceBaseInfo(null, null, null,
+                List.of(transferOrganizationDefinitionId), null, 1, 1, Whether.NO.getValue(), List.of(3), null, null).getRecords()
+                .get(0);
        // 保存出院医嘱请求
        ServiceRequest serviceRequest = new ServiceRequest();
        serviceRequest.setStatusEnum(RequestStatus.DRAFT.getValue());// 请求状态
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/controller/AdviceManageController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/controller/AdviceManageController.java
@@ -143,15 +143,4 @@ public class AdviceManageController {
        return iAdviceManageAppService.stopRegAdvice(paramList);
    }

-    /**
-     * 住院医嘱取消停嘱（恢复）
-     * 
-     * @param paramList 恢复参数
-     * @return 结果
-     */
-    @PostMapping(value = "/cancel-stop-reg-advice")
-    public R<?> cancelStopRegAdvice(@RequestBody List<AdviceBatchOpParam> paramList) {
-        return iAdviceManageAppService.cancelStopRegAdvice(paramList);
-    }
-
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/controller/RequestFormManageController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/controller/RequestFormManageController.java
@@ -143,23 +143,14 @@ public class RequestFormManageController {
     * 查询手术申请单
     *
     * @param encounterId 就诊id
-     * @param startDate 开始日期（可选，格式：yyyy-MM-dd）
-     * @param endDate 结束日期（可选，格式：yyyy-MM-dd）
-     * @param status 单据状态（可选）
-     * @param keyword 关键字（可选，申请单号/手术项目名称模糊匹配）
     * @return 手术申请单
     */
    @GetMapping(value = "/get-surgery")
-    public R<?> getSurgeryRequestForm(
-            @RequestParam(required = false) Long encounterId,
-            @RequestParam(required = false) String startDate,
-            @RequestParam(required = false) String endDate,
-            @RequestParam(required = false) String status,
-            @RequestParam(required = false) String keyword) {
+    public R<?> getSurgeryRequestForm(@RequestParam(required = false) Long encounterId) {
        if (encounterId == null) {
            return R.fail("就诊ID不能为空");
        }
-        return R.ok(iRequestFormManageAppService.getRequestForm(encounterId, ActivityDefCategory.PROCEDURE.getCode(), startDate, endDate, status, keyword));
+        return R.ok(iRequestFormManageAppService.getRequestForm(encounterId, ActivityDefCategory.PROCEDURE.getCode()));
    }
 /**
     * 分页查询手术申请单（全局，不需要encounterId，用于门诊手术安排查找弹窗）
@@ -203,8 +194,8 @@ public class RequestFormManageController {
     * @return 结果
     */
    @PostMapping(value = "/delete")
-    public R<?> deleteRequestForm(@RequestBody Map<String, Object> data) {
-        return iRequestFormManageAppService.deleteRequestForm(parseLong(data.get("requestFormId")));
+    public R<?> deleteRequestForm(@RequestBody Map<String, Long> data) {
+        return iRequestFormManageAppService.deleteRequestForm(data.get("requestFormId"));
    }

    /**
@@ -214,24 +205,7 @@ public class RequestFormManageController {
     * @return 结果
     */
    @PostMapping(value = "/withdraw")
-    public R<?> withdrawRequestForm(@RequestBody Map<String, Object> data) {
-        return iRequestFormManageAppService.withdrawRequestForm(parseLong(data.get("requestFormId")));
-    }
-
-    private Long parseLong(Object value) {
-        if (value == null) {
-            return null;
-        }
-        if (value instanceof Long) {
-            return (Long) value;
-        }
-        if (value instanceof Number) {
-            return ((Number) value).longValue();
-        }
-        try {
-            return Long.parseLong(value.toString());
-        } catch (NumberFormatException e) {
-            return null;
-        }
+    public R<?> withdrawRequestForm(@RequestBody Map<String, Long> data) {
+        return iRequestFormManageAppService.withdrawRequestForm(data.get("requestFormId"));
    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/AdviceBatchOpParam.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/AdviceBatchOpParam.java
@@ -1,13 +1,10 @@
 package com.openhis.web.regdoctorstation.dto;

-import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
 import lombok.Data;
 import lombok.experimental.Accessors;

-import java.util.Date;
-
 /**
 * 医嘱批量操作参数类
 */
@@ -24,10 +21,4 @@ public class AdviceBatchOpParam {
    @JsonSerialize(using = ToStringSerializer.class)
    private Long requestId;

-    /**
-     * 停嘱时间
-     */
-    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
-    private Date stopTime;
-
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/RegAdviceSaveDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/RegAdviceSaveDto.java
@@ -10,4 +10,8 @@ import lombok.experimental.Accessors;
@Data
@Accessors(chain = true)
 public class RegAdviceSaveDto extends AdviceSaveDto {
+
+    /** 请求类型 */
+    private Integer categoryEnum;
+
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/RegRequestBaseDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/regdoctorstation/dto/RegRequestBaseDto.java
@@ -50,9 +50,4 @@ public class RegRequestBaseDto extends RequestBaseDto {
    private String doseUnitCode;
    private String doseUnitCode_dictText;

-
-    /**
-     * 备注（最长50字）
-     */
-    private String remark;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/service/impl/HomeStatisticsServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/service/impl/HomeStatisticsServiceImpl.java
@@ -13,16 +13,7 @@ import com.openhis.administration.service.IPatientService;
 import com.openhis.administration.service.IPractitionerService;
 import com.openhis.common.enums.ParticipantType;
 import com.openhis.web.dto.HomeStatisticsDto;
-import com.openhis.financial.domain.PaymentReconciliation;
-import com.openhis.financial.service.IPaymentReconciliationService;
-import com.openhis.medication.domain.MedicationRequest;
-import com.openhis.medication.service.IMedicationRequestService;
-import com.openhis.common.enums.PaymentStatus;
 import com.openhis.web.service.IHomeStatisticsService;
-import java.math.BigDecimal;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Date;
 import com.openhis.web.patientmanage.mapper.PatientManageMapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -55,12 +46,6 @@ public class HomeStatisticsServiceImpl implements IHomeStatisticsService {
    @Autowired
    private IPatientService patientService;

-    @Autowired
-    private IPaymentReconciliationService paymentReconciliationService;
-
-    @Autowired
-    private IMedicationRequestService medicationRequestService;
-
    /**
     * 获取首页统计数据
     *
@@ -120,108 +105,18 @@ public class HomeStatisticsServiceImpl implements IHomeStatisticsService {
        double patientTrend = calculateTrend(totalPatients, yesterdayPatients);
        statistics.setPatientTrend(patientTrend);

-        // 查询今日收入
-        BigDecimal todayRevenue = queryRevenueByDate(new Date());
-        BigDecimal yesterdayRevenue = queryRevenueByDate(getYesterday());
-        java.text.DecimalFormat df = new java.text.DecimalFormat("#,##0.00");
-        statistics.setTodayRevenue("¥ " + df.format(todayRevenue));
-        statistics.setYesterdayRevenue("¥ " + df.format(yesterdayRevenue));
-        statistics.setTodayRevenueAmount(todayRevenue);
-        statistics.setYesterdayRevenueAmount(yesterdayRevenue);
-        statistics.setRevenueTrend(calculateTrend(todayRevenue.doubleValue(), yesterdayRevenue.doubleValue()));
-
-        // 今日预约和待审核（暂时设为0，后续实现）
+        // 今日收入和预约等其他统计（暂时设为0，后续从相应表查询）
+        statistics.setTodayRevenue("¥ 0");
+        statistics.setYesterdayRevenue("¥ 0");
+        statistics.setRevenueTrend(0.0);
        statistics.setTodayAppointments(0);
        statistics.setYesterdayAppointments(0);
        statistics.setAppointmentTrend(0.0);
        statistics.setPendingApprovals(0);

-
-        // 查询今日处方数量
-        int todayPrescriptions = queryPrescriptionCountByDate(new Date(), practitioner);
-        int yesterdayPrescriptions = queryPrescriptionCountByDate(getYesterday(), practitioner);
-        statistics.setTodayPrescriptions(todayPrescriptions);
-        statistics.setYesterdayPrescriptions(yesterdayPrescriptions);
-        statistics.setPrescriptionTrend(calculateTrend(todayPrescriptions, yesterdayPrescriptions));
-
        return statistics;
    }
    
-    /**
-     * 查询指定日期的处方数量
-     *
-     * @param date 日期
-     * @param practitioner 当前医生（null 则查全部）
-     * @return 处方数量
-     */
-    private int queryPrescriptionCountByDate(Date date, Practitioner practitioner) {
-        Calendar cal = Calendar.getInstance();
-        cal.setTime(date);
-        cal.set(Calendar.HOUR_OF_DAY, 0);
-        cal.set(Calendar.MINUTE, 0);
-        cal.set(Calendar.SECOND, 0);
-        cal.set(Calendar.MILLISECOND, 0);
-        Date dayStart = cal.getTime();
-
-        cal.add(Calendar.DAY_OF_MONTH, 1);
-        Date dayEnd = cal.getTime();
-
-        LambdaQueryWrapper<MedicationRequest> query = new LambdaQueryWrapper<>();
-        query.ge(MedicationRequest::getCreateTime, dayStart)
-             .lt(MedicationRequest::getCreateTime, dayEnd)
-             .eq(MedicationRequest::getDeleteFlag, "0");
-
-        // 如果是医生角色，只统计自己开的处方
-        if (practitioner != null) {
-            query.eq(MedicationRequest::getPractitionerId, practitioner.getId());
-        }
-
-        return (int) medicationRequestService.count(query);
-    }
-
-    /**
-     * 查询指定日期的收款总额（状态为支付成功且未全部退款）
-     *
-     * @param date 日期
-     * @return 收款总额
-     */
-    private BigDecimal queryRevenueByDate(Date date) {
-        Calendar cal = Calendar.getInstance();
-        cal.setTime(date);
-        cal.set(Calendar.HOUR_OF_DAY, 0);
-        cal.set(Calendar.MINUTE, 0);
-        cal.set(Calendar.SECOND, 0);
-        cal.set(Calendar.MILLISECOND, 0);
-        Date dayStart = cal.getTime();
-
-        cal.add(Calendar.DAY_OF_MONTH, 1);
-        Date dayEnd = cal.getTime();
-
-        LambdaQueryWrapper<PaymentReconciliation> query = new LambdaQueryWrapper<>();
-        query.ge(PaymentReconciliation::getBillDate, dayStart)
-             .lt(PaymentReconciliation::getBillDate, dayEnd)
-             .eq(PaymentReconciliation::getStatusEnum, PaymentStatus.SUCCESS.getValue())
-             .eq(PaymentReconciliation::getDeleteFlag, "0")
-             .select(PaymentReconciliation::getDisplayAmount);
-
-        java.util.List<PaymentReconciliation> list = paymentReconciliationService.list(query);
-        if (list == null || list.isEmpty()) {
-            return BigDecimal.ZERO;
-        }
-        return list.stream()
-                .map(p -> p.getDisplayAmount() != null ? p.getDisplayAmount() : BigDecimal.ZERO)
-                .reduce(BigDecimal.ZERO, BigDecimal::add);
-    }
-
-    /**
-     * 获取昨天的日期
-     */
-    private Date getYesterday() {
-        Calendar cal = Calendar.getInstance();
-        cal.add(Calendar.DAY_OF_MONTH, -1);
-        return cal.getTime();
-    }
-
    /**
     * 计算相对前日的百分比变化
     *
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/system/controller/HomeController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/system/controller/HomeController.java
@@ -31,8 +31,8 @@ public class HomeController {
        HomeStatisticsDto statisticsDto = homeStatisticsService.getHomeStatistics();

        // 获取待写病历数量
-        Long practitionerId = SecurityUtils.getLoginUser().getPractitionerId();
-        R<?> pendingEmrCount = doctorStationEmrAppService.getPendingEmrCount(practitionerId, null);
+        Long userId = SecurityUtils.getLoginUser().getUserId();
+        R<?> pendingEmrCount = doctorStationEmrAppService.getPendingEmrCount(userId);

        // 将待写病历数量添加到统计数据中
        statisticsDto.setPendingEmr((Integer) pendingEmrCount.getData());
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/appservice/impl/TriageQueueAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/appservice/impl/TriageQueueAppServiceImpl.java
@@ -74,6 +74,7 @@ public class TriageQueueAppServiceImpl implements TriageQueueAppService {
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getQueueDate, qd)
            .eq(TriageQueueItem::getDeleteFlag, "0")
+            .ne(TriageQueueItem::getStatus, TriageQueueStatus.COMPLETED.getValue())
            .orderByAsc(TriageQueueItem::getQueueOrder);
        
        // 如果指定了科室，按科室过滤；否则查询所有科室（全科模式）
@@ -91,6 +92,14 @@ public class TriageQueueAppServiceImpl implements TriageQueueAppService {
                }
            });
        }
+
+        // 双重保险：再次过滤掉 COMPLETED 状态的患者（防止数据库中有异常数据）
+        if (list != null && !list.isEmpty()) {
+            int beforeSize = list.size();
+            list = list.stream()
+                .filter(item -> !TriageQueueStatus.COMPLETED.getValue().equals(item.getStatus()))
+                .collect(java.util.stream.Collectors.toList());
+        }
        return R.ok(list);
    }

--- a/openhis-server-new/openhis-application/src/main/resources/application-dev.yml.bak
+++ b/openhis-server-new/openhis-application/src/main/resources/application-dev.yml.bak
@@ -1,93 +0,0 @@
-# 数据源配置
-spring:
-  datasource:
-    type: com.alibaba.druid.pool.DruidDataSource
-    driverClassName: org.postgresql.Driver
-    druid:
-      # 主库数据源
-      master:
-        url: jdbc:postgresql://192.168.110.252:15432/postgresql?currentSchema=hisdev&characterEncoding=UTF-8&client_encoding=UTF-8
-        username: postgresql
-        password: Jchl1528  # 请替换为实际的数据库密码
-      # 从库数据源
-      slave:
-        # 从数据源开关/默认关闭
-        enabled: false
-        url:
-        username:
-        password:
-      # 初始连接数
-      initialSize: 5
-      # 最小连接池数量
-      minIdle: 10
-      # 最大连接池数量
-      maxActive: 20
-      # 配置获取连接等待超时的时间
-      maxWait: 60000
-      # 配置连接超时时间
-      connectTimeout: 30000
-      # 配置网络超时时间
-      socketTimeout: 60000
-      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
-      timeBetweenEvictionRunsMillis: 60000
-      # 配置一个连接在池中最小生存的时间，单位是毫秒
-      minEvictableIdleTimeMillis: 300000
-      # 配置一个连接在池中最大生存的时间，单位是毫秒
-      maxEvictableIdleTimeMillis: 900000
-      # 配置检测连接是否有效
-      validationQuery: SELECT 1
-      testWhileIdle: true
-      testOnBorrow: true  # 改为true以确保连接有效
-      testOnReturn: false
-      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
-      filters: stat,wall,slf4j
-      webStatFilter:
-        enabled: true
-      statViewServlet:
-        enabled: true
-        # 设置白名单，不填则允许所有访问
-        allow:
-        url-pattern: /druid/*
-        # 控制台管理用户名和密码
-        login-username: openhis
-        login-password: 123456
-      filter:
-        stat:
-          enabled: true
-          # 慢SQL记录
-          log-slow-sql: true
-          slow-sql-millis: 1000
-          merge-sql: true
-        wall:
-          config:
-            multi-statement-allow: true
-  # redis 配置
-  redis:
-    # 地址
-    host: 192.168.110.252
-    # 端口，默认为6379
-    port: 6379
-    # 数据库索引
-    database: 1
-    # 密码
-    password: Jchl1528
-    # 连接超时时间
-    timeout: 10s
-    lettuce:
-      pool:
-        # 连接池中的最小空闲连接
-        min-idle: 0
-        # 连接池中的最大空闲连接
-        max-idle: 8
-        # 连接池的最大数据库连接数
-        max-active: 8
-        # #连接池最大阻塞等待时间（使用负值表示没有限制）
-        max-wait: -1ms
-
-# 服务器配置
-server:
-  # 服务器的HTTP端口，默认为18080
-  port: 18080
-  servlet:
-    # 应用的访问路径
-    context-path: /openhis
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/chargemanage/OutpatientRegistrationAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/chargemanage/OutpatientRegistrationAppMapper.xml
@@ -31,34 +31,6 @@
            ${ew.customSqlSegment}
    </select>

-    <!-- 查询全院医生（不限科室），用于手术申请等需跨科室选择医生的场景 -->
-    <select id="getAllDoctorPage" resultType="com.openhis.web.chargemanage.dto.PractitionerMetadata">
-        SELECT T3.tenant_id,
-               T3.ID,
-               T3.NAME,
-               T3.gender_enum,
-               T3.py_str,
-               T3.wb_str,
-               T3.dr_profttl_code
-        FROM (
-                 SELECT T1.tenant_id,
-                        T1.ID,
-                        T1.NAME,
-                        T1.gender_enum,
-                        T1.py_str,
-                        T1.wb_str,
-                        T1.dr_profttl_code
-                 FROM adm_practitioner AS T1
-                 WHERE T1.delete_flag = '0'
-                   AND EXISTS(SELECT 1
-                              FROM adm_practitioner_role AS T2
-                              WHERE T2.practitioner_id = T1.ID
-                                AND T2.delete_flag = '0'
-                                AND T2.ROLE_code = #{RoleCode})
-             ) AS T3
-            ${ew.customSqlSegment}
-    </select>
-
    <select id="getNumByPatientIdAndOrganizationId" resultType="Integer">
        SELECT COUNT
                   (1)
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/common/CommonAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/common/CommonAppMapper.xml
@@ -262,7 +262,7 @@
        AND T1.inventory_status_enum != 3
        AND T1.delete_flag = '0'
        <choose>
-            <when test="lotNumber != null and lotNumber != ''">
+            <when test="lotNumber != null">
                AND T1.lot_number = #{lotNumber}
            </when>
        </choose>
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml
@@ -516,8 +516,6 @@
        T1.patient_id AS patient_id,
        'med_medication_definition' AS advice_table_name,
        T1.medication_id AS advice_definition_id
-        , T1.content_json::jsonb ->> 'remark' AS remark
-        , T1.back_reason AS reason_text
        FROM med_medication_request AS T1
        LEFT JOIN med_medication_definition AS T2 ON T2.ID = T1.medication_id
        AND T2.delete_flag = '0'
@@ -579,8 +577,6 @@
        T1.patient_id AS patient_id,
        'med_medication_definition' AS advice_table_name,
        T3.ID AS advice_definition_id
-        , T2.content_json::jsonb ->> 'remark' AS remark
-        , T2.back_reason AS reason_text
        FROM adm_charge_item AS T1
        INNER JOIN med_medication_request AS T2 ON T2.ID = T1.service_id AND T2.delete_flag = '0'
        LEFT JOIN med_medication_definition AS T3 ON T3.ID = T2.medication_id AND T3.delete_flag = '0'
@@ -588,9 +584,6 @@
        WHERE T1.delete_flag = '0'
          AND T1.service_table = #{MED_MEDICATION_REQUEST}
        <if test="historyFlag == '0'.toString()">
-        <if test="generateSourceEnum != null">
-            AND (T2.generate_source_enum IS NULL OR T2.generate_source_enum = #{generateSourceEnum})
-        </if>
            AND T1.encounter_id = #{encounterId}
        </if>
        <if test="historyFlag == '1'.toString()">
@@ -644,8 +637,6 @@
        CI.patient_id AS patient_id,
        'adm_device_definition' AS advice_table_name,
        CI.product_id AS advice_definition_id
-        , NULL AS remark
-        , NULL AS reason_text
        FROM adm_charge_item AS CI
        LEFT JOIN adm_charge_item_definition CID ON CID.id = CI.definition_id AND CID.delete_flag = '0'
        LEFT JOIN wor_device_request DR ON DR.id = CI.service_id AND DR.delete_flag = '0'
@@ -700,8 +691,6 @@
        T1.patient_id AS patient_id,
        'adm_device_definition' AS advice_table_name,
        T1.device_def_id AS advice_definition_id
-        , T1.content_json::jsonb ->> 'remark' AS remark
-        , NULL AS reason_text
        FROM wor_device_request AS T1
        LEFT JOIN adm_device_definition AS T2 ON T2.ID = T1.device_def_id
        AND T2.delete_flag = '0'
@@ -757,9 +746,7 @@
         T1.encounter_id AS encounter_id,
         T1.patient_id AS patient_id,
        'wor_activity_definition' AS advice_table_name,
-        T1.activity_id AS advice_definition_id,
-        T1.remark AS remark
-        , T1.reason_text AS reason_text
+        T1.activity_id AS advice_definition_id
         FROM wor_service_request AS T1
        LEFT JOIN wor_activity_definition AS T2
        ON T2.ID = T1.activity_id
@@ -884,7 +871,6 @@
    </select>

    <!-- 手术项目专用分页查询：仅查手术 + 定价，无库存/草稿库存/取药科室等无关逻辑 -->
-    <!-- 使用 LIMIT/OFFSET 直接查询，避免 MyBatis Plus 分页插件的 COUNT 开销 -->
    <select id="getSurgeryPage" resultType="com.openhis.web.doctorstation.dto.SurgeryItemDto">
        SELECT DISTINCT ON (t1.ID)
            t1.ID AS advice_definition_id,
@@ -894,17 +880,13 @@
            t2.ID AS charge_item_definition_id,
            t2.price AS price,
            t1.permitted_unit_code AS unit_code,
-            COALESCE(sdd.dict_label, t1.permitted_unit_code) AS unit_code_dict_text
+            t1.permitted_unit_code AS unit_code_dict_text
        FROM wor_activity_definition t1
        LEFT JOIN adm_charge_item_definition t2
            ON t2.instance_id = t1.ID
            AND t2.delete_flag = '0'
            AND t2.status_enum = #{statusEnum}
            AND t2.instance_table = 'wor_activity_definition'
-        LEFT JOIN sys_dict_data sdd
-            ON sdd.dict_value = t1.permitted_unit_code
-            AND sdd.dict_type = 'unit_code'
-            AND sdd.status = '0'
        WHERE t1.delete_flag = '0'
          AND (t1.category_code = '手术' OR t1.category_code = '24')
          <if test="searchKey != null and searchKey != ''">
@@ -913,34 +895,25 @@
        ORDER BY t1.ID, t1.name ASC, t2.ID ASC
    </select>

-    <!-- 检查/检验项目专用分页查询：仅查指定 category_code + 定价，无库存/草稿库存/取药科室等无关逻辑 -->
+    <!-- 检查项目专用分页查询：仅查检查(23) + 定价，无库存/草稿库存/取药科室等无关逻辑 -->
    <select id="getExaminationPage" resultType="com.openhis.web.doctorstation.dto.SurgeryItemDto">
        SELECT DISTINCT ON (t1.ID)
            t1.ID AS advice_definition_id,
            t1.NAME AS advice_name,
            t1.org_id AS org_id,
-            t3.name AS org_name,
            t1.org_id AS position_id,
            t2.ID AS charge_item_definition_id,
            t2.price AS price,
            t1.permitted_unit_code AS unit_code,
-            COALESCE(sdd.dict_label, t1.permitted_unit_code) AS unit_code_dict_text,
-            t1.specimen_code AS specimen_code
+            t1.permitted_unit_code AS unit_code_dict_text
        FROM wor_activity_definition t1
        LEFT JOIN adm_charge_item_definition t2
            ON t2.instance_id = t1.ID
            AND t2.delete_flag = '0'
            AND t2.status_enum = #{statusEnum}
            AND t2.instance_table = 'wor_activity_definition'
-        LEFT JOIN adm_organization t3
-            ON t3.id = t1.org_id
-            AND t3.delete_flag = '0'
-        LEFT JOIN sys_dict_data sdd
-            ON sdd.dict_value = t1.permitted_unit_code
-            AND sdd.dict_type = 'unit_code'
-            AND sdd.status = '0'
        WHERE t1.delete_flag = '0'
-          AND t1.category_code = #{categoryCode}
+          AND t1.category_code = '23'
          <if test="searchKey != null and searchKey != ''">
              AND (t1.name ILIKE '%' || #{searchKey} || '%' OR t1.py_str ILIKE '%' || #{searchKey} || '%')
          </if>
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationEmrAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationEmrAppMapper.xml
@@ -4,38 +4,4 @@
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.openhis.web.doctorstation.mapper.DoctorStationEmrAppMapper">

-    <select id="getPendingEmrList" resultType="java.util.HashMap">
-        SELECT e.id AS "encounterId",
-               e.patient_id AS "patientId",
-               p.name AS "patientName",
-               p.gender_enum AS "gender",
-               p.birth_date AS "birthDate",
-               e.create_time AS "registerTime",
-               e.bus_no AS "busNo"
-        FROM adm_encounter e
-        INNER JOIN adm_encounter_participant ep ON e.id = ep.encounter_id AND ep.practitioner_id = #{doctorId}
-        LEFT JOIN adm_patient p ON e.patient_id = p.id
-        LEFT JOIN doc_emr emr ON e.id = emr.encounter_id
-        WHERE e.status_enum = 2
-          AND emr.id IS NULL
-        <if test="patientName != null and patientName != ''">
-            AND p.name LIKE CONCAT('%', #{patientName}, '%')
-        </if>
-        ORDER BY e.create_time DESC
-        LIMIT #{pageSize} OFFSET #{offset}
-    </select>
-
-    <select id="getPendingEmrCount" resultType="java.lang.Long">
-        SELECT COUNT(*)
-        FROM adm_encounter e
-        INNER JOIN adm_encounter_participant ep ON e.id = ep.encounter_id AND ep.practitioner_id = #{doctorId}
-        LEFT JOIN adm_patient p ON e.patient_id = p.id
-        LEFT JOIN doc_emr emr ON e.id = emr.encounter_id
-        WHERE e.status_enum = 2
-          AND emr.id IS NULL
-        <if test="patientName != null and patientName != ''">
-            AND p.name LIKE CONCAT('%', #{patientName}, '%')
-        </if>
-    </select>
-
 </mapper>
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationPtDetailsAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationPtDetailsAppMapper.xml
@@ -11,10 +11,6 @@
        p.birth_date,
        p.phone,
        p.address,
-        p.address_province,
-        p.address_city,
-        p.address_district,
-        p.address_street,
        p.work_company,
        p.nationality_code,
        p.marital_status_enum,
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/pharmacymanage/PendingMedicationDetailsMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/pharmacymanage/PendingMedicationDetailsMapper.xml
@@ -51,7 +51,7 @@
                                     ON T5.medication_def_id = T6.id
                                          AND T5.delete_flag = '0'
                  WHERE T1.delete_flag = '0'
-                    AND T1.status_enum IN (#{inProgress}, #{preparation}, #{prepared}, #{summarized})
+                    AND T1.status_enum IN (#{inProgress}, #{preparation}, #{prepared})
                  ORDER BY T1.create_time DESC
              ) AS T7
            ${ew.customSqlSegment}
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/pharmacymanage/WesternMedicineDispenseMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/pharmacymanage/WesternMedicineDispenseMapper.xml
@@ -97,10 +97,10 @@
                                    ON T4.med_req_id = T5.id
                                        AND T5.delete_flag = '0'
                   WHERE <if test="statusEnum == null">
-                            T4.status_enum IN (#{inProgress},#{completed},#{preparation},#{prepared},#{summarized})
+                            T4.status_enum IN (#{inProgress},#{completed},#{preparation},#{prepared})
                         </if>
                         <if test="statusEnum == 3">
-                             T4.status_enum IN (#{inProgress},#{preparation},#{prepared},#{summarized})
+                             T4.status_enum IN (#{inProgress},#{preparation},#{prepared})
                         </if>
                         <if test="statusEnum == 4">
                             T4.status_enum = #{completed}
@@ -269,10 +269,10 @@
        AND T1.summary_no != ''
        AND
        <if test="dispenseStatus == null">
-            T1.status_enum IN (#{inProgress},#{completed},#{preparation},#{prepared},#{summarized})
+            T1.status_enum IN (#{inProgress},#{completed},#{preparation},#{prepared})
        </if>
        <if test="dispenseStatus == 3">
-            T1.status_enum IN (#{inProgress},#{preparation},#{prepared},#{summarized})
+            T1.status_enum IN (#{inProgress},#{preparation},#{prepared})
        </if>
        <if test="dispenseStatus == 4">
            T1.status_enum = #{completed}
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/regdoctorstation/AdviceManageAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/regdoctorstation/AdviceManageAppMapper.xml
@@ -216,12 +216,8 @@
        ccd.name AS condition_definition_name,
        T1.therapy_enum AS therapyEnum,
        T1.sort_number AS sort_number,
-        T1.effective_dose_start AS start_time,
        T1.based_on_id AS based_on_id,
-        T1.medication_id AS advice_definition_id,
-        T1.content_json::jsonb ->> 'remark' AS remark,
-        T1.effective_dose_end AS stop_time,
-        T1.update_by AS stop_user_name
+        T1.medication_id AS advice_definition_id
        FROM med_medication_request AS T1
        LEFT JOIN med_medication_definition AS T2 ON T2.ID = T1.medication_id
        AND T2.delete_flag = '0'
@@ -273,12 +269,8 @@
        '' AS condition_definition_name,
        2 AS therapyEnum,
        99 AS sort_number,
-        T1.req_authored_time AS start_time,
        T1.based_on_id AS based_on_id,
-        T1.device_def_id AS advice_definition_id,
-        T1.content_json::jsonb ->> 'remark' AS remark,
-        NULL::timestamp AS stop_time,
-        '' AS stop_user_name
+        T1.device_def_id AS advice_definition_id
        FROM wor_device_request AS T1
        LEFT JOIN adm_device_definition AS T2 ON T2.ID = T1.device_def_id
        AND T2.delete_flag = '0'
@@ -327,12 +319,8 @@
        '' AS condition_definition_name,
        COALESCE(T1.therapy_enum, 2) AS therapyEnum,
        99 AS sort_number,
-        T1.occurrence_start_time AS start_time,
        T1.based_on_id AS based_on_id,
-        T1.activity_id AS advice_definition_id,
-        T1.remark AS remark,
-        T1.occurrence_end_time AS stop_time,
-        T1.update_by AS stop_user_name
+        T1.activity_id AS advice_definition_id
        FROM wor_service_request AS T1
        LEFT JOIN wor_activity_definition AS T2
        ON T2.ID = T1.activity_id
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/regdoctorstation/RequestFormManageAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/regdoctorstation/RequestFormManageAppMapper.xml
@@ -30,79 +30,26 @@
                   drf.create_time,
                   ap.NAME AS patient_name,
                   CASE
-                       -- ========== 手术专用映射 (categoryEnum=24) ==========
-                       -- 手术申请单状态枚举: 1=待签发 2=已签发 3=已校对 4=已执行 5=已安排 6=已完成 10=已作废
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 10
-                       ) THEN 10
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 6
-                       ) THEN 6
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 5
-                       ) THEN 5
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 4
-                       ) THEN 4
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 3
-                       ) THEN 3
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 2
-                       ) THEN 2
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.category_enum = 24 AND ws.status_enum = 1
-                       ) THEN 1
-                       -- ========== 通用映射 (非手术类型: 检查/检验/药品/输血) ==========
                       WHEN EXISTS (
                           SELECT 1 FROM wor_service_request ws
                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
                             AND ws.status_enum = 8
                       ) THEN 6
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.status_enum = 5
-                       ) THEN 7
                       WHEN EXISTS (
                           SELECT 1 FROM wor_service_request ws
                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
                             AND ws.status_enum = 3
                       ) THEN 5
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.status_enum = 12
-                       ) THEN 4
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.status_enum = 11
-                       ) THEN 3
-                       WHEN EXISTS (
-                           SELECT 1 FROM wor_service_request ws
-                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
-                             AND ws.status_enum = 10
-                       ) THEN 2
                       WHEN EXISTS (
                           SELECT 1 FROM wor_service_request ws
                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
                             AND ws.status_enum = 2
                       ) THEN 1
+                       WHEN EXISTS (
+                           SELECT 1 FROM wor_service_request ws
+                           WHERE ws.prescription_no = drf.prescription_no AND ws.delete_flag = '0'
+                             AND ws.status_enum = 5
+                       ) THEN 7
                       ELSE 0
                   END AS computed_status
            FROM doc_request_form AS drf
@@ -110,6 +57,8 @@
                AND ae.delete_flag = '0'
                     LEFT JOIN adm_patient AS ap ON ap.ID = ae.patient_id
                AND ap.delete_flag = '0'
+                     LEFT JOIN wor_service_request AS wsr ON wsr.prescription_no = drf.prescription_no
+                AND wsr.delete_flag = '0'
            WHERE drf.delete_flag = '0'
              AND drf.encounter_id = #{encounterId}
              AND drf.type_code = #{typeCode}
--- a/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/AssignSeqEnum.java
+++ b/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/AssignSeqEnum.java
@@ -274,14 +274,6 @@ public enum AssignSeqEnum {
     * 检查申请单号（住院）
     */
    CHECK_APPLY_NO("72", "检查申请单号", "JCZ"),
-    /**
-     * 手术申请单号（住院）
-     */
-    SURGERY_APPLY_NO("73", "手术申请单号", "SSZ"),
-    /**
-     * 检验申请单号（住院）
-     */
-    LAB_APPLY_NO("74", "检验申请单号", "JYZ"),
    /**
     * b 病历文书
     */
--- a/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/RequestStatus.java
+++ b/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/RequestStatus.java
@@ -57,22 +57,7 @@ public enum RequestStatus implements HisEnumInterface {
    /**
     * 未知
     */
-    UNKNOWN(9, "unknown", "未知"),
-
-    /**
-     * 已校对（检查申请：护士校对通过）
-     */
-    CHECK_VERIFIED(10, "check_verified", "已校对"),
-
-    /**
-     * 待接收（检查申请：等待医技科室接单）
-     */
-    PENDING_RECEIVE(11, "pending_receive", "待接收"),
-
-    /**
-     * 已接收（检查申请：医技科室已接单）
-     */
-    CHECK_RECEIVED(12, "check_received", "已接收");
+    UNKNOWN(9, "unknown", "未知");

    @EnumValue
    private final Integer value;
--- a/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SlotStatus.java
+++ b/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SlotStatus.java
@@ -8,10 +8,10 @@ import lombok.Getter;
 *
 * <pre>
 * 状态流转:
- *   预约     → 0→2 (锁定), locked_num+1, booked_num+1
- *   取消预约 → 2→0 (释放), refreshPoolStats 重算
- *   签到     → 2→3 (已签到), locked_num-1
- *   退号     → →0 (释放), refreshPoolStats 重算
+ *   预约     → 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>
 *
--- a/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SurgeryAppStatusEnum.java
+++ b/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SurgeryAppStatusEnum.java
@@ -1,84 +0,0 @@
-package com.openhis.common.enums;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-/**
- * 手术申请单状态枚举
- * <p>
- * 区别于 {@link SurgeryStatusEnum}（手术管理状态：待排期/已排期/手术中/已完成/已取消/暂停），
- * 本枚举用于手术申请单的业务流转状态，覆盖从医生开立到手术完成的完整生命周期。
- *
- * <pre>
- * 正向流转:
- *   待签发(1) → 已签发(2) → 已校对(3) → 已执行(4) → 已安排(5) → 已完成(6)
- *
- * 逆向流转:
- *   已签发(2) → 待签发(1)   （医生撤回 / 护士退回）
- *   已执行(4) → 已校对(3)   （护士取消执行）
- *   任意状态 → 已作废(10)   （医生撤销）
- * </pre>
- *
- * @author system
- * @date 2026-06-02
- */
-@Getter
-@AllArgsConstructor
-public enum SurgeryAppStatusEnum {
-
-    /** 待签发 — 医生已保存但尚未提交，仅在医生站可见 */
-    PENDING_SIGN(1, "待签发"),
-
-    /** 已签发 — 医生已提交，自动流转至护士工作站待校对 */
-    SIGNED(2, "已签发"),
-
-    /** 已校对 — 病区护士已校对手术医嘱 */
-    VERIFIED(3, "已校对"),
-
-    /** 已执行 — 病区护士已执行手术医嘱，已向手麻科提交申请 */
-    EXECUTED(4, "已执行"),
-
-    /** 已安排 — 手麻科已排好手术间及时间，待手术 */
-    SCHEDULED(5, "已安排"),
-
-    /** 已完成 — 手术已结束并录入完毕（终态只读） */
-    COMPLETED(6, "已完成"),
-
-    /** 已作废 — 医生中途撤销了手术申请（终态） */
-    CANCELLED(10, "已作废");
-
-    private final Integer code;
-    private final String info;
-
-    /**
-     * 根据状态码获取枚举
-     *
-     * @param code 状态码
-     * @return 对应的枚举，未匹配返回 null
-     */
-    public static SurgeryAppStatusEnum getByCode(Integer code) {
-        if (code == null) {
-            return null;
-        }
-        for (SurgeryAppStatusEnum val : values()) {
-            if (val.getCode().equals(code)) {
-                return val;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 判断是否为终态（不可再变更）
-     */
-    public boolean isFinal() {
-        return this == COMPLETED || this == CANCELLED;
-    }
-
-    /**
-     * 判断是否允许医生编辑
-     */
-    public boolean isEditable() {
-        return this == PENDING_SIGN;
-    }
-}
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/appointmentmanage/mapper/SchedulePoolMapper.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/appointmentmanage/mapper/SchedulePoolMapper.java
@@ -24,7 +24,7 @@ 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 IN (#{bookedStatus}, #{lockedStatus}, 3)
+                      AND s.status = #{bookedStatus}
                ), 0),
                locked_num = COALESCE((
                    SELECT COUNT(1)
@@ -42,7 +42,7 @@ public interface SchedulePoolMapper extends BaseMapper<SchedulePool> {
                         @Param("lockedStatus") Integer lockedStatus);

    /**
-     * 签到时更新号源池统计：锁定数-1（booked_num 在预约时已累加）
+     * 签到时更新号源池统计：锁定数-1，已预约数+1
     *
     * @param poolId 号源池ID
     * @return 结果
@@ -50,6 +50,7 @@ public interface SchedulePoolMapper extends BaseMapper<SchedulePool> {
    @Update("""
            UPDATE adm_schedule_pool
            SET locked_num = locked_num - 1,
+                booked_num = booked_num + 1,
                update_time = NOW()
            WHERE id = #{poolId}
              AND locked_num > 0
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/impl/TicketServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/impl/TicketServiceImpl.java
@@ -267,7 +267,7 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
        if (poolId != null) {
            schedulePoolMapper.update(null,
                new LambdaUpdateWrapper<SchedulePool>()
-                    .setSql("locked_num = locked_num + 1, booked_num = booked_num + 1, version = version + 1")
+                    .setSql("locked_num = locked_num + 1, version = version + 1")
                    .set(SchedulePool::getUpdateTime, new Date())
                    .eq(SchedulePool::getId, poolId));
        }
@@ -329,16 +329,16 @@ 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→3(LOCKED→CHECKED_IN)
+        // 2. 只有锁定态(2)的号源才能签到，签到时 2→1(LOCKED→BOOKED)
        ScheduleSlot slot = scheduleSlotMapper.selectById(slotId);
        if (slot == null || !SlotStatus.LOCKED.getValue().equals(slot.getStatus())) {
            throw new RuntimeException("号源状态异常，无法签到");
        }

-        // 3. 更新号源槽位状态 2→3（LOCKED→CHECKED_IN，已签到）
-        scheduleSlotMapper.updateSlotStatusAndCheckInTime(slotId, SlotStatus.CHECKED_IN.getValue(), new Date(), SlotStatus.LOCKED.getValue());
+        // 3. 更新号源槽位状态 2→1（LOCKED→BOOKED，已预约=已签到）
+        scheduleSlotMapper.updateSlotStatusAndCheckInTime(slotId, SlotStatus.BOOKED.getValue(), new Date(), SlotStatus.LOCKED.getValue());

-        // 4. 更新号源池统计：锁定数-1，已签到数+1
+        // 4. 更新号源池统计：锁定数-1，已预约数+1
        if (slot != null && slot.getPoolId() != null) {
            schedulePoolMapper.updatePoolStatsOnCheckIn(slot.getPoolId());
        }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/medication/domain/MedicationRequest.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/medication/domain/MedicationRequest.java
@@ -111,9 +111,6 @@ public class MedicationRequest extends HisBaseEntity {
    /** 支持用药信息 */
    private String supportInfo;

-    /** 退回原因 */
-    private String backReason = "";
-
    /** 请求开始时间 */
    private Date reqAuthoredTime;

--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/medication/service/IMedicationRequestService.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/medication/service/IMedicationRequestService.java
@@ -30,7 +30,7 @@ public interface IMedicationRequestService extends IService<MedicationRequest> {
     * @param practitionerId 校对人
     * @param checkDate 校对时间
     */
-    void updateDraftStatusBatch(List<Long> requestIdList, Long practitionerId, Date checkDate, String backReason);
+    void updateDraftStatusBatch(List<Long> requestIdList, Long practitionerId, Date checkDate);

    /**
     * 更新请求状态：取消
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/medication/service/impl/MedicationRequestServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/medication/service/impl/MedicationRequestServiceImpl.java
@@ -44,7 +44,7 @@ public class MedicationRequestServiceImpl extends ServiceImpl<MedicationRequestM
     * @param checkDate 校对时间
     */
    @Override
-    public void updateDraftStatusBatch(List<Long> requestIdList, Long practitionerId, Date checkDate, String backReason) {
+    public void updateDraftStatusBatch(List<Long> requestIdList, Long practitionerId, Date checkDate) {
        LambdaUpdateWrapper<MedicationRequest> updateWrapper =
            new LambdaUpdateWrapper<MedicationRequest>().in(MedicationRequest::getId, requestIdList)
                .set(MedicationRequest::getStatusEnum, RequestStatus.DRAFT.getValue());
@@ -54,9 +54,6 @@ public class MedicationRequestServiceImpl extends ServiceImpl<MedicationRequestM
        if (checkDate != null) {
            updateWrapper.set(MedicationRequest::getCheckTime, checkDate);
        }
-        if (backReason != null) {
-            updateWrapper.set(MedicationRequest::getBackReason, backReason);
-        }
        baseMapper.update(null, updateWrapper);
    }

--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/surgicalschedule/domain/OpSchedule.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/surgicalschedule/domain/OpSchedule.java
@@ -79,13 +79,11 @@ public class OpSchedule extends HisBaseEntity {
    private String surgerySite;

    /** 入院时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime admissionTime;

    /** 入手术室时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime entryTime;

    /** 手术室编码 */
@@ -144,23 +142,19 @@ public class OpSchedule extends HisBaseEntity {
    private String assistant3Code;

    /** 手术开始时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime startTime;

    /** 手术结束时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime endTime;

    /** 麻醉开始时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime anesStart;

    /** 麻醉结束时间 */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime anesEnd;

    /** 手术状态 */
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/domain/ServiceRequest.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/domain/ServiceRequest.java
@@ -173,9 +173,4 @@ public class ServiceRequest extends HisBaseEntity {
     */
    private Integer generateSourceEnum;

-    /**
-     * 备注（最长50字）
-     */
-    private String remark;
-
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/IServiceRequestService.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/IServiceRequestService.java
@@ -39,22 +39,6 @@ public interface IServiceRequestService extends IService<ServiceRequest> {
     */
    void updateCompleteRequestStatus(List<Long> serReqIdList, Long practitionerId, Date checkDate);

-    /**
-     * 更新检查申请状态：已校对（护士校对检查申请后状态为CHECK_VERIFIED，而非COMPLETED）
-     *
-     * @param serReqIdList 服务请求id列表
-     * @param practitionerId 校对人
-     * @param checkDate 校对时间
-     */
-    void updateCheckVerifiedStatus(List<Long> serReqIdList, Long practitionerId, Date checkDate);
-
-    /**
-     * 更新检查申请状态：待接收（护士执行检查申请后状态为PENDING_RECEIVE）
-     *
-     * @param serReqIdList 服务请求id列表
-     */
-    void updatePendingReceiveStatus(List<Long> serReqIdList);
-
    /**
     * 获取执行过的诊疗数据
     *
@@ -109,7 +93,7 @@ public interface IServiceRequestService extends IService<ServiceRequest> {
     * @param practitionerId 校对人
     * @param checkDate 校对时间
     */
-    void updateDraftStatus(List<Long> serviceRequestIdList, Long practitionerId, Date checkDate, String backReason);
+    void updateDraftStatus(List<Long> serviceRequestIdList, Long practitionerId, Date checkDate);

    /**
     * 更新服务状态：待发送
@@ -149,12 +133,4 @@ public interface IServiceRequestService extends IService<ServiceRequest> {
     * @return 请求信息列表
     */
    List<ServiceRequest> getServiceRequestListByEncounterId(Long encounterId);
-
-    /**
-     * 更新手术申请单状态（批量）
-     *
-     * @param serReqIdList 服务请求id列表
-     * @param statusCode 手术申请单状态码 (SurgeryAppStatusEnum)
-     */
-    void updateSurgeryAppStatus(List<Long> serReqIdList, Integer statusCode);
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/impl/ServiceRequestServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/impl/ServiceRequestServiceImpl.java
@@ -66,31 +66,6 @@ public class ServiceRequestServiceImpl extends ServiceImpl<ServiceRequestMapper,
                        .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
    }

-    /**
-     * 更新检查申请状态：已校对（护士校对检查申请后状态为CHECK_VERIFIED，而非COMPLETED）
-     *
-     * @param serReqIdList 服务请求id列表
-     */
-    @Override
-    public void updateCheckVerifiedStatus(List<Long> serReqIdList, Long practitionerId, Date checkDate) {
-        baseMapper.update(new ServiceRequest().setStatusEnum(RequestStatus.CHECK_VERIFIED.getValue())
-                .setPerformerCheckId(SecurityUtils.getLoginUser().getPractitionerId()).setCheckTime(DateUtils.getNowDate()),
-                new LambdaUpdateWrapper<ServiceRequest>().in(ServiceRequest::getId, serReqIdList)
-                        .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
-    }
-
-    /**
-     * 更新检查申请状态：待接收（护士执行检查申请后状态为PENDING_RECEIVE）
-     *
-     * @param serReqIdList 服务请求id列表
-     */
-    @Override
-    public void updatePendingReceiveStatus(List<Long> serReqIdList) {
-        baseMapper.update(new ServiceRequest().setStatusEnum(RequestStatus.PENDING_RECEIVE.getValue()),
-                new LambdaUpdateWrapper<ServiceRequest>().in(ServiceRequest::getId, serReqIdList)
-                        .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
-    }
-
    /**
     * 获取执行过的诊疗数据
     *
@@ -197,15 +172,9 @@ public class ServiceRequestServiceImpl extends ServiceImpl<ServiceRequestMapper,
     * @param checkDate 校对时间
     */
    @Override
-    public void updateDraftStatus(List<Long> serviceRequestIdList, Long practitionerId, Date checkDate, String backReason) {
-        ServiceRequest updateEntity = new ServiceRequest()
-                .setStatusEnum(RequestStatus.DRAFT.getValue())
-                .setPerformerCheckId(SecurityUtils.getLoginUser().getPractitionerId())
-                .setCheckTime(DateUtils.getNowDate());
-        if (backReason != null && !backReason.isEmpty()) {
-            updateEntity.setReasonText(backReason);
-        }
-        baseMapper.update(updateEntity,
+    public void updateDraftStatus(List<Long> serviceRequestIdList, Long practitionerId, Date checkDate) {
+        baseMapper.update(new ServiceRequest().setStatusEnum(RequestStatus.DRAFT.getValue())
+                .setPerformerCheckId(SecurityUtils.getLoginUser().getPractitionerId()).setCheckTime(DateUtils.getNowDate()),
                new LambdaUpdateWrapper<ServiceRequest>().in(ServiceRequest::getId, serviceRequestIdList)
                        .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
    }
@@ -278,19 +247,4 @@ public class ServiceRequestServiceImpl extends ServiceImpl<ServiceRequestMapper,
        return baseMapper.selectList(new LambdaQueryWrapper<ServiceRequest>()
                .eq(ServiceRequest::getEncounterId, encounterId).eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
    }
-
-    /**
-     * 更新手术申请单状态（批量）
-     *
-     * @param serReqIdList 服务请求id列表
-     * @param statusCode 手术申请单状态码 (SurgeryAppStatusEnum: 1=待签发,2=已签发,3=已校对,4=已执行,5=已安排,6=已完成,10=已作废)
-     */
-    @Override
-    public void updateSurgeryAppStatus(List<Long> serReqIdList, Integer statusCode) {
-        baseMapper.update(null,
-                new LambdaUpdateWrapper<ServiceRequest>()
-                        .set(ServiceRequest::getStatusEnum, statusCode)
-                        .in(ServiceRequest::getId, serReqIdList)
-                        .eq(ServiceRequest::getDeleteFlag, DelFlag.NO.getCode()));
-    }
 }
--- a/openhis-server-new/openhis-domain/src/main/resources/mapper/administration/EncounterDiagnosisMapper.xml
+++ b/openhis-server-new/openhis-domain/src/main/resources/mapper/administration/EncounterDiagnosisMapper.xml
@@ -27,7 +27,6 @@
          AND T1.delete_flag = '0'
          AND T2.delete_flag = '0'
          AND T1.tenant_id = #{tenantId}
-        LIMIT 1
    </select>

 </mapper>
--- a/openhis-server-new/openhis-domain/src/main/resources/mapper/administration/ScheduleSlotMapper.xml
+++ b/openhis-server-new/openhis-domain/src/main/resources/mapper/administration/ScheduleSlotMapper.xml
@@ -340,8 +340,8 @@
                            OR d.is_stopped = FALSE
                        )
                    </when>
-                    <when test="'checked'.equals(query.status) or '已取号'.equals(query.status) or '已签到'.equals(query.status)">
-                        AND (<include refid="slotStatusNormExpr" /> = 1 OR <include refid="slotStatusNormExpr" /> = 3)
+                    <when test="'checked'.equals(query.status) or '已取号'.equals(query.status)">
+                        AND <include refid="slotStatusNormExpr" /> = 1
                        AND (
                            d.is_stopped IS NULL
                            OR d.is_stopped = FALSE
--- a/openhis-ui-vue3/.gitignore
+++ b/openhis-ui-vue3/.gitignore
@@ -26,4 +26,3 @@ yarn.lock
 test-results/
 tests/e2e/report/
 tests/tests/
-vite.config.js.timestamp*
--- a/openhis-ui-vue3/package-lock.json
+++ b/openhis-ui-vue3/package-lock.json
--- a/openhis-ui-vue3/package.json
+++ b/openhis-ui-vue3/package.json
@@ -28,61 +28,66 @@
  },
  "dependencies": {
    "@element-plus/icons-vue": "^2.3.2",
-                         "@vue/shared":  "^3.5.25",
-                         "@vueup/vue-quill":  "^1.5.1",
-                         "@vueuse/core":  "^14.3.0",
-                         "axios":  "^1.16.1",
+    "@vueup/vue-quill": "1.2.0",
+    "@vueuse/core": "10.6.1",
+    "axios": "0.27.2",
    "china-division": "^2.7.0",
    "d3": "^7.9.0",
    "dayjs": "^1.11.19",
    "decimal.js": "^10.5.0",
    "echarts": "^5.4.3",
    "element-china-area-data": "^6.1.0",
-                         "element-plus":  "^2.14.1",
+    "element-plus": "^2.12.0",
    "file-saver": "^2.0.5",
    "fuse.js": "^7.0.0",
    "html2pdf.js": "^0.10.3",
    "js-cookie": "^3.0.5",
    "jsencrypt": "^3.3.2",
    "json-bigint": "^1.0.0",
+    "lodash": "^4.17.21",
    "lodash-es": "^4.17.21",
+    "moment": "^2.30.1",
+    "next": "^16.1.0",
    "nprogress": "^0.2.0",
    "pinia": "^2.2.0",
    "pinyin": "^4.0.0-alpha.2",
    "province-city-china": "^8.5.8",
+    "qrcode": "^1.5.4",
    "qrcodejs2": "^0.0.2",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
    "segmentit": "^2.0.3",
-                         "sortablejs":  "^1.15.7",
+    "sortablejs": "^1.15.6",
    "v-region": "^3.3.0",
-                         "vue":  "^3.5.25",
+    "vue": "^3.5.13",
    "vue-area-linkage": "^5.1.0",
    "vue-cropper": "^1.1.1",
-                         "vue-plugin-hiprint":  "^0.0.60",
-                         "vue-router":  "^4.3.0",
-                         "vxe-table":  "^4.19.6",
-                         "xe-utils":  "^4.0.8"
+    "vue-plugin-hiprint": "^0.0.19",
+    "vue-router": "^4.3.0"
  },
  "devDependencies": {
-                            "@playwright/test":  "^1.60.0",
+    "@playwright/test": "^1.58.2",
    "@types/node": "^25.0.1",
-                            "@vitejs/plugin-vue":  "^5.2.4",
+    "@vitejs/plugin-vue": "4.5.0",
+    "@vue/compiler-sfc": "3.3.9",
    "@vue/test-utils": "^2.4.6",
-                            "eslint":  "^10.4.1",
+    "eslint": "^9.39.4",
    "eslint-import-resolver-alias": "^1.1.2",
    "eslint-plugin-import": "^2.32.0",
-                            "eslint-plugin-vue":  "^10.9.1",
+    "eslint-plugin-vue": "^10.9.0",
    "globals": "^17.5.0",
    "happy-dom": "^20.8.3",
    "jsdom": "^28.1.0",
    "pg": "^8.18.0",
-                            "sass":  "^1.100.0",
+    "sass": "1.69.5",
    "typescript": "^5.9.3",
-                            "unplugin-auto-import":  "^0.18.6",
-                            "vite":  "^6.4.3",
+    "unplugin-auto-import": "0.17.1",
+    "unplugin-vue-setup-extend-plus": "1.0.0",
+    "vite": "5.0.4",
    "vite-plugin-compression": "0.5.1",
    "vite-plugin-svg-icons": "2.0.1",
    "vite-plugin-vue-mcp": "^0.3.2",
    "vitest": "^4.0.18",
-                            "vue-tsc":  "^3.3.3"
+    "vue-tsc": "^3.1.8"
  }
 }
--- a/openhis-ui-vue3/src/action/nurseStation/temperatureSheet/drawfn.js
+++ b/openhis-ui-vue3/src/action/nurseStation/temperatureSheet/drawfn.js
@@ -1,5 +1,6 @@
-// 数据处理
+// 数据处理
 import * as d3 from 'd3';
+import {symbol} from 'd3-shape';
 import {
    degreesOnline,
    disconnectEvents,
@@ -141,7 +142,7 @@ export const iconDrawObj = {
      })
      .append('path')
      .call((path) => {
-        const symbolThree = d3.symbol();
+        const symbolThree = symbol();
        const symbolIndex = 5;
        symbolThree.type(d3.symbols[symbolIndex]);
        path.attr('d', symbolThree.size(riangle)).attr('fill', fill).attr('stroke', stroke);
@@ -161,24 +162,6 @@ export function getG(svg, viewConfig) {
 // 设置数据
 export function getData(allData) {
  const rowsData = allData.rows; // allData, '【全部数据】'
-  // 兼容旧数据：将旧 typeCode 映射到新 typeCode（心率 004→014，脉搏 005→002，呼吸 006→001）
-  const OLD_CODE_MAP = { '004': '014', '005': '002', '006': '001' };
-  rowsData.forEach(row => {
-    if (row.rowBOS) {
-      const prependItems = [];
-      row.rowBOS.forEach(item => {
-        const newCode = OLD_CODE_MAP[item.typeCode];
-        // 始终添加映射条目，用 unshift 插入数组头部
-        // 这样 getType 的 find() 优先匹配映射后的编码（如脉冲、呼吸）
-        // 即使存在同编码的旧条目（如血压舒张压用 002、收缩压用 001），
-        // 映射后的脉搏(002)和呼吸(001)条目排在前面，确保图表正确渲染
-        if (newCode) {
-          prependItems.push({ ...item, typeCode: newCode });
-        }
-      });
-      row.rowBOS.unshift(...prependItems);
-    }
-  });
  const infoData = allData.grParamBOS;
  const typesData = getTypeDatas(allData.types, allData.grParamBOS.beginDate);
  const selectOp = allData.selectOp;
--- a/openhis-ui-vue3/src/action/nurseStation/temperatureSheet/utils.js
+++ b/openhis-ui-vue3/src/action/nurseStation/temperatureSheet/utils.js
@@ -1,4 +1,4 @@
-import dayjs from 'dayjs';
+import moment from 'moment';

 export function getG(svg, translateX, translateY) {
  return svg.append('g').attr('transform', `translate(${translateX},${translateY})`);
@@ -228,7 +228,7 @@ export function getHeartRate(
 function getIndex(beginDate, date, time) {
  if (beginDate === undefined || date === undefined) return;
  const diffTime =
-    dayjs(date.substring(0, 10)).diff(dayjs(beginDate.substring(0, 10))) / 1000 / 3600 / 24;
+    moment(date.substring(0, 10)).diff(moment(beginDate.substring(0, 10))) / 1000 / 3600 / 24;
  const diffIndex = parseInt(time.substring(0, 2));
  return diffTime * 6 + Math.floor(diffIndex / 4);
 }
--- a/openhis-ui-vue3/src/assets/styles/btn.scss
+++ b/openhis-ui-vue3/src/assets/styles/btn.scss
@@ -1,4 +1,3 @@
-@use 'sass:color';
@import './variables.module.scss';

 // Element Plus风格的颜色按钮样式
@@ -23,14 +22,14 @@

  &:hover,
  &:focus {
-    background-color: color.adjust($color, $lightness: 10%);
-    border-color: color.adjust($color, $lightness: 10%);
+    background-color: lighten($color, 10%);
+    border-color: lighten($color, 10%);
    color: #fff;
  }

  &:active {
-    background-color: color.adjust($color, $lightness: -5%);
-    border-color: color.adjust($color, $lightness: -5%);
+    background-color: darken($color, 5%);
+    border-color: darken($color, 5%);
    color: #fff;
  }

@@ -91,7 +90,7 @@

  &:hover,
  &:focus {
-    color: #3B82F6;
+    color: #409eff;
    border-color: #c6e2ff;
    background-color: #ecf5ff;
  }
@@ -150,7 +149,7 @@
 // 不同颜色的链接按钮
 .blue-btn-link {
  @extend .pan-btn-link;
-  color: #3B82F6;
+  color: #409eff;
  
  &:hover,
  &:focus {
@@ -160,7 +159,7 @@

 .red-btn-link {
  @extend .pan-btn-link;
-  color: #EF4444;
+  color: #f56c6c;
  
  &:hover,
  &:focus {
@@ -170,7 +169,7 @@

 .info-btn-link {
  @extend .pan-btn-link;
-  color: #64748B;
+  color: #909399;
  
  &:hover,
  &:focus {
--- a/Show More
+++ b/Show More