Merge remote-tracking branch 'origin/develop' into develop

门诊管理-》门诊划价：新增耗材点击【保存】报错的问题（设置租户id，创建者，创建时间）
上传文件至 md/需求
2026-01-23 17:11:51 +08:00 · 2026-01-23 17:08:29 +08:00 · 2026-01-23 16:49:43 +08:00 · 2026-01-23 16:17:00 +08:00 · 2026-01-23 16:13:57 +08:00 · 2026-01-23 16:12:56 +08:00
135 changed files with 11233 additions and 5565 deletions
--- a/md/test.html
+++ b/md/test.html
@@ -1,10 +0,0 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
    <meta charset="UTF-8">
    <title>测试合并11111</title>
 </head>
 <body>
 </body>
 </html>
--- a/md/需求/100-门诊手术中临时医嘱生成界面PRD_2026-1-23.md
+++ b/md/需求/100-门诊手术中临时医嘱生成界面PRD_2026-1-23.md
@@ -0,0 +1,273 @@
 ## 门诊手术中临时医嘱生成界面PRD文档
 ### 一、页面概述
 **页面名称**：门诊手术中临时医嘱生成界面  
 **页面目标**：帮助麻醉医师在手术过程中快速生成临时医嘱，完成药品计费引用、医嘱预览和电子签名确认的全流程操作  
 **适用场景**：门诊手术过程中需要追加药品医嘱时使用  
 **页面类型**：表单页+数据展示页
 **核心功能**：
 1.  患者手术信息展示
 2.  已引用计费药品列表展示与汇总
 3.  临时医嘱预览与编辑功能
 4.  医师电子签名确认流程
 5.  数据刷新与退出操作  
    **用户价值**：简化手术中医嘱生成流程，确保医嘱准确性，实现无纸化操作，提高手术室工作效率
 原型图地址：https://static.pm-ai.cn/prototype/20260122/e1d7f10b85e9efea543bf47bd6831600/index.html
 **流程图：**
 ```mermaid
 flowchart TD
    Start(["Start"]) --> Enter["进入门诊手术中临时医嘱生成界面"]
    Enter --> ShowBase["展示患者基本信息"]
    ShowBase --> ShowQuoted["显示已引用计费药品列表"]
    ShowQuoted --> ShowPreview["显示医嘱预览表格"]
    ShowPreview --> UserOp{用户操作}
    UserOp -- "引用计费" --> GetLatest{"获取最新计费药品数据\n获取成功?"}
    GetLatest -- "否" --> ErrTip1["显示错误提示"]
    GetLatest -- "是" --> UpdateTable["更新药品表格和汇总"]
    UserOp -- "编辑" --> PopEdit["弹出医嘱编辑表单"]
    PopEdit --> EditVal{"验证通过?"}
    EditVal -- "否" --> ErrTip2["返回错误提示"]
    EditVal -- "是" --> SaveClick{"点击保存?"}
    SaveClick -- "是" --> GenTemp["生成临时药品医嘱"]
    SaveClick -- "否" --> UserOp
    GenTemp --> UpdatePreview["更新医嘱预览表格"]
    UpdatePreview --> UpdateRecord["更新手术记录"]
    UpdateRecord --> ShowResult["显示生成结果"]
    UserOp -- "一键签名并生成医嘱" --> PopPwd["弹出账户密码输入框"]
    PopPwd --> PopConfirm{"弹出确认对话框"}
    PopConfirm -- "否" --> UserOp
    PopConfirm -- "是" --> GenTemp
    UserOp -- "刷新" --> Reload["重新加载界面数据"]
    Reload --> ShowQuoted
    UserOp -- "退出" --> ExitConfirm{"确认退出？"}
    ExitConfirm -- "否" --> UserOp
    ExitConfirm -- "是" --> ReturnUp["返回上级页面"]
    ErrTip1 --> UserOp
    ErrTip2 --> PopEdit
    ShowResult --> UserOp
    ReturnUp --> End([结束])
 ```
 ### 二、整体布局分析
 **页面宽度**：自适应布局
 **要区域划分**：
 1.  顶部信息区（15%）：患者基本信息+操作按钮区
 2.  计费药品展示区（35%）：已引用计费药品表格+金额汇总
 3.  医嘱预览区（35%）：待生成医嘱的预览表格
 4.  签名确认区（15%）：医师签名信息+操作按钮  
    **布局特点**：上下分块布局，采用卡片式设计，主要区域间有明确分隔线  
    **响应式要求**：768px以下时患者信息改为纵向排列，操作按钮换行显示
 ### 三、页面区域详细描述
 #### 1. 顶部信息区
 **区域位置**：页面顶部  
 **区域尺寸**：高度180px（包含20px内边距）  
 **区域功能**：展示患者基本信息+提供主要操作入口  
 **包含元素**：
 -   **标题栏**：
    -   元素类型：标题文本
    -   显示内容：“门诊术中临时医嘱”
    -   样式特征：白色文字，1.5rem字号，居中显示，渐变蓝色背景
 -   **患者信息卡**：
    -   元素类型：信息展示区块
    -   显示内容：患者姓名、就诊卡号、手术单号、科室、医师、角色
        -   患者：样例值-张三
        -   就诊卡号：样例值-202507010122
        -   手术单号：样例值- S202507010135
        -   科室： 样例值-手术室(OR101)-取值于手术安排的手术间号字段
        -   医师：样例值-李麻(3015)
        -   角色：样例值-麻醉医师
    -   样式特征：半透明白色背景，圆角8px，内部flex布局
 -   **操作按钮组**：
    -   **[刷新按钮]**：
        -   元素类型：主要操作按钮
        -   显示内容：↻ 刷新
        -   交互行为：点击后重新加载当前界面的数据
        -   样式特征：蓝色渐变背景，悬停有上浮效果
    -   **[引用计费按钮]**：
        -   元素类型：次要操作按钮
        -   显示内容：引用计费
        -   交互行为：点击后拉取当前患者最新计费药品的数据
 #### 2. 计费药品展示区
 **区域位置**：顶部信息区下方  
 **区域尺寸**：高度约420px（包含标题和表格）  
 **区域功能**：展示待生成医嘱的计费药品清单  
 **包含元素**：
 -   **表格标题**：
    -   显示内容：“一、已引用计费药品（待生成医嘱）”
    -   样式特征：1.2rem字号，底部边框线
 -   **药品数据表格**：
    **取值于门诊术中计费界面生成的药品计费数据（adm_charge_item（费用项管理）、med_medication_request（药品请求管理）等），具体与系统实际业务数据为主。**
    **(参考)关联字段：adm_charge_item. encounter_id = med_medication_request. encounter_id and –就诊ID**
    **adm_charge_item. service_table = 'med_medication_request' and --记录药品数据**
    **adm_charge_item. bus_no = med_medication_request. bus_no -- adm_charge_item. bus_no的值之前多加了‘CI’**
    -   展示方式：斑马纹表格
    -   数据字段：
        -   序号：数字 - 自动生成
        -   药品名称：文本 - 如"罗哌卡因注射液"
        -   规格：文本 - 如"10ml"
        -   数量：数字 - 可编辑
        -   批号：文本 - 如"L240715"
        -   单价：数字 - 如"38"
        -   小计：数字 - 自动计算
        -   医保：标签 - “甲/乙/自费”
    -   样式特征：表头浅灰色背景，医保类型有颜色区分（蓝色=医保，绿色=自费）
 -   **金额汇总栏**：
    -   显示内容：
        -   医保内金额（蓝色强调）
        -   自费金额（绿色强调）
        -   总计金额（红色强调）
    -   位置：表格底部右对齐
 #### 3. 医嘱预览区
 **区域位置**：计费药品展示区下方  
 **区域尺寸**：高度约420px（包含标题和表格）  
 **区域功能**：展示即将生成的药品医嘱  
 **包含元素**：
 \*生成门诊药品医嘱表相关的数据，满足**计费药品明细 ↔ 药品医嘱** 一一对应的要求。
 可以对照参考：需结合门诊医生站开立药品医嘱时生成的药品医嘱表
 -   **表格标题**：
    -   显示内容：“二、临时医嘱预览（已生成）”
 -   **医嘱表格**：
    -   展示方式：斑马纹表格
    -   数据字段：
        -   序号：数字
        -   医嘱名称：文本（取已引用计费药品的药品名称）
        -   剂量：数字（自动计算=规格×数量）
        -   单位：文本（根据药品类型自动判断）
        -   用法：下拉选择（不可编辑）
        -   频次：固定"临时"
        -   执行时间：自动生成当前时间
        -   操作：编辑/删除按钮
    -   操作功能：
        -   编辑：弹出表单修改剂量、用法等字段
        -   删除：二次确认后移除该条医嘱
 #### 4. 签名确认区
 **区域位置**：页面底部  
 **区域尺寸**：高度约180px  
 **区域功能**：完成医嘱确认和电子签名  
 **包含元素**：
 -   **签名信息卡**：
    -   显示内容：医师姓名工号、签名状态、签名时间
    -   样式特征：浅灰色背景，圆角边框
 -   **[一键签名按钮]**：
    -   元素类型：主要操作按钮
    -   显示内容：“一键签名并生成医嘱”
    -   交互行为：点击后弹出账户密码输入框
    -   样式特征：绿色背景，悬停效果
 -   **[取消按钮]**：
    -   元素类型：次要操作按钮
    -   显示内容：“取消”
    -   交互行为：返回上级页面
 ### 四、交互功能详细说明
 #### 1. 引用计费功能
 **功能描述**：从术中计费药品获取患者当前最新的计费药品数据  
 **触发条件**：点击"引用计费"按钮  
 **操作流程**：
 1.  点击按钮获取患者当前最新的计费药品数据
 2.  成功返回后更新药品表格数据
 3.  自动计算并更新费用汇总
    **反馈机制**：成功提示弹窗"已成功引用最新计费药品信息！"  
    **异常处理**：请求失败时显示错误提示“获取计费数据失败，请重试”，保留原数据
 #### 2. 医嘱生成功能
 **功能描述**：将计费药品转为正式医嘱  
 **触发条件**：点击"一键签名并生成医嘱"按钮  
 **操作流程**：
 1.  自动生成药品医嘱预览（带默认用法和剂量）
 2.  弹出账户密码输入框
 3.  验证通过后生成临时药品医嘱数据
 4.  成功返回后显示生成结果  
    **数据转换规则**：
 -   剂量 = 规格数值 × 数量（如"10ml"×2 → 20ml）
 -   单位：根据药品名称自动判断（默认获取当前药品在《药品目录》维护剂量单位的值）
 -   用法：根据药品名称自动判断（默认获取当前药品在《药品目录》维护用法的值，如果未维护默认空）
 -   医嘱名称：取值药品名称
 -   频次：默认ST
 -   执行时间：默认当前系统时间
 #### 3. 医嘱编辑功能
 **功能描述**：修改已生成的医嘱明细  
 **触发条件**：点击"编辑"按钮  
 **操作流程**：
 1.  弹出编辑表单（带当前值医嘱值）
 2.  修改后点击保存更新表格
 3.  自动重新计算相关字段得值  
    **字段限制**：
 -   剂量：必须为数字
 -   用法：限定下拉选项，取值于字典管理：用药途径(用法)的值
 -   频次：固定为"ST"不可编辑
 ### 五、数据结构说明
 **关键数据字段**：
 | **字段名**    | **说明** | **数据类型** | **示例值**         | **是否必填** | **备注**         |
 |---------------|----------|--------------|--------------------|--------------|------------------|
 | patientId     | 患者ID   | string       | “202507010122”     | 是           | 就诊卡号         |
 | surgeryNo     | 手术单号 | string       | “S202507010135”    | 是           |                  |
 | medicineName  | 药品名称 | string       | “罗哌卡因注射液”   | 是           |                  |
 | spec          | 规格     | string       | “10ml”             | 是           | 需包含数值和单位 |
 | batchNo       | 批号     | string       | “L240715”          | 是           |                  |
 | insuranceType | 医保类型 | string       | “乙”               | 是           | 甲/乙/自费       |
 | usage         | 用法     | string       | “静脉推注”         | 是           |                  |
 | execTime      | 执行时间 | datetime     | “2025-07-01 08:41” | 是           | 精确到分钟       |
 ### 六、开发实现要点
 **样式规范**：
 -   **主色调**：\#4a90e2（按钮/标题）
 -   **辅助色**：\#5cb85c（成功操作）、\#e74c3c（警告）
 -   **字体规范**：标题1.5rem/正文0.95rem，行高1.6
 -   **间距系统**：区块padding20px，元素间距15px
 -   **表格样式**：斑马纹，行高56px，单元格padding15px 20px
 **技术要求**：
 -   **浏览器兼容**：Chrome/Firefox/Edge最新版
 **注意事项**：
 1.  医嘱生成后需同步更新手术记录
 2.  所有金额显示保留两位小数
--- a/md/需求/99-门诊手术中计费界面PRD_2026-1-22.md
+++ b/md/需求/99-门诊手术中计费界面PRD_2026-1-22.md
@@ -0,0 +1,62 @@
 **门诊手术中计费PRD文档**
 **目标：**
 支持手术中追加计费（耗材、药品等）、退费等场景使用
 术后一站式结算（发票、清单、医保等）
 **流程图：**
 ```mermaid
 flowchart TD
    A["医生开立手术申请单"] --> B{"系统生成计费包"}
    B --> C["患者缴费"]
    C --> D["手术室确认"]
    D --> E{"术中追加/退费?"}
    E -- "是" --> F{"术中计费"}
    F -- "耗材" --> F2["护士扫码追加耗材\n实时计价 更新库存"]
    F -- "药品" --> F3["麻醉师追加药品\n实时计价 更新库存"]
    F -- "诊疗项目" --> F4["追加麻醉时长/项目\n实时计价"]
    F2 --> F6["生成术中追加计费单"]
    F3 --> F6
    F4 --> F6
    F6 --> G{"患者支付?"}
    G -- "是" --> P["提示支付成功"]--> J
    G -- "否" --> H["提示支付失败\n保持待支付"]
    H --> D
    E -- "否" --> I["手术完成"]
    I --> J["术后统一结算"]
    J --> K["发票/清单/分割单"]
    K --> L["财务对账"]
 ```
 **注意：**待门诊手术安排界面（禅道需求编号：93）完成后再执行
 ![](media/4fa3fca6b8362de7b938ded77d6e4982.png)
 图1：门诊手术安排界面（禅道需求编号：93）
 ![](media/2756f39fb624c7f686d56b675b4d4d10.png)
 图2：门诊管理-》门诊划价：手术计费界面复制《门诊划价》界面红色框内容
 1、如上图1、2所示：在门诊手术安排界面增加【计费】按钮，实现对门诊手术中追加的费用进行记账，手术计费界面如图2所示复制《门诊划价》界面红色框内容进行个性化改造，患者信息：取值于手术安排界面选中行的患者信息，计费账号为当前系统登录的账号。
 \*比如：在手术计费界面给患者1计费成功后，重新从手术按钮界面选中患者1点击【计费】打开界面时显示当前患者已计费成功的手术费用。
 写入事务注意：
 adm_charge_item费用项管理表
 ①、术中费用仍走“门诊就诊管理”的就诊ID（adm_encounter.id = adm_charge_item.encounter_id）。
 2\. 为了事后能追溯“这些费用是术中发生的”，在费用项管理表明细上加一个 “来源业务单据（SourceBillNo）” 字段（adm_charge_item.generate_source_enum = 2（帐单生成来源为手术计费），SourceBillNo = 手术申请单号）。
 3\. 其他内容按照《门诊划价》的业务数据流程走。
--- a/openhis-server-new/core-framework/src/main/java/com/core/framework/config/MybatisPlusConfig.java
+++ b/openhis-server-new/core-framework/src/main/java/com/core/framework/config/MybatisPlusConfig.java
@@ -1,22 +1,29 @@
 package com.core.framework.config;
 import com.baomidou.mybatisplus.annotation.DbType;
 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
 import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
 import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
 import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
 import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
 import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
 import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
 import com.core.common.utils.SecurityUtils;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.LongValue;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 import javax.servlet.http.HttpServletRequest;
 import javax.sql.DataSource;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
@@ -149,4 +156,41 @@ public class MybatisPlusConfig {
        return result != null ? result : 1; // 默认租户ID
    }
    /**
     * 配置 SqlSessionFactory
     * 由于排除了 DataSourceAutoConfiguration，需要手动配置
     */
    @Bean
    @Primary
    public SqlSessionFactory sqlSessionFactory(
            @Qualifier("dynamicDataSource") DataSource dataSource,
            MybatisPlusInterceptor mybatisPlusInterceptor) throws Exception {
        MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        // 设置 mapper 文件位置
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
            .getResources("classpath*:mapper/**/*Mapper.xml"));
        // 设置 typeAliases 包路径
        sessionFactory.setTypeAliasesPackage("com.core.**.domain,com.openhis.**.domain");
        // 配置 MyBatis-Plus
        MybatisConfiguration configuration = new MybatisConfiguration();
        // 使用驼峰命名法转换字段
        configuration.setMapUnderscoreToCamelCase(true);
        // 开启缓存
        configuration.setCacheEnabled(true);
        // 允许JDBC支持自动生成主键
        configuration.setUseGeneratedKeys(true);
        // 配置默认的执行器
        configuration.setDefaultExecutorType(org.apache.ibatis.session.ExecutorType.SIMPLE);
        // 配置日志实现
        configuration.setLogImpl(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
        sessionFactory.setConfiguration(configuration);
        // 设置拦截器（通过参数注入避免循环依赖）
        sessionFactory.setPlugins(mybatisPlusInterceptor);
        return sessionFactory.getObject();
    }
 }
--- a/openhis-server-new/core-system/src/main/java/com/core/system/domain/vo/MetaVo.java
+++ b/openhis-server-new/core-system/src/main/java/com/core/system/domain/vo/MetaVo.java
@@ -28,6 +28,11 @@ public class MetaVo {
     */
    private String link;
    /**
     * 菜单是否可见（用于前端侧边栏显示控制）
     */
    private String visible;
    public MetaVo() {}
    public MetaVo(String title, String icon) {
@@ -56,6 +61,16 @@ public class MetaVo {
        }
    }
    public MetaVo(String title, String icon, boolean noCache, String link, String visible) {
        this.title = title;
        this.icon = icon;
        this.noCache = noCache;
        if (StringUtils.ishttp(link)) {
            this.link = link;
        }
        this.visible = visible;
    }
    public boolean isNoCache() {
        return noCache;
    }
@@ -87,4 +102,12 @@ public class MetaVo {
    public void setLink(String link) {
        this.link = link;
    }
    public String getVisible() {
        return visible;
    }
    public void setVisible(String visible) {
        this.visible = visible;
    }
 }
--- a/openhis-server-new/core-system/src/main/java/com/core/system/service/impl/SysMenuServiceImpl.java
+++ b/openhis-server-new/core-system/src/main/java/com/core/system/service/impl/SysMenuServiceImpl.java
@@ -147,13 +147,15 @@ public class SysMenuServiceImpl implements ISysMenuService {
        List<RouterVo> routers = new LinkedList<RouterVo>();
        for (SysMenu menu : menus) {
            RouterVo router = new RouterVo();
-            router.setHidden("1".equals(menu.getVisible()));
+            // 不再根据 visible 字段设置 hidden，确保所有有权限的路由都可用
            // router.setHidden("1".equals(menu.getVisible()));
            router.setHidden(false);
            router.setName(getRouteName(menu));
            router.setPath(getRouterPath(menu));
            router.setComponent(getComponent(menu));
            router.setQuery(menu.getQuery());
            router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()),
-                menu.getPath()));
+                menu.getPath(), menu.getVisible()));
            List<SysMenu> cMenus = menu.getChildren();
            if (StringUtils.isNotEmpty(cMenus) && UserConstants.TYPE_DIR.equals(menu.getMenuType())) {
                router.setAlwaysShow(true);
@@ -167,12 +169,12 @@ public class SysMenuServiceImpl implements ISysMenuService {
                children.setComponent(menu.getComponent());
                children.setName(getRouteName(menu.getRouteName(), menu.getPath()));
                children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(),
-                    StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
+                    StringUtils.equals("1", menu.getIsCache()), menu.getPath(), menu.getVisible()));
                children.setQuery(menu.getQuery());
                childrenList.add(children);
                router.setChildren(childrenList);
            } else if (menu.getParentId().intValue() == 0 && isInnerLink(menu)) {
-                router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon()));
+                router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), false, null, menu.getVisible()));
                router.setPath("/");
                List<RouterVo> childrenList = new ArrayList<RouterVo>();
                RouterVo children = new RouterVo();
@@ -180,7 +182,7 @@ public class SysMenuServiceImpl implements ISysMenuService {
                children.setPath(routerPath);
                children.setComponent(UserConstants.INNER_LINK);
                children.setName(getRouteName(menu.getRouteName(), routerPath));
-                children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), menu.getPath()));
+                children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), false, menu.getPath(), menu.getVisible()));
                childrenList.add(children);
                router.setChildren(childrenList);
            }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/ITicketAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/ITicketAppService.java
@@ -13,14 +13,6 @@ import java.util.Map;
 */
 public interface ITicketAppService {
    /**
     * 查询号源列表
     *
     * @param params 查询参数
     * @return 号源列表
     */
    R<?> listTicket(Map<String, Object> params);
    /**
     * 预约号源
     *
--- 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
@@ -4,20 +4,28 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.core.common.core.domain.R;
 import com.openhis.administration.domain.Patient;
 import com.openhis.administration.service.IPatientService;
 import com.openhis.appointmentmanage.domain.DoctorSchedule;
 import com.openhis.appointmentmanage.mapper.DoctorScheduleMapper;
 import com.openhis.appointmentmanage.service.IDoctorScheduleService;
 import com.openhis.clinical.domain.Order;
 import com.openhis.clinical.domain.Ticket;
 import com.openhis.clinical.mapper.OrderMapper;
 import com.openhis.clinical.service.ITicketService;
 import com.openhis.web.appointmentmanage.appservice.IDoctorScheduleAppService;
 import com.openhis.web.appointmentmanage.appservice.ITicketAppService;
 import com.openhis.web.appointmentmanage.dto.TicketDto;
 import org.springframework.stereotype.Service;
 import javax.annotation.Resource;
 import java.text.SimpleDateFormat;
 import java.time.*;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
+import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 /**
 * 号源管理应用服务实现类
 *
@@ -31,145 +39,14 @@ public class TicketAppServiceImpl implements ITicketAppService {
    @Resource
    private IPatientService patientService;
    @Resource
    private IDoctorScheduleAppService doctorScheduleAppService;
    @Resource
    private DoctorScheduleMapper doctorScheduleMapper;
    @Resource
    private OrderMapper orderMapper;
-    /**
+    private static final Logger log = LoggerFactory.getLogger(TicketAppServiceImpl.class);
     * 查询号源列表
     *
     * @param params 查询参数
     * @return 号源列表
     */
    @Override
    public R<?> listTicket(Map<String, Object> params) {
        // 调试日志：打印所有参数
        System.out.println("=== listTicket方法收到的所有参数：===");
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("=================================");
        // 构建查询条件
        Ticket ticket = new Ticket();
        // 设置查询参数
        // 处理日期参数
        if (params.containsKey("date")) {
            String date = (String) params.get("date");
            try {
                // 将日期字符串转换为Date类型，设置到appointmentDate字段
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                Date appointmentDate = sdf.parse(date);
                ticket.setAppointmentDate(appointmentDate);
                System.out.println("设置的appointmentDate：" + appointmentDate);
            } catch (Exception e) {
                // 日期格式错误，忽略该参数
                System.out.println("日期格式错误，忽略该参数：" + date + "，错误信息：" + e.getMessage());
            }
        }
        // 处理状态参数
        if (params.containsKey("status")) {
            String status = (String) params.get("status");
            System.out.println("接收到的status参数：" + status);
            if (!"all".equals(status) && !"全部".equals(status)) {
                // 将中文状态转换为英文状态
                if ("未预约".equals(status)) {
                    ticket.setStatus("unbooked");
                } else if ("已预约".equals(status)) {
                    ticket.setStatus("booked");
                } else if ("已取号".equals(status)) {
                    ticket.setStatus("checked");
                } else if ("已取消".equals(status)) {
                    ticket.setStatus("cancelled");
                } else if ("已锁定".equals(status)) {
                    ticket.setStatus("locked");
                } else {
                    ticket.setStatus(status);
                }
                System.out.println("设置的status：" + ticket.getStatus());
            }
        }
        if (params.containsKey("name")) {
            String name = (String) params.get("name");
            ticket.setPatientName(name);
        }
        if (params.containsKey("card")) {
            String card = (String) params.get("card");
            ticket.setMedicalCard(card);
        }
        if (params.containsKey("phone")) {
            String phone = (String) params.get("phone");
            ticket.setPhone(phone);
        }
        if (params.containsKey("type")) {
            String type = (String) params.get("type");
            System.out.println("前端传递的type参数值：" + type);
            if (!"all".equals(type)) {
                // 类型映射转换：前端传递英文类型，数据库存储中文类型
                if ("general".equals(type)) {
                    ticket.setTicketType("普通");
                } else if ("expert".equals(type)) {
                    ticket.setTicketType("专家");
                } else if ("普通".equals(type)) {
                    ticket.setTicketType("普通");
                } else if ("专家".equals(type)) {
                    ticket.setTicketType("专家");
                } else {
                    ticket.setTicketType(type);
                }
                System.out.println("转换后的ticketType值：" + ticket.getTicketType());
            }
        }
        // 手动实现分页查询，避免MyBatis-Plus自动COUNT查询的问题
        int pageNum = params.get("page") != null ? Integer.valueOf(params.get("page").toString()) : 1;
        int pageSize = params.get("limit") != null ? Integer.valueOf(params.get("limit").toString()) : 10;
        // 调试：输出构建的查询条件
        System.out.println("构建的查询条件：ticketType=" + ticket.getTicketType() + ", status=" + ticket.getStatus() + ", appointmentDate=" + ticket.getAppointmentDate());
        // 1. 获取所有符合条件的记录
        List<Ticket> allTickets = ticketService.selectTicketList(ticket);
        // 调试：输出查询到的所有记录
        System.out.println("查询到的所有记录：" + allTickets);
        if (!allTickets.isEmpty()) {
            for (Ticket t : allTickets) {
                System.out.println("记录详情：id=" + t.getId() + ", ticketType=" + t.getTicketType() + ", status=" + t.getStatus() + ", appointmentDate=" + t.getAppointmentDate() + ", deleteFlag=" + t.getDeleteFlag());
            }
        }
        // 2. 计算总记录数
        long total = allTickets.size();
        System.out.println("手动计算的总记录数：" + total);
        // 3. 手动分页
        int start = (pageNum - 1) * pageSize;
        int end = Math.min(start + pageSize, allTickets.size());
        List<Ticket> pageTickets;
        if (start >= end) {
            pageTickets = new ArrayList<>();
        } else {
            pageTickets = allTickets.subList(start, end);
        }
        // 4. 转换为DTO
        List<TicketDto> dtoList = pageTickets.stream().map(this::convertToDto).toList();
        // 5. 构建响应数据，符合前端预期格式
        Map<String, Object> result = new HashMap<>();
        result.put("list", dtoList);
        result.put("records", dtoList); // 兼容前端框架（如Element UI）可能使用的records字段
        result.put("total", total);
        result.put("page", pageNum);
        result.put("current", pageNum); // 兼容前端框架可能使用的current字段
        result.put("limit", pageSize);
        result.put("pageSize", pageSize); // 兼容前端框架可能使用的pageSize字段
        result.put("size", pageSize); // 兼容前端框架可能使用的size字段
        result.put("pageNum", pageNum); // 兼容前端框架可能使用的pageNum字段
        result.put("pages", (int) Math.ceil((double) total / pageSize)); // 计算总页数
        // 调试：输出响应数据
        System.out.println("返回的响应数据：" + result);
        return R.ok(result);
    }
    /**
     * 预约号源
@@ -179,35 +56,73 @@ public class TicketAppServiceImpl implements ITicketAppService {
     */
    @Override
    public R<?> bookTicket(Map<String, Object> params) {
        // 1. 获取 ticketId 和 slotId
        Long ticketId = null;
        Long slotId = null;
        if (params.get("ticketId") != null) {
            ticketId = Long.valueOf(params.get("ticketId").toString());
        }
-        if (ticketId == null) {
+        if (params.get("slotId") != null) {
-            return R.fail("参数错误");
+            slotId = Long.valueOf(params.get("slotId").toString());
        }
        // 2. 参数校验
        if (ticketId == null || slotId == null) {
            return R.fail("参数错误：ticketId 或 slotId 不能为空");
        }
        try {
            // 3. 执行原有的预约逻辑
            int result = ticketService.bookTicket(params);
-            return R.ok(result > 0 ? "预约成功" : "预约失败");
+            if (result > 0) {
                // 4. 预约成功后，更新排班表状态
                DoctorSchedule schedule = new DoctorSchedule();
                schedule.setId(Math.toIntExact(slotId));             // 对应 XML 中的 WHERE id = #{id}
                schedule.setIsStopped(true);         // 设置为已预约
                schedule.setStopReason("booked");    // 设置停用原因
                // 执行更新
                int updateCount = doctorScheduleMapper.updateDoctorSchedule(schedule);
                if (updateCount > 0) {
                    return R.ok("预约成功并已更新排班状态");
                } else {
                    // 如果更新失败，可能需要根据业务逻辑决定是否回滚预约
                    return R.ok("预约成功，但排班状态更新失败");
                }
            } else {
                return R.fail("预约失败");
            }
        } catch (Exception e) {
-            return R.fail(e.getMessage());
+           // e.printStackTrace();
            log.error(e.getMessage());
            return R.fail("系统异常：" + e.getMessage());
        }
    }
    /**
     * 取消预约
     *
-     * @param ticketId 号源ID
+     * @param slotId 医生排班ID
     * @return 结果
     */
    @Override
-    public R<?> cancelTicket(Long ticketId) {
+    public R<?> cancelTicket(Long slotId) {
-        if (ticketId == null) {
+        if (slotId == null) {
            return R.fail("参数错误");
        }
        try {
-            int result = ticketService.cancelTicket(ticketId);
+            ticketService.cancelTicket(slotId);
-            return R.ok(result > 0 ? "取消成功" : "取消失败");
+            DoctorSchedule schedule = new DoctorSchedule();
            schedule.setId(Math.toIntExact(slotId));            // 对应 WHERE id = #{id}
            schedule.setIsStopped(false);      // 设置为 false (数据库对应 0)
            schedule.setStopReason("");        // 将原因清空 (设为空字符串)
            // 3. 调用自定义更新方法
            int updateCount = doctorScheduleMapper.updateDoctorSchedule(schedule);
            if (updateCount > 0) {
                return R.ok("取消成功");
            } else {
                return R.ok("取消成功");
            }
        } catch (Exception e) {
            return R.fail(e.getMessage());
        }
@@ -253,31 +168,87 @@ public class TicketAppServiceImpl implements ITicketAppService {
    @Override
    public R<?> listAllTickets() {
-        // 创建固定的测试数据，用于验证前端是否能展示数据
+        // 1. 从 AppService 获取排班数据
-        List<TicketDto> testTickets = new ArrayList<>();
+        R<?> response = doctorScheduleAppService.getDoctorScheduleList();
        // 获取返回的 List 数据 (假设 R.ok 里的数据是 List<DoctorSchedule>)
        List<DoctorSchedule> scheduleList = (List<DoctorSchedule>) response.getData();
-        // 创建5条测试数据
+        // 2. 转换数据为 TicketDto
-        for (int i = 1; i <= 5; i++) {
+        List<TicketDto> tickets = new ArrayList<>();
-            TicketDto dto = new TicketDto();
+
-            dto.setSlot_id((long) i);
+        if (scheduleList != null) {
-            dto.setBusNo("TEST0000" + i);
+            for (DoctorSchedule schedule : scheduleList) {
-            dto.setDepartment("内科");
+                TicketDto dto = new TicketDto();
-            dto.setDoctor("张三");
+
-            dto.setTicketType("expert");
+                // 基础信息映射
-            dto.setDateTime("08:00-08:50");
+                dto.setSlot_id(Long.valueOf(schedule.getId())); // Integer 转 Long
-            dto.setStatus("未预约");
+                dto.setBusNo(String.valueOf(schedule.getId()));         // 生成一个业务编号
-            dto.setFee("150");
+                dto.setDepartment(String.valueOf(schedule.getDeptId())); // 如果有科室名建议关联查询，这里暂填ID
-            dto.setAppointmentDate(new Date());
+                dto.setDoctor(schedule.getDoctor());
-            testTickets.add(dto);
+
                // 号源类型处理：根据挂号项目判断是普通号还是专家号
                String registerItem = schedule.getRegisterItem();
                if (registerItem != null && registerItem.contains("专家")) {
                    dto.setTicketType("expert");
                } else {
                    dto.setTicketType("general");
                }
                // 时间处理：格式化为日期+时间范围，如 "2025-12-01 08:00-12:00"
                String currentDate = LocalDate.now().toString(); // 或者从schedule中获取具体日期
                String timeRange = schedule.getStartTime() + "-" + schedule.getEndTime();
                dto.setDateTime(currentDate + " " + timeRange);
                LocalTime nowTime = LocalTime.now();
                LocalTime endTime = schedule.getEndTime();
                String stopReason1 = schedule.getStopReason();
                if ("cancelled".equals(stopReason1)||(endTime != null && nowTime.isAfter(endTime))) {
                    dto.setStatus("已停诊");
                }else if (Boolean.TRUE.equals(schedule.getIsStopped())) {
                    // 获取原因并处理可能的空值
                    String stopReason = schedule.getStopReason();
                    // 使用 .equals() 比较内容，并将常量放在前面防止空指针
                    if ("booked".equals(stopReason)) {
                        dto.setStatus("已预约");
                        // --- 新增：获取患者信息 ---
                        List<Order> Order = orderMapper.selectOrderBySlotId(Long.valueOf(schedule.getId()));
                        Order latestOrder=Order.get(0);
                        if (latestOrder != null) {
                            dto.setPatientName(latestOrder.getPatientName());
                            dto.setPatientId(String.valueOf(latestOrder.getPatientId()));
                            dto.setPhone(latestOrder.getPhone());
                        }
                        // -----------------------
                    } else if ("checked".equals(stopReason)) {
                        dto.setStatus("已取号");
                    } else {
                        // 兜底逻辑：如果 is_stopped 为 true 但没有匹配到原因
                        dto.setStatus("不可预约");
                    }
                } else {
                    // is_stopped 为 false 或 null 时
                    dto.setStatus("未预约");
                }
                // 费用处理 (挂号费 + 诊疗费)
                int totalFee = schedule.getRegisterFee() + schedule.getDiagnosisFee();
                dto.setFee(String.valueOf(totalFee));
                // 日期处理：LocalDateTime 转 Date
                if (schedule.getCreateTime() != null) {
                    ZonedDateTime zdt = schedule.getCreateTime().atZone(ZoneId.systemDefault());
                    dto.setAppointmentDate(Date.from(zdt.toInstant()));
                }
                tickets.add(dto);
            }
        }
-        // 构建响应数据
+        // 3. 封装分页响应结构
        Map<String, Object> result = new HashMap<>();
-        result.put("list", testTickets);
+        result.put("list", tickets);
-        result.put("total", testTickets.size());
+        result.put("total", tickets.size());
        result.put("page", 1);
        result.put("limit", 20);
        return R.ok(result);
    }
@@ -322,9 +293,6 @@ public class TicketAppServiceImpl implements ITicketAppService {
            case "cancelled":
                dto.setStatus("已取消");
                break;
            case "locked":
                dto.setStatus("已锁定");
                break;
            default:
                dto.setStatus(status);
        }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/controller/TicketController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/controller/TicketController.java
@@ -22,28 +22,6 @@ public class TicketController {
    @Resource
    private ITicketAppService ticketAppService;
    /**
     * 查询号源列表
     *
     * @param params 查询参数
     * @return 号源列表
     */
    @PostMapping("/list")
    public R<?> listTicket(@RequestBody Map<String, Object> params) {
        return ticketAppService.listTicket(params);
    }
    /**
     * 查询号源列表（支持GET请求，兼容旧版本）
     *
     * @param params 查询参数
     * @return 号源列表
     */
    @GetMapping("/list")
    public R<?> listTicketByGet(@RequestParam Map<String, Object> params) {
        return ticketAppService.listTicket(params);
    }
    /**
     * 查询所有号源（用于测试）
     *
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientPricingAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientPricingAppServiceImpl.java
@@ -73,8 +73,10 @@ public class OutpatientPricingAppServiceImpl implements IOutpatientPricingAppSer
        } else {
            adviceTypes = List.of(1, 2, 3);
        }
        // 门诊划价：不要强制 pricingFlag=1 参与过滤（wor_activity_definition.pricing_flag 可能为 0），
        // 否则会导致诊疗项目(adviceType=3)查询结果为空 records=[]
        return iDoctorStationAdviceAppService.getAdviceBaseInfo(adviceBaseDto, searchKey, locationId, null,
-            organizationId, pageNo, pageSize, Whether.YES.getValue(), adviceTypes, null);
+            organizationId, pageNo, pageSize, null, adviceTypes, null);
    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientRefundAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/chargemanage/appservice/impl/OutpatientRefundAppServiceImpl.java
@@ -383,6 +383,7 @@ public class OutpatientRefundAppServiceImpl implements IOutpatientRefundAppServi
                    newRefundRequest.setStatusEnum(RequestStatus.CANCELLED.getValue());
                    newRefundRequest.setRefundDeviceId(deviceRequest.getId()); // 关联原ID
                    newRefundRequest.setPrescriptionNo("T" + deviceRequest.getPrescriptionNo());
                    newRefundRequest.setTenantId(deviceRequest.getTenantId()); // 显式设置租户ID
                    deviceRequestService.save(newRefundRequest);
                    Long newRequestId = newRefundRequest.getId();
--- 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
@@ -29,6 +29,8 @@ import com.openhis.web.chargemanage.dto.PatientMetadata;
 import com.openhis.web.chargemanage.dto.PractitionerMetadata;
 import com.openhis.web.chargemanage.dto.ReprintRegistrationDto;
 import com.openhis.web.chargemanage.mapper.OutpatientRegistrationAppMapper;
 import com.openhis.triageandqueuemanage.domain.TriageCandidateExclusion;
 import com.openhis.triageandqueuemanage.service.TriageCandidateExclusionService;
 import com.openhis.web.paymentmanage.appservice.IPaymentRecService;
 import com.openhis.web.paymentmanage.dto.CancelPaymentDto;
 import com.openhis.web.paymentmanage.dto.CancelRegPaymentDto;
@@ -38,12 +40,15 @@ import org.springframework.stereotype.Service;
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import java.time.LocalDate;
 import java.util.*;
 import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 /**
 * 门诊挂号 应用实现类
 */
@Slf4j
@Service
 public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistrationAppService {
@@ -77,6 +82,9 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
    @Resource
    IPatientIdentifierService patientIdentifierService;
    @Resource
    TriageCandidateExclusionService triageCandidateExclusionService;
    /**
     * 门诊挂号 - 查询患者信息
     *
@@ -308,6 +316,47 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
            new Page<>(pageNo, pageSize), EncounterClass.AMB.getValue(), EncounterStatus.IN_PROGRESS.getValue(),
            ParticipantType.ADMITTER.getCode(), ParticipantType.REGISTRATION_DOCTOR.getCode(), queryWrapper,
            ChargeItemContext.REGISTER.getValue(), PaymentStatus.SUCCESS.getValue());
        // 过滤候选池排除列表（如果是从智能候选池查询，排除已加入队列的患者）
        // 检查请求参数 excludeFromCandidatePool，如果为 true 或未设置，则过滤排除列表
        String excludeParam = request.getParameter("excludeFromCandidatePool");
        boolean shouldExclude = excludeParam == null || "true".equalsIgnoreCase(excludeParam);
        if (shouldExclude && currentDayEncounter != null && !currentDayEncounter.getRecords().isEmpty()) {
            try {
                // 获取当前租户和日期
                Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
                LocalDate today = LocalDate.now();
                // 查询排除列表
                List<TriageCandidateExclusion> exclusions = triageCandidateExclusionService.list(
                    new LambdaQueryWrapper<TriageCandidateExclusion>()
                        .eq(TriageCandidateExclusion::getTenantId, tenantId)
                        .eq(TriageCandidateExclusion::getExclusionDate, today)
                        .eq(TriageCandidateExclusion::getDeleteFlag, "0")
                );
                if (exclusions != null && !exclusions.isEmpty()) {
                    // 构建排除的 encounterId 集合
                    Set<Long> excludedEncounterIds = exclusions.stream()
                        .map(TriageCandidateExclusion::getEncounterId)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toSet());
                    // 过滤结果
                    List<CurrentDayEncounterDto> filteredRecords = currentDayEncounter.getRecords().stream()
                        .filter(e -> e.getEncounterId() == null || !excludedEncounterIds.contains(e.getEncounterId()))
                        .collect(Collectors.toList());
                    // 更新分页结果
                    currentDayEncounter.setRecords(filteredRecords);
                    currentDayEncounter.setTotal(filteredRecords.size());
                }
            } catch (Exception e) {
                // 如果过滤失败，记录日志但不影响正常查询
                log.warn("过滤候选池排除列表失败", e);
            }
        }
        currentDayEncounter.getRecords().forEach(e -> {
            // 性别
            e.setGenderEnum_enumText(EnumUtils.getInfoByValue(AdministrativeGender.class, e.getGenderEnum()));
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/datadictionary/appservice/impl/DiagTreatMAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/datadictionary/appservice/impl/DiagTreatMAppServiceImpl.java
@@ -6,6 +6,7 @@ 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.core.domain.entity.SysDictData;
 import com.core.common.core.domain.model.LoginUser;
 import com.core.common.utils.*;
 import com.core.common.utils.bean.BeanUtils;
 import com.core.common.utils.poi.ExcelUtil;
@@ -400,6 +401,21 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
        // 新增外来诊疗目录
        activityDefinition.setStatusEnum(PublicationStatus.ACTIVE.getValue());
        // 显式设置创建者和租户ID，确保插入时不为null
        String createBy = "system";
        Integer tenantId = null;
        try {
            LoginUser loginUser = SecurityUtils.getLoginUser();
            if (loginUser != null) {
                createBy = loginUser.getUsername();
                tenantId = loginUser.getTenantId();
            }
        } catch (Exception e) {
            // 如果获取失败，使用默认值
        }
        activityDefinition.setCreateBy(createBy);
        activityDefinition.setTenantId(tenantId != null ? tenantId : 1); // 默认租户ID为1
        // 检查编码是否已存在
        List<ActivityDefinition> existingDefinitions = activityDefinitionMapper.selectList(
            new LambdaQueryWrapper<ActivityDefinition>()
@@ -624,6 +640,20 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
                .setYbMatchFlag(CommonUtil.tryParseInt(importDto.getYbMatchFlag()))
                .setStatusEnum(PublicationStatus.ACTIVE.getValue())
                .setChrgitmLv(CommonUtil.tryParseInt(importDto.getChrgitmLv()));
        // 显式设置创建者和租户ID，确保插入时不为null
        String createBy = "system";
        Integer tenantId = null;
        try {
            LoginUser loginUser = SecurityUtils.getLoginUser();
            if (loginUser != null) {
                createBy = loginUser.getUsername();
                tenantId = loginUser.getTenantId();
            }
        } catch (Exception e) {
            // 如果获取失败，使用默认值
        }
        activityDefinition.setCreateBy(createBy);
        activityDefinition.setTenantId(tenantId != null ? tenantId : 1); // 默认租户ID为1
        return activityDefinition;
    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/IDoctorStationMainAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/IDoctorStationMainAppService.java
@@ -90,4 +90,10 @@ public interface IDoctorStationMainAppService {
     */
    List<ReceptionStatisticsDto> getReceptionStatistics(String startTime,String endTime,Long practitionerId);
    /**
     * 过号重排
     * @param encounterId 就诊ID
     * @return 操作结果
     */
    R<?> rearrangeMissedEncounter(Long encounterId);
 }
--- 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
@@ -127,8 +127,11 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
        log.info("从数据库查询医嘱基础信息");
-        // 设置默认科室 (不取前端传的了)
+        // 设置默认科室：仅当前端/调用方未传 organizationId 时才回退到登录人科室
-        organizationId = SecurityUtils.getLoginUser().getOrgId();
+        // 否则会导致门诊划价等场景（按患者挂号科室查询）返回空
        if (organizationId == null) {
            organizationId = SecurityUtils.getLoginUser().getOrgId();
        }
        // 医嘱定价来源
        String orderPricingSource = TenantOptionUtil.getOptionContent(TenantOptionDict.ORDER_PRICING_SOURCE);
@@ -551,6 +554,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
            medicationRequest.setId(adviceSaveDto.getRequestId()); // 主键id
            medicationRequest.setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue()); // 请求状态
            medicationRequest.setPrescriptionNo(adviceSaveDto.getPrescriptionNo()); // 处方号
            medicationRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            medicationRequest.setGroupId(adviceSaveDto.getGroupId()); // 组号
            if (is_sign) {
                medicationRequest.setSignCode(signCode);
@@ -628,6 +632,11 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                chargeItem.setUnitPrice(adviceSaveDto.getUnitPrice()); // 单价
                chargeItem.setTotalPrice(adviceSaveDto.getTotalPrice()); // 总价
                // 显式设置tenantId、createBy和createTime字段，防止自动填充机制失效
                chargeItem.setTenantId(SecurityUtils.getLoginUser().getTenantId());
                chargeItem.setCreateBy(SecurityUtils.getLoginUser().getUsername());
                chargeItem.setCreateTime(new Date());
                iChargeItemService.saveOrUpdate(chargeItem);
            }
@@ -680,6 +689,10 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
            deviceRequest = new DeviceRequest();
            deviceRequest.setId(adviceSaveDto.getRequestId()); // 主键id
            deviceRequest.setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue()); // 请求状态
            deviceRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            // 显式设置审计字段，防止自动填充机制失效
            deviceRequest.setCreateBy(SecurityUtils.getLoginUser().getUsername());
            deviceRequest.setCreateTime(new Date());
            // 保存时,处理数据(请求,发放,账单)
            if (is_save) {
@@ -740,6 +753,11 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                chargeItem.setUnitPrice(adviceSaveDto.getUnitPrice()); // 单价
                chargeItem.setTotalPrice(adviceSaveDto.getTotalPrice()); // 总价
                // 显式设置审计字段，防止自动填充机制失效
                chargeItem.setTenantId(SecurityUtils.getLoginUser().getTenantId());
                chargeItem.setCreateBy(SecurityUtils.getLoginUser().getUsername());
                chargeItem.setCreateTime(new Date());
                iChargeItemService.saveOrUpdate(chargeItem);
            }
        }
@@ -791,6 +809,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
            serviceRequest = new ServiceRequest();
            serviceRequest.setId(adviceSaveDto.getRequestId()); // 主键id
            serviceRequest.setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue());// 请求状态
            serviceRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            if (is_sign) {
                serviceRequest.setSignCode(signCode);
            }
@@ -851,6 +870,11 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                chargeItem.setUnitPrice(adviceSaveDto.getUnitPrice()); // 单价
                chargeItem.setTotalPrice(adviceSaveDto.getTotalPrice()); // 总价
                // 显式设置审计字段，防止自动填充机制失效
                chargeItem.setTenantId(SecurityUtils.getLoginUser().getTenantId());
                chargeItem.setCreateBy(SecurityUtils.getLoginUser().getUsername());
                chargeItem.setCreateTime(new Date());
                iChargeItemService.saveOrUpdate(chargeItem);
                // 第一次保存时,处理诊疗套餐的子项信息
@@ -872,7 +896,6 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                    }
                }
            }
            // 只有在签发时
            if (is_sign) {
                // 发送跨系统申请
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationDiagnosisAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationDiagnosisAppServiceImpl.java
@@ -260,7 +260,8 @@ public class DoctorStationDiagnosisAppServiceImpl implements IDoctorStationDiagn
                    .eq(EncounterDiagnosis::getEncounterId, encounterId)
                    .set(EncounterDiagnosis::getMaindiseFlag, 0));
        }
-
+        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        String username = SecurityUtils.getUsername();
        // 保存诊断管理
        Condition condition;
        for (SaveDiagnosisChildParam saveDiagnosisChildParam : diagnosisChildList) {
@@ -277,13 +278,24 @@ public class DoctorStationDiagnosisAppServiceImpl implements IDoctorStationDiagn
            condition.setYbNo(saveDiagnosisChildParam.getYbNo());
            condition.setRecordedDatetime(new Date());
            condition.setRecorderId(SecurityUtils.getLoginUser().getPractitionerId());// 记录人
            if(condition.getCreateBy() == null){
                condition.setCreateBy(username);
            }
            condition.setUpdateBy(username);
            condition.setTenantId(tenantId);
            if(condition.getCreateTime() == null){
                condition.setCreateTime(new Date());
            }
            condition.setUpdateTime(new Date());
            iConditionService.saveOrUpdate(condition);
            saveDiagnosisChildParam.setConditionId(condition.getId());
        }
        // 保存就诊诊断
-        EncounterDiagnosis encounterDiagnosis;
+        EncounterDiagnosis encounterDiagnosis = null;
        for (SaveDiagnosisChildParam saveDiagnosisChildParam : diagnosisChildList) {
            if (saveDiagnosisChildParam.getUpdateId() != null) {
                String updateId = saveDiagnosisChildParam.getUpdateId();
@@ -306,6 +318,19 @@ public class DoctorStationDiagnosisAppServiceImpl implements IDoctorStationDiagn
                    encounterDiagnosis.setDiagnosisDesc(saveDiagnosisChildParam.getDiagnosisDesc()); // 诊断描述
                    encounterDiagnosis.setIptDiseTypeCode(saveDiagnosisChildParam.getIptDiseTypeCode()); // 患者疾病诊断类型代码
                    encounterDiagnosis.setTcmFlag(Whether.YES.getValue());// 中医标识
                    encounterDiagnosis.setDoctor(saveDiagnosisChildParam.getDiagnosisDoctor());
                    encounterDiagnosis.setClassification(saveDiagnosisChildParam.getClassification());
                    encounterDiagnosis.setName(saveDiagnosisChildParam.getName());
                    encounterDiagnosis.setTenantId(tenantId);
                    encounterDiagnosis.setLongTermFlag(saveDiagnosisChildParam.getLongTermFlag());
                    if(encounterDiagnosis.getCreateBy() == null){
                        encounterDiagnosis.setCreateBy(username);
                    }
                    encounterDiagnosis.setUpdateBy(username);
                    if(encounterDiagnosis.getCreateTime() == null){
                        encounterDiagnosis.setCreateTime(new Date());
                    }
                    encounterDiagnosis.setUpdateTime(new Date());
                    iEncounterDiagnosisService.saveOrUpdate(encounterDiagnosis);
                    i++;
                }
@@ -319,11 +344,24 @@ public class DoctorStationDiagnosisAppServiceImpl implements IDoctorStationDiagn
                encounterDiagnosis.setMedTypeCode(saveDiagnosisChildParam.getMedTypeCode());// 医疗类型
                encounterDiagnosis.setDiagnosisDesc(saveDiagnosisChildParam.getDiagnosisDesc()); // 诊断描述
                encounterDiagnosis.setIptDiseTypeCode(saveDiagnosisChildParam.getIptDiseTypeCode()); // 患者疾病诊断类型代码
                encounterDiagnosis.setDoctor(saveDiagnosisChildParam.getDiagnosisDoctor());
                encounterDiagnosis.setClassification(saveDiagnosisChildParam.getClassification());
                encounterDiagnosis.setName(saveDiagnosisChildParam.getName());
                encounterDiagnosis.setTenantId(tenantId);
                encounterDiagnosis.setLongTermFlag(saveDiagnosisChildParam.getLongTermFlag());
                if(encounterDiagnosis.getCreateBy() == null){
                    encounterDiagnosis.setCreateBy(username);
                }
                encounterDiagnosis.setUpdateBy(username);
                if(encounterDiagnosis.getCreateTime() == null){
                    encounterDiagnosis.setCreateTime(new Date());
                }
                encounterDiagnosis.setUpdateTime(new Date());
                iEncounterDiagnosisService.saveOrUpdate(encounterDiagnosis);
            }
        }
-        return R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00002, new Object[] {"诊断"}));
+        return R.ok(encounterDiagnosis, MessageUtils.createMessage(PromptMsgConstant.Common.M00002, new Object[] {"诊断"}));
    }
    /**
--- 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
@@ -26,9 +26,11 @@ import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.transaction.annotation.Transactional;
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -121,6 +123,8 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
     */
    @Override
    public R<?> receiveEncounter(Long encounterId) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        String currentUsername = SecurityUtils.getUsername();
        int update = encounterMapper.update(null,
            new LambdaUpdateWrapper<Encounter>().eq(Encounter::getId, encounterId)
                .set(Encounter::getReceptionTime, new Date())
@@ -138,6 +142,9 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
        encounterParticipant.setTypeCode(ParticipantType.ADMITTER.getCode());// 接诊医生
        encounterParticipant.setPractitionerId(SecurityUtils.getLoginUser().getPractitionerId());
        encounterParticipant.setStatusEnum(EncounterActivityStatus.ACTIVE.getValue()); // 状态
        encounterParticipant.setTenantId(tenantId);
        encounterParticipant.setCreateBy(currentUsername);
        encounterParticipant.setCreateTime(new Date());
        iEncounterParticipantService.save(encounterParticipant);
        return update > 0 ? R.ok() : R.fail();
    }
@@ -323,4 +330,45 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
            practitionerId);
    }
    /**
     * 过号重排核心实现
     */
    @Override
    @Transactional(rollbackFor = Exception.class) // 事务保证原子性
    public R<?> rearrangeMissedEncounter(Long encounterId) {
        // 1. 校验就诊记录是否存在
        Encounter encounter = encounterMapper.selectById(encounterId);
        if (encounter == null) {
            return R.fail("就诊记录不存在");
        }
        // 2. 校验状态：仅「在诊（IN_PROGRESS=2）」可重排
        if (!EncounterStatus.IN_PROGRESS.getValue().equals(encounter.getStatusEnum())) {
            return R.fail("仅「在诊」状态的患者可执行过号重排");
        }
        // 3. 核心更新：改回待诊+更新missed_time
        Date now = new Date();
        Long practitionerId = SecurityUtils.getLoginUser().getPractitionerId();
        int updateCount = encounterMapper.update(null,
                new LambdaUpdateWrapper<Encounter>()
                        .eq(Encounter::getId, encounterId)
                        .set(Encounter::getStatusEnum, EncounterStatus.PLANNED.getValue()) // 改回1-待诊
                        .set(Encounter::getMissedTime, now) // 新增：设置过号时间为当前时间
                        .set(Encounter::getUpdateBy, practitionerId.toString()) // 操作医生ID
                        .eq(Encounter::getStatusEnum, EncounterStatus.IN_PROGRESS.getValue())); // 防并发
        if (updateCount == 0) {
            return R.fail("过号重排失败：状态更新异常");
        }
        // 4. 同步更新接诊参与记录
        iEncounterParticipantService.update(new LambdaUpdateWrapper<EncounterParticipant>()
                .eq(EncounterParticipant::getEncounterId, encounterId)
                .eq(EncounterParticipant::getTypeCode, ParticipantType.ADMITTER.getCode())
                .set(EncounterParticipant::getStatusEnum, EncounterActivityStatus.COMPLETED.getValue()));
        return R.ok("过号重排成功");
    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationMainController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationMainController.java
@@ -133,6 +133,29 @@ public class DoctorStationMainController {
        }
    }
    /**
     * 过号重排
     *
     * @param encounterId 就诊id
     * @return 结果
     */
    @GetMapping(value = "/rearrange-missed-encounter")
    public R<?> rearrangeMissedEncounter(@RequestParam(value = "encounterId", required = false) String encounterId) {
        // 1. 空值校验（和现有接口保持一致）
        if (encounterId == null || "undefined".equals(encounterId) || "null".equals(encounterId)) {
            return R.fail("就诊ID不能为空");
        }
        try {
            // 2. 字符串转Long（和现有接口保持一致）
            Long id = Long.parseLong(encounterId);
            // 3. 调用AppService的过号重排方法
            return iDoctorStationMainAppService.rearrangeMissedEncounter(id);
        } catch (NumberFormatException e) {
            // 4. 格式错误处理（和现有接口保持一致）
            return R.fail("就诊ID格式错误");
        }
    }
    /**
     * 查询处方号列表信息
     * 
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/PatientInfoDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/PatientInfoDto.java
@@ -1,5 +1,6 @@
 package com.openhis.web.doctorstation.dto;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
 import com.openhis.common.annotation.Dict;
@@ -127,4 +128,9 @@ public class PatientInfoDto {
     * 就诊卡号
     */
    private String identifierNo;
    /**
     * 过号时间
     */
    private Date missedTime;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/SaveDiagnosisChildParam.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/SaveDiagnosisChildParam.java
@@ -5,6 +5,8 @@ import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
 import lombok.Data;
 import lombok.experimental.Accessors;
 import java.util.Date;
 /**
 * 保存诊断 子参数类
 *
@@ -33,6 +35,9 @@ public class SaveDiagnosisChildParam {
    @JsonSerialize(using = ToStringSerializer.class)
    private Long definitionId;
    private String classification;
    private String name;
    /**
     * 医保编码
     */
@@ -64,6 +69,18 @@ public class SaveDiagnosisChildParam {
     */
    private String diagnosisDesc;
    private String diagnosisDoctor;
    /**
     * 诊断时间
     */
    private Date diagnosisTime;
    /**
     * 发病时间
     */
    private Date onsetDate;
    /** 患者疾病诊断类型代码 */
    private Integer iptDiseTypeCode;
@@ -77,4 +94,6 @@ public class SaveDiagnosisChildParam {
     */
    private String updateConditionId;
    private Integer longTermFlag;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/ATDManageAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/ATDManageAppServiceImpl.java
@@ -293,11 +293,8 @@ public class ATDManageAppServiceImpl implements IATDManageAppService {
            if (admissionPatientInfoDto.getPriorityEnum() != null) {
                // 更新患者病情
                encounterService.updatePriorityEnumById(encounterId, admissionPatientInfoDto.getPriorityEnum());
-                // 将之前的住院参与者更新为已完成
+                // 将之前的住院参与者更新为已完成（如果存在的话）
-                Integer result = encounterParticipantService.updateEncounterParticipantsStatus(encounterId);
+                encounterParticipantService.updateEncounterParticipantsStatus(encounterId);
                if (result == 0) {
                    return R.fail("患者信息更新失败，请联系管理员");
                }
                // 更新住院参与者
                // 住院医生
                encounterParticipantService.creatEncounterParticipants(encounterId, startTime,
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/NurseBillingAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inhospitalnursestation/appservice/impl/NurseBillingAppService.java
@@ -462,6 +462,7 @@ public class NurseBillingAppService implements INurseBillingAppService {
        // 基础配置：主键（新增为null，修改为已有ID）、状态、业务编号
        deviceRequest.setId(adviceDto.getRequestId());
        deviceRequest.setTenantId(loginUser.getTenantId()); // 显式设置租户ID
        // 业务编号：按日生成，前缀+4位序列号（确保每日唯一）
        deviceRequest
                .setBusNo(assignSeqUtil.getSeqByDay(AssignSeqEnum.DEVICE_RES_NO.getPrefix(), DEVICE_RES_NO_SEQ_LENGTH));
@@ -533,6 +534,7 @@ public class NurseBillingAppService implements INurseBillingAppService {
        // 基础配置：主键、状态、业务编号、签发编码
        serviceRequest.setId(activityDto.getRequestId()); // 主键ID（新增为null，修改为已有ID）
        serviceRequest.setStatusEnum(RequestStatus.ACTIVE.getValue()); // 状态：激活（划价即生效）
        serviceRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
        serviceRequest.setAuthoredTime(authoredTime); // 医嘱签发时间
        serviceRequest.setSignCode(signCode); // 全局签发编码（关联同一批次划价的医嘱）
        serviceRequest.setOccurrenceStartTime(startTime); // 医嘱开始执行时间
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inventorymanage/appservice/impl/PurchaseInventoryAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/inventorymanage/appservice/impl/PurchaseInventoryAppServiceImpl.java
@@ -25,6 +25,7 @@ import com.openhis.web.inventorymanage.dto.*;
 import com.openhis.web.inventorymanage.mapper.PurchaseInventoryMapper;
 import com.openhis.workflow.domain.SupplyRequest;
 import com.openhis.workflow.service.ISupplyRequestService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import javax.annotation.Resource;
@@ -40,6 +41,7 @@ import java.util.stream.Stream;
 * @author zwh
 * @date 2025-03-08
 */
@Slf4j
@Service
 public class PurchaseInventoryAppServiceImpl implements IPurchaseInventoryAppService {
@@ -159,6 +161,7 @@ public class PurchaseInventoryAppServiceImpl implements IPurchaseInventoryAppSer
    @Override
    public R<List<ReceiptDetailDto>> getDetail(String busNo) {
        List<ReceiptDetailDto> receiptDetailList = purchaseInventoryMapper.selectDetail(busNo);
        log.debug("返回查询结果,receiptDetailList:{}", receiptDetailList);
        if (receiptDetailList.isEmpty()) {
            return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00006, null));
        }
@@ -182,7 +185,7 @@ public class PurchaseInventoryAppServiceImpl implements IPurchaseInventoryAppSer
                }
            });
        }
-
+        log.debug("返回查询结果,receiptDetailList:{}", receiptDetailList);
        return R.ok(receiptDetailList);
    }
@@ -194,7 +197,6 @@ public class PurchaseInventoryAppServiceImpl implements IPurchaseInventoryAppSer
     */
    @Override
    public R<?> addOrEditInventoryReceipt(List<PurchaseInventoryDto> purchaseInventoryDtoList) {
        // 校验(已经审批通过的单号(请求状态是同意),不能再重复编辑请求)
        boolean validation = supplyRequestService.supplyRequestValidation(purchaseInventoryDtoList.get(0).getBusNo());
        if (validation) {
@@ -232,11 +234,14 @@ public class PurchaseInventoryAppServiceImpl implements IPurchaseInventoryAppSer
                    // 制单人
                    .setApplicantId(SecurityUtils.getLoginUser().getPractitionerId())
                    // 申请时间
-                    .setApplyTime(DateUtils.getNowDate());
+                    .setApplyTime(DateUtils.getNowDate())
                    .setCreateBy(SecurityUtils.getLoginUser().getUsername())
                    .setCreateTime(DateUtils.getNowDate())
                    .setTenantId(SecurityUtils.getLoginUser().getTenantId());
            supplyRequestList.add(supplyRequest);
        }
        // 保存
        supplyRequestService.saveOrUpdateBatch(supplyRequestList);
--- 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
@@ -308,12 +308,20 @@ public class PatientInformationServiceImpl implements IPatientInformationService
     * @return 患者信息
     */
    private Patient handlePatientInfo(PatientBaseInfoDto patientInfoDto) {
-        Patient patient = new Patient();
+        Patient patient;
-        patient.setId(patientInfoDto.getId());
+        if (patientInfoDto.getId() != null) {
-        if (patientInfoDto.getId() == null) {
+            // 更新现有患者信息
            patient = patientService.getById(patientInfoDto.getId());
            if (patient == null) {
                throw new ServiceException("患者信息不存在，无法更新");
            }
        } else {
            // 新增患者信息
            patient = new Patient();
            patient.setBusNo(assignSeqUtil.getSeq(AssignSeqEnum.PATIENT_NUM.getPrefix(), 10));
-            patientInfoDto.setActiveFlag(PublicationStatus.ACTIVE.getValue()); // 默认启用
+            patient.setActiveFlag(PublicationStatus.ACTIVE.getValue()); // 默认启用
        }
        patient.setName(patientInfoDto.getName()); // 患者姓名
        patient.setPyStr(ChineseConvertUtils.toPinyinFirstLetter(patientInfoDto.getName())); // 拼音首拼
        patient.setWbStr(ChineseConvertUtils.toWBFirstLetter(patientInfoDto.getName())); // 五笔首拼
@@ -337,7 +345,14 @@ public class PatientInformationServiceImpl implements IPatientInformationService
        patient.setDeceasedDate(patientInfoDto.getDeceasedDate()); // 死亡时间
        patient.setNationalityCode(patientInfoDto.getNationalityCode());// 民族
        patient.setActiveFlag(patientInfoDto.getActiveFlag());// 活动标识
-        patientService.saveOrUpdate(patient);
+
        if (patientInfoDto.getId() != null) {
            // 更新操作
            patientService.updateById(patient);
        } else {
            // 新增操作
            patientService.save(patient);
        }
        return patient;
    }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseProfitLossOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseProfitLossOrderServiceImpl.java
@@ -57,15 +57,15 @@ public class PharmacyWarehouseProfitLossOrderServiceImpl implements IPharmacyWar
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-        // supplyCategoryOption.add(new
+        supplyCategoryOption.add(new
-        // PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.GENERAL_PROFIT_AND_LOSS.getValue(),
+        PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.GENERAL_PROFIT_AND_LOSS.getValue(),
-        // SupplyCategory.GENERAL_PROFIT_AND_LOSS.getInfo()));
+        SupplyCategory.GENERAL_PROFIT_AND_LOSS.getInfo()));
-        // supplyCategoryOption.add(new
+        supplyCategoryOption.add(new
-        // PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getValue(),
+        PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getValue(),
-        // SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getInfo()));
+        SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getInfo()));
-        // supplyCategoryOption.add(new
+        supplyCategoryOption.add(new
-        // PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PREPARATION_CONSUMPTION.getValue(),
+        PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PREPARATION_CONSUMPTION.getValue(),
-        // SupplyCategory.PREPARATION_CONSUMPTION.getInfo()));
+        SupplyCategory.PREPARATION_CONSUMPTION.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehousePurchaseOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehousePurchaseOrderServiceImpl.java
@@ -56,11 +56,11 @@ public class PharmacyWarehousePurchaseOrderServiceImpl implements IPharmacyWareh
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.STOCK_SUPPLY.getValue(),
-        // SupplyCategory.NORMAL.getInfo()));
+         SupplyCategory.STOCK_SUPPLY.getInfo()));
-        // supplyCategoryOption.add(new
+        supplyCategoryOption.add(new
-        // PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PURCHASE_PLAN_GENERATION.getValue(),
+        PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NON_STOCK.getValue(),
-        // SupplyCategory.PURCHASE_PLAN_GENERATION.getInfo()));
+        SupplyCategory.NON_STOCK.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseReturnOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseReturnOrderServiceImpl.java
@@ -56,8 +56,8 @@ public class PharmacyWarehouseReturnOrderServiceImpl implements IPharmacyWarehou
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
-        // SupplyCategory.NORMAL.getInfo()));
+         SupplyCategory.NORMAL.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseReturnToWarehouseOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseReturnToWarehouseOrderServiceImpl.java
@@ -56,8 +56,8 @@ public class PharmacyWarehouseReturnToWarehouseOrderServiceImpl implements IPhar
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-//        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
-//            SupplyCategory.NORMAL.getInfo()));
+            SupplyCategory.NORMAL.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseStockInOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseStockInOrderServiceImpl.java
@@ -57,18 +57,16 @@ public class PharmacyWarehouseStockInOrderServiceImpl implements IPharmacyWareho
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-        // supplyCategoryOption
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getValue(),
-        // .add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getValue(),
+         SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getInfo()));
-        // SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getInfo()));
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
-        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
+         SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getValue(), SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getInfo()));
-        // SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getValue(), SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getInfo()));
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getValue(),
-        // supplyCategoryOption
+         SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getInfo()));
-        // .add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
-        // SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getInfo()));
+         SupplyCategory.OTHER_DRUGS_WAREHOUSING.getValue(), SupplyCategory.OTHER_DRUGS_WAREHOUSING.getInfo()));
-        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
-        // SupplyCategory.OTHER_DRUGS_WAREHOUSING.getValue(), SupplyCategory.OTHER_DRUGS_WAREHOUSING.getInfo()));
+         SupplyCategory.DONATED_DRUGS_WAREHOUSING.getValue(), SupplyCategory.DONATED_DRUGS_WAREHOUSING.getInfo()));
        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
        // SupplyCategory.DONATED_DRUGS_WAREHOUSING.getValue(), SupplyCategory.DONATED_DRUGS_WAREHOUSING.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseStockOutOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseStockOutOrderServiceImpl.java
@@ -56,12 +56,12 @@ public class PharmacyWarehouseStockOutOrderServiceImpl implements IPharmacyWareh
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-//        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.IN_HOSPITAL_OUTBOUND.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.IN_HOSPITAL_OUTBOUND.getValue(),
-//            SupplyCategory.IN_HOSPITAL_OUTBOUND.getInfo()));
+            SupplyCategory.IN_HOSPITAL_OUTBOUND.getInfo()));
-//        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getValue(),
-//            SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getInfo()));
+            SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getInfo()));
-//        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OTHER_OUTBOUND.getValue(),
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OTHER_OUTBOUND.getValue(),
-//            SupplyCategory.OTHER_OUTBOUND.getInfo()));
+            SupplyCategory.OTHER_OUTBOUND.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseStocktakingOrderServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacyWarehousemanage/appservice/impl/PharmacyWarehouseStocktakingOrderServiceImpl.java
@@ -57,10 +57,10 @@ public class PharmacyWarehouseStocktakingOrderServiceImpl implements IPharmacyWa
        // 单据分类
        List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
-        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
-        // SupplyCategory.GENERAL_STOCKTAKING.getValue(), SupplyCategory.GENERAL_STOCKTAKING.getInfo()));
+         SupplyCategory.GENERAL_STOCKTAKING.getValue(), SupplyCategory.GENERAL_STOCKTAKING.getInfo()));
-        // supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
+        supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
-        // SupplyCategory.MONTHLY_STOCKTAKING.getValue(), SupplyCategory.MONTHLY_STOCKTAKING.getInfo()));
+         SupplyCategory.MONTHLY_STOCKTAKING.getValue(), SupplyCategory.MONTHLY_STOCKTAKING.getInfo()));
        purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);
--- 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
@@ -276,6 +276,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                    .setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue()); // 请求状态
            longMedicationRequest.setPrescriptionNo(regAdviceSaveDto.getPrescriptionNo()); // 处方号
            longMedicationRequest.setGroupId(regAdviceSaveDto.getGroupId()); // 组号
            longMedicationRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            if (is_sign) {
                longMedicationRequest.setReqAuthoredTime(authoredTime); // 医嘱签发时间
                longMedicationRequest.setSignCode(signCode);
@@ -340,6 +341,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
                    .setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue()); // 请求状态
            tempMedicationRequest.setPrescriptionNo(regAdviceSaveDto.getPrescriptionNo()); // 处方号
            tempMedicationRequest.setGroupId(regAdviceSaveDto.getGroupId()); // 组号
            tempMedicationRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            if (is_sign) {
                tempMedicationRequest.setReqAuthoredTime(authoredTime); // 医嘱签发时间
                tempMedicationRequest.setSignCode(signCode);
@@ -458,6 +460,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            longServiceRequest.setId(regAdviceSaveDto.getRequestId()); // 主键id
            longServiceRequest
                    .setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue());// 请求状态
            longServiceRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            if (is_sign) {
                longServiceRequest.setAuthoredTime(authoredTime); // 医嘱签发时间
                longServiceRequest.setSignCode(signCode);
@@ -505,6 +508,7 @@ public class AdviceManageAppServiceImpl implements IAdviceManageAppService {
            tempServiceRequest.setId(regAdviceSaveDto.getRequestId()); // 主键id
            tempServiceRequest
                    .setStatusEnum(is_save ? RequestStatus.DRAFT.getValue() : RequestStatus.ACTIVE.getValue());// 请求状态
            tempServiceRequest.setTenantId(SecurityUtils.getLoginUser().getTenantId()); // 显式设置租户ID
            if (is_sign) {
                tempServiceRequest.setAuthoredTime(authoredTime); // 医嘱签发时间
                tempServiceRequest.setSignCode(signCode);
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/appservice/TriageQueueAppService.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/appservice/TriageQueueAppService.java
@@ -0,0 +1,27 @@
 package com.openhis.web.triageandqueuemanage.appservice;
 import com.core.common.core.domain.R;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueActionReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueAddReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueAdjustReq;
 import java.time.LocalDate;
 public interface TriageQueueAppService {
    R<?> list(Long organizationId, LocalDate date);
    R<?> add(TriageQueueAddReq req);
    R<?> remove(Long id);
    R<?> adjust(TriageQueueAdjustReq req);
    /** 选呼：将之前叫号中置为完成，选中的置为叫号中 */
    R<?> call(TriageQueueActionReq req);
    /** 完成：叫号中 -> 完成(移出列表)，并自动推进下一个等待为叫号中 */
    R<?> complete(TriageQueueActionReq req);
    /** 过号重排：叫号中 -> 跳过并移到末尾，并自动推进下一个等待为叫号中 */
    R<?> requeue(TriageQueueActionReq req);
    /** 跳过：兼容前端按钮（当前实现等同于过号重排） */
    R<?> skip(TriageQueueActionReq req);
    /** 下一患者：当前叫号中 -> 完成，下一位等待 -> 叫号中 */
    R<?> next(TriageQueueActionReq req);
 }
--- 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
@@ -0,0 +1,556 @@
 package com.openhis.web.triageandqueuemanage.appservice.impl;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.core.common.core.domain.R;
 import com.core.common.utils.SecurityUtils;
 import com.openhis.triageandqueuemanage.domain.TriageQueueItem;
 import com.openhis.triageandqueuemanage.domain.TriageCandidateExclusion;
 import com.openhis.triageandqueuemanage.service.TriageQueueItemService;
 import com.openhis.triageandqueuemanage.service.TriageCandidateExclusionService;
 import com.openhis.web.triageandqueuemanage.appservice.TriageQueueAppService;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueActionReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueAddReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueAdjustReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueEncounterItem;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import javax.annotation.Resource;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
@Service
 public class TriageQueueAppServiceImpl implements TriageQueueAppService {
    private static final String STATUS_WAITING = "WAITING";
    private static final String STATUS_CALLING = "CALLING";
    private static final String STATUS_SKIPPED = "SKIPPED";
    private static final String STATUS_COMPLETED = "COMPLETED";
    @Resource
    private TriageQueueItemService triageQueueItemService;
    @Resource
    private TriageCandidateExclusionService triageCandidateExclusionService;
    @Override
    public R<?> list(Long organizationId, LocalDate date) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        // 只查询今天的患者
        LocalDate qd = date != null ? date : LocalDate.now();
        LambdaQueryWrapper<TriageQueueItem> wrapper = new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getQueueDate, qd)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .ne(TriageQueueItem::getStatus, STATUS_COMPLETED)
            .orderByAsc(TriageQueueItem::getQueueOrder);
        // 如果指定了科室，按科室过滤；否则查询所有科室（全科模式）
        if (organizationId != null) {
            wrapper.eq(TriageQueueItem::getOrganizationId, organizationId);
        }
        List<TriageQueueItem> list = triageQueueItemService.list(wrapper);
        // 双重保险：再次过滤掉 COMPLETED 状态的患者（防止数据库中有异常数据）
        if (list != null && !list.isEmpty()) {
            int beforeSize = list.size();
            list = list.stream()
                .filter(item -> !STATUS_COMPLETED.equals(item.getStatus()))
                .collect(java.util.stream.Collectors.toList());
            if (beforeSize != list.size()) {
                System.out.println(">>> [TriageQueue] list() 警告：过滤掉了 " + (beforeSize - list.size()) + " 条 COMPLETED 状态的记录");
            }
        }
        // 调试日志：检查状态值
        if (list != null && !list.isEmpty()) {
            System.out.println(">>> [TriageQueue] list() 返回 " + list.size() + " 条记录（已排除 COMPLETED）");
            for (int i = 0; i < Math.min(3, list.size()); i++) {
                TriageQueueItem item = list.get(i);
                System.out.println("    [" + i + "] patientName=" + item.getPatientName() 
                    + ", status=" + item.getStatus() 
                    + ", organizationId=" + item.getOrganizationId());
            }
        }
        return R.ok(list);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> add(TriageQueueAddReq req) {
        if (req == null || ObjectUtil.isNull(req.getOrganizationId())) {
            return R.fail("organizationId 不能为空");
        }
        if (CollUtil.isEmpty(req.getItems())) {
            return R.fail("items 不能为空");
        }
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        LocalDate qd = LocalDate.now();
        Long orgId = req.getOrganizationId();
        List<TriageQueueItem> existing = triageQueueItemService.list(new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getOrganizationId, orgId)
            .eq(TriageQueueItem::getQueueDate, qd)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .ne(TriageQueueItem::getStatus, STATUS_COMPLETED));
        int maxOrder = existing.stream().map(TriageQueueItem::getQueueOrder).filter(Objects::nonNull).max(Integer::compareTo).orElse(0);
        int added = 0;
        for (TriageQueueEncounterItem it : req.getItems()) {
            if (it == null || it.getEncounterId() == null) continue;
            boolean exists = existing.stream().anyMatch(e -> Objects.equals(e.getEncounterId(), it.getEncounterId()));
            if (exists) continue;
            TriageQueueItem qi = new TriageQueueItem()
                .setTenantId(tenantId)
                .setQueueDate(qd)
                .setOrganizationId(orgId)
                .setOrganizationName(req.getOrganizationName())
                .setEncounterId(it.getEncounterId())
                .setPatientId(it.getPatientId())
                .setPatientName(it.getPatientName())
                .setHealthcareName(it.getHealthcareName())
                .setPractitionerName(it.getPractitionerName())
                .setStatus(STATUS_WAITING)
                .setQueueOrder(++maxOrder)
                .setDeleteFlag("0")
                .setCreateTime(LocalDateTime.now())
                .setUpdateTime(LocalDateTime.now());
            triageQueueItemService.save(qi);
            // 记录到候选池排除列表（避免刷新后重新出现在候选池）
            TriageCandidateExclusion exclusion = triageCandidateExclusionService.getOne(
                new LambdaQueryWrapper<TriageCandidateExclusion>()
                    .eq(TriageCandidateExclusion::getTenantId, tenantId)
                    .eq(TriageCandidateExclusion::getExclusionDate, qd)
                    .eq(TriageCandidateExclusion::getEncounterId, it.getEncounterId())
                    .eq(TriageCandidateExclusion::getDeleteFlag, "0")
            );
            if (exclusion == null) {
                exclusion = new TriageCandidateExclusion()
                    .setTenantId(tenantId)
                    .setExclusionDate(qd)
                    .setEncounterId(it.getEncounterId())
                    .setPatientId(it.getPatientId())
                    .setPatientName(it.getPatientName())
                    .setOrganizationId(orgId)
                    .setOrganizationName(req.getOrganizationName())
                    .setReason("ADDED_TO_QUEUE")
                    .setDeleteFlag("0")
                    .setCreateTime(LocalDateTime.now())
                    .setUpdateTime(LocalDateTime.now());
                triageCandidateExclusionService.save(exclusion);
            }
            added++;
        }
        return R.ok(added);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> remove(Long id) {
        if (id == null) return R.fail("id 不能为空");
        TriageQueueItem item = triageQueueItemService.getById(id);
        if (item == null) return R.fail("队列项不存在");
        // 逻辑删除队列项
        item.setDeleteFlag("1").setUpdateTime(LocalDateTime.now());
        triageQueueItemService.updateById(item);
        // 从排除列表中删除记录，使患者重新出现在候选池中
        Integer tenantId = item.getTenantId();
        LocalDate exclusionDate = item.getQueueDate();
        Long encounterId = item.getEncounterId();
        if (tenantId != null && exclusionDate != null && encounterId != null) {
            TriageCandidateExclusion exclusion = triageCandidateExclusionService.getOne(
                new LambdaQueryWrapper<TriageCandidateExclusion>()
                    .eq(TriageCandidateExclusion::getTenantId, tenantId)
                    .eq(TriageCandidateExclusion::getExclusionDate, exclusionDate)
                    .eq(TriageCandidateExclusion::getEncounterId, encounterId)
                    .eq(TriageCandidateExclusion::getDeleteFlag, "0")
            );
            if (exclusion != null) {
                // 逻辑删除排除记录
                exclusion.setDeleteFlag("1").setUpdateTime(LocalDateTime.now());
                triageCandidateExclusionService.updateById(exclusion);
            }
        }
        recalcOrders(item.getOrganizationId(), item.getQueueDate());
        return R.ok(true);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> adjust(TriageQueueAdjustReq req) {
        if (req == null || req.getId() == null) return R.fail("id 不能为空");
        if (!"up".equalsIgnoreCase(req.getDirection()) && !"down".equalsIgnoreCase(req.getDirection())) {
            return R.fail("direction 只能是 up/down");
        }
        TriageQueueItem cur = triageQueueItemService.getById(req.getId());
        if (cur == null) return R.fail("队列项不存在");
        List<TriageQueueItem> list = listInternal(cur.getOrganizationId(), cur.getQueueDate());
        list.sort(Comparator.comparing(TriageQueueItem::getQueueOrder).thenComparing(TriageQueueItem::getId));
        int idx = -1;
        for (int i = 0; i < list.size(); i++) {
            if (Objects.equals(list.get(i).getId(), cur.getId())) { idx = i; break; }
        }
        if (idx == -1) return R.fail("队列项不在当前队列");
        int targetIdx = "up".equalsIgnoreCase(req.getDirection()) ? idx - 1 : idx + 1;
        if (targetIdx < 0 || targetIdx >= list.size()) return R.ok(false);
        TriageQueueItem other = list.get(targetIdx);
        Integer tmp = cur.getQueueOrder();
        cur.setQueueOrder(other.getQueueOrder()).setUpdateTime(LocalDateTime.now());
        other.setQueueOrder(tmp).setUpdateTime(LocalDateTime.now());
        triageQueueItemService.updateById(cur);
        triageQueueItemService.updateById(other);
        recalcOrders(cur.getOrganizationId(), cur.getQueueDate());
        return R.ok(true);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> call(TriageQueueActionReq req) {
        if (req == null || req.getId() == null) return R.fail("id 不能为空");
        TriageQueueItem selected = triageQueueItemService.getById(req.getId());
        if (selected == null) return R.fail("队列项不存在");
        // 只将"等待"状态的患者转为"叫号中"，允许有多个"叫号中"的患者
        if (STATUS_WAITING.equals(selected.getStatus())) {
            selected.setStatus(STATUS_CALLING).setUpdateTime(LocalDateTime.now());
            triageQueueItemService.updateById(selected);
            return R.ok(true);
        } else if (STATUS_CALLING.equals(selected.getStatus())) {
            // 如果已经是"叫号中"状态，直接返回成功（不做任何操作）
            return R.ok(true);
        } else {
            // 其他状态（如 SKIPPED、COMPLETED）不能选呼
            return R.fail("只能选呼\"等待\"状态的患者，当前患者状态为：" + selected.getStatus());
        }
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> complete(TriageQueueActionReq req) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        TriageQueueItem calling = null;
        // 关键改进：如果提供了 id，直接通过ID获取（像 call 方法一样），不依赖查询条件
        if (req != null && req.getId() != null) {
            calling = triageQueueItemService.getById(req.getId());
            if (calling == null) {
                return R.fail("队列项不存在");
            }
            // 验证状态
            if (!STATUS_CALLING.equals(calling.getStatus())) {
                return R.fail("只能完成\"叫号中\"状态的患者，当前患者状态为：" + calling.getStatus());
            }
        } else {
            // 如果没有提供 id，通过查询条件查找（兼容旧逻辑）
            Long orgId = req != null && req.getOrganizationId() != null ? req.getOrganizationId() : null;
            System.out.println(">>> [TriageQueue] complete() 开始执行（不限制日期，通过查询条件）, tenantId=" + tenantId + ", orgId=" + orgId);
            LambdaQueryWrapper<TriageQueueItem> callingWrapper = new LambdaQueryWrapper<TriageQueueItem>()
                .eq(TriageQueueItem::getTenantId, tenantId)
                .eq(TriageQueueItem::getDeleteFlag, "0")
                .eq(TriageQueueItem::getStatus, STATUS_CALLING)
                .orderByAsc(TriageQueueItem::getQueueOrder)
                .last("LIMIT 1");
            if (orgId != null) {
                callingWrapper.eq(TriageQueueItem::getOrganizationId, orgId);
            }
            calling = triageQueueItemService.getOne(callingWrapper, false);
            System.out.println(">>> [TriageQueue] complete() 查询叫号中患者（不限制日期）: orgId=" + orgId + ", 结果=" + (calling != null ? calling.getPatientName() + "(status=" + calling.getStatus() + ", queueDate=" + calling.getQueueDate() + ")" : "null"));
            if (calling == null) {
                return R.fail("当前没有叫号中的患者");
            }
        }
        // 使用实际找到的科室ID
        Long actualOrgId = calling.getOrganizationId();
        // 1) 叫号中 -> 完成（移出列表）
        calling.setStatus(STATUS_COMPLETED).setUpdateTime(LocalDateTime.now());
        triageQueueItemService.updateById(calling);
        // 2) 自动推进下一个等待为叫号中（同一科室，包含跳过状态，不限制日期）
        LambdaQueryWrapper<TriageQueueItem> nextWrapper = new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .and(w -> w.eq(TriageQueueItem::getStatus, STATUS_WAITING)
                       .or()
                       .eq(TriageQueueItem::getStatus, STATUS_SKIPPED))
            .orderByAsc(TriageQueueItem::getQueueOrder)
            .last("LIMIT 1");
        // 如果指定了科室ID，则按科室过滤；否则查询所有科室（全科模式）
        if (actualOrgId != null) {
            nextWrapper.eq(TriageQueueItem::getOrganizationId, actualOrgId);
        }
        TriageQueueItem next = triageQueueItemService.getOne(nextWrapper, false);
        System.out.println(">>> [TriageQueue] complete() 查询等待患者（不限制日期）: actualOrgId=" + actualOrgId + ", 结果=" + (next != null ? next.getPatientName() + "(status=" + next.getStatus() + ")" : "null"));
        if (next != null) {
            next.setStatus(STATUS_CALLING).setUpdateTime(LocalDateTime.now());
            triageQueueItemService.updateById(next);
        }
        recalcOrders(actualOrgId, null);
        return R.ok(true);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> requeue(TriageQueueActionReq req) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        TriageQueueItem calling = null;
        if (req != null && req.getId() != null) {
            calling = triageQueueItemService.getById(req.getId());
            if (calling == null) {
                return R.fail("队列项不存在");
            }
            // 验证状态
            if (!STATUS_CALLING.equals(calling.getStatus())) {
                return R.fail("只能对\"叫号中\"状态的患者进行过号重排，当前患者状态为：" + calling.getStatus());
            }
        } else {
            // 如果没有提供 id，通过查询条件查找（兼容旧逻辑）
            Long orgId = req != null && req.getOrganizationId() != null ? req.getOrganizationId() : null;
            LambdaQueryWrapper<TriageQueueItem> callingWrapper = new LambdaQueryWrapper<TriageQueueItem>()
                .eq(TriageQueueItem::getTenantId, tenantId)
                .eq(TriageQueueItem::getDeleteFlag, "0")
                .eq(TriageQueueItem::getStatus, STATUS_CALLING)
                .orderByAsc(TriageQueueItem::getQueueOrder)
                .last("LIMIT 1");
            if (orgId != null) {
                callingWrapper.eq(TriageQueueItem::getOrganizationId, orgId);
            }
            calling = triageQueueItemService.getOne(callingWrapper, false);
            if (calling == null) return R.fail("当前没有叫号中的患者");
        }
        // 使用实际找到的科室ID
        Long actualOrgId = calling.getOrganizationId();
        // 关键改进：在执行"跳过"操作之前，先检查是否有等待中的患者（判断队列状态）
        // 如果没有等待中的患者，就不应该执行"过号重排"操作
        LambdaQueryWrapper<TriageQueueItem> nextWrapper = new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .and(w -> w.eq(TriageQueueItem::getStatus, STATUS_WAITING)
                       .or()
                       .eq(TriageQueueItem::getStatus, STATUS_SKIPPED))
            .orderByAsc(TriageQueueItem::getQueueOrder)
            .last("LIMIT 1");
        // 如果指定了科室ID，则按科室过滤；否则查询所有科室（全科模式）
        if (actualOrgId != null) {
            nextWrapper.eq(TriageQueueItem::getOrganizationId, actualOrgId);
        }
        TriageQueueItem next = triageQueueItemService.getOne(nextWrapper, false);
        // 调试日志：检查查询结果
        System.out.println(">>> [TriageQueue] requeue() 查询等待中的患者:");
        System.out.println(">>>   - 科室ID: " + actualOrgId);
        System.out.println(">>>   - 找到的等待患者: " + (next != null ? next.getPatientName() + " (状态: " + next.getStatus() + ")" : "null"));
        // 如果找不到等待中的患者，直接返回失败（不执行跳过操作）
        if (next == null) {
            System.out.println(">>> [TriageQueue] requeue() 失败：没有等待中的患者");
            return R.fail("当前没有等待中的患者");
        }
        // 找末尾序号（同一科室，不限制日期）
        Integer maxOrder = triageQueueItemService.list(new LambdaQueryWrapper<TriageQueueItem>()
                .eq(TriageQueueItem::getTenantId, tenantId)
                .eq(TriageQueueItem::getOrganizationId, actualOrgId)
                .eq(TriageQueueItem::getDeleteFlag, "0")
                .ne(TriageQueueItem::getStatus, STATUS_COMPLETED))
            .stream()
            .map(TriageQueueItem::getQueueOrder)
            .filter(Objects::nonNull)
            .max(Integer::compareTo)
            .orElse(0);
        // 1) 叫号中 -> 跳过，并移到末尾
        calling.setStatus(STATUS_SKIPPED).setQueueOrder(maxOrder + 1).setUpdateTime(LocalDateTime.now());
        triageQueueItemService.updateById(calling);
        // 2) 自动推进下一个等待为叫号中
        next.setStatus(STATUS_CALLING).setUpdateTime(LocalDateTime.now());
        triageQueueItemService.updateById(next);
        recalcOrders(actualOrgId, null);
        return R.ok(true);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> skip(TriageQueueActionReq req) {
        // 当前业务“跳过”按“过号重排”处理：叫号中 -> 跳过并移到末尾，自动推进下一等待
        return requeue(req);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<?> next(TriageQueueActionReq req) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        TriageQueueItem calling = null;
        System.out.println(">>> [TriageQueue] next() 开始执行（不限制日期）, tenantId=" + tenantId);
        // 关键改进：如果提供了 id，优先使用 id 直接查找（像 call 方法一样）
        if (req != null && req.getId() != null) {
            calling = triageQueueItemService.getById(req.getId());
            if (calling == null) {
                return R.fail("队列项不存在");
            }
            // 验证状态：必须是"叫号中"状态
            if (!STATUS_CALLING.equals(calling.getStatus())) {
                return R.fail("只能对\"叫号中\"状态的患者执行\"下一患者\"操作，当前患者状态为：" + calling.getStatus());
            }
        } else {
            // 如果没有提供 id，通过查询条件查找（兼容旧逻辑）
            Long orgId = req != null && req.getOrganizationId() != null ? req.getOrganizationId() : null;
            LambdaQueryWrapper<TriageQueueItem> callingWrapper = new LambdaQueryWrapper<TriageQueueItem>()
                .eq(TriageQueueItem::getTenantId, tenantId)
                .eq(TriageQueueItem::getDeleteFlag, "0")
                .eq(TriageQueueItem::getStatus, STATUS_CALLING)
                .orderByAsc(TriageQueueItem::getQueueOrder)
                .last("LIMIT 1");
            if (orgId != null) {
                callingWrapper.eq(TriageQueueItem::getOrganizationId, orgId);
            }
            calling = triageQueueItemService.getOne(callingWrapper, false);
        }
        Long actualOrgId = null;
        // 当前叫号中 -> 完成（如果不存在，就当作从头找第一位等待）
        if (calling != null) {
            calling.setStatus(STATUS_COMPLETED).setUpdateTime(LocalDateTime.now());
            triageQueueItemService.updateById(calling);
            actualOrgId = calling.getOrganizationId(); // 使用叫号中患者所在的科室
        } else {
            // 如果没有叫号中的患者，使用请求中的 organizationId（如果有）
            if (req != null && req.getOrganizationId() != null) {
                actualOrgId = req.getOrganizationId();
            }
        }
        // 下一位等待 -> 叫号中（如果之前有叫号中的，就在同一科室找；否则在全科找）
        // 注意：也包含"跳过"状态的患者，因为跳过后的患者也可以重新叫号（不限制日期）
        LambdaQueryWrapper<TriageQueueItem> nextWrapper = new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .and(w -> w.eq(TriageQueueItem::getStatus, STATUS_WAITING)
                       .or()
                       .eq(TriageQueueItem::getStatus, STATUS_SKIPPED))
            .orderByAsc(TriageQueueItem::getQueueOrder)
            .last("LIMIT 1");
        if (actualOrgId != null) {
            nextWrapper.eq(TriageQueueItem::getOrganizationId, actualOrgId);
        }
        TriageQueueItem next = triageQueueItemService.getOne(nextWrapper, false);
        // 调试日志：打印查询条件和结果
        System.out.println(">>> [TriageQueue] next() 查询条件（不限制日期）: tenantId=" + tenantId 
            + ", actualOrgId=" + actualOrgId
            + ", deleteFlag=0"
            + ", status IN (WAITING, SKIPPED)");
        System.out.println(">>> [TriageQueue] next() 查询结果: calling=" + (calling != null ? calling.getPatientName() + "(status=" + calling.getStatus() + ", queueDate=" + calling.getQueueDate() + ")" : "null")
            + ", next=" + (next != null ? next.getPatientName() + "(status=" + next.getStatus() + ", queueDate=" + next.getQueueDate() + ")" : "null"));
        if (next == null) {
            if (actualOrgId != null) {
                recalcOrders(actualOrgId, null);
            }
            return R.fail("当前没有等待的患者");
        }
        next.setStatus(STATUS_CALLING).setUpdateTime(LocalDateTime.now());
        triageQueueItemService.updateById(next);
        if (next.getOrganizationId() != null) {
            recalcOrders(next.getOrganizationId(), null);
        }
        return R.ok(true);
    }
    private List<TriageQueueItem> listInternal(Long orgId, LocalDate qd) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        LambdaQueryWrapper<TriageQueueItem> wrapper = new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getOrganizationId, orgId)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .ne(TriageQueueItem::getStatus, STATUS_COMPLETED);
        // 如果 qd 不为 null，才添加日期限制
        if (qd != null) {
            wrapper.eq(TriageQueueItem::getQueueDate, qd);
        }
        return triageQueueItemService.list(wrapper);
    }
    private TriageQueueItem findCalling(Long orgId, LocalDate qd) {
        Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
        return triageQueueItemService.getOne(new LambdaQueryWrapper<TriageQueueItem>()
            .eq(TriageQueueItem::getTenantId, tenantId)
            .eq(TriageQueueItem::getOrganizationId, orgId)
            .eq(TriageQueueItem::getQueueDate, qd)
            .eq(TriageQueueItem::getDeleteFlag, "0")
            .eq(TriageQueueItem::getStatus, STATUS_CALLING)
            .last("LIMIT 1"), false);
    }
    private void recalcOrders(Long orgId, LocalDate qd) {
        List<TriageQueueItem> list = listInternal(orgId, qd);
        list.sort(Comparator.comparing(TriageQueueItem::getQueueOrder).thenComparing(TriageQueueItem::getId));
        int i = 1;
        for (TriageQueueItem it : list) {
            if (!Objects.equals(it.getQueueOrder(), i)) {
                it.setQueueOrder(i).setUpdateTime(LocalDateTime.now());
                triageQueueItemService.updateById(it);
            }
            i++;
        }
    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/controller/TriageQueueController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/controller/TriageQueueController.java
@@ -0,0 +1,70 @@
 package com.openhis.web.triageandqueuemanage.controller;
 import com.core.common.core.domain.R;
 import com.openhis.web.triageandqueuemanage.appservice.TriageQueueAppService;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueActionReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueAddReq;
 import com.openhis.web.triageandqueuemanage.dto.TriageQueueAdjustReq;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.web.bind.annotation.*;
 import javax.annotation.Resource;
 import java.time.LocalDate;
@RestController
@Slf4j
@RequestMapping("/triage/queue")
 public class TriageQueueController {
    @Resource
    private TriageQueueAppService triageQueueAppService;
    @GetMapping("/list")
    public R<?> list(@RequestParam(value = "organizationId", required = false) Long organizationId,
                     @RequestParam(value = "date", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date) {
        return triageQueueAppService.list(organizationId, date);
    }
    @PostMapping("/add")
    public R<?> add(@RequestBody TriageQueueAddReq req) {
        return triageQueueAppService.add(req);
    }
    @DeleteMapping("/remove/{id}")
    public R<?> remove(@PathVariable("id") Long id) {
        return triageQueueAppService.remove(id);
    }
    @PutMapping("/adjust")
    public R<?> adjust(@RequestBody TriageQueueAdjustReq req) {
        return triageQueueAppService.adjust(req);
    }
    @PostMapping("/call")
    public R<?> call(@RequestBody TriageQueueActionReq req) {
        return triageQueueAppService.call(req);
    }
    @PostMapping("/complete")
    public R<?> complete(@RequestBody(required = false) TriageQueueActionReq req) {
        return triageQueueAppService.complete(req);
    }
    @PostMapping("/requeue")
    public R<?> requeue(@RequestBody(required = false) TriageQueueActionReq req) {
        return triageQueueAppService.requeue(req);
    }
    @PostMapping("/skip")
    public R<?> skip(@RequestBody(required = false) TriageQueueActionReq req) {
        return triageQueueAppService.skip(req);
    }
    @PostMapping("/next")
    public R<?> next(@RequestBody(required = false) TriageQueueActionReq req) {
        return triageQueueAppService.next(req);
    }
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueActionReq.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueActionReq.java
@@ -0,0 +1,14 @@
 package com.openhis.web.triageandqueuemanage.dto;
 import lombok.Data;
@Data
 public class TriageQueueActionReq {
    /** 目标队列项ID（例如：选呼时选中的患者） */
    private Long id;
    /** 科室ID（可选：不传则用当前登录人orgId） */
    private Long organizationId;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueAddReq.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueAddReq.java
@@ -0,0 +1,18 @@
 package com.openhis.web.triageandqueuemanage.dto;
 import lombok.Data;
 import java.util.List;
@Data
 public class TriageQueueAddReq {
    /** 科室ID（就诊科室） */
    private Long organizationId;
    /** 科室名称（冗余存储，便于展示） */
    private String organizationName;
    /** 要加入队列的就诊记录 */
    private List<TriageQueueEncounterItem> items;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueAdjustReq.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueAdjustReq.java
@@ -0,0 +1,13 @@
 package com.openhis.web.triageandqueuemanage.dto;
 import lombok.Data;
@Data
 public class TriageQueueAdjustReq {
    private Long id;
    /** up / down */
    private String direction;
 }
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueEncounterItem.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/triageandqueuemanage/dto/TriageQueueEncounterItem.java
@@ -0,0 +1,15 @@
 package com.openhis.web.triageandqueuemanage.dto;
 import lombok.Data;
@Data
 public class TriageQueueEncounterItem {
    private Long encounterId;
    private Long patientId;
    private String patientName;
    private String healthcareName;
    private String practitionerName;
 }
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/Inventorymanage/PurchaseInventoryMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/Inventorymanage/PurchaseInventoryMapper.xml
@@ -86,7 +86,7 @@
               T3.total_volume,
               T5."name"                                       AS practitioner_name,
               T6."name"                                       AS purpose_location_name,
-               T6."id"                                         AS purpose_location_id,
+               T1.purpose_location_id                    AS purpose_location_id,
               T7."name"                                       AS purpose_location_store_name,
               T1.occurrence_time,
               (SELECT SUM(T9.quantity)
@@ -119,7 +119,7 @@
                           ON T1.supplier_id = T10.id
                               AND T10.delete_flag = '0'
                 LEFT JOIN sys_dict_data sdt
-                           ON sdt.dict_value = T1.unit_code AND dict_type = 'unit_code'
+                           ON sdt.dict_value = T1.unit_code AND sdt.dict_type = 'unit_code'
        WHERE T1.bus_no = #{busNo}
          AND T1.delete_flag = '0'
        UNION
@@ -145,7 +145,7 @@
               T8."size"                                       AS total_volume,
               T5."name"                                       AS practitioner_name,
               T6."name"                                       AS purpose_location_name,
-               T6."id"                                         AS purpose_location_id,
+               T1.purpose_location_id                    AS purpose_location_id,
               T7."name"                                       AS purpose_location_store_name,
               T1.occurrence_time,
               (SELECT SUM(T9.quantity)
@@ -175,7 +175,7 @@
                           ON T1.supplier_id = T10.id
                               AND T10.delete_flag = '0'
                 LEFT JOIN sys_dict_data sdt
-                           ON sdt.dict_value = T1.unit_code AND dict_type = 'unit_code'
+                           ON sdt.dict_value = T1.unit_code AND sdt.dict_type = 'unit_code'
        WHERE T1.bus_no = #{busNo}
          AND T1.delete_flag = '0'
    </select>
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/appointmentmanage/DoctorScheduleMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/appointmentmanage/DoctorScheduleMapper.xml
@@ -46,6 +46,29 @@
            <if test="updateTime != null">, #{updateTime}</if>
        )
    </insert>
-
+    <!--自定义更新方法-->
    <update id="updateDoctorSchedule" parameterType="com.openhis.appointmentmanage.domain.DoctorSchedule">
        UPDATE adm_doctor_schedule
        <set>
            <if test="weekday != null">weekday = #{weekday},</if>
            <if test="timePeriod != null">time_period = #{timePeriod},</if>
            <if test="doctor != null">doctor = #{doctor},</if>
            <if test="clinic != null">clinic = #{clinic},</if>
            <if test="startTime != null">start_time = #{startTime},</if>
            <if test="endTime != null">end_time = #{endTime},</if>
            <if test="limitNumber != null">limit_number = #{limitNumber},</if>
            <if test="callSignRecord != null">call_sign_record = #{callSignRecord},</if>
            <if test="registerItem != null">register_item = #{registerItem},</if>
            <if test="registerFee != null">register_fee = #{registerFee},</if>
            <if test="diagnosisItem != null">diagnosis_item = #{diagnosisItem},</if>
            <if test="diagnosisFee != null">diagnosis_fee = #{diagnosisFee},</if>
            <if test="isOnline != null">is_online = #{isOnline},</if>
            <if test="isStopped != null">is_stopped = #{isStopped},</if>
            <if test="stopReason != null">stop_reason = #{stopReason},</if>
            <if test="deptId != null">dept_id = #{deptId},</if>
            <if test="updateTime != null">update_time = #{updateTime}</if>
        </set>
        WHERE id = #{id}
    </update>
 </mapper>
--- 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
@@ -227,17 +227,17 @@
                AND T2.instance_table = #{activityTableName}
                LEFT JOIN adm_organization_location AS T3 ON T3.activity_definition_id = T1.ID
                AND T3.delete_flag = '0' AND (CURRENT_TIME :: time (6) BETWEEN T3.start_time AND T3.end_time)
-                WHERE T1.delete_flag = '0'
+                <if test="organizationId != null">
-                <if test="pricingFlag ==1">
+                    AND T3.organization_id = #{organizationId}
                    AND (T1.pricing_flag = #{pricingFlag} OR T1.pricing_flag IS NULL)
                </if>
                WHERE T1.delete_flag = '0'
                    AND (T1.pricing_flag = 1 OR T1.pricing_flag IS NULL)
                <if test="adviceDefinitionIdParamList != null and !adviceDefinitionIdParamList.isEmpty()">
                    AND T1.id IN
                    <foreach collection="adviceDefinitionIdParamList" item="itemId" open="(" separator="," close=")">
                        #{itemId}
                    </foreach>
                </if>
                AND T1.status_enum = #{statusEnum}
                )
            </if>
        </if>
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationMainAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationMainAppMapper.xml
@@ -24,7 +24,8 @@
        T10.practitioner_user_id,
        T10.jz_practitioner_user_id,
        T10.bus_no,
-        T10.identifier_no
+        T10.identifier_no,
        T10.missed_time
        from
        (
        SELECT T1.tenant_id AS tenant_id,
@@ -50,7 +51,8 @@
        T1.reception_time AS reception_time,
        T1.organization_id AS org_id,
        T8.bus_no AS bus_no,
-        T9.identifier_no AS identifier_no
+        T9.identifier_no AS identifier_no,
        T1.missed_time AS missed_time
        FROM adm_encounter AS T1
        LEFT JOIN adm_organization AS T2 ON T1.organization_id = T2.ID AND T2.delete_flag = '0'
        LEFT JOIN adm_healthcare_service AS T3 ON T1.service_type_id = T3.ID AND T3.delete_flag = '0'
@@ -70,18 +72,18 @@
        LEFT JOIN fin_contract AS T7 ON T6.contract_no = T7.bus_no AND T7.delete_flag = '0'
        LEFT JOIN adm_patient AS T8 ON T1.patient_id = T8.ID AND T8.delete_flag = '0'
        LEFT JOIN (
-           SELECT patient_id,
+        SELECT patient_id,
-                  identifier_no
+        identifier_no
-           FROM (
+        FROM (
-                SELECT patient_id,
+        SELECT patient_id,
-                       identifier_no,
+        identifier_no,
-                       ROW_NUMBER() OVER (PARTITION BY patient_id ORDER BY create_time ASC) AS rn
+        ROW_NUMBER() OVER (PARTITION BY patient_id ORDER BY create_time ASC) AS rn
-                FROM adm_patient_identifier
+        FROM adm_patient_identifier
-                WHERE delete_flag = '0'
+        WHERE delete_flag = '0'
-                  AND identifier_no IS NOT NULL
+        AND identifier_no IS NOT NULL
-                  AND identifier_no != ''
+        AND identifier_no != ''
-           ) t
+        ) t
-           WHERE rn = 1
+        WHERE rn = 1
        ) AS T9 ON T8.id = T9.patient_id
        WHERE
        T1.delete_flag = '0'
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/inhospitalnursestation/ATDManageAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/inhospitalnursestation/ATDManageAppMapper.xml
@@ -224,28 +224,7 @@
    </select>
    <select id="selectAdmissionPatientInfo"
            resultType="com.openhis.web.inhospitalnursestation.dto.AdmissionPatientInfoDto">
-        WITH locations AS (SELECT ael.encounter_id,
+        SELECT DISTINCT ae.id                             AS encounter_id,
                                  ael.start_time,
                                  al.form_enum,
                                  al.id     AS location_id,
                                  al."name" AS location_name
                           FROM adm_encounter_location ael
                                    LEFT JOIN adm_location al
                                              ON ael.location_id = al.id
                                                  AND al.delete_flag = '0'
                           WHERE ael.status_enum = #{active}
                             AND ael.delete_flag = '0'),
             practitioners AS (SELECT aep.encounter_id,
                                      aep.type_code,
                                      pra.id     AS practitioner_id,
                                      pra."name" AS practitioner_name
                               FROM adm_encounter_participant aep
                                        LEFT JOIN adm_practitioner pra
                                                  ON aep.practitioner_id = pra.id
                                                      AND pra.delete_flag = '0'
                               WHERE aep.status_enum = #{active}
                                 AND aep.delete_flag = '0')
        SELECT ae.id                             AS encounter_id,
               ae.bus_no,
               ae.priority_enum,
               ae.organization_id,
@@ -273,27 +252,84 @@
               fc.contract_name,
               diagnosis.condition_names
        FROM adm_encounter ae
-                 LEFT JOIN locations AS bed
+                 LEFT JOIN (
-                           ON bed.encounter_id = ae.id
+                    SELECT ael.encounter_id,
-                               AND bed.form_enum = #{bed}
+                           ael.start_time,
-                 LEFT JOIN locations AS house
+                           al.id     AS location_id,
-                           ON house.encounter_id = ae.id
+                           al."name" AS location_name
-                               AND house.form_enum = #{house}
+                    FROM adm_encounter_location ael
-                 LEFT JOIN locations AS ward
+                             LEFT JOIN adm_location al ON ael.location_id = al.id AND al.delete_flag = '0'
-                           ON ward.encounter_id = ae.id
+                    WHERE ael.status_enum = #{active}
-                               AND ward.form_enum = #{ward}
+                      AND ael.delete_flag = '0'
-                 LEFT JOIN practitioners AS primaryNurse
+                      AND ael.form_enum = #{bed}
-                           ON primaryNurse.encounter_id = ae.id
+                    LIMIT 1
-                               AND primaryNurse.type_code = #{primaryNurse}
+                ) AS bed ON bed.encounter_id = ae.id
-                 LEFT JOIN practitioners AS attendingDoctor
+                 LEFT JOIN (
-                           ON attendingDoctor.encounter_id = ae.id
+                    SELECT ael.encounter_id,
-                               AND attendingDoctor.type_code = #{attendingDoctor}
+                           al.id     AS location_id,
-                 LEFT JOIN practitioners AS admittingDoctor
+                           al."name" AS location_name
-                           ON admittingDoctor.encounter_id = ae.id
+                    FROM adm_encounter_location ael
-                               AND admittingDoctor.type_code = #{admittingDoctor}
+                             LEFT JOIN adm_location al ON ael.location_id = al.id AND al.delete_flag = '0'
-                 LEFT JOIN practitioners AS chiefDoctor
+                    WHERE ael.status_enum = #{active}
-                           ON chiefDoctor.encounter_id = ae.id
+                      AND ael.delete_flag = '0'
-                               AND chiefDoctor.type_code = #{chiefDoctor}
+                      AND ael.form_enum = #{house}
                    LIMIT 1
                ) AS house ON house.encounter_id = ae.id
                 LEFT JOIN (
                    SELECT ael.encounter_id,
                           al.id     AS location_id,
                           al."name" AS location_name
                    FROM adm_encounter_location ael
                             LEFT JOIN adm_location al ON ael.location_id = al.id AND al.delete_flag = '0'
                    WHERE ael.status_enum = #{active}
                      AND ael.delete_flag = '0'
                      AND ael.form_enum = #{ward}
                    LIMIT 1
                ) AS ward ON ward.encounter_id = ae.id
                 LEFT JOIN (
                    SELECT aep.encounter_id,
                           pra.id     AS practitioner_id,
                           pra."name" AS practitioner_name
                    FROM adm_encounter_participant aep
                             LEFT JOIN adm_practitioner pra ON aep.practitioner_id = pra.id AND pra.delete_flag = '0'
                    WHERE aep.status_enum = #{active}
                      AND aep.delete_flag = '0'
                      AND aep.type_code = #{primaryNurse}
                    LIMIT 1
                ) AS primaryNurse ON primaryNurse.encounter_id = ae.id
                 LEFT JOIN (
                    SELECT aep.encounter_id,
                           pra.id     AS practitioner_id,
                           pra."name" AS practitioner_name
                    FROM adm_encounter_participant aep
                             LEFT JOIN adm_practitioner pra ON aep.practitioner_id = pra.id AND pra.delete_flag = '0'
                    WHERE aep.status_enum = #{active}
                      AND aep.delete_flag = '0'
                      AND aep.type_code = #{attendingDoctor}
                    LIMIT 1
                ) AS attendingDoctor ON attendingDoctor.encounter_id = ae.id
                 LEFT JOIN (
                    SELECT aep.encounter_id,
                           pra.id     AS practitioner_id,
                           pra."name" AS practitioner_name
                    FROM adm_encounter_participant aep
                             LEFT JOIN adm_practitioner pra ON aep.practitioner_id = pra.id AND pra.delete_flag = '0'
                    WHERE aep.status_enum = #{active}
                      AND aep.delete_flag = '0'
                      AND aep.type_code = #{admittingDoctor}
                    LIMIT 1
                ) AS admittingDoctor ON admittingDoctor.encounter_id = ae.id
                 LEFT JOIN (
                    SELECT aep.encounter_id,
                           pra.id     AS practitioner_id,
                           pra."name" AS practitioner_name
                    FROM adm_encounter_participant aep
                             LEFT JOIN adm_practitioner pra ON aep.practitioner_id = pra.id AND pra.delete_flag = '0'
                    WHERE aep.status_enum = #{active}
                      AND aep.delete_flag = '0'
                      AND aep.type_code = #{chiefDoctor}
                    LIMIT 1
                ) AS chiefDoctor ON chiefDoctor.encounter_id = ae.id
                 LEFT JOIN adm_organization ao
                           ON ao.id = ae.organization_id
                               AND ao.delete_flag = '0'
@@ -307,47 +343,17 @@
                 LEFT JOIN fin_contract fc
                           ON aa.contract_no = fc.bus_no
                               AND fc.delete_flag = '0'
-                 LEFT JOIN (SELECT aed.encounter_id,
+                 LEFT JOIN (
-                                   STRING_AGG(ccd.name, ', ') AS condition_names
+                    SELECT aed.encounter_id,
-                            FROM adm_encounter_diagnosis aed
+                           STRING_AGG(ccd.name, ', ') AS condition_names
-                                     INNER JOIN cli_condition cc
+                    FROM adm_encounter_diagnosis aed
-                                                ON cc.id = aed.condition_id
+                             INNER JOIN cli_condition cc ON cc.id = aed.condition_id AND cc.delete_flag = '0'
-                                                    AND cc.delete_flag = '0'
+                             INNER JOIN cli_condition_definition ccd ON ccd.id = cc.definition_id AND ccd.delete_flag = '0'
-                                     INNER JOIN cli_condition_definition ccd
+                    WHERE aed.delete_flag = '0'
-                                                ON ccd.id = cc.definition_id
+                    GROUP BY aed.encounter_id
-                                                    AND ccd.delete_flag = '0'
+                ) AS diagnosis ON ae.id = diagnosis.encounter_id
                            WHERE aed.delete_flag = '0'
                            GROUP BY aed.encounter_id) AS diagnosis
                           ON ae.id = diagnosis.encounter_id
        WHERE ae.id = #{encounterId}
          AND ae.delete_flag = '0'
        GROUP BY ae.id,
                 ae.bus_no,
                 ae.priority_enum,
                 ae.organization_id,
                 ae.start_time,
                 bed.start_time,
                 bed.location_id,
                 bed.location_name,
                 house.location_id,
                 house.location_name,
                 ward.location_id,
                 ward.location_name,
                 primaryNurse.practitioner_id,
                 primaryNurse.practitioner_name,
                 attendingDoctor.practitioner_id,
                 attendingDoctor.practitioner_name,
                 admittingDoctor.practitioner_id,
                 admittingDoctor.practitioner_name,
                 chiefDoctor.practitioner_id,
                 chiefDoctor.practitioner_name,
                 ao."name",
                 ap."name",
                 ap.gender_enum,
                 ap.birth_date,
                 ap.phone,
                 fc.contract_name,
                 diagnosis.condition_names
    </select>
    <select id="getAmount" resultType="com.openhis.web.inhospitalnursestation.dto.EncounterAccountDto">
        SELECT aa.id,
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/inpatientmanage/PatientHomeAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/inpatientmanage/PatientHomeAppMapper.xml
@@ -2,189 +2,250 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.openhis.web.inpatientmanage.mapper.PatientHomeAppMapper">
-    <!-- 患者首页信息分页查询-->
+    <!-- 患者首页信息分页查询 -->
    <select id="getPage" parameterType="java.util.Map"
            resultType="com.openhis.web.inpatientmanage.dto.PatientHomeDto">
        SELECT
-            T1.id,
+            id,
-            T1.active_flag,
+            active_flag,
-            T1.temp_flag,
+            temp_flag,
-            T1."name" AS patientName, -- 患者姓名
+            patientName,
-            T1.name_json,
+            name_json,
-            T1.bus_no AS patientNo, -- 病历号
+            patientNo,
-            T1.gender_enum, -- 患者性别
+            gender_enum,
-            T1.birth_date,
+            birth_date,
-            T1.deceased_date,
+            deceased_date,
-            T1.marital_status_enum,
+            marital_status_enum,
-            T1.prfs_enum,
+            prfs_enum,
-            T1.phone, -- 患者手机号
+            phone,
-            COALESCE(NULLIF(T1.address, ''), '') AS address, -- 处理空地址
+            address,
-            T1.address_province,
+            address_province,
-            T1.address_city,
+            address_city,
-            T1.address_district,
+            address_district,
-            T1.address_street,
+            address_street,
-            T1.address_json,
+            address_json,
-            T1.nationality_code,
+            nationality_code,
-            T1.id_card,
+            id_card,
-            T1.py_str,
+            py_str,
-            T1.wb_str,
+            wb_str,
-            T1.blood_abo,
+            blood_abo,
-            T1.blood_rh,
+            blood_rh,
-            T1.work_company,
+            work_company,
-            T1.native_place,
+            native_place,
-            T1.country_code,
+            country_code,
-            T1.link_name,
+            link_name,
-            T1.link_relation_code,
+            link_relation_code,
-            T1.link_telcom,
+            link_telcom,
-            T1.link_jsons,
+            link_jsons,
-            T1.tenant_id,
+            tenant_id,
-            T2.bus_no AS hospitalNo, -- 住院号
+            hospitalNo,
-            T2.id AS encounterId, -- 就诊ID
+            encounterId,
-            T2.priority_enum, -- 护理级别
+            priority_enum,
-            T2.status_enum, -- 患者状态
+            status_enum,
-            T2.organization_id,-- 入院科室
+            organization_id,
-            T2.start_time AS admissionDate, -- 入院日期
+            admissionDate,
-            T2.end_time AS dischargeDate, -- 出院日期
+            dischargeDate,
-            T2.class_enum, -- 就诊类别
+            class_enum,
-            Doctor.name AS responsibleDoctor, -- 责任医生
+            responsibleDoctor,
-            Nurse.name AS responsibleNurse, -- 责任护士
+            responsibleNurse,
-            T6.type_code, -- 费别
+            type_code,
-            T7.status_enum AS surgeryStatusEnum, -- 手术状态
+            surgeryStatusEnum,
-            T8.start_time AS surgeryStartTime,  -- 手术开始时间
+            surgeryStartTime,
-            T8.end_time AS surgeryEndTime,    -- 手术结束时间
+            surgeryEndTime,
-            T9.id AS encounterLocationId, -- 就诊位置ID
+            encounterLocationId,
-            T9.location_id, -- 床位号
+            location_id,
-            T11."name" AS caty, -- 入院科室
+            caty,
-            T12."name" AS mainDiagnosis -- 主要诊断
+            mainDiagnosis
-        FROM adm_patient AS T1
+        FROM (
-            LEFT JOIN adm_encounter T2
+            SELECT
-                ON T1.id = T2.patient_id  -- 患者ID
+                patient_base.*,
-                AND T2.delete_flag = '0'
+                ROW_NUMBER() OVER (PARTITION BY patient_base.id ORDER BY patient_base.encounterId) as rn
-                AND T2.class_enum = '1'   -- 仅选择住院患者
+            FROM (
-            -- 获取责任医生
+                SELECT DISTINCT
-            LEFT JOIN (
+                    T1.id,
-                SELECT
+                    T1.active_flag,
-                    encounter_id,
+                    T1.temp_flag,
-                    practitioner_id,
+                    T1."name" AS patientName, -- 患者姓名
-                    "name",
+                    T1.name_json,
-                    ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY practitioner_id) as rn
+                    T1.bus_no AS patientNo, -- 病历号
-                FROM (
+                    T1.gender_enum, -- 患者性别
-                    SELECT
+                    T1.birth_date,
-                        T3.encounter_id,
+                    T1.deceased_date,
-                        T4."name",
+                    T1.marital_status_enum,
-                        T3.practitioner_id
+                    T1.prfs_enum,
-                    FROM adm_encounter_participant T3
+                    T1.phone, -- 患者手机号
-                        LEFT JOIN adm_practitioner T4
+                    COALESCE(NULLIF(T1.address, ''), '') AS address, -- 处理空地址
-                            ON T3.practitioner_id = T4.id
+                    T1.address_province,
-                            AND T4.delete_flag = '0'
+                    T1.address_city,
-                    WHERE T3.type_code = '9' -- 责任医生类型
+                    T1.address_district,
-                        AND T3.delete_flag = '0'
+                    T1.address_street,
-                    ) sub
+                    T1.address_json,
-            ) Doctor ON T2.id = Doctor.encounter_id AND Doctor.rn = 1
+                    T1.nationality_code,
-            -- 获取责任护士
+                    T1.id_card,
-            LEFT JOIN (
+                    T1.py_str,
-                SELECT
+                    T1.wb_str,
-                    encounter_id,
+                    T1.blood_abo,
-                    practitioner_id,
+                    T1.blood_rh,
-                    "name",
+                    T1.work_company,
-                    ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY practitioner_id) as rn
+                    T1.native_place,
-                FROM (
+                    T1.country_code,
-                    SELECT
+                    T1.link_name,
-                        T3.encounter_id,
+                    T1.link_relation_code,
-                        T4."name",
+                    T1.link_telcom,
-                        T3.practitioner_id
+                    T1.link_jsons,
-                    FROM adm_encounter_participant T3
+                    T1.tenant_id,
-                        LEFT JOIN adm_practitioner T4
+                    T2.bus_no AS hospitalNo, -- 住院号
-                            ON T3.practitioner_id = T4.id
+                    T2.id AS encounterId, -- 就诊ID
-                            AND T4.delete_flag = '0'
+                    T2.priority_enum, -- 护理级别
-                    WHERE T3.type_code = '2' -- 责任护士类型
+                    T2.status_enum, -- 患者状态
-                        AND T3.delete_flag = '0'
+                    T2.organization_id,-- 入院科室
-                ) sub
+                    T2.start_time AS admissionDate, -- 入院日期
-            ) Nurse ON T2.id = Nurse.encounter_id AND Nurse.rn = 1
+                    T2.end_time AS dischargeDate, -- 出院日期
-            LEFT JOIN adm_encounter_diagnosis T5
+                    T2.class_enum, -- 就诊类别
-                ON T2.id = T5.encounter_id -- 就诊ID
+                    -- 获取责任医生（使用子查询确保只返回一个值）
-                AND T5.maindise_flag = 1
+                    (SELECT p."name"
-                AND T5.delete_flag = '0'
+                     FROM adm_encounter_participant ep
-            LEFT JOIN adm_account T6
+                     LEFT JOIN adm_practitioner p ON ep.practitioner_id = p.id AND p.delete_flag = '0'
-                ON T2.id = T6.encounter_id -- 就诊ID
+                     WHERE ep.encounter_id = T2.id
-                AND T6.delete_flag = '0'
+                       AND ep.type_code = '9'
-            LEFT JOIN cli_procedure T7
+                       AND ep.delete_flag = '0'
-                ON T1.id = T7.patient_id -- 患者ID
+                     ORDER BY ep.practitioner_id
-                AND T7.delete_flag = '0'
+                     LIMIT 1) AS responsibleDoctor,
-            LEFT JOIN cli_procedure_performer T8
+                    -- 获取责任护士（使用子查询确保只返回一个值）
-                ON T7.id = T8.procedure_id -- 手术ID
+                    (SELECT p."name"
-                AND T8.delete_flag = '0'
+                     FROM adm_encounter_participant ep
-            LEFT JOIN adm_encounter_location T9
+                     LEFT JOIN adm_practitioner p ON ep.practitioner_id = p.id AND p.delete_flag = '0'
-                ON T2.id = T9.encounter_id -- 就诊ID
+                     WHERE ep.encounter_id = T2.id
-                AND T9.form_enum = 8
+                       AND ep.type_code = '2'
-                AND T9.delete_flag = '0'
+                       AND ep.delete_flag = '0'
-            LEFT JOIN adm_organization T11
+                     ORDER BY ep.practitioner_id
-                ON T2.organization_id = T11.id
+                     LIMIT 1) AS responsibleNurse,
-                AND T11.type_enum = 2
+                    T6.type_code, -- 费别
-                AND T11.delete_flag = '0'
+                    T7.status_enum AS surgeryStatusEnum, -- 手术状态
-            LEFT JOIN cli_condition_definition T12
+                    T8.start_time AS surgeryStartTime,  -- 手术开始时间
-                ON T5.condition_id = T12.id
+                    T8.end_time AS surgeryEndTime,    -- 手术结束时间
-                AND T12.delete_flag = '0'
+                    T9.id AS encounterLocationId, -- 就诊位置ID
-            LEFT JOIN wor_service_request T13
+                    T9.location_id, -- 床位号
-                ON T2.id = T13.encounter_id
+                    T11."name" AS caty, -- 入院科室
-                AND T7.base_service_req_id = T13.id
+                    T12."name" AS mainDiagnosis -- 主要诊断
-                AND T13.delete_flag = '0'
+                FROM adm_patient AS T1
-            LEFT JOIN wor_service_request_detail T14
+                    INNER JOIN adm_encounter T2  -- 改为INNER JOIN确保患者有就诊记录
-                ON T13.id = T14.service_req_id
+                        ON T1.id = T2.patient_id  -- 患者ID
-                AND T14.type_code = '3'
+                        AND T2.delete_flag = '0'
-                AND T14.delete_flag = '0'
+                        AND T2.class_enum = '1'   -- 仅选择住院患者
-        <where>
+                    LEFT JOIN adm_encounter_diagnosis T5
-            T1.delete_flag = '0'
+                        ON T2.id = T5.encounter_id -- 就诊ID
-            -- 患者ID
+                        AND T5.maindise_flag = 1
-            <if test="patientId != null">
+                        AND T5.delete_flag = '0'
-                AND T1.id = #{patientId}
+                    LEFT JOIN adm_account T6
-            </if>
+                        ON T2.id = T6.encounter_id -- 就诊ID
                        AND T6.delete_flag = '0'
                    LEFT JOIN (
                        SELECT
                            patient_id,
                            status_enum,
                            id,
                            request_id,
                            ROW_NUMBER() OVER (PARTITION BY patient_id ORDER BY id DESC) as rn
                        FROM cli_procedure
                        WHERE delete_flag = '0'
                    ) T7 ON T1.id = T7.patient_id AND T7.rn = 1
                    LEFT JOIN (
                        SELECT
                            procedure_id,
                            start_time,
                            end_time,
                            ROW_NUMBER() OVER (PARTITION BY procedure_id ORDER BY id DESC) as rn
                        FROM cli_procedure_performer
                        WHERE delete_flag = '0'
                    ) T8 ON T7.id = T8.procedure_id AND T8.rn = 1
                    LEFT JOIN adm_encounter_location T9
                        ON T2.id = T9.encounter_id -- 就诊ID
                        AND T9.form_enum = 8
                        AND T9.delete_flag = '0'
                    LEFT JOIN adm_organization T11
                        ON T2.organization_id = T11.id
                        AND T11.type_enum = 2
                        AND T11.delete_flag = '0'
                    LEFT JOIN cli_condition_definition T12
                        ON T5.condition_id = T12.id
                        AND T12.delete_flag = '0'
                WHERE T1.delete_flag = '0'
                -- 患者ID
                <if test="patientId != null">
                    AND T1.id = #{patientId}
                </if>
-            -- 在科
+                -- 在科
-            <if test="statusEnum == 1">
+                <if test="statusEnum == 1">
-                AND T9.status_enum = 2
+                    AND T9.status_enum = 2
-            </if>
+                </if>
-            -- 待出院
+                -- 待出院
-            <if test="statusEnum == 3">
+                <if test="statusEnum == 3">
-                AND T2.status_enum = 4
+                    AND T2.status_enum = 4
-            </if>
+                </if>
-            -- 危重
+                -- 危重
-            <if test="statusEnum == 4">
+                <if test="statusEnum == 4">
-                AND T2.priority_enum = 1
+                    AND T2.priority_enum = 1
-            </if>
+                </if>
-            -- 手术
+                -- 手术
-            <if test="statusEnum == 5">
+                <if test="statusEnum == 5">
-                AND T14.type_code = '3'
+                    AND EXISTS (
-            </if>
+                        SELECT 1
-
+                        FROM wor_service_request_detail wsrd
-            -- 欠费
+                        INNER JOIN wor_service_request wsr ON wsrd.service_req_id = wsr.id
-            <if test="statusEnum == 6">
+                        WHERE wsr.encounter_id = T2.id
-                AND T6.balance_amount &lt; 0
+                          AND wsrd.type_code = '3'
-            </if>
+                          AND wsr.delete_flag = '0'
-
+                          AND wsrd.delete_flag = '0'
            -- 已出院
            <if test="statusEnum == 7">
                AND T2.status_enum = 5
            </if>
            <if test="searchKey != null and searchKey != ''">
                AND (
                    -- 住院号
                    T2.bus_no = #{searchKey}
                    -- 患者姓名
                    OR T1.name like concat('%', #{searchKey}, '%')
                    -- 责任医生
                    OR Doctor.name like concat('%', #{searchKey}, '%')
                    -- 责任护士
                    OR Nurse.name like concat('%', #{searchKey}, '%')
                    )
-            </if>
+                </if>
        </where>
-        ORDER BY T9.location_id ASC
+                -- 欠费
                <if test="statusEnum == 6">
                    AND T6.balance_amount &lt; 0
                </if>
                -- 已出院
                <if test="statusEnum == 7">
                    AND T2.status_enum = 5
                </if>
                <if test="searchKey != null and searchKey != ''">
                    AND (
                        -- 住院号
                        T2.bus_no = #{searchKey}
                        -- 患者姓名
                        OR T1.name like concat('%', #{searchKey}, '%')
                        -- 责任医生（在子查询中处理）
                        OR EXISTS (
                            SELECT 1
                            FROM adm_encounter_participant ep
                            LEFT JOIN adm_practitioner p ON ep.practitioner_id = p.id AND p.delete_flag = '0'
                            WHERE ep.encounter_id = T2.id
                              AND ep.type_code = '9'
                              AND ep.delete_flag = '0'
                              AND p."name" like concat('%', #{searchKey}, '%')
                        )
                        -- 责任护士（在子查询中处理）
                        OR EXISTS (
                            SELECT 1
                            FROM adm_encounter_participant ep
                            LEFT JOIN adm_practitioner p ON ep.practitioner_id = p.id AND p.delete_flag = '0'
                            WHERE ep.encounter_id = T2.id
                              AND ep.type_code = '2'
                              AND ep.delete_flag = '0'
                              AND p."name" like concat('%', #{searchKey}, '%')
                        )
                    )
                </if>
            ) patient_base
        ) ranked_result
        WHERE rn = 1
        ORDER BY location_id ASC
    </select>
    <!-- 科室空床查询-->
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/inpatientmanage/VitalSignsAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/inpatientmanage/VitalSignsAppMapper.xml
@@ -46,7 +46,7 @@
            AND T6.delete_flag = '0'
        LEFT JOIN wor_service_request T7
            ON T1.encounter_id = T7.encounter_id
-            AND T5.base_service_req_id = T7.id
+            AND T5.request_id = T7.id
            AND T7.delete_flag = '0'
        LEFT JOIN wor_service_request_detail T8
            ON T7.id = T8.service_req_id
--- 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
@@ -5,7 +5,8 @@
 <mapper namespace="com.openhis.web.regdoctorstation.mapper.AdviceManageAppMapper">
    <select id="getRegPatientMainInfo" resultType="com.openhis.web.regdoctorstation.dto.RegPatientMainInfoDto">
-        SELECT rpmi.tenant_id,
+        SELECT DISTINCT ON (rpmi.patient_id)
               rpmi.tenant_id,
               rpmi.encounter_id,
               rpmi.status_enum,
               rpmi.bus_no,
@@ -26,7 +27,7 @@
               rpmi.contract_name,
               rpmi.reg_diagnosis_name,
               rpmi.account_id
-        from (SELECT ae.tenant_id,
+        FROM (SELECT ae.tenant_id,
                     ae.ID                                                             AS encounter_id,
                     ae.status_enum                                                    AS status_enum,
                     ae.bus_no                                                         AS bus_no,
@@ -94,7 +95,90 @@
                    AND practitioner_id = #{practitionerId}
                    AND org_id = ae.organization_id
              )) AS rpmi
-            ${ew.customSqlSegment}
+        <if test="ew != null and ew.sqlSegment != null and ew.sqlSegment != ''">
            WHERE ${ew.sqlSegment}
        </if>
        ORDER BY rpmi.patient_id, rpmi.encounter_id DESC
    </select>
    <!-- 用于分页的COUNT查询，与主查询保持一致的去重逻辑 -->
    <select id="getRegPatientMainInfoCount" resultType="java.lang.Long">
        SELECT COUNT(*) FROM (
            SELECT DISTINCT ON (rpmi.patient_id)
                   rpmi.patient_id
            FROM (SELECT ae.tenant_id,
                         ae.ID                                                             AS encounter_id,
                         ae.status_enum                                                    AS status_enum,
                         ae.bus_no                                                         AS bus_no,
                         ae.start_time                                                     AS in_hospital_time,
                         (EXTRACT(DAY FROM (CURRENT_DATE - ae.start_time)) :: INTEGER + 1) AS in_hospital_days,
                         ae.end_time                                                       AS out_hospital_time,
                         ap.ID                                                             AS patient_id,
                         ap.NAME                                                           AS patient_name,
                         ap.gender_enum                                                    AS gender_enum,
                         ap.birth_date                                                     AS birth_date,
                         alw.NAME                                                          AS ward_name,
                         alh.NAME                                                          AS house_name,
                         alb.NAME                                                          AS bed_name,
                         aelb.start_time                                                   AS in_org_time,
                         ao.id                                                             AS in_hospital_org_id,
                         ao.NAME                                                           AS in_hospital_org_name,
                         aa.id                                                             AS account_id,
                         aa.contract_no                                                    AS contract_no,
                         fc.contract_name                                                  AS contract_name,
                         ccd.NAME                                                          AS reg_diagnosis_name
                  FROM adm_encounter AS ae
                           LEFT JOIN adm_patient AS ap ON ap.ID = ae.patient_id
                      AND ap.delete_flag = '0'
                           LEFT JOIN adm_organization AS ao ON ao.ID = ae.organization_id
                      AND ao.delete_flag = '0'
                           LEFT JOIN adm_encounter_location AS aelw ON aelw.encounter_id = ae.ID
                      AND aelw.delete_flag = '0'
                      AND aelw.form_enum = #{wardEnum}
                      AND aelw.status_enum = #{encounterActivityStatus}
                           LEFT JOIN adm_location AS alw ON alw.ID = aelw.location_id
                      AND alw.delete_flag = '0'
                           LEFT JOIN adm_encounter_location AS aelh ON aelh.encounter_id = ae.ID
                      AND aelh.delete_flag = '0'
                      AND aelh.form_enum = #{houseEnum}
                      AND aelh.status_enum = #{encounterActivityStatus}
                           LEFT JOIN adm_location AS alh ON alh.ID = aelh.location_id
                      AND alh.delete_flag = '0'
                           LEFT JOIN adm_encounter_location AS aelb ON aelb.encounter_id = ae.ID
                      AND aelb.delete_flag = '0'
                      AND aelb.form_enum = #{bedEnum}
                      AND aelb.status_enum = #{encounterActivityStatus}
                           LEFT JOIN adm_location AS alb ON alb.ID = aelb.location_id
                      AND alb.delete_flag = '0'
                           INNER JOIN adm_account AS aa ON aa.encounter_id = ae.ID
                      AND aa.delete_flag = '0'
                      AND aa.encounter_flag = 1
                           LEFT JOIN fin_contract AS fc ON fc.bus_no = aa.contract_no
                      AND fc.delete_flag = '0'
                           LEFT JOIN adm_encounter_diagnosis AS aed ON aed.encounter_id = ae.ID
                      AND aed.delete_flag = '0'
                      AND aed.maindise_flag = #{maindiseFlag}
                           LEFT JOIN cli_condition AS cc ON cc.ID = aed.condition_id
                      AND cc.delete_flag = '0'
                           LEFT JOIN cli_condition_definition AS ccd ON ccd.ID = cc.definition_id
                      AND ccd.delete_flag = '0'
                  WHERE ae.delete_flag = '0'
                    AND ae.class_enum = #{classEnum}
                    AND ae.status_enum != #{toBeRegistered}
                    AND ae.status_enum != #{alreadySettled}
                    AND ae.status_enum != #{registered}
                    AND EXISTS(
                      SELECT 1
                      FROM adm_practitioner_role
                      WHERE delete_flag = '0'
                        AND practitioner_id = #{practitionerId}
                        AND org_id = ae.organization_id
                  )) AS rpmi
            <if test="ew != null and ew.sqlSegment != null and ew.sqlSegment != ''">
                WHERE ${ew.sqlSegment}
            </if>
            ORDER BY rpmi.patient_id, rpmi.encounter_id DESC
        ) AS distinct_patients
    </select>
    <select id="getRegRequestBaseInfo" resultType="com.openhis.web.regdoctorstation.dto.RegRequestBaseDto">
@@ -275,7 +359,9 @@
              WHERE aa.type_code = #{personalCashAccount}
                AND aa.delete_flag = '0'
              GROUP BY aa.tenant_id, aa.id, aa.insutype, aa.encounter_id, aa.balance_amount) AS final_res
-            ${ew.customSqlSegment}
+        <if test="ew != null and ew.sqlSegment != null and ew.sqlSegment != ''">
            WHERE ${ew.sqlSegment}
        </if>
    </select>
 </mapper>
--- a/openhis-server-new/openhis-common/src/main/java/com/openhis/common/aspectj/DictAspect.java
+++ b/openhis-server-new/openhis-common/src/main/java/com/openhis/common/aspectj/DictAspect.java
@@ -116,11 +116,16 @@ public class DictAspect {
    }
    private String queryDictLabel(String dictTable, String dictCode, String dictText, String dictValue) {
-        if (StringUtils.hasText(dictTable)) {
+        if (!StringUtils.hasText(dictTable)) {
-            // 场景 1：默认字典走DictUtils缓存
+            // 场景 1：默认字典走DictUtils缓存（dictTable 为空时）
            return DictUtils.getDictLabel(dictCode, dictValue);
        } else {
-            // 场景 2：查询指定表
+            // 场景 2：查询指定表（dictTable 有值时）
            // 必须同时有 dictTable 和 dictText 才能执行 SQL 查询
            if (!StringUtils.hasText(dictText)) {
                // 如果 dictText 为空，回退到字典缓存查询
                return DictUtils.getDictLabel(dictCode, dictValue);
            }
            String sql = String.format("SELECT %s FROM %s WHERE %s::varchar = ? LIMIT 1", dictText, dictTable, dictCode);
            try {
                return jdbcTemplate.queryForObject(sql, String.class, dictValue);
--- a/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SupplyCategory.java
+++ b/openhis-server-new/openhis-common/src/main/java/com/openhis/common/enums/SupplyCategory.java
@@ -23,120 +23,120 @@ public enum SupplyCategory implements HisEnumInterface {
    /**
     * 非库存供应
     */
-    NON_STOCK(2, "2", "非库存供应");
+    NON_STOCK(2, "2", "非库存供应"),
-    // /**
+    /**
-    // * 普通
+     * 普通
-    // */
+     */
-    // NORMAL(3, "3","0.普通"),
+    NORMAL(3, "3", "0.普通"),
-    // /**
+    /**
-    // * 采购计划生成
+     * 采购计划生成
-    // */
+     */
-    // PURCHASE_PLAN_GENERATION(4, "4","1.采购计划生成"),
+    PURCHASE_PLAN_GENERATION(4, "4", "1.采购计划生成"),
-    // /**
+    /**
-    // * 外购药品入库
+     * 外购药品入库
-    // */
+     */
-    // PURCHASED_DRUGS_WAREHOUSING(5, "5","0.外购药品入库"),
+    PURCHASED_DRUGS_WAREHOUSING(5, "5", "0.外购药品入库"),
-    // /**
+    /**
-    // * 自制药品入库
+     * 自制药品入库
-    // */
+     */
-    // HOMEMADE_DRUGS_WAREHOUSING(6, "6","1.自制药品入库"),
+    HOMEMADE_DRUGS_WAREHOUSING(6, "6", "1.自制药品入库"),
-    // /**
+    /**
-    // * 代销药品入库
+     * 代销药品入库
-    // */
+     */
-    // CONSIGNMENT_DRUGS_WAREHOUSING(7, "7","2.代销药品入库"),
+    CONSIGNMENT_DRUGS_WAREHOUSING(7, "7", "2.代销药品入库"),
-    // /**
+    /**
-    // * 其他药品入库
+     * 其他药品入库
-    // */
+     */
-    // OTHER_DRUGS_WAREHOUSING(8, "8","3.其他药品入库"),
+    OTHER_DRUGS_WAREHOUSING(8, "8", "3.其他药品入库"),
-    // /**
+    /**
-    // * 赠送药品入库
+     * 赠送药品入库
-    // */
+     */
-    // DONATED_DRUGS_WAREHOUSING(9, "9","4.赠送药品入库"),
+    DONATED_DRUGS_WAREHOUSING(9, "9", "4.赠送药品入库"),
-    // /**
+    /**
-    // * 申请采购
+     * 申请采购
-    // */
+     */
-    // PURCHASE_APPLICATION(10, "10","1.申请采购"),
+    PURCHASE_APPLICATION(10, "10", "1.申请采购"),
-    // /**
+    /**
-    // * 院内出库
+     * 院内出库
-    // */
+     */
-    // IN_HOSPITAL_OUTBOUND(11, "11","0.院内出库"),
+    IN_HOSPITAL_OUTBOUND(11, "11", "0.院内出库"),
-    // /**
+    /**
-    // * 院外出库
+     * 院外出库
-    // */
+     */
-    // OUT_OF_HOSPITAL_OUTBOUND(12, "12","1.院外出库"),
+    OUT_OF_HOSPITAL_OUTBOUND(12, "12", "1.院外出库"),
-    // /**
+    /**
-    // * 其他出库
+     * 其他出库
-    // */
+     */
-    // OTHER_OUTBOUND(13, "13","2.其他出库"),
+    OTHER_OUTBOUND(13, "13", "2.其他出库"),
-    // /**
+    /**
-    // * 普通损益
+     * 普通损益
-    // */
+     */
-    // GENERAL_PROFIT_AND_LOSS(14, "14","0.普通损益"),
+    GENERAL_PROFIT_AND_LOSS(14, "14", "0.普通损益"),
-    // /**
+    /**
-    // * 盘点损益
+     * 盘点损益
-    // */
+     */
-    // STOCKTAKING_PROFIT_AND_LOSS(15, "15","1.盘点损益"),
+    STOCKTAKING_PROFIT_AND_LOSS(15, "15", "1.盘点损益"),
-    // /**
+    /**
-    // * 制剂消耗
+     * 制剂消耗
-    // */
+     */
-    // PREPARATION_CONSUMPTION(16, "16","2.制剂消耗"),
+    PREPARATION_CONSUMPTION(16, "16", "2.制剂消耗"),
-    // /**
+    /**
-    // * 常备抢救药品
+     * 常备抢救药品
-    // */
+     */
-    // STANDBY_RESCUE_MEDICINES(16, "16","2.常备抢救药品"),
+    STANDBY_RESCUE_MEDICINES(17, "17", "2.常备抢救药品"),
-    // /**
+    /**
-    // * 破损过期药品
+     * 破损过期药品
-    // */
+     */
-    // DAMAGED_EXPIRED_MEDICINES(16, "16","3.破损过期药品"),
+    DAMAGED_EXPIRED_MEDICINES(18, "18", "3.破损过期药品"),
-    // /**
+    /**
-    // * 捐赠药品
+     * 捐赠药品
-    // */
+     */
-    // DONATED_MEDICINES(16, "16","4.捐赠药品"),
+    DONATED_MEDICINES(19, "19", "4.捐赠药品"),
-    // /**
+    /**
-    // * 普通盘点
+     * 普通盘点
-    // */
+     */
-    // GENERAL_STOCKTAKING(17, "17","0.普通盘点"),
+    GENERAL_STOCKTAKING(20, "20", "0.普通盘点"),
-    // /**
+    /**
-    // * 月度盘点
+     * 月度盘点
-    // */
+     */
-    // MONTHLY_STOCKTAKING(18, "18","1.月度盘点"),
+    MONTHLY_STOCKTAKING(21, "21", "1.月度盘点"),
-    // /**
+    /**
-    // * 门诊病人发药
+     * 门诊病人发药
-    // */
+     */
-    // OUTPATIENT_PATIENT_DISPENSING(19, "19","0.门诊病人发药"),
+    OUTPATIENT_PATIENT_DISPENSING(22, "22", "0.门诊病人发药"),
-    // /**
+    /**
-    // * 住院病人发药
+     * 住院病人发药
-    // */
+     */
-    // INPATIENT_PATIENT_DISPENSING(20, "20","1.住院病人发药"),
+    INPATIENT_PATIENT_DISPENSING(23, "23", "1.住院病人发药"),
-    // /**
+    /**
-    // * 住院病人汇总发药
+     * 住院病人汇总发药
-    // */
+     */
-    // INPATIENT_PATIENT_SUMMARY_DISPENSING(21, "21","2.住院病人汇总发药"),
+    INPATIENT_PATIENT_SUMMARY_DISPENSING(24, "24", "2.住院病人汇总发药"),
-    // /**
+    /**
-    // * 赠送
+     * 赠送
-    // */
+     */
-    // PRESENT(22, "22","1.赠送"),
+    PRESENT(25, "25", "1.赠送"),
-    // /**
+    /**
-    // * 视光材料
+     * 视光材料
-    // */
+     */
-    // OPTICAL_MATERIALS(23, "23","2.视光材料"),
+    OPTICAL_MATERIALS(26, "26", "2.视光材料"),
-    // /**
+    /**
-    // * 调价分类 药品
+     * 调价分类 药品
-    // */
+     */
-    // REQUEST_CATEGORY_CHANGE_PRICE_MEDICATION(24, "24","药品调价单"),
+    REQUEST_CATEGORY_CHANGE_PRICE_MEDICATION(27, "27", "药品调价单"),
-    // /**
+    /**
-    // * 调价分类 耗材
+     * 调价分类 耗材
-    // */
+     */
-    // REQUEST_CATEGORY_CHANGE_PRICE_DEVICE(25, "25","耗材调价单"),
+    REQUEST_CATEGORY_CHANGE_PRICE_DEVICE(28, "28", "耗材调价单"),
-    // /**
+    /**
-    // * 调价分类 诊疗
+     * 调价分类 诊疗
-    // */
+     */
-    // REQUEST_CATEGORY_CHANGE_PRICE_ACTIVITY(26, "26","诊疗调价单"),
+    REQUEST_CATEGORY_CHANGE_PRICE_ACTIVITY(29, "29", "诊疗调价单"),
-    // /**
+    /**
-    // * 调价分类 挂号
+     * 调价分类 挂号
-    // */
+     */
-    // REQUEST_CATEGORY_CHANGE_PRICE_HEALTH(27, "27","挂号调价单");
+    REQUEST_CATEGORY_CHANGE_PRICE_HEALTH(30, "30", "挂号调价单");
    private Integer value;
    private String code;
    private String info;
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/domain/Encounter.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/domain/Encounter.java
@@ -1,8 +1,6 @@
 package com.openhis.administration.domain;
-import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.*;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.core.common.core.domain.HisBaseEntity;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
@@ -145,4 +143,9 @@ public class Encounter extends HisBaseEntity {
     */
    private Long registrarId;
    /**
     * 过号时间
     */
    @TableField("missed_time")
    private Date missedTime;
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/domain/EncounterDiagnosis.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/domain/EncounterDiagnosis.java
@@ -66,4 +66,25 @@ public class EncounterDiagnosis extends HisBaseEntity {
     */
    private String diagnosisDesc;
    /**
     * 医生
     */
    private String doctor;
    /**
     *病名
     */
    private String name;
    /**
     *分类
     */
    private String classification;
    /**
     * 长诊断标识
     */
    private Integer longTermFlag;
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/domain/EncounterParticipant.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/domain/EncounterParticipant.java
@@ -1,6 +1,7 @@
 package com.openhis.administration.domain;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.core.common.core.domain.HisBaseEntity;
@@ -43,4 +44,9 @@ public class EncounterParticipant extends HisBaseEntity {
    /** 状态 */
    private Integer statusEnum;
    /**
     * 租户ID（新增字段，和数据库的tenant_id对应）
     */
    @TableField("tenant_id") // 显式映射数据库字段名，避免MyBatis-Plus自动转换出错
    private Integer tenantId;
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/service/impl/PatientServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/administration/service/impl/PatientServiceImpl.java
@@ -32,18 +32,11 @@ public class PatientServiceImpl extends ServiceImpl<PatientMapper, Patient> impl
     */
    @Override
    public boolean saveOrUpdatePatient(Patient patient) {
-
+        if (patient.getId() != null) {
-        // 身份证ID，患者ID，确定唯一患者
+            // 如果提供了ID，则直接更新该ID的记录
        LambdaQueryWrapper<Patient> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Patient::getId, patient.getId()).eq(Patient::getIdCard, patient.getIdCard());
        Patient existingPatient = baseMapper.selectOne(queryWrapper);
        if (existingPatient != null) {
            // 如果记录存在，更新记录
            patient.setId(existingPatient.getId());
            return baseMapper.updateById(patient) > 0;
        } else {
-            // 如果记录不存在，插入新记录
+            // 如果没有提供ID，则插入新记录
            return baseMapper.insert(patient) > 0;
        }
    }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/appointmentmanage/mapper/DoctorScheduleMapper.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/appointmentmanage/mapper/DoctorScheduleMapper.java
@@ -10,4 +10,8 @@ public interface DoctorScheduleMapper extends BaseMapper<DoctorSchedule> {
     * 自定义插入方法，排除id字段（数据库GENERATED ALWAYS）
     */
    int insertWithoutId(DoctorSchedule doctorSchedule);
    /**
     * 自定义更新方法
     */
    int updateDoctorSchedule(DoctorSchedule doctorSchedule);
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/mapper/OrderMapper.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/mapper/OrderMapper.java
@@ -27,7 +27,7 @@ public interface OrderMapper extends BaseMapper<Order> {
    int countOrders(Map<String, Object> params);
-    Order selectOrderBySlotId(Long slotId);
+    List<Order> selectOrderBySlotId(Long slotId);
    int updateOrderStatusById(Long id, Integer status);
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/IOrderService.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/IOrderService.java
@@ -25,8 +25,7 @@ public interface IOrderService extends IService<Order> {
    int countOrders(Map<String, Object> params);
-    Order selectOrderBySlotId(Long slotId);
+    List<Order> selectOrderBySlotId(Long slotId);
    int updateOrderStatusById(Long id, Integer status);
    int updateOrderCancelInfoById(Long id, java.util.Date cancelTime, String cancelReason);
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/impl/OrderServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/clinical/service/impl/OrderServiceImpl.java
@@ -3,7 +3,6 @@ package com.openhis.clinical.service.impl;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.core.common.utils.AssignSeqUtil;
 import com.core.common.utils.SecurityUtils;
 import com.openhis.clinical.domain.Order;
 import com.openhis.clinical.domain.Ticket;
 import com.openhis.clinical.mapper.OrderMapper;
@@ -71,7 +70,7 @@ public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements
    }
    @Override
-    public Order selectOrderBySlotId(Long slotId) {
+    public List<Order> selectOrderBySlotId(Long slotId) {
        return orderMapper.selectOrderBySlotId(slotId);
    }
--- 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
@@ -197,8 +197,8 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
            throw new RuntimeException("号源不可取消预约");
        }
-        Order order = orderService.selectOrderBySlotId(ticketId);
+        List<Order> orders = orderService.selectOrderBySlotId(ticketId);
-        if (order != null) {
+        for(Order order:orders){
            orderService.cancelAppointmentOrder(order.getId(), "患者取消预约");
        }
@@ -249,8 +249,8 @@ public class TicketServiceImpl extends ServiceImpl<TicketMapper, Ticket> impleme
        }
        // 检查是否存在相关订单，如果存在则取消
-        Order order = orderService.selectOrderBySlotId(ticketId);
+        List<Order> orders = orderService.selectOrderBySlotId(ticketId);
-        if (order != null) {
+        for(Order order:orders){
            orderService.cancelAppointmentOrder(order.getId(), "医生停诊");
        }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/domain/TriageCandidateExclusion.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/domain/TriageCandidateExclusion.java
@@ -0,0 +1,36 @@
 package com.openhis.triageandqueuemanage.domain;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@Data
@Accessors(chain = true)
@TableName(value = "hisdev.triage_candidate_exclusion")
@EqualsAndHashCode(callSuper = false)
 public class TriageCandidateExclusion {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Integer tenantId;
    private LocalDate exclusionDate;
    private Long encounterId;
    private Long patientId;
    private String patientName;
    private Long organizationId;
    private String organizationName;
    /** 排除原因：ADDED_TO_QUEUE（加入队列）、MANUAL_REMOVE（手动移除）等 */
    private String reason;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    private String deleteFlag;
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/domain/TriageQueueItem.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/domain/TriageQueueItem.java
@@ -0,0 +1,43 @@
 package com.openhis.triageandqueuemanage.domain;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@Data
@Accessors(chain = true)
@TableName(value = "hisdev.triage_queue_item")
@EqualsAndHashCode(callSuper = false)
 public class TriageQueueItem {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Integer tenantId;
    private LocalDate queueDate;
    private Long organizationId;
    private String organizationName;
    private Long encounterId;
    private Long patientId;
    private String patientName;
    private String healthcareName;
    private String practitionerName;
    /** WAITING / CALLING / SKIPPED / COMPLETED */
    private String status;
    private Integer queueOrder;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    private String deleteFlag;
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/mapper/TriageCandidateExclusionMapper.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/mapper/TriageCandidateExclusionMapper.java
@@ -0,0 +1,10 @@
 package com.openhis.triageandqueuemanage.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.openhis.triageandqueuemanage.domain.TriageCandidateExclusion;
 import org.springframework.stereotype.Repository;
@Repository
 public interface TriageCandidateExclusionMapper extends BaseMapper<TriageCandidateExclusion> {
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/mapper/TriageQueueItemMapper.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/mapper/TriageQueueItemMapper.java
@@ -0,0 +1,12 @@
 package com.openhis.triageandqueuemanage.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.openhis.triageandqueuemanage.domain.TriageQueueItem;
 import org.springframework.stereotype.Repository;
@Repository
 public interface TriageQueueItemMapper extends BaseMapper<TriageQueueItem> {
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/TriageCandidateExclusionService.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/TriageCandidateExclusionService.java
@@ -0,0 +1,8 @@
 package com.openhis.triageandqueuemanage.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.openhis.triageandqueuemanage.domain.TriageCandidateExclusion;
 public interface TriageCandidateExclusionService extends IService<TriageCandidateExclusion> {
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/TriageQueueItemService.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/TriageQueueItemService.java
@@ -0,0 +1,10 @@
 package com.openhis.triageandqueuemanage.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.openhis.triageandqueuemanage.domain.TriageQueueItem;
 public interface TriageQueueItemService extends IService<TriageQueueItem> {
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/impl/TriageCandidateExclusionServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/impl/TriageCandidateExclusionServiceImpl.java
@@ -0,0 +1,12 @@
 package com.openhis.triageandqueuemanage.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.openhis.triageandqueuemanage.domain.TriageCandidateExclusion;
 import com.openhis.triageandqueuemanage.mapper.TriageCandidateExclusionMapper;
 import com.openhis.triageandqueuemanage.service.TriageCandidateExclusionService;
 import org.springframework.stereotype.Service;
@Service
 public class TriageCandidateExclusionServiceImpl extends ServiceImpl<TriageCandidateExclusionMapper, TriageCandidateExclusion> implements TriageCandidateExclusionService {
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/impl/TriageQueueItemServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/triageandqueuemanage/service/impl/TriageQueueItemServiceImpl.java
@@ -0,0 +1,14 @@
 package com.openhis.triageandqueuemanage.service.impl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.openhis.triageandqueuemanage.domain.TriageQueueItem;
 import com.openhis.triageandqueuemanage.mapper.TriageQueueItemMapper;
 import com.openhis.triageandqueuemanage.service.TriageQueueItemService;
 import org.springframework.stereotype.Service;
@Service
 public class TriageQueueItemServiceImpl extends ServiceImpl<TriageQueueItemMapper, TriageQueueItem> implements TriageQueueItemService {
 }
--- a/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/impl/DeviceDispenseServiceImpl.java
+++ b/openhis-server-new/openhis-domain/src/main/java/com/openhis/workflow/service/impl/DeviceDispenseServiceImpl.java
@@ -87,6 +87,11 @@ public class DeviceDispenseServiceImpl extends ServiceImpl<DeviceDispenseMapper,
        // 设置限制发药时间
        deviceDispense.setLimitTime(limitTime);
        // 显式设置tenantId、createBy和createTime字段，防止自动填充机制失效
        deviceDispense.setTenantId(getLoginUser().getTenantId());
        deviceDispense.setCreateBy(getLoginUser().getUsername());
        deviceDispense.setCreateTime(new Date());
        baseMapper.insert(deviceDispense);
        // if (DbOpType.INSERT.getCode().equals(dbOpType)) {
--- a/openhis-server-new/openhis-domain/src/main/resources/mapper/clinical/OrderMapper.xml
+++ b/openhis-server-new/openhis-domain/src/main/resources/mapper/clinical/OrderMapper.xml
@@ -119,6 +119,8 @@
    <select id="selectOrderById" resultMap="OrderResult">
        select * from order_main where id = #{id}
        and status = 1
        order by create_time desc
    </select>
    <select id="selectOrderBySlotId" resultMap="OrderResult">
--- a/openhis-server-new/sql/20260115_add_table_triage_candidate_exclusion.sql
+++ b/openhis-server-new/sql/20260115_add_table_triage_candidate_exclusion.sql
@@ -0,0 +1,45 @@
 -- 智能分诊排队：候选池排除记录表
 -- 用途：记录已从智能候选池中移除的患者（加入队列后不再出现在候选池）
 -- 注意：必须在后端实际连接的 schema 中执行（dev环境是 hisdev，test环境是 histest，prd环境是 hisprd）
 -- 执行前请先确认：SET search_path TO hisdev; （或对应的 schema）
 CREATE TABLE IF NOT EXISTS hisdev.triage_candidate_exclusion (
    id               BIGSERIAL PRIMARY KEY,
    tenant_id        INTEGER      NOT NULL,
    exclusion_date   DATE         NOT NULL,
    encounter_id     BIGINT       NOT NULL,
    patient_id       BIGINT,
    patient_name     VARCHAR(255),
    organization_id  BIGINT,
    organization_name VARCHAR(255),
    reason           VARCHAR(100) DEFAULT 'ADDED_TO_QUEUE', -- 排除原因：ADDED_TO_QUEUE（加入队列）、MANUAL_REMOVE（手动移除）等
    create_time      TIMESTAMP    DEFAULT CURRENT_TIMESTAMP,
    update_time      TIMESTAMP    DEFAULT CURRENT_TIMESTAMP,
    delete_flag      CHAR(1)      NOT NULL DEFAULT '0'
 );
 -- 常用查询索引：按租户/日期/就诊记录查询
 CREATE INDEX IF NOT EXISTS idx_triage_candidate_exclusion_list
    ON hisdev.triage_candidate_exclusion (tenant_id, exclusion_date, delete_flag, encounter_id);
 -- 防重复：同一天同租户同就诊记录只能有一条排除记录（未删除）
 CREATE UNIQUE INDEX IF NOT EXISTS uq_triage_candidate_exclusion_encounter
    ON hisdev.triage_candidate_exclusion (tenant_id, exclusion_date, encounter_id, delete_flag)
    WHERE delete_flag = '0';
 -- 就诊记录ID索引（用于关联查询）
 CREATE INDEX IF NOT EXISTS idx_triage_candidate_exclusion_encounter_id
    ON hisdev.triage_candidate_exclusion (encounter_id);
 -- 注释
 COMMENT ON TABLE hisdev.triage_candidate_exclusion IS '智能分诊排队候选池排除记录表';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.tenant_id IS '租户ID';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.exclusion_date IS '排除日期（通常为当天）';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.encounter_id IS '就诊记录ID（唯一标识）';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.patient_id IS '患者ID';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.patient_name IS '患者姓名';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.organization_id IS '科室ID';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.organization_name IS '科室名称';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.reason IS '排除原因：ADDED_TO_QUEUE（加入队列）、MANUAL_REMOVE（手动移除）等';
 COMMENT ON COLUMN hisdev.triage_candidate_exclusion.delete_flag IS '删除标志：0-未删除，1-已删除';
--- a/openhis-server-new/sql/20260115_add_table_triage_queue_item.sql
+++ b/openhis-server-new/sql/20260115_add_table_triage_queue_item.sql
@@ -0,0 +1,35 @@
 -- 智能分诊排队：队列持久化表（与 TriageQueueItem.java 字段一致）
 -- 注意：必须在后端实际连接的 schema 中执行（dev环境是 hisdev，test环境是 histest，prd环境是 hisprd）
 -- 执行前请先确认：SET search_path TO hisdev; （或对应的 schema）
 CREATE TABLE IF NOT EXISTS triage_queue_item (
    id               BIGSERIAL PRIMARY KEY,
    tenant_id        INTEGER      NOT NULL,
    queue_date       DATE         NOT NULL,
    organization_id  BIGINT       NOT NULL,
    organization_name VARCHAR(255),
    encounter_id     BIGINT       NOT NULL,
    patient_id       BIGINT,
    patient_name     VARCHAR(255),
    healthcare_name  VARCHAR(255),
    practitioner_name VARCHAR(255),
    status           VARCHAR(50)  NOT NULL, -- WAITING/CALLING/SKIPPED/COMPLETED
    queue_order      INTEGER      NOT NULL,
    create_time      TIMESTAMP,
    update_time      TIMESTAMP,
    delete_flag      CHAR(1)      NOT NULL DEFAULT '0'
 );
 -- 常用查询索引：按租户/科室/日期/状态/顺序取队列
 CREATE INDEX IF NOT EXISTS idx_triage_queue_item_list
    ON triage_queue_item (tenant_id, queue_date, organization_id, delete_flag, status, queue_order);
 -- 防重复：同一天同租户同科室同就诊记录只能在队列里一条（未删除）
 CREATE UNIQUE INDEX IF NOT EXISTS uq_triage_queue_item_encounter
    ON triage_queue_item (tenant_id, queue_date, organization_id, encounter_id, delete_flag)
    WHERE delete_flag = '0';
 -- 就诊记录ID索引（用于关联查询）
 CREATE INDEX IF NOT EXISTS idx_triage_queue_item_encounter_id
    ON triage_queue_item (encounter_id);
--- a/openhis-server-new/sql/check_outpatient_charge_activity_data.sql
+++ b/openhis-server-new/sql/check_outpatient_charge_activity_data.sql
@@ -0,0 +1,94 @@
 -- ============================================
 -- 检查门诊划价"诊疗判断"下没有数据的原因
 -- ============================================
 -- 1. 检查是否有诊疗类型的收费项目（context_enum = 3）
 SELECT 
    COUNT(*) AS total_activity_charge_items,
    COUNT(CASE WHEN delete_flag = '0' THEN 1 END) AS active_charge_items
 FROM adm_charge_item
 WHERE context_enum = 3;  -- ACTIVITY = 3
 -- 2. 检查诊疗类型的收费项目是否能关联到 wor_activity_definition
 SELECT 
    T1.id AS charge_item_id,
    T1.encounter_id,
    T1.context_enum,
    T1.product_id,
    T1.status_enum AS charge_status,
    T2.id AS activity_def_id,
    T2.name AS activity_name,
    T2.status_enum AS activity_status,
    T2.delete_flag AS activity_delete_flag,
    CASE 
        WHEN T2.id IS NULL THEN '❌ 无法关联到诊疗项目定义'
        WHEN T2.delete_flag != '0' THEN '❌ 诊疗项目定义已删除'
        WHEN T2.status_enum != 1 THEN '❌ 诊疗项目定义未激活（status_enum != 1）'
        ELSE '✅ 正常'
    END AS match_status
 FROM adm_charge_item AS T1
 LEFT JOIN wor_activity_definition AS T2
    ON T1.context_enum = 3
    AND T1.product_id = T2.id
    AND T2.delete_flag = '0'
    AND T2.status_enum = 1  -- 当前查询条件
 WHERE T1.context_enum = 3
  AND T1.delete_flag = '0'
 LIMIT 20;
 -- 3. 检查如果移除 status_enum = 1 条件，能关联多少条
 SELECT 
    COUNT(*) AS total_count,
    COUNT(CASE WHEN T2.id IS NOT NULL AND T2.delete_flag = '0' AND T2.status_enum = 1 THEN 1 END) AS matched_active,
    COUNT(CASE WHEN T2.id IS NOT NULL AND T2.delete_flag = '0' AND T2.status_enum != 1 THEN 1 END) AS matched_inactive,
    COUNT(CASE WHEN T2.id IS NULL THEN 1 END) AS unmatched
 FROM adm_charge_item AS T1
 LEFT JOIN wor_activity_definition AS T2
    ON T1.context_enum = 3
    AND T1.product_id = T2.id
    AND T2.delete_flag = '0'
 WHERE T1.context_enum = 3
  AND T1.delete_flag = '0';
 -- 4. 检查具体某个就诊的诊疗项目（替换 encounterId 为实际值）
 -- SELECT 
 --     T1.id AS charge_item_id,
 --     T1.encounter_id,
 --     T1.product_id,
 --     T1.status_enum AS charge_status,
 --     T2.id AS activity_def_id,
 --     T2.name AS activity_name,
 --     T2.status_enum AS activity_status,
 --     CASE 
 --         WHEN T2.id IS NULL THEN '无法关联'
 --         WHEN T2.status_enum != 1 THEN '诊疗项目未激活'
 --         ELSE '正常'
 --     END AS status
 -- FROM adm_charge_item AS T1
 -- LEFT JOIN wor_activity_definition AS T2
 --     ON T1.context_enum = 3
 --     AND T1.product_id = T2.id
 --     AND T2.delete_flag = '0'
 --     AND T2.status_enum = 1
 -- WHERE T1.encounter_id = :encounterId  -- 替换为实际的encounterId
 --   AND T1.context_enum = 3
 --   AND T1.delete_flag = '0';
 -- 5. 如果诊疗项目 status_enum != 1，查看这些项目
 SELECT 
    T1.id AS charge_item_id,
    T1.encounter_id,
    T1.product_id,
    T2.name AS activity_name,
    T2.status_enum AS activity_status,
    '诊疗项目未激活，导致无法显示' AS issue
 FROM adm_charge_item AS T1
 INNER JOIN wor_activity_definition AS T2
    ON T1.context_enum = 3
    AND T1.product_id = T2.id
    AND T2.delete_flag = '0'
    AND T2.status_enum != 1  -- 未激活
 WHERE T1.context_enum = 3
  AND T1.delete_flag = '0'
 LIMIT 20;
--- a/openhis-server-new/sql/check_pricing_flag_zero_data.sql
+++ b/openhis-server-new/sql/check_pricing_flag_zero_data.sql
@@ -0,0 +1,142 @@
 -- ============================================
 -- 检查 wor_activity_definition 表中 pricing_flag = 0 的数据
 -- 用途：分析哪些项目被标记为"不允许划价"，是否符合业务预期
 -- ============================================
 -- 1. 查看所有 pricing_flag = 0 的项目详情
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    category_code,
    type_enum,
    pricing_flag,
    status_enum,
    org_id,
    location_id,
    description_text,
    create_time,
    update_time
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND pricing_flag = '0'  -- 注意：字段类型是 char(1)，所以是字符串 '0'
 ORDER BY id;
 -- 2. 统计 pricing_flag = 0 的项目数量（按状态）
 SELECT 
    status_enum,
    COUNT(*) AS count,
    CASE 
        WHEN status_enum = 1 THEN '激活'
        WHEN status_enum = 2 THEN '停用'
        ELSE '其他'
    END AS status_desc
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND pricing_flag = '0'
 GROUP BY status_enum
 ORDER BY status_enum;
 -- 3. 检查 pricing_flag = 0 的项目是否有关联的费用定价
 SELECT 
    T1.id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.pricing_flag,
    T1.status_enum,
    T2.id AS charge_item_definition_id,
    T2.charge_name,
    T2.price,
    T2.status_enum AS charge_status,
    CASE 
        WHEN T2.id IS NOT NULL THEN '有费用定价但不允许划价（可能异常）'
        ELSE '无费用定价，不允许划价（正常）'
    END AS analysis
 FROM wor_activity_definition AS T1
 LEFT JOIN adm_charge_item_definition AS T2
    ON T2.instance_id = T1.id
    AND T2.delete_flag = '0'
    AND T2.status_enum = 1
    AND T2.instance_table = 'wor_activity_definition'
 WHERE T1.delete_flag = '0'
  AND T1.pricing_flag = '0'
 ORDER BY T1.id;
 -- 4. 检查 pricing_flag = 0 的项目是否在收费项目表中被使用
 SELECT 
    T1.id AS activity_id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.pricing_flag,
    COUNT(T3.id) AS charge_item_count,
    CASE 
        WHEN COUNT(T3.id) > 0 THEN '已被使用（可能异常：不允许划价但已有收费记录）'
        ELSE '未被使用（正常）'
    END AS analysis
 FROM wor_activity_definition AS T1
 LEFT JOIN adm_charge_item AS T3
    ON T3.product_id = T1.id
    AND T3.context_enum = 3  -- ACTIVITY
    AND T3.delete_flag = '0'
 WHERE T1.delete_flag = '0'
  AND T1.pricing_flag = '0'
 GROUP BY T1.id, T1.bus_no, T1.name, T1.pricing_flag
 HAVING COUNT(T3.id) > 0  -- 只显示已被使用的
 ORDER BY charge_item_count DESC;
 -- 5. 按类别统计 pricing_flag = 0 的项目
 SELECT 
    category_code,
    COUNT(*) AS count,
    STRING_AGG(name, ', ') AS activity_names  -- 列出项目名称
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND pricing_flag = '0'
  AND status_enum = 1  -- 只统计激活的
 GROUP BY category_code
 ORDER BY category_code;
 -- 6. 对比：pricing_flag = 0 和 pricing_flag = 1 的项目特征
 SELECT 
    pricing_flag,
    COUNT(*) AS count,
    COUNT(DISTINCT category_code) AS category_count,
    COUNT(DISTINCT org_id) AS org_count,
    STRING_AGG(DISTINCT category_code::text, ', ') AS categories
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
  AND pricing_flag IN ('0', '1')
 GROUP BY pricing_flag
 ORDER BY pricing_flag;
 -- 7. 检查是否有子项的项目（childrenJson 不为空）被标记为 pricing_flag = 0
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    pricing_flag,
    children_json,
    CASE 
        WHEN children_json IS NOT NULL AND children_json != '' THEN '有子项但不允许划价（可能是套餐子项）'
        ELSE '无子项'
    END AS analysis
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND pricing_flag = '0'
  AND children_json IS NOT NULL
  AND children_json != ''
 ORDER BY id;
 -- 8. 查看 pricing_flag 字段的所有可能值（包括 NULL）
 SELECT 
    COALESCE(pricing_flag::text, 'NULL') AS pricing_flag_value,
    COUNT(*) AS count,
    ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 2) AS percentage
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
 GROUP BY pricing_flag
 ORDER BY pricing_flag NULLS LAST;
--- a/openhis-server-new/sql/check_treatment_items_detailed.sql
+++ b/openhis-server-new/sql/check_treatment_items_detailed.sql
@@ -0,0 +1,116 @@
 -- 详细检查诊疗项目检索问题
 -- 已知：wor_activity_definition 表中有4条数据
 -- 1. 检查这4条诊疗项目定义的详细信息
 SELECT 
    id,
    name,
    bus_no,
    delete_flag,
    tenant_id,
    create_time
 FROM wor_activity_definition
 ORDER BY id;
 -- 2. 检查收费项目中是否有诊疗项目类型的记录
 -- 注意：ChargeItemContext.ACTIVITY.getValue() 返回的是 Integer 3
 -- 但数据库中 context_enum 可能是字符串类型，需要检查是 '3' 还是 3
 SELECT 
    COUNT(*) as total_activity_charge_items,
    COUNT(CASE WHEN delete_flag = '0' THEN 1 END) as active_activity_charge_items,
    COUNT(CASE WHEN delete_flag != '0' THEN 1 END) as deleted_activity_charge_items
 FROM adm_charge_item
 WHERE context_enum::text = '3' OR context_enum = 3;  -- 诊疗项目类型是3
 -- 3. 检查收费项目中的product_id是否能匹配到诊疗项目定义
 -- 注意：诊疗项目类型的 context_enum = 3（ChargeItemContext.ACTIVITY.getValue()）
 SELECT 
    aci.id as charge_item_id,
    aci.encounter_id,
    aci.context_enum,
    aci.product_id as charge_product_id,
    aci.status_enum,
    aci.delete_flag as charge_delete_flag,
    wad.id as activity_def_id,
    wad.name as activity_name,
    wad.delete_flag as activity_delete_flag,
    CASE 
        WHEN wad.id IS NULL THEN '❌ 诊疗项目定义不存在'
        WHEN wad.delete_flag != '0' THEN '❌ 诊疗项目定义已删除'
        WHEN aci.delete_flag != '0' THEN '❌ 收费项目已删除'
        ELSE '✅ 正常'
    END as match_status
 FROM adm_charge_item aci
 LEFT JOIN wor_activity_definition wad 
    ON aci.product_id = wad.id
 WHERE (aci.context_enum::text = '3' OR aci.context_enum = 3)  -- 诊疗项目类型是3
 LIMIT 20;
 -- 4. 检查context_enum的所有可能值（确认诊疗项目的枚举值是什么）
 SELECT DISTINCT 
    context_enum,
    COUNT(*) as count
 FROM adm_charge_item
 WHERE delete_flag = '0'
 GROUP BY context_enum
 ORDER BY context_enum;
 -- 5. 检查是否有收费项目，但无法匹配到诊疗项目定义
 SELECT 
    COUNT(*) as unmatched_count,
    STRING_AGG(DISTINCT CAST(product_id AS VARCHAR), ', ') as unmatched_product_ids,
    STRING_AGG(DISTINCT CAST(id AS VARCHAR), ', ') as unmatched_charge_item_ids
 FROM adm_charge_item aci
 WHERE (aci.context_enum::text = '3' OR aci.context_enum = 3)  -- 诊疗项目类型是3
    AND aci.delete_flag = '0'
    AND NOT EXISTS (
        SELECT 1 
        FROM wor_activity_definition wad
        WHERE wad.id = aci.product_id
            AND wad.delete_flag = '0'
    );
 -- 6. 检查具体某个就诊的诊疗项目（如果有具体的encounterId）
 -- SELECT 
 --     T1.encounter_id,
 --     T1.id as charge_item_id,
 --     T1.context_enum,
 --     T1.product_id,
 --     T1.status_enum,
 --     T1.delete_flag,
 --     T2.id as activity_def_id,
 --     T2.name as activity_name,
 --     T2.delete_flag as activity_delete_flag
 -- FROM adm_charge_item AS T1
 -- LEFT JOIN wor_activity_definition AS T2
 --     ON T1.product_id = T2.id
 -- WHERE T1.encounter_id = :encounterId  -- 替换为实际的encounterId
 --     AND T1.context_enum IN ('ACTIVITY', '1', 'ACTIVITY_CODE')  -- 尝试多种可能的值
 --     AND T1.delete_flag = '0';
 -- 7. 检查后端代码中使用的context_enum值
 -- ChargeItemContext.ACTIVITY.getValue() 的实际返回值需要查看枚举类
 -- 可能是：'ACTIVITY', '1', 'ACTIVITY_CODE', 或其他值
 -- 建议先运行查询4，查看数据库中实际使用的context_enum值
 -- 8. 检查status_enum的值（查询条件中需要匹配的状态）
 -- SQL查询中要求 status_enum IN (1, 2, 3, 4, 5, 6)
 -- 检查收费项目中的状态值是否在这个范围内
 SELECT 
    status_enum,
    COUNT(*) as count,
    CASE 
        WHEN status_enum IN (1, 2, 3, 4, 5, 6) THEN '✅ 在查询范围内'
        ELSE '❌ 不在查询范围内'
    END as status_check
 FROM adm_charge_item
 WHERE context_enum IN (
    SELECT DISTINCT context_enum 
    FROM adm_charge_item 
    WHERE delete_flag = '0'
    LIMIT 10
 )
 AND delete_flag = '0'
 GROUP BY status_enum
 ORDER BY status_enum;
--- a/openhis-server-new/sql/debug_queue_date_issue.sql
+++ b/openhis-server-new/sql/debug_queue_date_issue.sql
@@ -0,0 +1,108 @@
 -- ============================================
 -- 调试队列日期问题
 -- 用途：检查数据库中的 queue_date 字段值，找出为什么查询不到数据
 -- ============================================
 -- 1. 查看所有队列记录的日期分布
 SELECT 
    queue_date,
    status,
    COUNT(*) AS count,
    STRING_AGG(patient_name, ', ') AS patients
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
 GROUP BY queue_date, status
 ORDER BY queue_date DESC, status;
 -- 2. 查看指定科室的所有记录（不限制日期）
 SELECT 
    id,
    queue_date,
    status,
    patient_name,
    organization_id,
    organization_name,
    queue_order,
    create_time
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
  AND organization_id = 1995302136614969300
 ORDER BY queue_date DESC, queue_order ASC;
 -- 3. 查看今天的记录（使用 CURRENT_DATE）
 SELECT 
    id,
    queue_date,
    status,
    patient_name,
    organization_id,
    queue_order
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
  AND queue_date = CURRENT_DATE
  AND organization_id = 1995302136614969300
 ORDER BY queue_order ASC;
 -- 4. 查看 2026-01-16 的记录
 SELECT 
    id,
    queue_date,
    status,
    patient_name,
    organization_id,
    queue_order
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
  AND queue_date = '2026-01-16'::DATE
  AND organization_id = 1995302136614969300
 ORDER BY queue_order ASC;
 -- 5. 查看 2025-01-16 的记录（可能是昨天的数据）
 SELECT 
    id,
    queue_date,
    status,
    patient_name,
    organization_id,
    queue_order
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
  AND queue_date = '2025-01-16'::DATE
  AND organization_id = 1995302136614969300
 ORDER BY queue_order ASC;
 -- 6. 查看最近的记录（最近7天）
 SELECT 
    queue_date,
    status,
    COUNT(*) AS count
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
  AND queue_date >= CURRENT_DATE - INTERVAL '7 days'
 GROUP BY queue_date, status
 ORDER BY queue_date DESC, status;
 -- 7. 检查系统当前日期（PostgreSQL）
 SELECT CURRENT_DATE AS current_date_in_db;
 -- 8. 查看所有状态为 WAITING 或 SKIPPED 的记录（不限制日期）
 SELECT 
    id,
    queue_date,
    status,
    patient_name,
    organization_id,
    queue_order
 FROM hisdev.triage_queue_item
 WHERE tenant_id = 1
  AND delete_flag = '0'
  AND status IN ('WAITING', 'SKIPPED')
  AND organization_id = 1995302136614969300
 ORDER BY queue_date DESC, queue_order ASC;
--- a/openhis-server-new/sql/diagnose_treatment_items_issue.sql
+++ b/openhis-server-new/sql/diagnose_treatment_items_issue.sql
@@ -0,0 +1,94 @@
 -- 诊断：门诊划价检索不出诊疗项目的问题
 -- 问题描述：在门诊划价页面，检索不出诊疗项目
 -- 1. 检查是否有诊疗项目定义数据
 SELECT 
    COUNT(*) as total_count,
    COUNT(CASE WHEN delete_flag = '0' THEN 1 END) as active_count,
    COUNT(CASE WHEN delete_flag != '0' THEN 1 END) as deleted_count
 FROM wor_activity_definition;
 -- 2. 检查是否有收费项目（诊疗项目类型）
 SELECT 
    T1.id,
    T1.encounter_id,
    T1.context_enum,
    T1.product_id,
    T1.status_enum,
    T1.delete_flag,
    T2.id as activity_def_id,
    T2.name as activity_name,
    T2.delete_flag as activity_delete_flag
 FROM adm_charge_item AS T1
 LEFT JOIN wor_activity_definition AS T2
    ON T1.context_enum = 'ACTIVITY'  -- 诊疗项目类型
    AND T1.product_id = T2.id
    AND T2.delete_flag = '0'
 WHERE T1.context_enum = 'ACTIVITY'
    AND T1.delete_flag = '0'
 LIMIT 20;
 -- 3. 检查是否有诊疗项目定义，但收费项目中的product_id无法匹配
 SELECT 
    '诊疗项目定义存在，但收费项目无法匹配' as issue_type,
    COUNT(*) as count
 FROM wor_activity_definition wad
 WHERE wad.delete_flag = '0'
    AND NOT EXISTS (
        SELECT 1 
        FROM adm_charge_item aci
        WHERE aci.context_enum = 'ACTIVITY'
            AND aci.product_id = wad.id
            AND aci.delete_flag = '0'
    );
 -- 4. 检查收费项目中的诊疗项目，但定义表中没有对应数据
 SELECT 
    '收费项目存在，但诊疗项目定义缺失' as issue_type,
    COUNT(*) as count
 FROM adm_charge_item aci
 WHERE aci.context_enum = 'ACTIVITY'
    AND aci.delete_flag = '0'
    AND NOT EXISTS (
        SELECT 1 
        FROM wor_activity_definition wad
        WHERE wad.id = aci.product_id
            AND wad.delete_flag = '0'
    );
 -- 5. 检查某个具体就诊的诊疗项目（替换encounterId为实际值）
 -- SELECT 
 --     T1.encounter_id,
 --     T1.id as charge_item_id,
 --     T1.context_enum,
 --     T1.product_id,
 --     T1.status_enum,
 --     T2.id as activity_def_id,
 --     T2.name as activity_name,
 --     T2.delete_flag as activity_delete_flag,
 --     CASE 
 --         WHEN T2.id IS NULL THEN '诊疗项目定义不存在或已删除'
 --         WHEN T2.delete_flag != '0' THEN '诊疗项目定义已删除'
 --         ELSE '正常'
 --     END as status
 -- FROM adm_charge_item AS T1
 -- LEFT JOIN wor_activity_definition AS T2
 --     ON T1.context_enum = 'ACTIVITY'
 --     AND T1.product_id = T2.id
 -- WHERE T1.encounter_id = :encounterId  -- 替换为实际的encounterId
 --     AND T1.context_enum = 'ACTIVITY'
 --     AND T1.delete_flag = '0'
 --     AND T1.status_enum IN (1, 2, 3, 4, 5, 6);  -- PLANNED, BILLABLE, BILLED, REFUNDING, REFUNDED, PART_REFUND
--- a/openhis-server-new/sql/query_pricing_flag_distribution.sql
+++ b/openhis-server-new/sql/query_pricing_flag_distribution.sql
@@ -0,0 +1,144 @@
 -- ============================================
 -- 查询诊疗项目 pricing_flag 字段分布情况
 -- 用途：了解哪些项目允许划价，哪些不允许
 -- ============================================
 -- 1. 统计 pricing_flag 字段的分布情况
 SELECT 
    COUNT(*) AS total_count,
    COUNT(CASE WHEN pricing_flag = 1 THEN 1 END) AS pricing_flag_1_count,  -- 允许划价
    COUNT(CASE WHEN pricing_flag = 0 THEN 1 END) AS pricing_flag_0_count,  -- 不允许划价
    COUNT(CASE WHEN pricing_flag IS NULL THEN 1 END) AS pricing_flag_null_count,  -- 未设置
    ROUND(COUNT(CASE WHEN pricing_flag = 1 THEN 1 END) * 100.0 / COUNT(*), 2) AS flag_1_percent,
    ROUND(COUNT(CASE WHEN pricing_flag = 0 THEN 1 END) * 100.0 / COUNT(*), 2) AS flag_0_percent,
    ROUND(COUNT(CASE WHEN pricing_flag IS NULL THEN 1 END) * 100.0 / COUNT(*), 2) AS flag_null_percent
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1;  -- 只统计激活状态的项目
 -- 2. 查看所有允许划价的项目（pricing_flag = 1 或 NULL）
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    pricing_flag,
    status_enum,
    org_id,
    category_code,
    type_enum,
    CASE 
        WHEN pricing_flag = 1 THEN '允许划价'
        WHEN pricing_flag = 0 THEN '不允许划价'
        WHEN pricing_flag IS NULL THEN '未设置（默认允许）'
        ELSE '未知'
    END AS pricing_flag_desc
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
  AND (pricing_flag = 1 OR pricing_flag IS NULL)  -- 之前过滤条件
 ORDER BY id;
 -- 3. 查看不允许划价的项目（pricing_flag = 0）
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    pricing_flag,
    status_enum,
    org_id,
    category_code,
    type_enum,
    description_text,
    '不允许划价' AS pricing_flag_desc
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
  AND pricing_flag = 0  -- 这些项目之前不会显示
 ORDER BY id;
 -- 4. 查看未设置 pricing_flag 的项目（NULL）
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    pricing_flag,
    status_enum,
    org_id,
    category_code,
    type_enum,
    '未设置（默认允许）' AS pricing_flag_desc
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
  AND pricing_flag IS NULL
 ORDER BY id;
 -- 5. 按科室统计 pricing_flag 分布
 SELECT 
    org_id,
    COUNT(*) AS total_count,
    COUNT(CASE WHEN pricing_flag = 1 THEN 1 END) AS flag_1_count,
    COUNT(CASE WHEN pricing_flag = 0 THEN 1 END) AS flag_0_count,
    COUNT(CASE WHEN pricing_flag IS NULL THEN 1 END) AS flag_null_count
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
 GROUP BY org_id
 ORDER BY org_id;
 -- 6. 按类别统计 pricing_flag 分布
 SELECT 
    category_code,
    COUNT(*) AS total_count,
    COUNT(CASE WHEN pricing_flag = 1 THEN 1 END) AS flag_1_count,
    COUNT(CASE WHEN pricing_flag = 0 THEN 1 END) AS flag_0_count,
    COUNT(CASE WHEN pricing_flag IS NULL THEN 1 END) AS flag_null_count
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND status_enum = 1
 GROUP BY category_code
 ORDER BY category_code;
 -- 7. 检查是否有费用定价关联的项目，但 pricing_flag = 0
 SELECT 
    T1.id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.pricing_flag,
    T2.id AS charge_item_definition_id,
    T2.charge_name,
    T2.price,
    '有费用定价但不允许划价' AS issue_desc
 FROM wor_activity_definition AS T1
 LEFT JOIN adm_charge_item_definition AS T2
    ON T2.instance_id = T1.id
    AND T2.delete_flag = '0'
    AND T2.status_enum = 1
    AND T2.instance_table = 'wor_activity_definition'
 WHERE T1.delete_flag = '0'
  AND T1.status_enum = 1
  AND T1.pricing_flag = 0
  AND T2.id IS NOT NULL  -- 有关联的费用定价
 ORDER BY T1.id;
 -- 8. 检查没有费用定价关联的项目，但 pricing_flag = 1
 SELECT 
    T1.id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.pricing_flag,
    T2.id AS charge_item_definition_id,
    '允许划价但没有费用定价' AS issue_desc
 FROM wor_activity_definition AS T1
 LEFT JOIN adm_charge_item_definition AS T2
    ON T2.instance_id = T1.id
    AND T2.delete_flag = '0'
    AND T2.status_enum = 1
    AND T2.instance_table = 'wor_activity_definition'
 WHERE T1.delete_flag = '0'
  AND T1.status_enum = 1
  AND (T1.pricing_flag = 1 OR T1.pricing_flag IS NULL)
  AND T2.id IS NULL  -- 没有关联的费用定价
 ORDER BY T1.id;
--- a/openhis-server-new/sql/query_smart_candidate_pool.sql
+++ b/openhis-server-new/sql/query_smart_candidate_pool.sql
@@ -0,0 +1,313 @@
 -- ============================================
 -- 智能候选池查询SQL（当日已挂号患者）
 -- 对应接口：GET /charge-manage/register/current-day-encounter
 -- 用途：查询当日已挂号但未入队的患者，用于智能分诊排队管理
 -- ============================================
 -- 完整SQL查询（包含所有关联表）
 SELECT T9.tenant_id AS tenantId,
       T9.encounter_id AS encounterId,
       T9.display_order AS displayOrder,
       T9.organization_id AS organizationId,
       T9.organization_name AS organizationName,
       T9.healthcare_name AS healthcareName,
       T9.practitioner_user_id AS practitionerUserId,
       T9.practitioner_name AS practitionerName,
       T9.contract_name AS contractName,
       T9.patient_id AS patientId,
       T9.patient_name AS patientName,
       T9.phone,
       T9.gender_enum AS genderEnum,
       T9.id_card AS idCard,
       T9.status_enum AS statusEnum,
       T9.register_time AS registerTime,
       T9.total_price AS totalPrice,
       T9.account_name AS accountName,
       T9.enterer_name AS entererName,
       T9.charge_item_ids AS chargeItemIds,
       T9.payment_id AS paymentId,
       T9.picture_url AS pictureUrl,
       T9.birth_date AS birthDate,
       COALESCE(T9.identifier_no, T9.patient_bus_no, '') AS identifierNo
 FROM (
    SELECT T1.tenant_id       AS tenant_id,
           T1.id              AS encounter_id,
           T1.display_order   AS display_order,
           T1.organization_id AS organization_id,
           T2.NAME            AS organization_name,
           T3.NAME            AS healthcare_name,
           T5.user_id         AS practitioner_user_id,
           T5.NAME            AS practitioner_name,
           T7.contract_name   AS contract_name,
           T8.id              AS patient_id,
           T8.NAME            AS patient_name,
           T8.phone           AS phone,
           T8.gender_enum     AS gender_enum,
           T8.id_card         AS id_card,
           T1.status_enum     AS status_enum,
           T1.create_time     AS register_time,
           T10.total_price,
           T11."name"         AS account_name,
           T12."name"         AS enterer_name,
           T13.charge_item_ids,
           T13.id             AS payment_id,
           ai.picture_url     AS picture_url,
           T8.birth_date      AS birth_date,
           T8.bus_no          AS patient_bus_no,
           T18.identifier_no  AS identifier_no
    FROM adm_encounter AS T1
    -- 关联科室表
    LEFT JOIN adm_organization AS T2 
        ON T1.organization_id = T2.ID 
        AND T2.delete_flag = '0'
    -- 关联医疗服务类型表（号别）
    LEFT JOIN adm_healthcare_service AS T3 
        ON T1.service_type_id = T3.ID 
        AND T3.delete_flag = '0'
    -- 关联就诊参与者表（医生信息）
    LEFT JOIN (
        SELECT *
        FROM (
            SELECT *,
                   ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
            FROM adm_encounter_participant
            WHERE delete_flag = '0'
              AND (
                  -- 如果就诊状态为"进行中"，查找"接诊医生"（admitter）
                  (type_code = 'admitter' AND EXISTS(SELECT 1
                                                     FROM adm_encounter AS T1
                                                     WHERE T1.status_enum = 2  -- IN_PROGRESS
                                                       AND T1.ID = encounter_id))
                  OR
                  -- 如果就诊状态不是"进行中"，查找"挂号医生"（registration_doctor）
                  (type_code = 'registration_doctor' AND NOT EXISTS(SELECT 1
                                                                     FROM adm_encounter AS T1
                                                                     WHERE T1.status_enum = 2  -- IN_PROGRESS
                                                                       AND T1.ID = encounter_id))
              )
        ) t
        WHERE rn = 1
    ) AS T4 ON T1.ID = T4.encounter_id
    -- 关联医生表
    LEFT JOIN adm_practitioner AS T5 
        ON T5.ID = T4.practitioner_id 
        AND T5.delete_flag = '0'
    -- 关联账户表
    LEFT JOIN adm_account AS T6
        ON T1.ID = T6.encounter_id 
        AND T6.delete_flag = '0' 
        AND T6.encounter_flag = '1'
    -- 关联合同表
    LEFT JOIN fin_contract AS T7 
        ON T6.contract_no = T7.bus_no 
        AND T7.delete_flag = '0'
    -- 关联患者表
    LEFT JOIN adm_patient AS T8 
        ON T1.patient_id = T8.ID 
        AND T8.delete_flag = '0'
    -- 关联患者标识表（身份证号等）
    LEFT JOIN (
        SELECT patient_id,
               identifier_no
        FROM (
            SELECT patient_id,
                   identifier_no,
                   ROW_NUMBER() OVER (PARTITION BY patient_id ORDER BY create_time ASC) AS rn
            FROM adm_patient_identifier
            WHERE delete_flag = '0'
              AND identifier_no IS NOT NULL
              AND identifier_no != ''
        ) t
        WHERE rn = 1
    ) AS T18 ON T8.id = T18.patient_id
    -- 关联收费项目表（挂号费）
    LEFT JOIN adm_charge_item AS T10 
        ON T1.id = T10.encounter_id 
        AND T10.delete_flag = '0'
        AND T10.context_enum = 1  -- REGISTER（挂号）
    -- 关联账户表（收费账户）
    LEFT JOIN adm_account AS T11 
        ON T10.account_id = T11.id 
        AND T11.delete_flag = '0'
    -- 关联医生表（收费医生）
    LEFT JOIN adm_practitioner AS T12 
        ON T12.ID = T10.enterer_id 
        AND T12.delete_flag = '0'
    -- 关联支付对账表（已支付）
    LEFT JOIN fin_payment_reconciliation T13
        ON T10.id::TEXT = ANY(string_to_array(T13.charge_item_ids,','))
            AND T13.delete_flag = '0'
            AND T13.status_enum = 1  -- SUCCESS（支付成功）
    -- 关联退号记录（当状态为退号时，通过relation_id关联原支付记录）
    LEFT JOIN fin_payment_reconciliation T14
        ON T13.id = T14.relation_id
            AND T14.delete_flag = '0'
            AND T14.status_enum = 3  -- REFUND（退款）
            AND T14.payment_enum = 1
    -- 关联退号医生
    LEFT JOIN adm_practitioner AS T15 
        ON T15.ID = T14.enterer_id 
        AND T15.delete_flag = '0'
    -- 关联系统用户表
    LEFT JOIN sys_user AS T17 
        ON T17.user_id = T15.user_id 
        AND T17.delete_flag = '0'
    -- 关联退号支付详情，获取退款方式（聚合多个支付方式）
    LEFT JOIN (
        SELECT reconciliation_id,
               STRING_AGG(
                   CASE pay_enum
                       WHEN 220400 THEN '现金'
                       WHEN 220100 THEN '微信'
                       WHEN 220200 THEN '支付宝'
                       WHEN 220300 THEN '银联'
                   END,
                   ','
                   ORDER BY pay_enum
               ) AS refund_method
        FROM fin_payment_rec_detail
        WHERE delete_flag = '0'
          AND amount < 0
          AND pay_enum IN (220400, 220100, 220200, 220300)
        GROUP BY reconciliation_id
    ) AS T16 ON T14.id = T16.reconciliation_id
    -- 关联发票表
    LEFT JOIN adm_invoice AS ai
        ON ai.reconciliation_id = T13.id 
        AND ai.delete_flag = '0'
    WHERE T1.delete_flag = '0'
      AND T1.class_enum = 1  -- 门诊（AMB）
      AND T10.context_enum = 1  -- 挂号（REGISTER）
      -- 动态条件（由前端传入，通过 ${ew.customSqlSegment} 注入）
      -- 例如：AND T1.create_time::DATE = CURRENT_DATE  -- 当日挂号
      -- 例如：AND T1.status_enum != 6  -- 排除退号（statusEnum = -1时）
      -- 例如：AND (T8.name LIKE '%关键词%' OR T2.name LIKE '%关键词%' ...)  -- 模糊搜索
 ) AS T9
 -- 动态查询条件（由 MyBatis-Plus QueryWrapper 生成）
 -- ${ew.customSqlSegment}
 ORDER BY T9.register_time DESC;
 -- ============================================
 -- 简化版查询（仅查询核心字段，用于快速测试）
 -- ============================================
 SELECT 
    enc.id AS encounterId,
    enc.patient_id AS patientId,
    pt.name AS patientName,
    pt.birth_date AS birthDate,
    org.id AS organizationId,
    org.name AS organizationName,
    hcs.name AS healthcareName,
    pr.name AS practitionerName,
    enc.create_time AS registerTime,
    enc.status_enum AS statusEnum
 FROM adm_encounter enc
 INNER JOIN adm_patient pt 
    ON enc.patient_id = pt.id 
    AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org 
    ON enc.organization_id = org.id 
    AND org.delete_flag = '0'
 LEFT JOIN adm_healthcare_service hcs 
    ON enc.service_type_id = hcs.id 
    AND hcs.delete_flag = '0'
 LEFT JOIN (
    SELECT encounter_id, practitioner_id,
           ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
    FROM adm_encounter_participant
    WHERE delete_flag = '0'
      AND type_code IN ('admitter', 'registration_doctor')
 ) ep ON enc.id = ep.encounter_id AND ep.rn = 1
 LEFT JOIN adm_practitioner pr 
    ON ep.practitioner_id = pr.id 
    AND pr.delete_flag = '0'
 INNER JOIN adm_charge_item ci 
    ON enc.id = ci.encounter_id 
    AND ci.delete_flag = '0'
    AND ci.context_enum = 1  -- 挂号
 INNER JOIN fin_payment_reconciliation prc
    ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0'
    AND prc.status_enum = 1  -- 支付成功
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1  -- 门诊
  AND enc.create_time::DATE = CURRENT_DATE  -- 当日挂号
  AND enc.status_enum != 6  -- 排除退号
 ORDER BY enc.create_time DESC;
 -- ============================================
 -- 查询条件说明
 -- ============================================
 -- 1. 基础条件：
 --    - enc.delete_flag = '0'  -- 未删除
 --    - enc.class_enum = 1     -- 门诊（AMB）
 --    - ci.context_enum = 1    -- 挂号（REGISTER）
 --    - prc.status_enum = 1    -- 支付成功（SUCCESS）
 --
 -- 2. 日期过滤：
 --    - enc.create_time::DATE = CURRENT_DATE  -- 当日挂号（由前端传入 date 参数）
 --
 -- 3. 状态过滤：
 --    - enc.status_enum != 6  -- 排除退号（当 statusEnum = -1 时）
 --    - enc.status_enum = 2   -- 进行中（IN_PROGRESS，用于判断医生类型）
 --
 -- 4. 模糊搜索（由前端传入 searchKey 参数）：
 --    - patient_name（患者姓名）
 --    - organization_name（科室名称）
 --    - practitioner_name（医生姓名）
 --    - healthcare_name（号别名称）
 --    - identifier_no（身份证号）
 --
 -- 5. 租户过滤（由后端自动添加）：
 --    - tenant_id = ?  -- 当前登录用户的租户ID
 --
 -- 6. 分页（由 MyBatis-Plus Page 对象处理）：
 --    - LIMIT ? OFFSET ?
 -- ============================================
 -- 常用查询示例
 -- ============================================
 -- 示例1：查询今天所有已挂号患者（排除退号）
 SELECT 
    enc.id AS encounterId,
    pt.name AS patientName,
    org.name AS organizationName,
    hcs.name AS healthcareName,
    pr.name AS practitionerName,
    enc.create_time AS registerTime
 FROM adm_encounter enc
 INNER JOIN adm_patient pt ON enc.patient_id = pt.id AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org ON enc.organization_id = org.id AND org.delete_flag = '0'
 LEFT JOIN adm_healthcare_service hcs ON enc.service_type_id = hcs.id AND hcs.delete_flag = '0'
 LEFT JOIN (
    SELECT encounter_id, practitioner_id,
           ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
    FROM adm_encounter_participant
    WHERE delete_flag = '0' AND type_code IN ('admitter', 'registration_doctor')
 ) ep ON enc.id = ep.encounter_id AND ep.rn = 1
 LEFT JOIN adm_practitioner pr ON ep.practitioner_id = pr.id AND pr.delete_flag = '0'
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6
 ORDER BY enc.create_time DESC;
 -- 示例2：查询指定科室的已挂号患者
 -- 在示例1的基础上添加：
 -- AND enc.organization_id = ?  -- 科室ID
 -- 示例3：按患者姓名模糊搜索
 -- 在示例1的基础上添加：
 -- AND pt.name LIKE '%关键词%'
 -- 示例4：查询已加入队列的患者（用于去重）
 SELECT DISTINCT encounter_id
 FROM hisdev.triage_queue_item
 WHERE delete_flag = '0'
  AND queue_date = CURRENT_DATE
  AND status != 'COMPLETED';
--- a/openhis-server-new/sql/query_smart_candidate_pool_page.sql
+++ b/openhis-server-new/sql/query_smart_candidate_pool_page.sql
@@ -0,0 +1,268 @@
 -- ============================================
 -- 智能候选池查询SQL（智能分诊排队管理页面专用）
 -- 页面：智能分诊排队管理 - 心内科
 -- 用途：查询"已签到未入队"的患者（当日已挂号，但未加入队列）
 -- ============================================
 -- ============================================
 -- 方案一：完整查询（包含所有字段，排除已在队列中的患者）
 -- ============================================
 SELECT 
    enc.id AS encounterId,
    enc.patient_id AS patientId,
    pt.name AS patientName,
    pt.birth_date AS birthDate,
    -- 计算年龄（前端会调用 parseAge 函数）
    CASE 
        WHEN pt.birth_date IS NOT NULL THEN
            EXTRACT(YEAR FROM AGE(pt.birth_date))::TEXT || '岁'
        ELSE ''
    END AS age,
    org.id AS organizationId,
    org.name AS organizationName,
    hcs.name AS healthcareName,
    pr.name AS practitionerName,
    enc.create_time AS registerTime,
    enc.status_enum AS statusEnum,
    -- 其他字段（如果需要）
    pt.phone,
    pt.gender_enum AS genderEnum,
    pt.id_card AS idCard
 FROM adm_encounter enc
 -- 关联患者表
 INNER JOIN adm_patient pt 
    ON enc.patient_id = pt.id 
    AND pt.delete_flag = '0'
 -- 关联科室表
 LEFT JOIN adm_organization org 
    ON enc.organization_id = org.id 
    AND org.delete_flag = '0'
 -- 关联医疗服务类型表（号别）
 LEFT JOIN adm_healthcare_service hcs 
    ON enc.service_type_id = hcs.id 
    AND hcs.delete_flag = '0'
 -- 关联就诊参与者表（医生信息）
 LEFT JOIN (
    SELECT encounter_id, practitioner_id,
           ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
    FROM adm_encounter_participant
    WHERE delete_flag = '0'
      AND (
          -- 如果就诊状态为"进行中"，查找"接诊医生"（admitter）
          (type_code = 'admitter' AND EXISTS(SELECT 1
                                             FROM adm_encounter AS e
                                             WHERE e.status_enum = 2  -- IN_PROGRESS
                                               AND e.id = encounter_id))
          OR
          -- 如果就诊状态不是"进行中"，查找"挂号医生"（registration_doctor）
          (type_code = 'registration_doctor' AND NOT EXISTS(SELECT 1
                                                            FROM adm_encounter AS e
                                                            WHERE e.status_enum = 2  -- IN_PROGRESS
                                                              AND e.id = encounter_id))
      )
 ) ep ON enc.id = ep.encounter_id AND ep.rn = 1
 -- 关联医生表
 LEFT JOIN adm_practitioner pr 
    ON ep.practitioner_id = pr.id 
    AND pr.delete_flag = '0'
 -- 关联收费项目表（挂号费）
 INNER JOIN adm_charge_item ci 
    ON enc.id = ci.encounter_id 
    AND ci.delete_flag = '0'
    AND ci.context_enum = 1  -- REGISTER（挂号）
 -- 关联支付对账表（已支付）
 INNER JOIN fin_payment_reconciliation prc
    ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0'
    AND prc.status_enum = 1  -- SUCCESS（支付成功）
 -- 排除已在队列中的患者（关键：LEFT JOIN + WHERE IS NULL）
 LEFT JOIN hisdev.triage_queue_item tqi
    ON enc.id = tqi.encounter_id
    AND tqi.delete_flag = '0'
    AND tqi.queue_date = CURRENT_DATE
    AND tqi.status != 'COMPLETED'  -- 排除已完成的状态
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1  -- 门诊（AMB）
  AND enc.create_time::DATE = CURRENT_DATE  -- 当日挂号（前端会过滤 registerTime）
  AND enc.status_enum != 6  -- 排除退号（statusEnum = -1 时）
  AND tqi.id IS NULL  -- 关键：只查询不在队列中的患者
 ORDER BY enc.create_time DESC;
 -- ============================================
 -- 方案二：简化查询（仅核心字段，便于快速测试）
 -- ============================================
 SELECT 
    enc.id AS encounterId,
    enc.patient_id AS patientId,
    pt.name AS patientName,
    org.id AS organizationId,
    org.name AS organizationName,
    hcs.name AS healthcareName,
    pr.name AS practitionerName,
    enc.create_time AS registerTime
 FROM adm_encounter enc
 INNER JOIN adm_patient pt ON enc.patient_id = pt.id AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org ON enc.organization_id = org.id AND org.delete_flag = '0'
 LEFT JOIN adm_healthcare_service hcs ON enc.service_type_id = hcs.id AND hcs.delete_flag = '0'
 LEFT JOIN (
    SELECT encounter_id, practitioner_id,
           ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
    FROM adm_encounter_participant
    WHERE delete_flag = '0' AND type_code IN ('admitter', 'registration_doctor')
 ) ep ON enc.id = ep.encounter_id AND ep.rn = 1
 LEFT JOIN adm_practitioner pr ON ep.practitioner_id = pr.id AND pr.delete_flag = '0'
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 -- 排除已在队列中的患者
 LEFT JOIN hisdev.triage_queue_item tqi
    ON enc.id = tqi.encounter_id
    AND tqi.delete_flag = '0'
    AND tqi.queue_date = CURRENT_DATE
    AND tqi.status != 'COMPLETED'
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6
  AND tqi.id IS NULL  -- 不在队列中
 ORDER BY enc.create_time DESC;
 -- ============================================
 -- 方案三：分步查询（便于调试和理解）
 -- ============================================
 -- 步骤1：查询当日已挂号的患者（不排除队列）
 SELECT 
    enc.id AS encounterId,
    pt.name AS patientName,
    org.name AS organizationName,
    enc.create_time AS registerTime
 FROM adm_encounter enc
 INNER JOIN adm_patient pt ON enc.patient_id = pt.id AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org ON enc.organization_id = org.id AND org.delete_flag = '0'
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6;
 -- 步骤2：查询已在队列中的患者
 SELECT DISTINCT encounter_id
 FROM hisdev.triage_queue_item
 WHERE delete_flag = '0'
  AND queue_date = CURRENT_DATE
  AND status != 'COMPLETED';
 -- 步骤3：合并查询（使用 NOT EXISTS 或 NOT IN）
 SELECT 
    enc.id AS encounterId,
    pt.name AS patientName,
    org.name AS organizationName,
    enc.create_time AS registerTime
 FROM adm_encounter enc
 INNER JOIN adm_patient pt ON enc.patient_id = pt.id AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org ON enc.organization_id = org.id AND org.delete_flag = '0'
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6
  -- 排除已在队列中的患者
  AND NOT EXISTS (
      SELECT 1
      FROM hisdev.triage_queue_item tqi
      WHERE tqi.encounter_id = enc.id
        AND tqi.delete_flag = '0'
        AND tqi.queue_date = CURRENT_DATE
        AND tqi.status != 'COMPLETED'
  )
 ORDER BY enc.create_time DESC;
 -- ============================================
 -- 查询条件说明
 -- ============================================
 -- 1. 基础条件：
 --    - enc.delete_flag = '0'  -- 未删除
 --    - enc.class_enum = 1     -- 门诊（AMB）
 --    - ci.context_enum = 1    -- 挂号（REGISTER）
 --    - prc.status_enum = 1    -- 支付成功（SUCCESS）
 --
 -- 2. 日期过滤：
 --    - enc.create_time::DATE = CURRENT_DATE  -- 当日挂号
 --    注意：前端还会基于 registerTime 字段再次过滤今天的数据
 --
 -- 3. 状态过滤：
 --    - enc.status_enum != 6  -- 排除退号（对应前端 statusEnum = -1）
 --
 -- 4. 队列去重：
 --    - LEFT JOIN hisdev.triage_queue_item ... WHERE tqi.id IS NULL
 --    或者
 --    - NOT EXISTS (SELECT 1 FROM hisdev.triage_queue_item ...)
 --    排除已在队列中且状态不是 COMPLETED 的患者
 --
 -- 5. 租户过滤（如果需要）：
 --    - enc.tenant_id = ?  -- 当前登录用户的租户ID
 --
 -- 6. 模糊搜索（如果需要）：
 --    - pt.name LIKE '%关键词%'  -- 患者姓名
 --    - org.name LIKE '%关键词%'  -- 科室名称
 --    - pr.name LIKE '%关键词%'  -- 医生姓名
 --    - hcs.name LIKE '%关键词%'  -- 号别名称
 -- ============================================
 -- 调试查询（检查数据是否正确）
 -- ============================================
 -- 1. 检查当日已挂号患者总数
 SELECT COUNT(*) AS total_registered
 FROM adm_encounter enc
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6;
 -- 2. 检查已在队列中的患者数量
 SELECT COUNT(DISTINCT encounter_id) AS in_queue_count
 FROM hisdev.triage_queue_item
 WHERE delete_flag = '0'
  AND queue_date = CURRENT_DATE
  AND status != 'COMPLETED';
 -- 3. 检查候选池应该显示的患者数量（已挂号 - 已在队列）
 SELECT 
    (SELECT COUNT(*) 
     FROM adm_encounter enc
     INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
     INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
         AND prc.delete_flag = '0' AND prc.status_enum = 1
     WHERE enc.delete_flag = '0'
       AND enc.class_enum = 1
       AND enc.create_time::DATE = CURRENT_DATE
       AND enc.status_enum != 6) 
    - 
    (SELECT COUNT(DISTINCT encounter_id)
     FROM hisdev.triage_queue_item
     WHERE delete_flag = '0'
       AND queue_date = CURRENT_DATE
       AND status != 'COMPLETED')
    AS candidate_pool_count;
 -- 4. 查看队列中的患者详情（用于对比）
 SELECT 
    tqi.encounter_id,
    tqi.patient_name,
    tqi.status,
    tqi.queue_order
 FROM hisdev.triage_queue_item tqi
 WHERE tqi.delete_flag = '0'
  AND tqi.queue_date = CURRENT_DATE
  AND tqi.status != 'COMPLETED'
 ORDER BY tqi.queue_order;
--- a/openhis-server-new/sql/query_smart_candidate_pool_with_exclusion.sql
+++ b/openhis-server-new/sql/query_smart_candidate_pool_with_exclusion.sql
@@ -0,0 +1,366 @@
 -- ============================================
 -- 智能候选池查询SQL（完整版 - 包含排除列表）
 -- 页面：智能分诊排队管理 - 心内科
 -- 用途：查询"已签到未入队"的患者（当日已挂号，但未加入队列，且未在排除列表中）
 -- 更新日期：2025-01-15
 -- ============================================
 -- ============================================
 -- 方案一：完整查询（包含所有字段，排除已在队列和排除列表中的患者）
 -- ============================================
 SELECT 
    T9.tenant_id AS tenantId,
    T9.encounter_id AS encounterId,
    T9.display_order AS displayOrder,
    T9.organization_id AS organizationId,
    T9.organization_name AS organizationName,
    T9.healthcare_name AS healthcareName,
    T9.practitioner_user_id AS practitionerUserId,
    T9.practitioner_name AS practitionerName,
    T9.contract_name AS contractName,
    T9.patient_id AS patientId,
    T9.patient_name AS patientName,
    T9.phone,
    T9.gender_enum AS genderEnum,
    T9.id_card AS idCard,
    T9.status_enum AS statusEnum,
    T9.register_time AS registerTime,
    T9.total_price AS totalPrice,
    T9.account_name AS accountName,
    T9.enterer_name AS entererName,
    T9.charge_item_ids AS chargeItemIds,
    T9.payment_id AS paymentId,
    T9.picture_url AS pictureUrl,
    T9.birth_date AS birthDate,
    COALESCE(T9.identifier_no, T9.patient_bus_no, '') AS identifierNo,
    -- 计算年龄（前端会调用 parseAge 函数）
    CASE 
        WHEN T9.birth_date IS NOT NULL THEN
            EXTRACT(YEAR FROM AGE(T9.birth_date))::TEXT || '岁'
        ELSE ''
    END AS age
 FROM (
    SELECT T1.tenant_id       AS tenant_id,
           T1.id              AS encounter_id,
           T1.display_order   AS display_order,
           T1.organization_id AS organization_id,
           T2.NAME            AS organization_name,
           T3.NAME            AS healthcare_name,
           T5.user_id         AS practitioner_user_id,
           T5.NAME            AS practitioner_name,
           T7.contract_name   AS contract_name,
           T8.id              AS patient_id,
           T8.NAME            AS patient_name,
           T8.phone           AS phone,
           T8.gender_enum     AS gender_enum,
           T8.id_card         AS id_card,
           T1.status_enum     AS status_enum,
           T1.create_time     AS register_time,
           T10.total_price,
           T11."name"         AS account_name,
           T12."name"         AS enterer_name,
           T13.charge_item_ids,
           T13.id             AS payment_id,
           ai.picture_url     AS picture_url,
           T8.birth_date      AS birth_date,
           T8.bus_no          AS patient_bus_no,
           T18.identifier_no  AS identifier_no
    FROM adm_encounter AS T1
    LEFT JOIN adm_organization AS T2 ON T1.organization_id = T2.ID AND T2.delete_flag = '0'
    LEFT JOIN adm_healthcare_service AS T3 ON T1.service_type_id = T3.ID AND T3.delete_flag = '0'
    LEFT JOIN (
        SELECT *
        FROM (
            SELECT *,
                   ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
            FROM adm_encounter_participant
            WHERE delete_flag = '0'
              AND (
                  (type_code = 'admitter' AND EXISTS(SELECT 1
                                                     FROM adm_encounter AS T1
                                                     WHERE T1.status_enum = 2  -- IN_PROGRESS
                                                       AND T1.ID = encounter_id))
                  OR
                  (type_code = 'registration_doctor' AND NOT EXISTS(SELECT 1
                                                                     FROM adm_encounter AS T1
                                                                     WHERE T1.status_enum = 2  -- IN_PROGRESS
                                                                       AND T1.ID = encounter_id))
              )
        ) t
        WHERE rn = 1
    ) AS T4 ON T1.ID = T4.encounter_id
    LEFT JOIN adm_practitioner AS T5 ON T5.ID = T4.practitioner_id AND T5.delete_flag = '0'
    LEFT JOIN adm_account AS T6
              ON T1.ID = T6.encounter_id AND T6.delete_flag = '0' AND T6.encounter_flag = '1'
    LEFT JOIN fin_contract AS T7 ON T6.contract_no = T7.bus_no AND T7.delete_flag = '0'
    LEFT JOIN adm_patient AS T8 ON T1.patient_id = T8.ID AND T8.delete_flag = '0'
    LEFT JOIN (
        SELECT patient_id,
               identifier_no
        FROM (
            SELECT patient_id,
                   identifier_no,
                   ROW_NUMBER() OVER (PARTITION BY patient_id ORDER BY create_time ASC) AS rn
            FROM adm_patient_identifier
            WHERE delete_flag = '0'
              AND identifier_no IS NOT NULL
              AND identifier_no != ''
        ) t
        WHERE rn = 1
    ) AS T18 ON T8.id = T18.patient_id
    LEFT JOIN adm_charge_item AS T10 ON T1.id = T10.encounter_id AND T10.delete_flag = '0'
    LEFT JOIN adm_account AS T11 ON T10.account_id = T11.id AND T11.delete_flag = '0'
    LEFT JOIN adm_practitioner AS T12 ON T12.ID = T10.enterer_id AND T12.delete_flag = '0'
    LEFT JOIN fin_payment_reconciliation T13
              ON T10.id::TEXT = ANY(string_to_array(T13.charge_item_ids,','))
                  AND T13.delete_flag = '0'
                  AND T13.status_enum = 1  -- SUCCESS（支付成功）
    LEFT JOIN adm_invoice AS ai
              ON ai.reconciliation_id = T13.id AND ai.delete_flag = '0'
    WHERE T1.delete_flag = '0'
      AND T1.class_enum = 1  -- 门诊（AMB）
      AND T1.create_time::DATE = CURRENT_DATE  -- 当日挂号
      AND T1.status_enum != 6  -- 排除退号
      AND T10.context_enum = 1  -- REGISTER（挂号）
 ) AS T9
 -- 排除已在队列中的患者（关键：LEFT JOIN + WHERE IS NULL）
 LEFT JOIN hisdev.triage_queue_item tqi
    ON T9.encounter_id = tqi.encounter_id
    AND tqi.delete_flag = '0'
    AND tqi.queue_date = CURRENT_DATE
    AND tqi.status != 'COMPLETED'  -- 排除已完成的状态
 -- 排除已在排除列表中的患者（新增：关键：LEFT JOIN + WHERE IS NULL）
 LEFT JOIN hisdev.triage_candidate_exclusion tce
    ON T9.encounter_id = tce.encounter_id
    AND tce.delete_flag = '0'
    AND tce.exclusion_date = CURRENT_DATE
    AND tce.tenant_id = T9.tenant_id  -- 按租户过滤
 WHERE tqi.id IS NULL  -- 关键：只查询不在队列中的患者
  AND tce.id IS NULL  -- 关键：只查询不在排除列表中的患者
 ORDER BY T9.register_time DESC;
 -- ============================================
 -- 方案二：简化查询（仅核心字段，便于快速测试）
 -- ============================================
 SELECT 
    enc.id AS encounterId,
    enc.patient_id AS patientId,
    pt.name AS patientName,
    org.id AS organizationId,
    org.name AS organizationName,
    hcs.name AS healthcareName,
    pr.name AS practitionerName,
    enc.create_time AS registerTime
 FROM adm_encounter enc
 INNER JOIN adm_patient pt ON enc.patient_id = pt.id AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org ON enc.organization_id = org.id AND org.delete_flag = '0'
 LEFT JOIN adm_healthcare_service hcs ON enc.service_type_id = hcs.id AND hcs.delete_flag = '0'
 LEFT JOIN (
    SELECT encounter_id, practitioner_id,
           ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
    FROM adm_encounter_participant
    WHERE delete_flag = '0' AND type_code IN ('admitter', 'registration_doctor')
 ) ep ON enc.id = ep.encounter_id AND ep.rn = 1
 LEFT JOIN adm_practitioner pr ON ep.practitioner_id = pr.id AND pr.delete_flag = '0'
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 -- 排除已在队列中的患者
 LEFT JOIN hisdev.triage_queue_item tqi
    ON enc.id = tqi.encounter_id
    AND tqi.delete_flag = '0'
    AND tqi.queue_date = CURRENT_DATE
    AND tqi.status != 'COMPLETED'
 -- 排除已在排除列表中的患者（新增）
 LEFT JOIN hisdev.triage_candidate_exclusion tce
    ON enc.id = tce.encounter_id
    AND tce.delete_flag = '0'
    AND tce.exclusion_date = CURRENT_DATE
    AND tce.tenant_id = enc.tenant_id
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6
  AND tqi.id IS NULL  -- 不在队列中
  AND tce.id IS NULL  -- 不在排除列表中
 ORDER BY enc.create_time DESC;
 -- ============================================
 -- 方案三：使用 NOT EXISTS 子查询（性能可能更好）
 -- ============================================
 SELECT 
    enc.id AS encounterId,
    enc.patient_id AS patientId,
    pt.name AS patientName,
    org.id AS organizationId,
    org.name AS organizationName,
    hcs.name AS healthcareName,
    pr.name AS practitionerName,
    enc.create_time AS registerTime
 FROM adm_encounter enc
 INNER JOIN adm_patient pt ON enc.patient_id = pt.id AND pt.delete_flag = '0'
 LEFT JOIN adm_organization org ON enc.organization_id = org.id AND org.delete_flag = '0'
 LEFT JOIN adm_healthcare_service hcs ON enc.service_type_id = hcs.id AND hcs.delete_flag = '0'
 LEFT JOIN (
    SELECT encounter_id, practitioner_id,
           ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY create_time ASC) AS rn
    FROM adm_encounter_participant
    WHERE delete_flag = '0' AND type_code IN ('admitter', 'registration_doctor')
 ) ep ON enc.id = ep.encounter_id AND ep.rn = 1
 LEFT JOIN adm_practitioner pr ON ep.practitioner_id = pr.id AND pr.delete_flag = '0'
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6
  -- 排除已在队列中的患者
  AND NOT EXISTS (
      SELECT 1
      FROM hisdev.triage_queue_item tqi
      WHERE tqi.encounter_id = enc.id
        AND tqi.delete_flag = '0'
        AND tqi.queue_date = CURRENT_DATE
        AND tqi.status != 'COMPLETED'
  )
  -- 排除已在排除列表中的患者（新增）
  AND NOT EXISTS (
      SELECT 1
      FROM hisdev.triage_candidate_exclusion tce
      WHERE tce.encounter_id = enc.id
        AND tce.delete_flag = '0'
        AND tce.exclusion_date = CURRENT_DATE
        AND tce.tenant_id = enc.tenant_id
  )
 ORDER BY enc.create_time DESC;
 -- ============================================
 -- 查询条件说明
 -- ============================================
 -- 1. 基础条件：
 --    - enc.delete_flag = '0'  -- 未删除
 --    - enc.class_enum = 1     -- 门诊（AMB）
 --    - ci.context_enum = 1    -- 挂号（REGISTER）
 --    - prc.status_enum = 1    -- 支付成功（SUCCESS）
 --
 -- 2. 日期过滤：
 --    - enc.create_time::DATE = CURRENT_DATE  -- 当日挂号
 --    注意：前端还会基于 registerTime 字段再次过滤今天的数据
 --
 -- 3. 状态过滤：
 --    - enc.status_enum != 6  -- 排除退号（对应前端 statusEnum = -1）
 --
 -- 4. 队列去重：
 --    - LEFT JOIN hisdev.triage_queue_item ... WHERE tqi.id IS NULL
 --    或者
 --    - NOT EXISTS (SELECT 1 FROM hisdev.triage_queue_item ...)
 --    排除已在队列中且状态不是 COMPLETED 的患者
 --
 -- 5. 排除列表去重（新增）：
 --    - LEFT JOIN hisdev.triage_candidate_exclusion ... WHERE tce.id IS NULL
 --    或者
 --    - NOT EXISTS (SELECT 1 FROM hisdev.triage_candidate_exclusion ...)
 --    排除已在排除列表中的患者（已加入队列后被记录）
 --
 -- 6. 租户过滤（如果需要）：
 --    - enc.tenant_id = ?  -- 当前登录用户的租户ID
 --
 -- 7. 模糊搜索（如果需要）：
 --    - pt.name LIKE '%关键词%'  -- 患者姓名
 --    - org.name LIKE '%关键词%'  -- 科室名称
 --    - pr.name LIKE '%关键词%'  -- 医生姓名
 --    - hcs.name LIKE '%关键词%'  -- 号别名称
 -- ============================================
 -- 调试查询（检查数据是否正确）
 -- ============================================
 -- 1. 检查当日已挂号患者总数
 SELECT COUNT(*) AS total_registered
 FROM adm_encounter enc
 INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
 INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
    AND prc.delete_flag = '0' AND prc.status_enum = 1
 WHERE enc.delete_flag = '0'
  AND enc.class_enum = 1
  AND enc.create_time::DATE = CURRENT_DATE
  AND enc.status_enum != 6;
 -- 2. 检查已在队列中的患者数量
 SELECT COUNT(DISTINCT encounter_id) AS in_queue_count
 FROM hisdev.triage_queue_item
 WHERE delete_flag = '0'
  AND queue_date = CURRENT_DATE
  AND status != 'COMPLETED';
 -- 3. 检查已在排除列表中的患者数量（新增）
 SELECT COUNT(DISTINCT encounter_id) AS in_exclusion_count
 FROM hisdev.triage_candidate_exclusion
 WHERE delete_flag = '0'
  AND exclusion_date = CURRENT_DATE;
 -- 4. 检查候选池应该显示的患者数量（已挂号 - 已在队列 - 已在排除列表）
 SELECT 
    (SELECT COUNT(*) 
     FROM adm_encounter enc
     INNER JOIN adm_charge_item ci ON enc.id = ci.encounter_id AND ci.delete_flag = '0' AND ci.context_enum = 1
     INNER JOIN fin_payment_reconciliation prc ON ci.id::TEXT = ANY(string_to_array(prc.charge_item_ids,','))
         AND prc.delete_flag = '0' AND prc.status_enum = 1
     WHERE enc.delete_flag = '0'
       AND enc.class_enum = 1
       AND enc.create_time::DATE = CURRENT_DATE
       AND enc.status_enum != 6) 
    - 
    (SELECT COUNT(DISTINCT encounter_id)
     FROM hisdev.triage_queue_item
     WHERE delete_flag = '0'
       AND queue_date = CURRENT_DATE
       AND status != 'COMPLETED')
    -
    (SELECT COUNT(DISTINCT encounter_id)
     FROM hisdev.triage_candidate_exclusion
     WHERE delete_flag = '0'
       AND exclusion_date = CURRENT_DATE)
    AS candidate_pool_count;
 -- 5. 查看队列中的患者详情（用于对比）
 SELECT 
    tqi.encounter_id,
    tqi.patient_name,
    tqi.status,
    tqi.queue_order
 FROM hisdev.triage_queue_item tqi
 WHERE tqi.delete_flag = '0'
  AND tqi.queue_date = CURRENT_DATE
  AND tqi.status != 'COMPLETED'
 ORDER BY tqi.queue_order;
 -- 6. 查看排除列表中的患者详情（新增）
 SELECT 
    tce.encounter_id,
    tce.patient_name,
    tce.reason,
    tce.create_time
 FROM hisdev.triage_candidate_exclusion tce
 WHERE tce.delete_flag = '0'
  AND tce.exclusion_date = CURRENT_DATE
 ORDER BY tce.create_time DESC;
 -- 7. 查看重叠的患者（既在队列中，又在排除列表中）
 SELECT 
    tqi.encounter_id,
    tqi.patient_name AS queue_patient_name,
    tce.patient_name AS exclusion_patient_name,
    tqi.status,
    tce.reason
 FROM hisdev.triage_queue_item tqi
 INNER JOIN hisdev.triage_candidate_exclusion tce
    ON tqi.encounter_id = tce.encounter_id
    AND tqi.queue_date = tce.exclusion_date
    AND tqi.tenant_id = tce.tenant_id
 WHERE tqi.delete_flag = '0'
  AND tce.delete_flag = '0'
  AND tqi.queue_date = CURRENT_DATE
 ORDER BY tqi.encounter_id;
--- a/openhis-server-new/sql/quick_check_pricing_flag_issue.sql
+++ b/openhis-server-new/sql/quick_check_pricing_flag_issue.sql
@@ -0,0 +1,86 @@
 -- ============================================
 -- 快速检查 pricing_flag = '0' 的数据问题
 -- 注意：pricing_flag 是 char(1) 类型，所以要用字符串 '0'
 -- ============================================
 -- 问题1：检查是否有费用定价但 pricing_flag = '0' 的项目（可能异常）
 SELECT 
    '异常：有费用定价但不允许划价' AS issue_type,
    T1.id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.pricing_flag,
    T2.charge_name,
    T2.price
 FROM wor_activity_definition AS T1
 INNER JOIN adm_charge_item_definition AS T2
    ON T2.instance_id = T1.id
    AND T2.delete_flag = '0'
    AND T2.status_enum = 1
    AND T2.instance_table = 'wor_activity_definition'
 WHERE T1.delete_flag = '0'
  AND T1.status_enum = 1
  AND T1.pricing_flag = '0'  -- 不允许划价，但有费用定价（矛盾）
 ORDER BY T1.id;
 -- 问题2：检查是否已被使用但 pricing_flag = '0' 的项目（可能异常）
 SELECT 
    '异常：已有收费记录但不允许划价' AS issue_type,
    T1.id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.pricing_flag,
    COUNT(DISTINCT T3.encounter_id) AS encounter_count,
    COUNT(T3.id) AS charge_item_count
 FROM wor_activity_definition AS T1
 INNER JOIN adm_charge_item AS T3
    ON T3.product_id = T1.id
    AND T3.context_enum = 3  -- ACTIVITY
    AND T3.delete_flag = '0'
 WHERE T1.delete_flag = '0'
  AND T1.pricing_flag = '0'
 GROUP BY T1.id, T1.bus_no, T1.name, T1.pricing_flag
 ORDER BY charge_item_count DESC;
 -- 问题3：查看所有 pricing_flag = '0' 的项目，判断哪些可能应该改为 '1'
 SELECT 
    T1.id,
    T1.bus_no,
    T1.name AS activity_name,
    T1.category_code,
    T1.pricing_flag,
    T1.status_enum,
    CASE 
        WHEN T2.id IS NOT NULL THEN '有费用定价'
        ELSE '无费用定价'
    END AS has_charge_definition,
    CASE 
        WHEN EXISTS (
            SELECT 1 FROM adm_charge_item 
            WHERE product_id = T1.id 
            AND context_enum = 3 
            AND delete_flag = '0'
        ) THEN '已被使用'
        ELSE '未使用'
    END AS usage_status,
    CASE 
        WHEN T2.id IS NOT NULL OR EXISTS (
            SELECT 1 FROM adm_charge_item 
            WHERE product_id = T1.id 
            AND context_enum = 3 
            AND delete_flag = '0'
        ) THEN '建议改为 pricing_flag = ''1'''
        ELSE '保持 pricing_flag = ''0''（可能正常）'
    END AS suggestion
 FROM wor_activity_definition AS T1
 LEFT JOIN adm_charge_item_definition AS T2
    ON T2.instance_id = T1.id
    AND T2.delete_flag = '0'
    AND T2.status_enum = 1
    AND T2.instance_table = 'wor_activity_definition'
 WHERE T1.delete_flag = '0'
  AND T1.status_enum = 1
  AND T1.pricing_flag = '0'
 ORDER BY T1.id;
--- a/openhis-server-new/sql/update_pricing_flag_to_one.sql
+++ b/openhis-server-new/sql/update_pricing_flag_to_one.sql
@@ -0,0 +1,123 @@
 -- ============================================
 -- 将 wor_activity_definition 表中的一两条记录的 pricing_flag 改成 '1'
 -- 注意：pricing_flag 是 char(1) 类型，所以要用字符串 '1'
 -- ============================================
 -- 方式1：更新前两条 pricing_flag = '0' 的记录（推荐）
 UPDATE wor_activity_definition
 SET pricing_flag = '1',
    update_time = CURRENT_TIMESTAMP
 WHERE id IN (
    SELECT id
    FROM wor_activity_definition
    WHERE delete_flag = '0'
      AND pricing_flag = '0'
      AND status_enum = 1  -- 只更新激活状态的项目
    ORDER BY id
    LIMIT 2
 );
 -- 方式2：更新指定 ID 的记录（更精确，推荐使用）
 -- 请将下面的 ID 替换为实际要更新的记录 ID
 UPDATE wor_activity_definition
 SET pricing_flag = '1',
    update_time = CURRENT_TIMESTAMP
 WHERE id IN (1906532604116348929, 1906544768434053121)  -- 替换为实际的 ID
  AND delete_flag = '0';
 -- 方式3：更新前两条记录（不管当前 pricing_flag 值是什么）
 UPDATE wor_activity_definition
 SET pricing_flag = '1',
    update_time = CURRENT_TIMESTAMP
 WHERE id IN (
    SELECT id
    FROM wor_activity_definition
    WHERE delete_flag = '0'
      AND status_enum = 1
    ORDER BY id
    LIMIT 2
 );
 -- 方式4：更新有费用定价但 pricing_flag = '0' 的前两条记录（业务逻辑更合理）
 UPDATE wor_activity_definition
 SET pricing_flag = '1',
    update_time = CURRENT_TIMESTAMP
 WHERE id IN (
    SELECT wad.id
    FROM wor_activity_definition wad
    INNER JOIN adm_charge_item_definition acid
        ON acid.instance_id = wad.id
        AND acid.delete_flag = '0'
        AND acid.status_enum = 1
        AND acid.instance_table = 'wor_activity_definition'
    WHERE wad.delete_flag = '0'
      AND wad.status_enum = 1
      AND wad.pricing_flag = '0'
    ORDER BY wad.id
    LIMIT 2
 );
 -- ============================================
 -- 执行前可以先查询要更新的记录（验证用）
 -- ============================================
 -- 查询前两条 pricing_flag = '0' 的记录
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    pricing_flag,
    status_enum,
    create_time,
    update_time
 FROM wor_activity_definition
 WHERE delete_flag = '0'
  AND pricing_flag = '0'
  AND status_enum = 1
 ORDER BY id
 LIMIT 2;
 -- 查询有费用定价但 pricing_flag = '0' 的记录
 SELECT 
    wad.id,
    wad.bus_no,
    wad.name AS activity_name,
    wad.pricing_flag,
    acid.charge_name,
    acid.price
 FROM wor_activity_definition wad
 INNER JOIN adm_charge_item_definition acid
    ON acid.instance_id = wad.id
    AND acid.delete_flag = '0'
    AND acid.status_enum = 1
    AND acid.instance_table = 'wor_activity_definition'
 WHERE wad.delete_flag = '0'
  AND wad.status_enum = 1
  AND wad.pricing_flag = '0'
 ORDER BY wad.id
 LIMIT 2;
 -- ============================================
 -- 执行后验证更新结果
 -- ============================================
 -- 验证更新是否成功
 SELECT 
    id,
    bus_no,
    name AS activity_name,
    pricing_flag,
    update_time
 FROM wor_activity_definition
 WHERE id IN (
    -- 这里放刚才更新的 ID，或者用子查询
    SELECT id
    FROM wor_activity_definition
    WHERE delete_flag = '0'
      AND pricing_flag = '1'
      AND status_enum = 1
    ORDER BY update_time DESC
    LIMIT 2
 );
--- a/openhis-server-new/sql/快速诊断诊疗项目问题.sql
+++ b/openhis-server-new/sql/快速诊断诊疗项目问题.sql
@@ -0,0 +1,86 @@
 -- 快速诊断诊疗项目检索问题
 -- 已知：wor_activity_definition 表中有4条数据
 -- 关键：ChargeItemContext.ACTIVITY.getValue() = 3（整数）
 -- 步骤1：检查这4条诊疗项目定义的delete_flag状态
 SELECT 
    id,
    name,
    delete_flag,
    CASE WHEN delete_flag = '0' THEN '✅ 可用' ELSE '❌ 已删除' END as status
 FROM wor_activity_definition
 ORDER BY id;
 -- 步骤2：检查收费项目中是否有诊疗项目类型（context_enum = 3）的记录
 SELECT 
    COUNT(*) as total_count,
    COUNT(CASE WHEN delete_flag = '0' THEN 1 END) as active_count
 FROM adm_charge_item
 WHERE (context_enum::text = '3' OR context_enum = 3);
 -- 步骤3：检查收费项目能否匹配到诊疗项目定义（最关键！）
 SELECT 
    aci.id as charge_item_id,
    aci.encounter_id,
    aci.product_id,
    aci.status_enum,
    wad.id as activity_def_id,
    wad.name as activity_name,
    CASE 
        WHEN wad.id IS NULL THEN '❌ 无法匹配：product_id=' || aci.product_id || ' 在诊疗项目定义表中不存在'
        WHEN wad.delete_flag != '0' THEN '❌ 无法匹配：诊疗项目定义已删除'
        WHEN aci.delete_flag != '0' THEN '❌ 无法匹配：收费项目已删除'
        WHEN aci.status_enum NOT IN (1,2,3,4,5,6) THEN '❌ 无法匹配：状态不在查询范围内 status=' || aci.status_enum
        ELSE '✅ 可以匹配'
    END as match_result
 FROM adm_charge_item aci
 LEFT JOIN wor_activity_definition wad 
    ON aci.product_id = wad.id AND wad.delete_flag = '0'
 WHERE (aci.context_enum::text = '3' OR aci.context_enum = 3)
    AND aci.delete_flag = '0'
 LIMIT 50;
 -- 步骤4：统计匹配情况
 SELECT 
    COUNT(*) as total_charge_items,
    COUNT(CASE WHEN wad.id IS NOT NULL AND wad.delete_flag = '0' THEN 1 END) as matched_count,
    COUNT(CASE WHEN wad.id IS NULL THEN 1 END) as unmatched_def_count,
    COUNT(CASE WHEN wad.delete_flag != '0' THEN 1 END) as deleted_def_count,
    COUNT(CASE WHEN wad.id IS NOT NULL AND wad.delete_flag = '0' AND aci.status_enum IN (1,2,3,4,5,6) THEN 1 END) as final_matched_count
 FROM adm_charge_item aci
 LEFT JOIN wor_activity_definition wad 
    ON aci.product_id = wad.id
 WHERE (aci.context_enum::text = '3' OR aci.context_enum = 3)
    AND aci.delete_flag = '0';
 -- 步骤5：检查具体就诊的诊疗项目（如果有encounterId，取消注释并替换）
 -- SELECT 
 --     T1.encounter_id,
 --     T1.id as charge_item_id,
 --     T1.product_id,
 --     T1.status_enum,
 --     T2.id as activity_def_id,
 --     T2.name as activity_name,
 --     CASE 
 --         WHEN T2.id IS NULL THEN '❌ 无法匹配'
 --         WHEN T2.delete_flag != '0' THEN '❌ 定义已删除'
 --         WHEN T1.status_enum NOT IN (1,2,3,4,5,6) THEN '❌ 状态不符合'
 --         ELSE '✅ 正常'
 --     END as status
 -- FROM adm_charge_item AS T1
 -- LEFT JOIN wor_activity_definition AS T2
 --     ON T1.product_id = T2.id AND T2.delete_flag = '0'
 -- WHERE T1.encounter_id = :encounterId  -- 替换为实际的encounterId
 --     AND (T1.context_enum::text = '3' OR T1.context_enum = 3)
 --     AND T1.delete_flag = '0';
--- a/openhis-server-new/sql/诊断门诊划价检索不出诊疗项目问题.md
+++ b/openhis-server-new/sql/诊断门诊划价检索不出诊疗项目问题.md
@@ -0,0 +1,165 @@
 # 诊断：门诊划价检索不出诊疗项目问题
 ## 问题描述
 在门诊划价页面，检索不出诊疗项目，显示"暂无数据"。
 ## 问题分析
 ### SQL查询逻辑
 根据 `OutpatientChargeAppMapper.xml` 中的 `selectEncounterPatientPrescription` 查询：
 1. **查询主表**：`adm_charge_item`（收费项目表）
 2. **关联诊疗项目定义表**：`wor_activity_definition`
   - 关联条件：`T1.context_enum = #{activity}` AND `T1.product_id = T2.id` AND `T2.delete_flag = '0'`
 3. **返回字段**：`item_name` 来自 `wor_activity_definition.name`
 ### 可能的原因
 #### 1. 数据库中没有诊疗项目定义数据
 - **检查**：`wor_activity_definition` 表中是否有数据
 - **SQL**：
 ```sql
 SELECT COUNT(*) FROM wor_activity_definition WHERE delete_flag = '0';
 ```
 #### 2. 收费项目中的product_id无法匹配到诊疗项目定义
 - **检查**：`adm_charge_item` 表中的 `product_id` 是否存在于 `wor_activity_definition` 表中
 - **SQL**：
 ```sql
 SELECT 
    aci.id,
    aci.encounter_id,
    aci.product_id,
    aci.context_enum,
    wad.id as activity_def_id,
    wad.name as activity_name
 FROM adm_charge_item aci
 LEFT JOIN wor_activity_definition wad ON aci.product_id = wad.id AND wad.delete_flag = '0'
 WHERE aci.context_enum = 'ACTIVITY'
    AND aci.delete_flag = '0'
    AND wad.id IS NULL;  -- 无法匹配的记录
 ```
 #### 3. 诊疗项目定义被标记为删除
 - **检查**：`wor_activity_definition` 表中的 `delete_flag` 是否为 '0'
 - **SQL**：
 ```sql
 SELECT 
    id,
    name,
    delete_flag
 FROM wor_activity_definition
 WHERE delete_flag != '0';
 ```
 #### 4. context_enum 值不匹配
 - **检查**：`adm_charge_item` 表中的 `context_enum` 值是否正确
 - **SQL**：
 ```sql
 SELECT DISTINCT context_enum FROM adm_charge_item WHERE delete_flag = '0';
 ```
 - **注意**：后端代码中传入的 `#{activity}` 参数值应该是 `ChargeItemContext.ACTIVITY.getValue()`
 ## 诊断步骤
 ### 步骤1：检查诊疗项目定义表是否有数据
 ```sql
 SELECT 
    COUNT(*) as total_count,
    COUNT(CASE WHEN delete_flag = '0' THEN 1 END) as active_count,
    COUNT(CASE WHEN delete_flag != '0' THEN 1 END) as deleted_count
 FROM wor_activity_definition;
 ```
 **预期结果**：`active_count` 应该 > 0
 ### 步骤2：检查收费项目中的诊疗项目是否能匹配到定义
 ```sql
 SELECT 
    COUNT(*) as total_charge_items,
    COUNT(CASE WHEN wad.id IS NOT NULL THEN 1 END) as matched_count,
    COUNT(CASE WHEN wad.id IS NULL THEN 1 END) as unmatched_count
 FROM adm_charge_item aci
 LEFT JOIN wor_activity_definition wad 
    ON aci.context_enum = 'ACTIVITY'
    AND aci.product_id = wad.id
    AND wad.delete_flag = '0'
 WHERE aci.context_enum = 'ACTIVITY'
    AND aci.delete_flag = '0';
 ```
 **预期结果**：`matched_count` 应该 > 0，`unmatched_count` 应该 = 0
 ### 步骤3：检查具体就诊的诊疗项目
 ```sql
 -- 替换 :encounterId 为实际的就诊ID
 SELECT 
    T1.encounter_id,
    T1.id as charge_item_id,
    T1.context_enum,
    T1.product_id,
    T1.status_enum,
    T2.id as activity_def_id,
    T2.name as activity_name,
    T2.delete_flag as activity_delete_flag,
    CASE 
        WHEN T2.id IS NULL THEN '诊疗项目定义不存在或已删除'
        WHEN T2.delete_flag != '0' THEN '诊疗项目定义已删除'
        ELSE '正常'
    END as status
 FROM adm_charge_item AS T1
 LEFT JOIN wor_activity_definition AS T2
    ON T1.context_enum = 'ACTIVITY'
    AND T1.product_id = T2.id
 WHERE T1.encounter_id = :encounterId  -- 替换为实际的encounterId
    AND T1.context_enum = 'ACTIVITY'
    AND T1.delete_flag = '0'
    AND T1.status_enum IN (1, 2, 3, 4, 5, 6);
 ```
 ### 步骤4：检查后端传入的参数值
 检查 `OutpatientChargeAppServiceImpl.java` 中：
 ```java
 ChargeItemContext.ACTIVITY.getValue()
 ```
 确认这个值是什么（应该是 'ACTIVITY' 或对应的枚举值）
 ## 解决方案
 ### 如果是数据问题：
 1. **缺少诊疗项目定义数据**：
   - 需要在 `wor_activity_definition` 表中添加诊疗项目数据
   - 或者在系统管理-目录管理-诊疗项目中添加
 2. **product_id无法匹配**：
   - 检查 `adm_charge_item` 表中的 `product_id` 是否正确
   - 检查 `wor_activity_definition` 表中的 `id` 是否与 `product_id` 匹配
 3. **delete_flag不正确**：
   - 将 `wor_activity_definition` 表中需要使用的记录的 `delete_flag` 设置为 '0'
 ### 如果是代码问题：
 1. **context_enum值不匹配**：
   - 检查后端代码中 `ChargeItemContext.ACTIVITY.getValue()` 返回的值
   - 确保与数据库中的 `context_enum` 值一致
 2. **SQL查询条件错误**：
   - 检查 SQL 中的关联条件是否正确
   - 检查是否有其他过滤条件导致数据被过滤掉
 ## 快速诊断SQL
 运行以下SQL可以快速诊断问题：
 ```sql
 -- 见 diagnose_treatment_items_issue.sql 文件
 ```
--- a/openhis-ui-vue3/src/api/system/lisConfig.js
+++ b/openhis-ui-vue3/src/api/system/lisConfig.js
@@ -0,0 +1,33 @@
 import request from '@/utils/request'
 export function getLisConfigPage(query) {
  return request({
    url: '/inspection/lisConfig/init-page',
    method: 'get',
    params: query
  })
 }
 export function getLisConfigDetail(id) {
  return request({
    url: '/inspection/lisConfig/info-detail',
    method: 'get',
    params: { id }
  })
 }
 export function getLisConfigList(searchKey, type) {
  return request({
    url: '/inspection/lisConfig/init-list',
    method: 'get',
    params: { searchKey, type }
  })
 }
 export function saveLisConfig(data) {
  return request({
    url: '/inspection/lisConfig/saveAll',
    method: 'post',
    data: data
  })
 }
--- a/openhis-ui-vue3/src/api/system/observation.js
+++ b/openhis-ui-vue3/src/api/system/observation.js
@@ -0,0 +1,48 @@
 import request from '@/utils/request'
 export function getObservationInit() {
  return request({
    url: '/inspection/observation/init',
    method: 'get'
  })
 }
 export function getObservationPage(query) {
  return request({
    url: '/inspection/observation/information-page',
    method: 'get',
    params: query
  })
 }
 export function getObservationOne(id) {
  return request({
    url: '/inspection/observation/information-one',
    method: 'get',
    params: { id }
  })
 }
 export function addObservation(data) {
  return request({
    url: '/inspection/observation/information',
    method: 'post',
    data: data
  })
 }
 export function updateObservation(data) {
  return request({
    url: '/inspection/observation/information',
    method: 'post',
    data: data
  })
 }
 export function deleteObservation(ids) {
  return request({
    url: '/inspection/observation/information-status',
    method: 'post',
    data: { ids, type: '停用' }
  })
 }
--- a/openhis-ui-vue3/src/components/PatientList/index.vue
+++ b/openhis-ui-vue3/src/components/PatientList/index.vue
@@ -33,18 +33,32 @@
                :class="{ actived: activeCardId === item.encounterId }"
              >
                <div class="patient-card-header">
-                  <div class="header-top">
+                  <!-- 第1行：姓名 -->
-                    <div class="bed-container">
+                  <div class="info-row name-row">
-                      <div class="bed">
+                    <div class="name">
-                        <div class="bed-info">
+                      <el-text :text="item.patientName" tclass="name" width="auto">
-                          <div v-if="item.houseName" class="house-name">{{ item.houseName }}</div>
+                        {{ item.patientName || '-' }}
-                          <div class="bed-name">{{ item.bedName || '未分床' }}</div>
+                      </el-text>
                        </div>
                      </div>
                    </div>
-                    <el-space>
+                  </div>
                  <!-- 第2行：性别 年龄 + 入院状态 -->
                  <div class="info-row gender-age-row">
                    <div class="age">
                      <el-tag
                        size="small"
                        class="age-tag"
                        effect="plain"
                        :class="{ 'age-tag-female': item.genderEnum_enumText === '女性' }"
                      >
                        {{ item.genderEnum_enumText || '-' }}
                        <span v-if="item.age"> · {{ item.age }}</span>
                      </el-tag>
                    </div>
                    <!-- 入院状态放在性别年龄旁边 -->
                    <div class="status-inline" v-if="item.statusEnum_enumText">
                      <el-tag
                        v-if="item.statusEnum_enumText"
                        size="small"
                        class="payer-tag-status"
                        effect="light"
@@ -52,22 +66,31 @@
                      >
                        {{ item.statusEnum_enumText }}
                      </el-tag>
-                      <el-tag
+                    </div>
                        v-if="item.contractName"
                        size="small"
                        class="payer-tag"
                        effect="light"
                      >
                        {{ item.contractName }}
                      </el-tag>
                    </el-space>
                  </div>
-                  <div class="header-bottom">
+                  <!-- 第3行：房间号-分床状态 -->
                  <div class="info-row room-bed-row">
                    <div class="bed-info">
                      <div v-if="item.houseName" class="house-name">{{ item.houseName }}</div>
                      <div class="bed-name">{{ item.bedName || '未分床' }}</div>
                    </div>
                  </div>
                  <!-- 第4行：住院号 -->
                  <div class="info-row busno-row">
                    <span class="bus-no">住院号：{{ item.busNo || '-' }}</span>
-                    <span class="insurance-type" v-if="item.insutype_dictText">
+                  </div>
-                      险种类型：{{ item.insutype_dictText }}
+
-                    </span>
+                  <!-- 第5行：居民保险类型 -->
                  <div class="info-row insurance-row" v-if="item.contractName">
                    <el-tag
                      size="small"
                      class="payer-tag"
                      effect="light"
                    >
                      {{ item.contractName }}
                    </el-tag>
                  </div>
                </div>
@@ -360,7 +383,7 @@ watch(
 <style lang="scss" scoped>
 .patient-card {
  width: 100%;
-  overflow: hidden;
+  overflow: visible; /* 改为visible以确保内容可见 */
  background-color: #fff;
  border-radius: 6px;
  border: 1px solid rgba(0, 0, 0, 0.04);
@@ -383,77 +406,128 @@ watch(
    display: flex;
    flex-direction: column;
    padding: 10px 12px 4px;
    overflow: visible; /* 确保内容可见 */
    gap: 4px; /* 行与行之间的间距 */
-    .header-top {
+    .info-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      width: 100%;
-      .bed-container {
+      &.room-bed-row {
        display: flex;
        flex: 1;
        align-items: center;
-        min-width: 0;
+        font-weight: 600;
        font-size: 16px;
        color: #1f2933;
-        .bed {
+        .bed-info {
-          flex-grow: 0;
+          display: flex;
-          flex-shrink: 1;
+          flex-direction: row;
-          min-width: 0;
+          align-items: center;
          gap: 4px;
          min-width: 0; /* 允许收缩 */
-          .bed-info {
+          .house-name {
-            display: flex;
+            color: #1f2933;
-            flex-direction: column;
+            font-weight: 600;
-            line-height: 1.4;
+            font-size: 16px;
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
          }
-            .house-name {
+          .bed-name {
-              color: #1f2933;
+            color: #1f2933;
-              font-weight: 600;
+            font-weight: 600;
-              font-size: 16px;
+            font-size: 16px;
-              white-space: normal;
+            white-space: nowrap;
-              word-break: break-all;
+            overflow: hidden;
-            }
+            text-overflow: ellipsis;
            .bed-name {
              color: #1f2933;
              font-weight: 600;
              font-size: 16px;
              white-space: normal;
              word-break: break-all;
            }
          }
        }
      }
-      .payer-tag {
+      &.insurance-row {
-        max-width: 120px;
+        align-items: center;
-        font-size: 12px;
+        margin-left: 8px; /* 添加一点左边距，与第一行对齐 */
        border-radius: 999px;
        font-weight: bolder;
      }
-      .payer-tag-status {
+
-        font-weight: bolder;
+      &.busno-row {
-        border-radius: 999px;
+        color: #6b7280;
        font-size: 12px;
        align-items: center;
        .bus-no {
          white-space: nowrap;
          overflow: hidden;
          text-overflow: ellipsis;
        }
      }
      &.name-row {
        align-items: center;
        color: #111827;
        .name {
          color: #111827;
          font-weight: 700 !important; /* 更粗的字体，使用important确保优先级 */
          font-size: 18px !important;  /* 更大的字体，使用important确保优先级 */
          flex: 1;
          overflow: hidden;
          text-overflow: ellipsis;
          white-space: nowrap;
          :deep(.el-text),
          :deep(.el-text__inner) {
            font-weight: 700 !important; /* 确保el-text组件也应用粗体 */
            font-size: 18px !important;  /* 确保el-text组件也应用更大字体 */
          }
        }
      }
      &.gender-age-row {
        display: flex;
        align-items: center;
        justify-content: space-between;
        width: 100%;
        .age {
          flex-shrink: 0;
          .age-tag {
            border-radius: 999px;
            padding: 0 8px;
          }
          .age-tag-female {
            border-color: rgb(255, 55, 158);
            color: rgb(255, 126, 184);
          }
        }
        .status-inline {
          flex-shrink: 0;
          margin-left: 8px;
        }
      }
    }
-    .header-bottom {
+    .payer-tag {
-      margin-top: 4px;
+      max-width: 100%;
      width: 100%;
      display: flex;
      flex-direction: column;
      align-items: flex-start;
      gap: 2px;
      color: #6b7280;
      font-size: 12px;
      border-radius: 999px;
      font-weight: bolder;
    }
    .payer-tag-status {
      font-weight: bolder;
      border-radius: 999px;
    }
-      .bus-no {
+    /* 隐藏旧的布局结构，因为已被新的info-row结构替代 */
-        white-space: nowrap;
+    .header-top,
-      }
+    .header-bottom,
-
+    .bed-container,
-      .insurance-type {
+    .tags-container {
-        white-space: nowrap;
+      display: none;
      }
    }
  }
@@ -476,6 +550,7 @@ watch(
        justify-content: space-between;
        gap: 8px;
        width: 100%;
        display: none; /* 新的布局中，name-container已在header中显示，这里隐藏 */
        .name {
          color: #111827;
@@ -522,15 +597,16 @@ watch(
  height: 100%;
  display: flex;
  flex-direction: column;
  height: 100%;
  border-right: 1px solid #ebeef5;
  background-color: #ffffff;
  width: 240px;
  min-width: 240px;
  &-unexpand {
    width: 84px;
    min-width: 84px;
  }
  .patientList-operate {
    display: flex;
    align-items: center;
@@ -551,22 +627,14 @@ watch(
    flex-direction: column;
    height: 0;
    width: 240px;
    &-unexpand {
      width: 84px;
    }
    .search-operate {
      padding: 0 8px;
      height: 48px;
      display: flex;
      align-items: center;
      flex: none;
    }
    .patient-cards {
      flex: 1;
      padding: 0 8px;
      overflow: hidden;
      :deep(.patient-cards-scrollbar) {
@@ -610,6 +678,7 @@ watch(
  display: flex;
  justify-content: flex-end;
  padding: 4px 16px 8px;
  &-unexpand {
    justify-content: center;
  }
--- a/openhis-ui-vue3/src/components/PendingPatientList/index.vue
+++ b/openhis-ui-vue3/src/components/PendingPatientList/index.vue
@@ -187,6 +187,7 @@ const getStatusClass = (item: any) => {
    align-items: center;
    justify-content: space-between;
    width: 100%;
    flex-wrap: nowrap; /* 防止换行 */
    .bed-container {
      display: flex;
@@ -216,9 +217,10 @@ const getStatusClass = (item: any) => {
    .header-tags {
      flex-shrink: 0;
      display: flex;
-      align-items: flex-end;
+      align-items: center;
      justify-content: flex-end;
      gap: 6px;
      flex-wrap: nowrap; /* 防止换行 */
    }
  }
--- a/openhis-ui-vue3/src/layout/components/Sidebar/SidebarItem.vue
+++ b/openhis-ui-vue3/src/layout/components/Sidebar/SidebarItem.vue
@@ -1,5 +1,5 @@
 <template>
-  <div v-if="!item.hidden">
+  <div v-if="!item.hidden && !(item.meta && item.meta.visible === '1')">
    <template v-if="hasOneShowingChild(item.children, item) && (!onlyOneChild.children || onlyOneChild.noShowingChildren) && !item.alwaysShow">
      <app-link v-if="onlyOneChild.meta" :to="resolvePath(onlyOneChild.path, onlyOneChild.query)">
        <el-menu-item :index="resolvePath(onlyOneChild.path)" :class="{ 'submenu-title-noDropdown': !isNest }">
--- a/openhis-ui-vue3/src/router/index.js
+++ b/openhis-ui-vue3/src/router/index.js
@@ -1,4 +1,4 @@
-import {createWebHistory, createRouter} from 'vue-router'
+import { createWebHistory, createRouter } from 'vue-router'
 /* Layout */
 import Layout from '@/layout'
@@ -61,7 +61,7 @@ export const constantRoutes = [
                path: '/index',
                component: () => import('@/views/index'),
                name: 'Index',
-                meta: {title: '首页', icon: 'dashboard', affix: true}
+                meta: { title: '首页', icon: 'dashboard', affix: true }
            }
        ]
    },
@@ -75,7 +75,21 @@ export const constantRoutes = [
                path: 'profile',
                component: () => import('@/views/system/user/profile/index'),
                name: 'Profile',
-                meta: {title: '个人中心', icon: 'user'}
+                meta: { title: '个人中心', icon: 'user' }
            }
        ]
    },
    // 添加套餐管理相关路由到公共路由，确保始终可用
    {
        path: '/maintainSystem/Inspection/PackageManagement',
        component: Layout,
        hidden: true,
        children: [
            {
                path: '',
                component: () => import('@/views/maintainSystem/Inspection/PackageManagement.vue'),
                name: 'DirectPackageManagement',
                meta: { title: '套餐管理' }
            }
        ]
    }
@@ -83,6 +97,148 @@ export const constantRoutes = [
 // 动态路由，基于用户权限动态去加载
 export const dynamicRoutes = [
    {
        path: '/basicmanage',
        component: Layout,
        redirect: '/basicmanage/invoice-management',
        name: 'BasicManage',
        meta: { title: '基础管理', icon: 'component' },
        children: [
            {
                path: 'invoice-management',
                component: () => import('@/views/basicmanage/InvoiceManagement/index.vue'),
                name: 'invoice-management',
                meta: { title: '发票管理' }
            }
        ]
    },
    {
        path: '/system/tenant-user',
        component: Layout,
        hidden: true,
        permissions: ['*:*:*'],
        children: [
            {
                path: 'set/:tenantId(\\d+)',
                component: () => import('@/views/system/tenant/setUser'),
                name: 'SetUser',
                meta: { title: '所属用户', activeMenu: '/system/tenant' }
            }
        ]
    },
    {
        path: '/system/tenant-contract',
        component: Layout,
        hidden: true,
        permissions: ['*:*:*'],
        children: [
            {
                path: 'set/:tenantId(\\d+)',
                component: () => import('@/views/system/tenant/setContract'),
                name: 'SetContract',
                meta: { title: '合同管理', activeMenu: '/system/tenant' }
            }
        ]
    },
    {
        path: '/system/user-auth',
        component: Layout,
        hidden: true,
        permissions: ['system:user:edit'],
        children: [
            {
                path: 'role/:userId(\\d+)',
                component: () => import('@/views/system/user/authRole'),
                name: 'AuthRole',
                meta: { title: '分配角色', activeMenu: '/system/user' }
            }
        ]
    },
    {
        path: '/system/role-auth',
        component: Layout,
        hidden: true,
        permissions: ['system:role:edit'],
        children: [
            {
                path: 'user/:roleId(\\d+)',
                component: () => import('@/views/system/role/authUser'),
                name: 'AuthUser',
                meta: { title: '分配用户', activeMenu: '/system/role' }
            }
        ]
    },
    {
        path: '/monitor',
        component: Layout,
        redirect: '/monitor/operlog',
        name: 'Monitor',
        meta: { title: '系统监控', icon: 'monitor' },
        children: [
            {
                path: 'operlog',
                component: () => import('@/views/monitor/operlog/index.vue'),
                name: 'Operlog',
                meta: { title: '操作日志', icon: 'operlog', permissions: ['monitor:operlog:list'] }
            },
            {
                path: 'logininfor',
                component: () => import('@/views/monitor/logininfor/index.vue'),
                name: 'Logininfor',
                meta: { title: '登录日志', icon: 'logininfor', permissions: ['monitor:logininfor:list'] }
            },
            {
                path: 'job',
                component: () => import('@/views/monitor/job/index.vue'),
                name: 'Job',
                meta: { title: '定时任务', icon: 'job', permissions: ['monitor:job:list'] }
            }
        ]
    },
    {
        path: '/tool',
        component: Layout,
        redirect: '/tool/gen',
        name: 'Tool',
        meta: { title: '系统工具', icon: 'tool' },
        children: [
            {
                path: 'gen',
                component: () => import('@/views/tool/gen/index.vue'),
                name: 'Gen',
                meta: { title: '代码生成', icon: 'gen', permissions: ['tool:gen:list'] }
            }
        ]
    },
    {
        path: '/monitor/job-log',
        component: Layout,
        hidden: true,
        permissions: ['monitor:job:list'],
        children: [
            {
                path: 'index/:jobId(\\d+)',
                component: () => import('@/views/monitor/job/log'),
                name: 'JobLog',
                meta: { title: '调度日志', activeMenu: '/monitor/job' }
            }
        ]
    },
    {
        path: '/tool/gen-edit',
        component: Layout,
        hidden: true,
        permissions: ['tool:gen:edit'],
        children: [
            {
                path: 'index/:tableId(\\d+)',
                component: () => import('@/views/tool/gen/editTable'),
                name: 'GenEdit',
                meta: { title: '修改生成配置', activeMenu: '/tool/gen' }
            }
        ]
    },
    {
        path: '/help-center',
        component: Layout,
@@ -92,7 +248,7 @@ export const dynamicRoutes = [
                path: '',
                component: () => import('@/views/helpcenter/index.vue'),
                name: 'HelpCenter',
-                meta: {title: '帮助中心'},
+                meta: { title: '帮助中心'},
            },
        ],
    },
@@ -115,7 +271,7 @@ const router = createRouter({
        if (savedPosition) {
            return savedPosition
        } else {
-            return {top: 0}
+            return { top: 0 }
        }
    },
 });
--- a/openhis-ui-vue3/src/template/HospitalRecordForm.vue
+++ b/openhis-ui-vue3/src/template/HospitalRecordForm.vue
@@ -347,7 +347,7 @@ const printForm = () => {
 };
 function handleClick() {
-  console.log('112313413');
+  console.log('住院记录表单点击事件触发');
 }
 const resetFun = (data) => {
--- a/openhis-ui-vue3/src/views/appoinmentmanage/index.vue
+++ b/openhis-ui-vue3/src/views/appoinmentmanage/index.vue
--- a/openhis-ui-vue3/src/views/appoinmentmanage/outpatientAppointment/index.vue
+++ b/openhis-ui-vue3/src/views/appoinmentmanage/outpatientAppointment/index.vue
@@ -4,7 +4,7 @@
    <div id="topSearchArea" class="top-search-area">
      <!-- 搜索标签行 -->
      <div class="search-labels">
-        <div class="search-label">导源日期</div>
+        <div class="search-label">号源日期</div>
        <div class="search-label">状态</div>
        <div class="search-label">患者姓名</div>
        <div class="search-label">就诊卡号</div>
@@ -34,8 +34,7 @@
          <select id="status-select" class="search-select" v-model="selectedStatus">
            <option value="all">全部</option>
            <option value="unbooked">未预约</option>
-            <option value="locked">锁定</option>
+            <option value="booked">已预约</option>
            <option value="booked">待缴费</option>
            <option value="checked">已取号</option>
            <option value="cancelled">已停诊</option>
          </select>
@@ -105,38 +104,34 @@
        <!-- 使用网格布局的号源卡片列表 -->
        <div class="ticket-grid" v-if="filteredTickets.length > 0">
          <div v-for="(item, index) in filteredTickets" :key="item.slot_id" class="ticket-card" @dblclick="handleDoubleClick(item)" @contextmenu.prevent="handleRightClick($event, item)">
-            <div class="ticket-header">
+            <!-- 序号放在最右侧 -->
-              <div class="ticket-number">{{ index + 1 }}</div>
+            <div class="ticket-index">{{ index + 1 }}</div>
-              <div class="ticket-type-badge" :class="item.ticketType === 'general' ? 'type-general' : 'type-expert'">
+            <!-- 1.时间 -->
-                {{ item.ticketType === 'general' ? '普通' : '专家' }}
+            <div class="ticket-id-time">{{ item.dateTime }}</div>
-              </div>
+            <!-- 2. 状态标签 -->
            </div>
            <div class="ticket-time">{{ item.dateTime }}</div>
            <div class="ticket-doctor">{{ item.doctor }}</div>
            <div class="ticket-status" :class="`status-${item.status}`">
              <span class="status-dot"></span>
              {{ item.status }}
            </div>
-            <div class="ticket-fee">挂号费: {{ item.fee }}</div>
+            <!-- 3. 医生姓名（截断显示，悬停展示完整信息） -->
-            <!-- 显示患者信息（如果已预约或已取号） -->
+            <div class="ticket-doctor" :title="item.doctor">{{ item.doctor }}</div>
            <!-- 4. 挂号费 -->
            <div class="ticket-fee">挂号费：{{ item.fee }}元</div>
            <!-- 5. 号源类型 -->
            <div class="ticket-type">{{ item.ticketType === 'general' ? '普通' : '专家' }}</div>
            <!-- 6. 已预约患者信息 -->
            <div v-if="(item.status === '已预约' || item.status === '已取号') && item.patientName" class="ticket-patient">
-              <div class="patient-name">{{ item.patientName }}</div>
+              {{ item.patientName }}({{ item.patientId }})
-              <div class="patient-card">{{ item.patientId }}</div>
+            </div>
-              <div class="patient-gender">性别：{{ item.patientGender || '-' }}</div>
+            <!-- 7. 患者电话号码 -->
            <div v-if="(item.status === '已预约' || item.status === '已取号') && item.phone" class="ticket-phone">
              电话号码： {{ item.phone }}
            </div>
            <div class="ticket-actions">
              <button class="action-button book-button" @click="openPatientSelectModal(item.slot_id)" :disabled="item.status !== '未预约'" :class="{ 'disabled': item.status !== '未预约' }">
                <i class="el-icon-tickets"></i>
                预约
              </button>
              <button class="action-button cancel-button" @click="confirmCancelConsultation(item)" :disabled="item.status === '已取消'" :class="{ 'disabled': item.status === '已取消' }">
                <i class="el-icon-close"></i>
                停诊
              </button>
              <button class="action-button check-in-button" @click="confirmCheckIn(item)" :disabled="item.status !== '已预约'" :class="{ 'disabled': item.status !== '已预约' }">
                <i class="el-icon-circle-check"></i>
                取号
              </button>
            </div>
          </div>
          <div v-if="hasMore" class="loading-more">
@@ -166,7 +161,7 @@
          <input id="phone" class="search-input" placeholder="手机号" v-model="patientSearchParams.phone" @input="onPatientSearchInput">
          <button id="patient-search-btn" class="search-btn" @click="searchPatients">查询</button>
          <div class="patient-table-container">
-            <table id="patient-table" class="patient-table">
+            <table id="patient-table" class="patient-table" v-if="patients.length > 0">
              <thead>
                <tr>
                  <th>序号</th>
@@ -192,6 +187,11 @@
                </tr>
              </tbody>
            </table>
            <!-- 无搜索结果提示 -->
            <div v-else-if="hasSearchCriteria && !isLoading" class="no-results">
              未找到符合条件的患者，请检查搜索条件
            </div>
          </div>
        </div>
        <div class="modal-footer">
@@ -231,13 +231,14 @@ import { listTicket, bookTicket, cancelTicket, checkInTicket, cancelConsultation
 import { getPatientList } from '@/api/cardRenewal/api';
 import { listDept } from '@/api/appoinmentmanage/dept';
 import { ref } from 'vue'
-import { ElDatePicker } from 'element-plus'
+import { ElDatePicker, ElPagination, ElMessageBox, ElMessage } from 'element-plus'
 import useUserStore from '@/store/modules/user'
 export default {
  name: 'OutpatientAppointment',
  components: {
-    ElDatePicker
+    ElDatePicker,
    ElPagination
  },
  // 添加全局点击事件监听器，用于关闭右键菜单
@@ -324,35 +325,34 @@ export default {
    filteredTickets() {
      let filtered = [...this.tickets];
-      // 按日期筛选（如果选择了日期） - 暂时注释掉以排查问题
+      //按日期筛选（如果选择了日期） 
-      // if (this.selectedDate) {
+      if (this.selectedDate) {
-      //   filtered = filtered.filter(ticket => {
+        filtered = filtered.filter(ticket => {
-      //     // 使用后端返回的dateTime字段进行筛选
+          // 使用后端返回的dateTime字段进行筛选
-      //     if (ticket.dateTime) {
+          if (ticket.dateTime) {
-      //       return ticket.dateTime.startsWith(this.selectedDate);
+            return ticket.dateTime.startsWith(this.selectedDate);
-      //     }
+          }
-      //     return true;
+          return true;
-      //   });
+        });
-      // }
+      }
-      // 按状态筛选 - 暂时注释掉以排查问题
+      //按状态筛选 
-      // if (this.selectedStatus !== 'all') {
+      if (this.selectedStatus !== 'all') {
-      //   // 状态映射表（后端返回中文状态，前端使用英文状态）
+        // 状态映射表（后端返回中文状态，前端使用英文状态）
-      //   const statusMap = {
+        const statusMap = {
-      //     'unbooked': '未预约',
+          'unbooked': '未预约',
-      //     'locked': '已锁定',
+          'booked': '已预约',
-      //     'booked': '已预约',
+          'checked': '已取号',
-      //     'checked': '已取号',
+          'cancelled': '已停诊'
-      //     'cancelled': '已取消'
+        };
-      //   };
+        const chineseStatus = statusMap[this.selectedStatus];
-      //   const chineseStatus = statusMap[this.selectedStatus];
+        filtered = filtered.filter(ticket => ticket.status === chineseStatus);
-      //   filtered = filtered.filter(ticket => ticket.status === chineseStatus);
+      }
      // }
-      // 按科室筛选 - 暂时注释掉以排查问题
+      // 按科室筛选 
-      // if (this.selectedDepartment !== 'all') {
+      if (this.selectedDepartment !== 'all') {
-      //   filtered = filtered.filter(ticket => ticket.department === this.selectedDepartment);
+        filtered = filtered.filter(ticket => ticket.department === this.selectedDepartment);
-      // }
+      }
      // 按号源类型筛选
      filtered = filtered.filter(ticket => {
@@ -365,62 +365,67 @@ export default {
      });
      // 按医生筛选 - 暂时注释掉以排查问题
-      // if (this.selectedDoctorId) {
+      if (this.selectedDoctorId) {
-      //   const selectedDoctor = this.doctors.find(d => d.id === this.selectedDoctorId);
+        const selectedDoctor = this.doctors.find(d => d.id === this.selectedDoctorId);
-      //   if (selectedDoctor) {
+        if (selectedDoctor) {
-      //     filtered = filtered.filter(ticket => ticket.doctor === selectedDoctor.name);
+          filtered = filtered.filter(ticket => ticket.doctor === selectedDoctor.name);
-      //   }
+        }
-      // }
+      }
      // 按患者信息筛选（姓名、就诊卡号、手机号） - 暂时注释掉以排查问题
      // if (this.patientName || this.patientCard || this.patientPhone) {
      //   filtered = filtered.filter(ticket => {
      //     const matchesName = !this.patientName || ticket.patientName?.includes(this.patientName);
      //     const matchesCard = !this.patientCard || ticket.patientId?.includes(this.patientCard);
      //     const matchesPhone = !this.patientPhone || ticket.phone?.includes(this.patientPhone);
      //     
      //     return matchesName && matchesCard && matchesPhone;
      //   });
      // }
      return filtered;
    },
    hasSearchCriteria() {
      return Object.values(this.patientSearchParams).some(value => value && value.trim() !== '');
    },
  },
  methods: {
    selectDoctor(doctorId) {
      this.selectedDoctorId = doctorId
      console.log('Selected doctor:', doctorId)
      // 医生选择后，筛选号源
      this.onSearch();
    },
    onTypeChange() {
      console.log('Type changed:', this.selectedType)
      // 移除onSearch()调用，让计算属性自动处理类型筛选
    },
    onDepartmentChange() {
      console.log('Department changed:', this.selectedDepartment)
      this.onSearch()
    },
    onDoctorSearch() {
      console.log('Searching doctor:', this.searchQuery)
      // 使用计算属性filteredDoctors实现实时搜索，无需调用API
    },
    openPatientSelectModal(ticketId) {
      console.log('openPatientSelectModal called with ticketId:', ticketId);
      this.currentTicket = this.tickets.find(ticket => ticket.slot_id === ticketId);
-      console.log('Found ticket for modal:', this.currentTicket);
+      // 重置搜索参数
-      // 打开患者选择弹窗时，查询患者列表
+      this.patientSearchParams = {
-      this.searchPatients();
+        patientName: '',
        medicalCard: '',
        idCard: '',
        phone: ''
      };
      // 清空患者列表
      this.patients = [];
      this.showPatientModal = true;
-      console.log('Show patient modal:', this.showPatientModal);
+      // 默认加载所有患者
      this.searchPatients();
    },
    // 患者搜索
    searchPatients() {      
-      console.log('searchPatients called with params:', this.patientSearchParams);
+      // 检查是否有搜索条件
      const hasSearchCriteria = Object.values(this.patientSearchParams).some(value => value && value.trim() !== '');
      // 设置加载状态
      this.isLoading = true;
      // 准备搜索参数，确保支持模糊匹配
      const searchParams = {
        patientName: this.patientSearchParams.patientName?.trim() || '',
        medicalCard: this.patientSearchParams.medicalCard?.trim() || '',
        idCard: this.patientSearchParams.idCard?.trim() || '',
        phone: this.patientSearchParams.phone?.trim() || ''
      };      
      // 调用真实API获取患者列表
      getPatientList(this.patientSearchParams).then(response => {
        console.log('Patient API response:', response);
        // 尝试不同的数据结构解析
        let records = [];
        if (response.data && response.data.records) {
@@ -432,30 +437,39 @@ export default {
        }
        this.patients = records;        
-        console.log('Loaded patients:', this.patients);
+        // 在前端进行额外的模糊匹配过滤（以防后端API不支持完整的模糊匹配）
        if (hasSearchCriteria) {
          this.patients = this.patients.filter(patient => {
            const nameMatch = !searchParams.patientName || 
              (patient.name && patient.name.toLowerCase().includes(searchParams.patientName.toLowerCase()));
            const cardMatch = !searchParams.medicalCard || 
              (patient.medicalCard && patient.medicalCard.toLowerCase().includes(searchParams.medicalCard.toLowerCase()));
            const idMatch = !searchParams.idCard || 
              (patient.idCard && patient.idCard.toLowerCase().includes(searchParams.idCard.toLowerCase()));
            const phoneMatch = !searchParams.phone || 
              (patient.phone && patient.phone.toLowerCase().includes(searchParams.phone.toLowerCase()));
            return nameMatch && cardMatch && idMatch && phoneMatch;
          });
        }        
        // 验证每个患者是否有idCard字段，如果没有，尝试使用其他唯一标识
        this.patients.forEach((patient, index) => {
          console.log(`Patient ${index}:`, patient);
          console.log(`Patient ${index} has idCard:`, patient.idCard ? 'Yes' : 'No');
          console.log(`Patient ${index} has id:`, patient.id ? 'Yes' : 'No');
          console.log(`Patient ${index} has medicalCard:`, patient.medicalCard ? 'Yes' : 'No');
          // 如果没有idCard，尝试设置一个临时唯一标识
          if (!patient.idCard) {
            patient.idCard = patient.id || patient.medicalCard || `temp_${index}`;
            console.log(`Set temporary idCard for patient ${index}:`, patient.idCard);
          }
        });
        if (this.patients.length === 0) {
-          console.log('No patients found in response');
+          ElMessage.error('没有找到患者数据，请检查搜索条件或联系管理员');
          alert('没有找到患者数据，请检查搜索条件或联系管理员');
        }        
        // 清除加载状态
        this.isLoading = false;
      }).catch(error => {
        console.error('获取患者列表失败:', error);
        this.patients = [];
-        alert('获取患者列表失败：' + (error.message || '未知错误'));
+        ElMessage.error('获取患者列表失败：' + (error.message || '未知错误'));
        // 清除加载状态
        this.isLoading = false;
      });
    },
@@ -483,18 +497,12 @@ export default {
    // 双击未预约卡片触发患者选择流程
    handleDoubleClick(ticket) {
      console.log('handleDoubleClick called with ticket:', ticket);
      if (ticket.status === '未预约') {
        this.currentTicket = ticket;
        console.log('Set currentTicket:', this.currentTicket);
        this.selectedPatientId = null;
        this.selectedPatient = null;  
        console.log('Reset selected patient info:', { selectedPatientId: this.selectedPatientId, selectedPatient: this.selectedPatient });
        // 先打开弹窗，再加载患者数据，避免等待
        this.showPatientModal = true;
        console.log('Show patient modal after double click:', this.showPatientModal);
        // 调用患者搜索接口，加载患者列表
        this.searchPatients();
      }
@@ -518,88 +526,66 @@ export default {
    // 确认取消预约
    confirmCancelAppointment() {
      if (this.selectedTicketForCancel) {
-        // 二次确认，显示患者姓名
+        // 使用 ElMessageBox.confirm 进行二次确认，显示患者姓名
-        if (confirm(`确认取消患者${this.selectedTicketForCancel.patientName || ''}的预约？`)) {
+        ElMessageBox.confirm(
-          // 调用API取消预约
+          `确认取消患者${this.selectedTicketForCancel.patientName || ''}的预约？`,
          '系统提示',
          {
            confirmButtonText: '确定',
            cancelButtonText: '取消',
            type: 'warning'
          }
        ).then(() => {
          // 用户点击确定，调用API取消预约
          this.cancelAppointment(this.selectedTicketForCancel);
-        }
+        }).catch(() => {
-        this.closeContextMenu();
+          // 用户取消操作
          this.closeContextMenu();
        });
      }
    },
    // 确认停诊
    confirmCancelConsultation(ticket) {
      // 二次确认
      if (confirm(`确认取消${ticket.doctor}在${ticket.dateTime}的看诊吗？`)) {
        // 调用API处理停诊
        this.cancelConsultation(ticket);
      }
    },
    // 处理停诊
    cancelConsultation(ticket) {
      // 使用真实API调用处理停诊
      cancelConsultation(ticket.slot_id).then(response => {
        // API调用成功后，重新获取最新的号源数据
        this.onSearch();
        alert('停诊已处理，该号源已被取消');
      }).catch(error => {
        console.error('停诊处理失败:', error);
        alert('停诊处理失败，请稍后重试。');
      });
    },
    // 确认取号
    confirmCheckIn(ticket) {
      // 二次确认
      if (confirm(`确认${ticket.patientName || ''}取号吗？`)) {
        // 调用API处理取号
        this.checkIn(ticket);
      }
    },
    // 处理取号
    checkIn(ticket) {
      // 使用真实API调用处理取号
      checkInTicket(ticket.slot_id).then(response => {
        // API调用成功后，重新获取最新的号源数据
        this.onSearch();
        alert('取号成功！');
      }).catch(error => {
        console.error('取号失败:', error);
        alert('取号失败，请稍后重试。');
      });
    },
    // 取消预约API调用
    cancelAppointment(ticket) {
      if (!ticket || !ticket.slot_id) {
-        console.error('取消预约失败：缺少号源信息');
+        ElMessage.error('取消预约失败：缺少号源信息');
        alert('取消预约失败：缺少号源信息');
        this.closeContextMenu();
        return;
      }
-      // 使用真实API调用取消预约
+      // 使用真实API调用取消预约，传递slot_id
      cancelTicket(ticket.slot_id).then(response => {        
-        // API调用成功后，更新当前卡片状态
+        // 根据后端返回判断是否成功
-        const ticketIndex = this.tickets.findIndex(t => t.slot_id === ticket.slot_id);
+        if (response.code === 200 || response.msg === '取消成功' || response.message === '取消成功') {
-        if (ticketIndex !== -1) {
+          console.log('取消预约成功，更新前端状态');
          // 清除该号源关联的所有患者信息
          this.tickets[ticketIndex].status = '未预约';
          this.tickets[ticketIndex].patientName = null;
          this.tickets[ticketIndex].patientId = null;
          this.tickets[ticketIndex].patientGender = null;
          this.tickets[ticketIndex].medicalCard = null;
          this.tickets[ticketIndex].phone = null;
        }
-        // 关闭上下文菜单
+          // API调用成功后，更新当前卡片状态
-        this.closeContextMenu();
+          const ticketIndex = this.tickets.findIndex(t => t.slot_id === ticket.slot_id);
-        alert('预约已取消，号源已释放');
+          if (ticketIndex !== -1) {
            // 清除该号源关联的所有患者信息
            this.tickets[ticketIndex].status = '未预约';
            this.tickets[ticketIndex].patientName = null;
            this.tickets[ticketIndex].patientId = null;
            this.tickets[ticketIndex].patientGender = null;
            this.tickets[ticketIndex].medicalCard = null;
            this.tickets[ticketIndex].phone = null;
            // 更新医生号源列表中的余号数量
            this.updateDoctorsList();
          }
          // 关闭上下文菜单
          this.closeContextMenu();
          ElMessage.success('预约已取消，号源已释放');
        } else {
          // 取消失败
          const errorMsg = response.msg || response.message || '取消预约失败';
          ElMessage.error(`取消预约失败：${errorMsg}`);
          this.closeContextMenu();
        }
      }).catch(error => {
-        console.error('取消预约失败:', error);
+        const errorMsg = error.message || '取消预约失败，请稍后重试';
-        alert('取消预约失败，请稍后重试。');
+        ElMessage.error(`取消预约失败：${errorMsg}`);
        this.closeContextMenu();
      });
    },
@@ -608,20 +594,13 @@ export default {
      this.selectedPatientId = null
    },
    selectPatient(patientId) {
      console.log('selectPatient called with patientId:', patientId);
      console.log('Current patients data:', this.patients);
      console.log('Patients array length:', this.patients.length);
      // 确保患者数据已加载
      if (this.patients.length === 0) {
-        console.error('No patients data available');
+        ElMessage.error('患者数据未加载，请先搜索患者');
        alert('患者数据未加载，请先搜索患者');
        return;
      }
      this.selectedPatientId = patientId;
      console.log('Set selectedPatientId:', this.selectedPatientId);
      // 保存选择的患者对象 - 使用idCard作为唯一标识，但增加容错性
      this.selectedPatient = this.patients.find(patient => {
        // 尝试多种匹配方式
@@ -629,42 +608,44 @@ export default {
        const matchById = patient.id === patientId;
        const matchByMedicalCard = patient.medicalCard === patientId;
        const match = matchByIdCard || matchById || matchByMedicalCard;        
        console.log(`Checking patient ${patient.name || 'unknown'}:`);
        console.log(`  idCard: ${patient.idCard}, matchByIdCard: ${matchByIdCard}`);
        console.log(`  id: ${patient.id}, matchById: ${matchById}`);
        console.log(`  medicalCard: ${patient.medicalCard}, matchByMedicalCard: ${matchByMedicalCard}`);
        console.log(`  Overall match: ${match}`);
        return match;
      });
      console.log('Selected patient:', this.selectedPatient);
      console.log('Selected patientId:', this.selectedPatientId);
      if (this.selectedPatient) {
-        // 添加视觉反馈，验证患者是否被选中
+        // 使用 ElMessageBox.confirm 进行二次确认
-        alert('已选择患者: ' + this.selectedPatient.name);
+        ElMessageBox.confirm(
-        
+          `确认选择患者 ${this.selectedPatient.name} 进行预约？`,
-        // 可以考虑自动滚动到确认按钮，提高用户体验
+          '患者确认',
-        const confirmBtn = document.querySelector('.confirm-btn');
+          {
-        if (confirmBtn) {
+            confirmButtonText: '确定',
-          confirmBtn.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+            cancelButtonText: '取消',
-        }
+            type: 'info'
          }
        ).then(() => {
          // 用户点击确定，自动滚动到确认按钮
          ElMessage.success('已选择患者: ' + this.selectedPatient.name);
          const confirmBtn = document.querySelector('.confirm-btn');
          if (confirmBtn) {
            confirmBtn.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
          }
        }).catch(() => {
          // 用户取消选择，清空已选患者
          this.selectedPatientId = null;
          this.selectedPatient = null;
          ElMessage.info('已取消患者选择');
        });
      } else {
-        console.error('Patient not found with id:', patientId);
+        ElMessage.error('未找到该患者，请重新选择');
        alert('未找到该患者，请重新选择');
        this.selectedPatientId = null;
      }
    },
    confirmPatientSelection() {
      if (!this.selectedPatientId || !this.selectedPatient) {
-        alert('请选择患者');
+        ElMessage.error('请选择患者');
        return;
      }
      if (!this.currentTicket) {
-        alert('预约信息错误，请重新选择号源');
+        ElMessage.error('预约信息错误，请重新选择号源');
        this.closePatientSelectModal();
        return;
      }
@@ -672,6 +653,7 @@ export default {
      try {
        const userStore = useUserStore();
        const appointmentData = {
          slotId: this.currentTicket.slot_id, // 添加号源ID
          ticketId: Number(this.currentTicket.slot_id),
          patientId: this.selectedPatientId, // 使用身份证号作为患者ID，不需要转换为数字
          patientName: this.selectedPatient.name,
@@ -685,16 +667,15 @@ export default {
        // 验证必填字段
        if (!appointmentData.ticketId || isNaN(appointmentData.ticketId)) {
-          alert('号源ID无效');
+          ElMessage.error('号源ID无效');
          return;
        }
        if (!appointmentData.patientId) {
-          alert('患者ID无效');
+          ElMessage.error('患者ID无效');
          return;
        }
-        
+        // 调用真实API进行预约
        console.log('Sending appointment data to backend:', appointmentData);
        bookTicket(appointmentData).then(response => {        
          const ticketIndex = this.tickets.findIndex(t => t.slot_id === this.currentTicket.slot_id);
          if (ticketIndex !== -1) {
@@ -702,22 +683,25 @@ export default {
            this.tickets[ticketIndex].patientName = this.selectedPatient.name;
            this.tickets[ticketIndex].patientId = this.selectedPatient.medicalCard;
            this.tickets[ticketIndex].patientGender = this.selectedPatient.gender;
            // 更新医生号源列表中的余号数量
            this.updateDoctorsList();
          }
          this.closePatientSelectModal();
-          alert('预约成功，号源已锁定。患者到院签到时需缴费取号。');
+          
          // 重新加载号源数据，确保显示最新状态
          this.onSearch();
          ElMessage.success('预约成功，号源已锁定。患者到院签到时需缴费取号。');
        }).catch(error => {
-          console.error('预约失败:', error);
+          ElMessage.error('预约失败，请稍后重试。');
          alert('预约失败，请稍后重试。');
        });
      } catch (error) {
-        console.error('预约数据处理错误:', error);
+        ElMessage.error('预约信息格式错误，请重新操作。');
        alert('预约信息格式错误，请重新操作。');
      }
    },
    onDateChange() {
      // 日期变化时刷新号源列表
      console.log('Date changed:', this.selectedDate)
      // 重置页码并重新加载数据
      this.currentPage = 1;
      this.onSearch()
@@ -732,15 +716,6 @@ export default {
    },
    onSearch() {
      this.isLoading = true      
      console.log('Searching with:', {
        date: this.selectedDate,
        status: this.selectedStatus,
        type: this.selectedType,
        name: this.patientName,
        card: this.patientCard,
        phone: this.patientPhone
      });
      // 调用真实API获取号源数据
      const queryParams = {
        date: this.selectedDate,
@@ -749,7 +724,7 @@ export default {
        name: this.patientName,
        card: this.patientCard,
        phone: this.patientPhone,
-        page: 1,
+        page: this.currentPage,
        limit: this.pageSize
      };
@@ -758,9 +733,6 @@ export default {
        listAllTickets(), // 使用测试接口获取固定的5条专家号数据
        listDept()
      ]).then(([ticketResponse, deptResponse]) => {       
        // 打印完整的响应数据以便调试
        console.log('完整的号源响应数据:', ticketResponse);
        // 处理号源数据
        if (ticketResponse) {
          // 检查是否有data.list字段（后端返回的数据结构是{code, data:{list, total}}）
@@ -775,6 +747,10 @@ export default {
          // 保存所有原始数据
          this.allTickets = [...this.tickets];
          // 根据患者信息进行前端筛选
          this.filterTicketsByPatientInfo();
          // 更新医生列表
          this.updateDoctorsList();
          this.hasMore = this.tickets.length < this.totalTickets;
@@ -787,7 +763,6 @@ export default {
        // 处理科室数据
        this.updateDepartmentsListFromApi(deptResponse);        
        this.isLoading = false;
      }).catch(error => {
        console.error('获取数据失败:', error);
@@ -799,8 +774,6 @@ export default {
        this.isLoading = false;
      });
    },    
    // 从号源数据中更新科室列表（备用方法）
    updateDepartmentsList() {
      const departmentSet = new Set();
@@ -855,6 +828,25 @@ export default {
      }
    },
    // 根据患者信息过滤号源
    filterTicketsByPatientInfo() {
      // 如果没有输入患者信息，就不进行过滤
      if (!this.patientName && !this.patientCard && !this.patientPhone) {
        return;
      }
      // 根据患者信息进行过滤（使用AND逻辑，全部匹配）
      this.tickets = this.tickets.filter(ticket => {
        const matchesName = !this.patientName || ticket.patientName?.includes(this.patientName);
        const matchesCard = !this.patientCard || ticket.patientId?.includes(this.patientCard);
        const matchesPhone = !this.patientPhone || ticket.phone?.includes(this.patientPhone);
        return matchesName && matchesCard && matchesPhone;
      });
      console.log('按患者信息过滤后的号源数量:', this.tickets.length);
    },
    // 获取号源状态文本
    getStatusText(status) {
      switch (status) {
@@ -902,9 +894,6 @@ export default {
      // 转换为数组
      this.doctors = Array.from(doctorMap.values());      
      // 打印医生列表以便调试
      console.log('生成的医生列表:', this.doctors);
    },
    // 加载更多数据
    loadMore() {
@@ -927,9 +916,6 @@ export default {
      };
      listTicket(queryParams).then(response => {        
        // 打印完整的响应数据以便调试
        console.log('加载更多的号源响应数据:', response);
        // 处理号源数据
        if (response) {
          let newRecords = [];
@@ -1461,6 +1447,15 @@ export default {
  align-items: center;
 }
 .ticket-index {
  position: absolute;
  top: 12px;
  left: 12px;
  color: #1890ff;
  font-size: 14px;
  font-weight: bold;
 }
 .ticket-time {
  font-size: 14px;
  color: #333;
@@ -1514,6 +1509,13 @@ export default {
  white-space: nowrap;
 }
 .ticket-id-time {
  font-size: 14px;
  color: #333;
  margin-bottom: 8px;
  text-align: center;
 }
 .ticket-fee {
  font-size: 14px;
  color: #333;
@@ -1548,50 +1550,6 @@ export default {
      cursor: not-allowed;
    }
    .cancel-button {
      background-color: #F56C6C;
      color: white;
      border: none;
      border-radius: 4px;
      padding: 4px 12px;
      cursor: pointer;
      font-size: 14px;
      transition: background-color 0.3s;
      margin-top: 8px;
      align-self: center;
    }
    .cancel-button:hover {
      background-color: #F78989;
    }
    .cancel-button:disabled {
      background-color: #C0C4CC;
      cursor: not-allowed;
    }
    .check-in-button {
      background-color: #67C23A;
      color: white;
      border: none;
      border-radius: 4px;
      padding: 4px 12px;
      cursor: pointer;
      font-size: 14px;
      transition: background-color 0.3s;
      margin-top: 8px;
      align-self: center;
    }
    .check-in-button:hover {
      background-color: #85ce61;
    }
    .check-in-button:disabled {
      background-color: #C0C4CC;
      cursor: not-allowed;
    }
 /* 患者信息样式 */
 .ticket-patient {
  margin-top: 8px;
@@ -1603,6 +1561,18 @@ export default {
  color: #333;
 }
 /* 患者电话号码样式 */
 .ticket-phone {
  margin-top: 4px;
  padding: 4px;
  background-color: rgba(34, 177, 76, 0.05);
  border-radius: 4px;
  font-size: 12px;
  text-align: center;
  color: #22b14c;
  font-weight: 500;
 }
 /* 响应式设计 */
@media (max-width: 768px) {
  .ticket-grid {
@@ -1618,6 +1588,14 @@ export default {
  .ticket-doctor {
    font-size: 13px;
  }
  .ticket-id-time {
    font-size: 13px;
  }
  .ticket-index {
    font-size: 13px;
  }
 }
 /* 弹窗样式 */
@@ -1803,6 +1781,54 @@ export default {
  box-shadow: none;
 }
 /* 搜索提示样式 */
 .search-hint {
  text-align: center;
  color: #999;
  font-size: 14px;
  padding: 20px;
  background-color: #fafafa;
  border-radius: 4px;
  margin: 10px 0;
 }
 /* 加载指示器样式 */
 .loading-indicator {
  text-align: center;
  color: #666;
  font-size: 14px;
  padding: 20px;
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 8px;
 }
 .loading-spinner {
  width: 16px;
  height: 16px;
  border: 2px solid #f3f3f3;
  border-top: 2px solid #1890ff;
  border-radius: 50%;
  animation: spin 1s linear infinite;
 }
@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
 }
 .no-results {
  text-align: center;
  color: #666;
  font-size: 14px;
  padding: 20px;
  background-color: #fff2f0;
  border: 1px solid #ffccc7;
  border-radius: 4px;
  margin: 10px 0;
 }
 /* 右键菜单样式 */
 .context-menu {
  position: fixed;
@@ -1842,4 +1868,60 @@ export default {
  opacity: 0.7;
  cursor: not-allowed;
 }
 /* 分页组件样式 */
 .pagination-container {
  display: flex;
  justify-content: center;
  margin-top: 20px;
  padding: 20px 0;
  background-color: #fafafa;
  border-radius: 4px;
 }
 .pagination-container .el-pagination {
  font-size: 14px;
 }
 .pagination-container .el-pagination .el-pager li {
  min-width: 36px;
  height: 36px;
  line-height: 36px;
  border-radius: 4px;
  margin: 0 2px;
 }
 .pagination-container .el-pagination .el-pager li:hover {
  background-color: #e6f7ff;
  color: #1890ff;
 }
 .pagination-container .el-pagination .el-pager li.active {
  background-color: #1890ff;
  color: white;
 }
 .pagination-container .el-pagination .btn-prev,
 .pagination-container .el-pagination .btn-next {
  width: 36px;
  height: 36px;
  border-radius: 4px;
  margin: 0 2px;
 }
 .pagination-container .el-pagination .el-pagination__sizes {
  margin-right: 10px;
 }
 .pagination-container .el-pagination .el-pagination__sizes .el-input {
  width: 100px;
 }
 .pagination-container .el-pagination .el-pagination__jump {
  margin-left: 10px;
 }
 .pagination-container .el-pagination .el-pagination__jump .el-input {
  width: 60px;
 }
 </style>
--- a/openhis-ui-vue3/src/views/appoinmentmanage/ticketManage.vue
+++ b/openhis-ui-vue3/src/views/appoinmentmanage/ticketManage.vue
--- a/openhis-ui-vue3/src/views/basicmanage/implementDepartment/index.vue
+++ b/openhis-ui-vue3/src/views/basicmanage/implementDepartment/index.vue
@@ -81,15 +81,15 @@
                v-model="scope.row.activityDefinitionId"
                filterable
                remote
-                reserve-keyword
+                :remote-method="(query) => handleRemoteQuery(query, scope.row)"
-                placeholder="请选择"
+                :loading="scope.row.loading"
-                remote-show-suffix
+                placeholder="请输入并搜索项目"
                style="width: 400px; max-width: 500px"
                :class="{ 'error-border': scope.row.error }"
                clearable
              >
                <el-option
-                  v-for="item in allImplementDepartmentList"
+                  v-for="item in scope.row.filteredOptions || []"
                  :key="item.value"
                  :label="item.label"
                  :value="item.value"
@@ -236,15 +236,34 @@ const filterNode = (value, data) => {
 };
 // 所有诊疗项目列表
 const allImplementDepartmentList = ref([]);
-function getAllImplementDepartment() {
+async function getAllImplementDepartment() {
  loading.value = true;
-  getAllTreatmentList().then((res) => {
+  try {
    const res = await getAllTreatmentList();
    allImplementDepartmentList.value = res.data.map((item) => ({
      value: item.activityDefinitionId,
      label: item.activityDefinitionName,
    }));
    // 为所有现有行初始化过滤选项（使用防抖处理，避免频繁更新）
    if (catagoryList.value && catagoryList.value.length > 0) {
      // 使用 setTimeout 将 DOM 更新推迟到下一个事件循环，避免阻塞
      setTimeout(() => {
        catagoryList.value.forEach(row => {
          if (!row.hasOwnProperty('filteredOptions')) {
            row.filteredOptions = allImplementDepartmentList.value.slice(0, 100); // 限制为前100个
            row.loading = false;
          }
        });
      }, 0);
    }
    loading.value = false;
-  });
+  } catch (error) {
    console.error('获取诊疗项目列表失败:', error);
    loading.value = false;
    proxy.$message.error('获取诊疗项目列表失败');
  }
 }
 /** 选择条数  */
@@ -253,18 +272,63 @@ function handleSelectionChange(selection) {
  single.value = selection.length != 1;
  multiple.value = !selection.length;
 }
 // 远程搜索处理函数
 function handleRemoteQuery(query, row) {
  if (query !== '') {
    // 设置加载状态
    row.loading = true;
    // 模拟异步延迟
    setTimeout(() => {
      // 确保数据已加载
      if (!allImplementDepartmentList.value || allImplementDepartmentList.value.length === 0) {
        row.filteredOptions = [];
        row.loading = false;
        return;
      }
      // 过滤选项，限制结果数量以提高性能
      const filtered = allImplementDepartmentList.value.filter(item => {
        return item.label.toLowerCase().includes(query.toLowerCase()) ||
               item.value.toLowerCase().includes(query.toLowerCase());
      });
      // 限制返回结果数量，避免过多选项导致性能问题
      row.filteredOptions = filtered.slice(0, 100); // 限制为前100个匹配项
      row.loading = false;
    }, 300); // 300ms 延迟，模拟网络请求
  } else {
    // 如果查询为空，显示所有选项（但限制数量以提高性能）
    if (allImplementDepartmentList.value && allImplementDepartmentList.value.length > 0) {
      row.filteredOptions = allImplementDepartmentList.value.slice(0, 100); // 限制为前100个
    } else {
      row.filteredOptions = [];
    }
  }
 }
 // 新增项目
 function handleAddItem() {
  if (data.isAdding) {
    proxy.$message.warning('请先保存当前行后再新增！');
    return;
  }
  // 确保 allImplementDepartmentList 已经初始化
  if (!allImplementDepartmentList.value || allImplementDepartmentList.value.length === 0) {
    proxy.$message.warning('正在加载数据，请稍后再试！');
    // 如果数据还未加载完成，尝试重新加载
    getAllImplementDepartment();
    return;
  }
  const newRow = {
    startTime: '00:00:00',
    endTime: '23:59:59',
    loading: false, // 添加加载状态
    filteredOptions: allImplementDepartmentList.value.slice(0, 100), // 初始化过滤选项，限制数量
  };
  catagoryList.value.push(newRow);
-  total.value = organization.value.length;
+  total.value = catagoryList.value.length; // 修正：使用实际数据列表长度，而不是组织结构长度
  data.isAdding = true; // 设置标志位为 true，表示有未保存的
 }
 // 批量添加
@@ -272,6 +336,7 @@ function handleBacthAddItem() {
  // 批量添加显示对话框
  bacthAddItemDialogVisible.value = true;
 }
 // 检验 编辑或 保存数据
 function handleBlur(row, index) {
  let hasError = false;
@@ -344,15 +409,25 @@ function deleteSelectedRows(row) {
 }
 /** 节点单击事件 */
 function handleNodeClick(res, node) {
-  // 新增按钮是否 disable
+  // 检查是否有未保存的数据
-  data.isAdding = false;
+  if (data.isAdding) {
-
+    proxy.$modal.confirm('当前有未保存的数据，切换节点将丢失未保存的数据，是否继续？').then(() => {
-  // 新增按钮是否 disable
+      // 确认切换，重置状态
-  if (node.parent === null || node.level === 1) {
+      data.isAdding = false;
-    isAddDisable.value = true;
+      continueHandleNodeClick(node);
    }).catch(() => {
      // 取消切换，保持当前状态
      return;
    });
  } else {
-    isAddDisable.value = false;
+    continueHandleNodeClick(node);
  }
 }
 // 实际的节点点击处理逻辑
 function continueHandleNodeClick(node) {
  // 新增按钮是否 disable
  isAddDisable.value = false;
  // 检查节点是否有子节点
  if (node.data.children && node.data.children.length > 0) {
    // proxy.$message.warning("不能选择父节点");
@@ -365,26 +440,28 @@ function handleNodeClick(res, node) {
 }
 /** 目录分类查询 */
-function getDiseaseTreatmentList() {
+async function getDiseaseTreatmentList() {
  loading.value = true;
-  getDiseaseTreatmentInit().then(({ data }) => {
+  try {
-    loading.value = false;
+    const { data } = await getDiseaseTreatmentInit();
-    //分类目录初始化获取
+    // 分类目录初始化获取
    catagoryDicts.value = data.diagnosisCategoryOptions.sort((a, b) => {
      return parseInt(a.value) - parseInt(b.value);
    });
-  });
+  } catch (error) {
-  // 诊疗目录分类查询下拉树结d构
+    console.error('获取疾病治疗初始化数据失败:', error);
-  loading.value = true;
+    proxy.$message.error('获取分类目录失败');
-  // 诊疗目录分类查询下拉树结d构
+  }
-  getImplDepartList();
+
  // 诊疗目录分类查询下拉树结构
  await getImplDepartList();
  loading.value = false;
 }
 // 诊疗目录分类查询下拉树结d构
-function getImplDepartList() {
+async function getImplDepartList() {
-  loading.value = true;
+  try {
-  getImplementDepartmentList().then((res) => {
+    const res = await getImplementDepartmentList();
    loading.value = false;
    if (res.code === 200) {
      if (res.data.records.length > 0) {
        organization.value = res.data.records.map((res) => {
@@ -398,13 +475,24 @@ function getImplDepartList() {
        organization.value = [];
      }
    } else {
-      this.$modal.msgError(res.code);
+      proxy.$modal.msgError(res.code);
    }
-  });
+  } catch (error) {
    console.error('获取实施部门列表失败:', error);
    proxy.$message.error('获取科室信息失败');
  }
 }
-onMounted(() => {
+onMounted(async () => {
-  getAllImplementDepartment();
+  try {
-  getDiseaseTreatmentList();
+    // 并行加载数据，提高效率
    await Promise.all([
      getAllImplementDepartment(),
      getDiseaseTreatmentList()
    ]);
  } catch (error) {
    console.error('初始化数据加载失败:', error);
    proxy.$message.error('数据加载失败，请稍后重试');
  }
 });
 </script>
 <style scoped>
--- a/openhis-ui-vue3/src/views/basicmanage/organization/index.vue
+++ b/openhis-ui-vue3/src/views/basicmanage/organization/index.vue
@@ -400,7 +400,15 @@ function resetQuery() {
 function getPageList() {
  loading.value = true;
-  getList(queryParams.value).then((res) => {
+  // 创建API调用的查询参数副本，处理classEnum的转换
  const apiParams = { ...queryParams.value };
  if (Array.isArray(apiParams.classEnum)) {
    apiParams.classEnum =
      apiParams.classEnum.length > 0
        ? apiParams.classEnum.join(',')
        : undefined;
  }
  getList(apiParams).then((res) => {
    // 处理返回的科室数据，确保科室分类显示与系统标准字典一致
    const processedData = res.data.records.map(item => {
      // 保留原有显示文本作为基础
--- a/openhis-ui-vue3/src/views/basicmanage/pharmacyDepartment/index.vue
+++ b/openhis-ui-vue3/src/views/basicmanage/pharmacyDepartment/index.vue
@@ -44,6 +44,7 @@
            align="center"
            key="name"
            prop="name"
            width="300"
            :show-overflow-tooltip="true"
          >
            <template #default="scope">
@@ -51,8 +52,10 @@
                <el-select
                  v-model="scope.row.organizationId"
                  placeholder="请选择"
                  :class="{ 'error-border': scope.row.error }"
                  clearable
                  style="width: 200px"
                  :class="{ 'error-border': scope.row.error }"
                  filterable
                >
                  <el-option
                    v-for="item in departmentOptions"
--- a/openhis-ui-vue3/src/views/basicmanage/ward/index.vue
+++ b/openhis-ui-vue3/src/views/basicmanage/ward/index.vue
@@ -582,7 +582,7 @@ function submitForm() {
  console.log('params11========>', JSON.stringify(params));
  orgRef.value.validate((valid) => {
    if (valid) {
-      console.log('99999999');
+      console.log('表单验证通过，准备提交数据');
      if (form.busNoParent) {
        if (form.formEnum == 4) {
--- a/openhis-ui-vue3/src/views/catalog/diagnosistreatment/index.vue
+++ b/openhis-ui-vue3/src/views/catalog/diagnosistreatment/index.vue
@@ -183,6 +183,23 @@
            prop="statusEnum_enumText"
            :show-overflow-tooltip="true"
          />
          <el-table-column
            label="划价标记"
            align="center"
            key="pricingFlag_enumText"
            prop="pricingFlag_enumText"
            :show-overflow-tooltip="true"
            width="100"
          >
            <template #default="scope">
              <el-tag
                :type="scope.row.pricingFlag === 1 ? 'success' : scope.row.pricingFlag === 0 ? 'danger' : 'info'"
                size="small"
              >
                {{ scope.row.pricingFlag_enumText || (scope.row.pricingFlag === 1 ? '允许' : scope.row.pricingFlag === 0 ? '不允许' : '未设置') }}
              </el-tag>
            </template>
          </el-table-column>
          <el-table-column
            label="操作"
            align="center"
--- a/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/adviceBaseList.vue
+++ b/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/adviceBaseList.vue
@@ -8,6 +8,7 @@
      @current-change="handleCurrentChange"
      row-key="patientId"
      @cell-click="clickRow"
      @row-click="clickRow"
    >
      <el-table-column label="名称" align="center" prop="adviceName" />
      <el-table-column label="类型" align="center" prop="activityType_enumText" />
@@ -38,6 +39,10 @@ const props = defineProps({
    type: Object,
    required: true,
  },
  popoverVisible: {
    type: Boolean,
    default: false,
  },
 });
 const emit = defineEmits(['selectAdviceBase']);
 const total = ref(0);
@@ -61,30 +66,80 @@ const throttledGetList = throttle(
 watch(
  () => props.adviceQueryParams,
  (newValue) => {
-    queryParams.value.searchKey = newValue.searchKey;
+    // 只有在弹窗打开时才响应 adviceQueryParams 的变化，避免选择项目后弹窗关闭时触发不必要的请求
-    queryParams.value.adviceType = newValue.adviceType;
+    if (!props.popoverVisible) {
      return;
    }
    queryParams.value.searchKey = newValue?.searchKey;
    queryParams.value.adviceType = newValue?.adviceType;
    throttledGetList();
  },
  { deep: true }
 );
-getList();
+// 监听弹窗打开状态，当弹窗打开时主动加载数据
 watch(
  () => props.popoverVisible,
  (visible) => {
    if (visible) {
      // 弹窗打开时，确保 adviceQueryParams 同步到 queryParams
      if (props.adviceQueryParams) {
        queryParams.value.searchKey = props.adviceQueryParams.searchKey;
        queryParams.value.adviceType = props.adviceQueryParams.adviceType;
      }
      // 主动触发数据加载
      getList();
    } else {
      // 弹窗关闭时，清空列表数据，避免显示错误的数据
      adviceBaseList.value = [];
      total.value = 0;
    }
  }
 );
 // 移除组件初始化时的 getList() 调用，避免在没有 adviceType 时查询所有类型的数据
 // getList();
 function getList() {
  // 验证是否已选择患者
  if (!props.patientInfo || Object.keys(props.patientInfo).length === 0) {
    console.log('[adviceBaseList] getList() 跳过：未选择患者');
    return; // 不执行API调用
  }
  // 只有在弹窗打开时才执行查询
  if (!props.popoverVisible) {
    console.log('[adviceBaseList] getList() 跳过：弹窗未打开');
    return;
  }
  // 必须有 adviceType 才查询，避免查询所有类型的数据
  if (!queryParams.value.adviceType) {
    console.log('[adviceBaseList] getList() 跳过：adviceType 未设置，当前值:', queryParams.value.adviceType);
    return;
  }
  queryParams.value.organizationId = props.patientInfo.orgId;
  console.log('[adviceBaseList] getList() 请求参数:', JSON.stringify(queryParams.value));
  getAdviceBaseInfo(queryParams.value).then((res) => {
-    adviceBaseList.value = res.data.records;
+    console.log('[adviceBaseList] getList() 响应数据:', {
-    total.value = res.data.total;
+      total: res.data?.total,
      recordsCount: res.data?.records?.length || 0,
      firstRecord: res.data?.records?.[0]?.adviceName || '无数据',
      adviceType: queryParams.value.adviceType
    });
    adviceBaseList.value = res.data.records || [];
    total.value = res.data.total || 0;
    nextTick(() => {
      currentIndex.value = 0;
      if (adviceBaseList.value.length > 0) {
-        adviceBaseRef.value.setCurrentRow(adviceBaseList.value[0]);
+        adviceBaseRef.value?.setCurrentRow(adviceBaseList.value[0]);
      }
    });
  }).catch((err) => {
    console.error('[adviceBaseList] getList() 请求失败:', err);
    adviceBaseList.value = [];
    total.value = 0;
  });
 }
@@ -136,8 +191,12 @@ const handleCurrentChange = (currentRow) => {
  currentSelectRow.value = currentRow;
 };
-function clickRow(row) {
+function clickRow(row, column, cell, event) {
-  emit('selectAdviceBase', row);
+  // cell-click 事件会传递 row, column, cell, event 四个参数
  // 确保传递的是完整的行数据
  if (row) {
    emit('selectAdviceBase', row);
  }
 }
 defineExpose({
--- a/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/prescriptionlist.vue
+++ b/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/prescriptionlist.vue
@@ -301,6 +301,7 @@ const nextId = ref(1);
 const unitCodeList = ref([]);
 const adviceTableRef = ref([]);
 const organization = ref([]);
 const orgTreeLoaded = ref(false);
 const rowRules = ref({
  conditionDefinitionId: [{ required: true, message: '请选择诊断', trigger: 'change' }],
  dose: [{ required: true, message: '请输入单次剂量', trigger: 'change' }],
@@ -449,6 +450,10 @@ function handleDiagnosisChange(item, row) {
 function handleFocus(row, index) {
  rowIndex.value = index;
  // 打开当前行弹窗前，先关闭其它行，避免多个弹窗同时存在
  prescriptionList.value.forEach((r, i) => {
    if (i !== index) r.showPopover = false;
  });
  // 如果当前行已选择adviceType，同步到adviceQueryParams
  if (row.adviceType !== undefined) {
    adviceQueryParams.value.adviceType = row.adviceType;
@@ -457,7 +462,9 @@ function handleFocus(row, index) {
 }
 function handleBlur(row) {
-  row.showPopover = false;
+  // 不能在 input blur 时立刻关闭弹窗：
  // 点击弹窗里的表格会先触发 blur，导致弹窗瞬间关闭，从而“点了项目没反应”
  // 弹窗关闭交给 selectAdviceBase()（选中后关闭）以及 handleFocus()（切行时关闭其他行）
 }
 function handleChange(value) {
@@ -465,10 +472,37 @@ function handleChange(value) {
 }
 /**
- * 选择药品回调
+ * 选择药品/诊疗项目回调
 * 这里恢复为之前“能正常工作”的简单逻辑，只做最小必要的修正
 */
 function selectAdviceBase(key, row) {
-  getOrgList();
+  if (!row) {
    console.error('[selectAdviceBase] row 为空');
    return;
  }
  // rowIndex 理论上由 handleFocus 设置；防御一下越界
  if (rowIndex.value < 0 || rowIndex.value >= prescriptionList.value.length) {
    const foundIndex = prescriptionList.value.findIndex((item) => item.uniqueKey === key);
    if (foundIndex === -1) {
      console.error('[selectAdviceBase] 找不到对应行，key =', key);
      return;
    }
    rowIndex.value = foundIndex;
  }
  // 关闭当前行弹窗
  const currentRow = prescriptionList.value[rowIndex.value];
  if (currentRow) {
    currentRow.showPopover = false;
  }
  // 诊疗(adviceType=3) 才需要加载执行科室树，且只加载一次
  if (row.adviceType === 3) {
    ensureOrgTreeLoaded();
  }
  // 构建单位列表（保持原有逻辑）
  unitCodeList.value = [];
  unitCodeList.value.push({ value: row.unitCode, label: row.unitCode_dictText, type: 'unit' });
  if (row.doseUnitCode != row.minUnitCode) {
@@ -488,10 +522,14 @@ function selectAdviceBase(key, row) {
      type: 'minUnit',
    });
  }
  // 将选中的基础项“覆盖”到当前处方行（这是之前正常工作的核心逻辑）
  prescriptionList.value[rowIndex.value] = {
    ...prescriptionList.value[rowIndex.value],
    ...JSON.parse(JSON.stringify(row)),
  };
  // 后续字段处理保持原样
  prescriptionList.value[rowIndex.value].orgId = undefined;
  prescriptionList.value[rowIndex.value].dose = undefined;
  prescriptionList.value[rowIndex.value].unitCodeList = unitCodeList.value;
@@ -500,12 +538,11 @@ function selectAdviceBase(key, row) {
  prescriptionList.value[rowIndex.value].minUnitCode = JSON.parse(JSON.stringify(row.doseUnitCode));
  prescriptionList.value[rowIndex.value].unitCode =
    row.partAttributeEnum == 1 ? row.minUnitCode : row.unitCode;
  // prescriptionList.value[rowIndex.value].doseUnitCode_dictText = row.minUnitCode_dictText;
  prescriptionList.value[rowIndex.value].definitionId = JSON.parse(
    JSON.stringify(row)
  ).chargeItemDefinitionId;
-  // 库存列表 + 价格列表拼成批次号的下拉框
+  // 库存列表 + 价格列表拼成批次号的下拉框（非诊疗）
  if (row.adviceType != 3) {
    if (row.inventoryList && row.inventoryList.length == 0) {
      expandOrder.value = [];
@@ -532,9 +569,15 @@ function selectAdviceBase(key, row) {
      prescriptionList.value[rowIndex.value].positionName = stock.locationName;
    }
  } else {
    // 诊疗：设置执行科室和价格
    prescriptionList.value[rowIndex.value].orgId = JSON.parse(JSON.stringify(row)).positionId;
-    prescriptionList.value[rowIndex.value].unitPrice = row.priceList[0].price;
+    if (row.priceList && row.priceList.length > 0) {
      prescriptionList.value[rowIndex.value].unitPrice = row.priceList[0].price;
    } else {
      prescriptionList.value[rowIndex.value].unitPrice = 0;
    }
  }
  expandOrder.value = [key];
  nextTick(() => {
    if (row.adviceType == 1) {
@@ -549,11 +592,18 @@ function selectAdviceBase(key, row) {
  });
 }
-function getOrgList() {
+function ensureOrgTreeLoaded() {
-  getOrgTree().then((res) => {
+  if (orgTreeLoaded.value) return;
-    organization.value = res.data.records;
+  orgTreeLoaded.value = true;
-    console.log(organization.value,"organization.value")
+  getOrgTree()
-  });
+    .then((res) => {
      // 组织机构树接口通常返回分页 records，这里做兼容兜底
      organization.value = res?.data?.records ?? res?.data ?? [];
    })
    .catch(() => {
      // 加载失败时允许重试
      orgTreeLoaded.value = false;
    });
 }
 function handleDelete() {
@@ -706,6 +756,8 @@ function handleSaveSign(row, index) {
      row.contentJson = JSON.stringify(row);
      row.dbOpType = row.requestId ? '2' : '1';
      row.minUnitQuantity = row.quantity * row.partPercent;
      row.categoryEnum = row.adviceType
      console.log('row', row)
      savePrescription({ adviceSaveList: [row] }).then((res) => {
        if (res.code === 200) {
          proxy.$modal.msgSuccess('保存成功');
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
wangjian963	55e3533600	Merge remote-tracking branch 'origin/develop' into develop	2026-01-23 17:11:51 +08:00
wangjian963	1522183432	门诊管理-》门诊划价：新增耗材点击【保存】报错的问题（设置租户id，创建者，创建时间）	2026-01-23 17:08:29 +08:00
chenxianjing	6382741b71	上传文件至 md/需求	2026-01-23 16:49:43 +08:00
chenqi	16c854d55f	feat(router): 添加基础管理和发票管理路由配置 - 新增基础管理模块路由配置，包含发票管理子页面 - 配置动态路由中的发票管理组件路径 - 移除监控模块的路由配置 - 修复路由数组结构，移除多余的逗号	2026-01-23 16:17:00 +08:00
chenqi	73617e1b0f	Merge remote-tracking branch 'origin/develop' into develop	2026-01-23 16:13:57 +08:00
chenqi	abd5bd9f2f	feat(system): 添加菜单显示状态控制功能并完善租户ID设置 - 在MetaVo中添加visible字段用于控制菜单显示状态 - 修改SysMenuServiceImpl中的路由构建逻辑，传递visible信息到前端 - 更新SidebarItem.vue组件，根据visible属性控制菜单项显示 - 在多个医嘱管理相关服务类中显式设置租户ID以确保多租户隔离 - 调整字典管理相关路由配置，优化页面跳转路径 - 在菜单管理界面添加显示状态查询和表格列展示功能	2026-01-23 16:12:56 +08:00
HuangShun	9000d66c0c	修复107 系统管理-》基础数据-》科室管理：科室分类筛选条件无效中搜索条件清空问题	2026-01-23 14:06:07 +08:00
huhuihua	61be9ff552	46 门诊医生站-》开立诊断：优化修改数据库中一些字段不能为null	2026-01-23 13:58:33 +08:00
huhuihua	9408cf6c2d	Merge branch 'develop' of https://gitea.gentronhealth.com/wangyizhe/his into develop	2026-01-23 13:58:25 +08:00
HuangShun	66c70a2b4a	修复103 门诊医生站-》药品医嘱开立内容重复/【确认】无响应	2026-01-23 13:28:17 +08:00
nanyangbreeze	f6d9321f95	代码回滚	2026-01-23 11:08:54 +08:00
chenqi	ccff9a7246	fix(hospitalizationEmr): 解决病历模板切换时数据显示残留问题 - 在切换模板前重置表单数据，避免显示之前的数据 - 先清空当前组件再设置新组件，确保组件完全重新渲染 - 使用 nextTick 确保 DOM 更新后再设置新组件 - 添加 JSON 解析异常处理，解析失败时清空组件数据 - 当没有历史记录或加载出错时清空表单数据 - 患者信息变化时重置当前组件和表单数据 - 没有患者信息时也重置组件和表单数据	2026-01-22 22:36:54 +08:00
chenqi	2884f610f5	refactor(pharmacy): 激活药品仓库各类订单的供应分类选项 - 激活损益订单中的通用损益、盘点损益和制剂消耗分类选项 - 更新采购订单中的库存供应和非库存供应分类选项 - 激活退货订单中的普通分类选项 - 激活退仓订单中的普通分类选项 - 激活入库订单中的外购药品、自制药品、代销药品、其他药品和赠送药品入库分类选项 - 激活出库订单中的院内出库、院外出库和其他出库分类选项 - 激活盘点订单中的普通盘点和月度盘点分类选项 - 在枚举类中启用所有被注释的供应分类并完善文档注释	2026-01-22 22:24:22 +08:00
wangjian963	035738f990	修改库房管理-》采购管理-》采购入库：仓库字段值为中心耗材库在采购管理未显示的问题，修改了采购入库仓库字段值的布局样式，修改了在批量保存入库业务中添加申请人等核心数据数据，修改了获取入库数据的查询SQL语句。	2026-01-22 19:38:58 +08:00
sindir	d0c6f57f6b	解决了无法接诊的问题	2026-01-22 16:37:20 +08:00
huhuihua	58c1e02415	Merge branch 'develop' of https://gitea.gentronhealth.com/wangyizhe/his into develop	2026-01-22 15:58:55 +08:00
huhuihua	1e459b8883	46 门诊医生站-》开立诊断：优化	2026-01-22 15:51:37 +08:00
huabuweixin	0d57e984a6	76 门诊预约挂号	2026-01-22 15:09:52 +08:00
chenxianjing	4450e3cc50	上传文件至 md/需求	2026-01-22 15:08:57 +08:00
wangjian963	902ee0587e	修改新增耗材“一次性静脉采血器” 点击保存categoryEnum为空值的问题。	2026-01-22 14:13:10 +08:00
nanyangbreeze	49550fcc2e	诊疗下面没有诊疗项目	2026-01-22 14:03:38 +08:00
sindir	1dd7ee3428	90，分诊排队管理-》医生叫号界面	2026-01-22 12:14:01 +08:00
wangjian963	8dff5d466a	Merge remote-tracking branch 'origin/develop' into develop	2026-01-22 09:22:22 +08:00
wangjian963	19ada4ace9	移除调用字典接口功能	2026-01-22 09:20:35 +08:00
chenqi	c92ff38133	Merge remote-tracking branch 'origin/develop' into develop	2026-01-21 17:50:58 +08:00
chenqi	1c07108e58	refactor(PatientList): 重构患者列表卡片布局结构 - 将原有的 header-top 和 header-bottom 结构替换为 info-row 统一布局 - 新增姓名、性别年龄、房间床号、住院号、保险类型等独立信息行 - 使用 el-text 组件优化姓名显示效果 - 为性别标签添加女性样式标识 - 调整床位信息展示方式，支持溢出省略 - 修改溢出属性从 hidden 为 visible 确保内容正常显示 - 优化标签样式和间距布局 - 隐藏已废弃的旧布局元素 - 调整 pending 患者列表的换行和对齐方式	2026-01-21 17:50:51 +08:00
weixin_45799331	34dd969cb4	门诊医生站-》医嘱：诊疗开具医嘱点击项目选择下拉框，获取时间过慢40多秒，解决了之后正常情况获取4秒	2026-01-21 17:27:28 +08:00
chenqi	a0b546266d	fix(mapper): 修复患者主信息查询的重复数据问题 - 在 getRegPatientMainInfo 查询中添加 DISTINCT ON 子句按 patient_id 去重 - 为分页功能添加 getRegPatientMainInfoCount 计数查询 - 修复 SQL 拼接条件的语法错误，将 ${ew.customSqlSegment} 替换为标准的动态 SQL 标签 - 调整字典标签查询逻辑，先查询指定表再回退到默认字典缓存 - 优化查询性能，避免不必要的数据重复和错误的 SQL 语法 - 添加缺失的 ORDER BY 子句确保查询结果的一致性	2026-01-21 16:22:05 +08:00
wangjian963	fc9ce6241e	Merge remote-tracking branch 'origin/develop' into develop	2026-01-21 13:38:23 +08:00
wangjian963	5187ff1ae3	添加申请单表单患者信息自动填充姓名、就诊卡号、费用性质,以及申请医生和申请科室的输入框格式，依据申请单和申请单明细表字段修改表单变量名。	2026-01-21 13:34:31 +08:00
huabuweixin	73b1d01044	修复 104 系统管理-》业务规则配置-》取药科室配置：开立科室字段内容显示不全	2026-01-21 10:02:04 +08:00
huabuweixin	b88ad89146	修复 107 系统管理-》基础数据-》科室管理：科室分类筛选条件无效	2026-01-20 18:02:41 +08:00
huabuweixin	de8039c513	Merge branch 'develop' of https://gitea.gentronhealth.com/wangyizhe/his into develop	2026-01-20 18:01:46 +08:00
chenqi	3464153d93	Merge remote-tracking branch 'origin/develop' into develop	2026-01-20 17:31:07 +08:00
chenqi	6b868e378f	feat(router): 添加新功能模块路由配置 - 添加套餐管理相关路由到公共路由，确保始终可用 - 新增基础管理模块，包含发票管理功能 - 添加系统监控模块，包含操作日志、登录日志、定时任务功能 - 新增系统工具模块，包含代码生成功能 - 扩展系统管理模块，增加租户用户、合同管理、用户角色授权等功能 - 添加字典数据、任务日志、代码生成编辑等隐藏路由 - 统一修复代码格式，调整对象属性间的空格格式 - 完善路由元信息配置，添加权限控制和图标支持	2026-01-20 17:30:42 +08:00
玉狻猊	f6403fa059	Fix 禅道 108 系统管理-》业务规则配置-》执行科室配置：【添加新项目】按钮无法操作	2026-01-20 17:12:26 +08:00
sindir	bc92b9aa62	正确转到字典类型页面	2026-01-20 16:29:30 +08:00
sindir	46145ff636	正确转到字典类型页面	2026-01-20 16:19:54 +08:00
huhuihua	3ad32fac9f	46 门诊医生站补充	2026-01-20 10:02:48 +08:00
nanyangbreeze	d1223aec07	挂号补单功能的完善	2026-01-20 09:31:37 +08:00
chenqi	649f7bcf5b	fix(database): 修复患者首页查询重复数据和关联查询问题 - 在ATDManageAppMapper.xml中添加DISTINCT关键字解决入院患者信息重复问题 - 重构PatientHomeAppMapper.xml中的复杂查询逻辑，使用子查询替代多层JOIN提高性能 - 修复vital signs查询中的字段关联错误，将base_service_req_id改为request_id - 优化前端implementDepartment组件的数据加载逻辑，添加异步处理和错误捕获 - 为诊疗项目下拉框添加数据加载状态检查，防止空数据导致的界面异常 - 实现防抖机制和数据量限制，提升大数据量下的响应性能 - 添加并行数据加载，减少页面初始化时间	2026-01-20 08:24:07 +08:00
chenqi	a3dce8de60	fix(inhospitalnurse): 优化住院护士站患者管理和床位分配功能 - 移除住院参与者更新失败时的异常返回，改为静默处理 - 更新床位分配提示信息，为用户提供更清晰的操作指导 - 实现实施科室下拉选择器的远程搜索功能，提升大数据量下的用户体验 - 添加节点切换时的未保存数据确认提醒，防止数据丢失 - 优化实施科室管理页面的选项过滤和加载状态管理	2026-01-19 23:18:38 +08:00
chenqi	f81dd54f0c	Merge remote-tracking branch 'origin/develop' into develop	2026-01-19 22:36:12 +08:00
chenqi	803e4d0bb5	refactor(inhospitalnursestation): 优化入院护士站应用的数据库查询性能 - 将CTE查询重构为子查询以提高执行效率 - 为位置和医生查询添加LIMIT 1约束以减少数据量 - 移除不必要的GROUP BY子句以简化查询逻辑 - 在前端组件中实现异步数据加载和错误处理机制 - 使用可选链操作符处理空值情况避免报错 - 添加防抖机制解决单击双击冲突问题 - 优化患者列表和床位列表的并行加载逻辑 - 清理调试用的console.log语句并替换为有意义的信息	2026-01-19 22:36:04 +08:00
chenqi	aa3beb848b	fix(patient): 修复患者信息新增和更新逻辑 - 修改handlePatientInfo方法中的患者对象初始化逻辑 - 添加患者ID存在时的查询验证机制 - 区分新增和更新操作分别调用不同的服务方法 - 移除重复的身份证号查询条件优化性能 - 统一患者信息保存和更新的操作流程	2026-01-19 21:41:05 +08:00
huabuweixin	f11b7380a4	Merge remote-tracking branch 'origin/develop' into develop	2026-01-19 15:01:28 +08:00
chenqi	da17b2b89c	fix(inpatient): 修复就诊位置更新逻辑 - 修改就诊位置表更新方式，直接更新指定ID的记录 - 添加位置ID设置功能 - 使用updateById方法替代saveOrUpdate方法提高准确性	2026-01-19 14:22:39 +08:00