80 Commits

Author SHA1 Message Date
ccff9a7246 fix(hospitalizationEmr): 解决病历模板切换时数据显示残留问题
- 在切换模板前重置表单数据,避免显示之前的数据
- 先清空当前组件再设置新组件,确保组件完全重新渲染
- 使用 nextTick 确保 DOM 更新后再设置新组件
- 添加 JSON 解析异常处理,解析失败时清空组件数据
- 当没有历史记录或加载出错时清空表单数据
- 患者信息变化时重置当前组件和表单数据
- 没有患者信息时也重置组件和表单数据
2026-01-22 22:36:54 +08:00
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
huabuweixin
0d57e984a6 76 门诊预约挂号 2026-01-22 15:09:52 +08:00
4450e3cc50 上传文件至 md/需求 2026-01-22 15:08:57 +08:00
wangjian963
902ee0587e 修改新增耗材“一次性静脉采血器” 点击保存categoryEnum为空值的问题。 2026-01-22 14:13:10 +08:00
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
c92ff38133 Merge remote-tracking branch 'origin/develop' into develop 2026-01-21 17:50:58 +08:00
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
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
3464153d93 Merge remote-tracking branch 'origin/develop' into develop 2026-01-20 17:31:07 +08:00
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
d1223aec07 挂号补单功能的完善 2026-01-20 09:31:37 +08:00
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
a3dce8de60 fix(inhospitalnurse): 优化住院护士站患者管理和床位分配功能
- 移除住院参与者更新失败时的异常返回,改为静默处理
- 更新床位分配提示信息,为用户提供更清晰的操作指导
- 实现实施科室下拉选择器的远程搜索功能,提升大数据量下的用户体验
- 添加节点切换时的未保存数据确认提醒,防止数据丢失
- 优化实施科室管理页面的选项过滤和加载状态管理
2026-01-19 23:18:38 +08:00
f81dd54f0c Merge remote-tracking branch 'origin/develop' into develop 2026-01-19 22:36:12 +08:00
803e4d0bb5 refactor(inhospitalnursestation): 优化入院护士站应用的数据库查询性能
- 将CTE查询重构为子查询以提高执行效率
- 为位置和医生查询添加LIMIT 1约束以减少数据量
- 移除不必要的GROUP BY子句以简化查询逻辑
- 在前端组件中实现异步数据加载和错误处理机制
- 使用可选链操作符处理空值情况避免报错
- 添加防抖机制解决单击双击冲突问题
- 优化患者列表和床位列表的并行加载逻辑
- 清理调试用的console.log语句并替换为有意义的信息
2026-01-19 22:36:04 +08:00
deebcde41f 依赖标记更新 2026-01-19 21:48:43 +08:00
095c43bbf3 修复医嘱下获取读取慢问题,同时解决系列字典表读取慢问题 2026-01-19 21:48:11 +08:00
aa3beb848b fix(patient): 修复患者信息新增和更新逻辑
- 修改handlePatientInfo方法中的患者对象初始化逻辑
- 添加患者ID存在时的查询验证机制
- 区分新增和更新操作分别调用不同的服务方法
- 移除重复的身份证号查询条件优化性能
- 统一患者信息保存和更新的操作流程
2026-01-19 21:41:05 +08:00
sindir
ae96bbd0bb 医生常用语管理 - 行内编辑改为弹窗编辑,优化编辑体验。新增编辑弹窗,点击编辑按钮弹窗回显数据,修改更便捷 2026-01-19 17:25:37 +08:00
sindir
1a2c444269 Merge branch 'develop' of https://gitea.gentronhealth.com/wangyizhe/his into develop 2026-01-19 15:47:38 +08:00
sindir
9cba8fea12 完善医生常用语管理功能
### 后端修改
1. 实体类DoctorPhrase:字段/注解调整
2. 枚举完善:新增DoctorPhraseAppTypeEnum/DoctorPhraseBizTypeEnum,统一业务分类
3. 服务实现类:修正类名拼写(DoctorPhraesAppS → DoctorPhraseAppServiceImpl
### 前端修改
1. 常用语管理页面(doctorphrase/index.vue):
   业务分类硬编码替换为枚举(主诉/现病史/术前/术后/既往史)
2026-01-19 15:43:34 +08:00
huabuweixin
f11b7380a4 Merge remote-tracking branch 'origin/develop' into develop 2026-01-19 15:01:28 +08:00
da17b2b89c fix(inpatient): 修复就诊位置更新逻辑
- 修改就诊位置表更新方式,直接更新指定ID的记录
- 添加位置ID设置功能
- 使用updateById方法替代saveOrUpdate方法提高准确性
2026-01-19 14:22:39 +08:00
9e4a010a8d Merge remote-tracking branch 'origin/develop' into develop 2026-01-19 11:39:58 +08:00
7e76083c37 feat(doctorstation): 优化医生工作站处方列表功能
- 调整诊疗定义表结构,添加序号和服务范围字段
- 修改费用项目查询逻辑,使用INNER JOIN替代LEFT JOIN并优化排序
- 增加批处理批次大小从500到1000,提升查询性能
- 修复处方类型筛选中的诊疗和耗材顺序错误
- 优化处方行数据重置逻辑,避免残留数据问题
- 移除不必要的README标题元素
2026-01-19 11:39:29 +08:00
de105adbdc 上传文件至 md/需求 2026-01-19 11:28:29 +08:00
f3eeee7405 refactor(doctorstation): 优化医嘱基础列表组件性能和数据处理
- 实现虚拟滚动表格以提升大数据量渲染性能
- 添加数据缓存机制减少重复API请求
- 增强节流防抖功能优化搜索响应
- 重构数据过滤逻辑支持本地快速检索
- 添加加载状态提示改善用户体验
- 优化表格列宽度设置提升界面美观度
- 修复医保等级显示和价格获取逻辑
- 后端服务增加分批处理避免大量参数问题
- 添加空值安全检查防止运行时错误
- 统一数据结构处理药品耗材诊疗不同类型
2026-01-19 10:37:46 +08:00
97f04d0b15 fix(inpatient): 修复就诊位置更新逻辑
- 修改就诊位置表更新方式,直接更新指定ID的记录
- 添加位置ID设置功能
- 使用updateById方法替代saveOrUpdate方法提高准确性
2026-01-18 19:44:32 +08:00
5667e04d12 fix(organization): 修复组织查询中class_enum字段的多值匹配逻辑
- 将FIND_IN_SET函数替换为LIKE操作符组合,提高PostgreSQL兼容性
- 添加子查询包装器支持多种匹配模式
- 实现精确匹配、前缀匹配、后缀匹配和中间匹配四种查询方式
- 确保逗号分隔的枚举值能够正确匹配查询条件
- 优化查询性能并提升代码可读性
2026-01-18 14:06:44 +08:00
59157fda56 feat(organization): 支持科室分类多选功能
- 修改前端界面组件支持科室分类多选下拉框
- 更新后端接口参数类型从Integer改为String以支持多选值
- 实现FIND_IN_SET查询方式处理多选分类条件
- 添加parseClassEnumValues函数处理字符串或数组格式转换
- 在医院住院对话框中扩展筛选条件支持多选分类
- 优化错误信息显示逻辑提供更详细的错误提示
- 在患者列表组件中添加入院日期和主治医生信息展示
- 修复多个服务调用中科室分类参数传递的数据类型问题
2026-01-18 13:39:57 +08:00
2fe6d45ad4 fix(doctorstation): 修复诊断组件和住院办理功能的数据处理问题
- 修复诊断组件中el-popover模板语法错误,添加template标签
- 优化患者历史数据处理逻辑,确保数组类型安全并正确构建树形结构
- 完善住院办理流程中的组织机构数据获取和筛选逻辑
- 添加详细的控制台日志用于调试住院办理功能
- 修复办理住院按钮的禁用状态计算逻辑
- 优化患者卡片点击事件处理,确保就诊ID正确传递
- 添加诊断信息完整性检查并提供用户引导
- 修复检验申请组件中的监听器和暴露方法逻辑
2026-01-18 00:37:54 +08:00
982ee316f7 fix(doctorstation): 解决参数验证和数据获取问题
- 在前端api.js中添加encounterId参数验证,避免无效参数导致的错误
- 在后端服务层添加参数检查,当encounterId为空时返回空数据而非报错
- 修改控制器参数注解,将required设置为false以允许空值传递
- 优化住院办理流程中的错误处理和参数验证
- 改进检验申请单获取时的数据验证和错误提示
- 更新maven编译器插件版本并添加必要的模块参数
- 统一错误处理机制,提供更友好的用户提示信息
2026-01-17 16:07:57 +08:00
64c7db68e8 上传文件至 md/需求 2026-01-17 00:03:51 +08:00
cb6b6ced67 上传文件至 md/需求 2026-01-16 18:54:27 +08:00
itcast
8fcfb481c9 门诊医生站-》开立诊断 页面调整 2026-01-16 16:32:36 +08:00
itcast
be0514bc08 门诊医生站-》开立诊断 页面调整 2026-01-16 15:46:43 +08:00
ljj
2b3add4808 91 分诊排队管理-》门诊医生站:【完诊】患者队列状态的变化
68 检验项目设置-检验类型 / 检验项目设置-检验项目
2026-01-16 11:31:40 +08:00
b33cb6f9a1 测试合并v13 2026-01-15 17:04:46 +08:00
072e71b025 测试合并v12 2026-01-15 16:58:14 +08:00
47394de43c Merge pull request 'document' (#2) from document into develop
Reviewed-on: #2
2026-01-15 07:37:39 +00:00
f0f1dde6b6 测试合并 2026-01-15 07:37:39 +00:00
1ab1165697 测试合并 2026-01-15 07:37:39 +00:00
a8f1b1fdfa feat(doctorstation): 添加医嘱类型对应的药品分类筛选功能
- 在处方列表组件中根据医嘱类型自动设置categoryCode筛选条件
- 为西药类型设置categoryCode为'2'
- 为中成药类型设置categoryCode为'1'
- 为耗材和诊疗类型清空categoryCode筛选条件
- 更新基础医嘱列表组件以接收并应用categoryCode查询参数
- 实现医嘱类型改变时的联动筛选逻辑
2026-01-15 15:34:34 +08:00
3b94d19199 Merge remote-tracking branch 'origin/develop' into develop 2026-01-15 15:13:20 +08:00
db1139a14f fix(prescription): 解决处方列表中价格显示的空值异常问题
- 在处方列表组件中添加对unitPrice和totalPrice的空值检查,防止NaN显示
- 优化价格计算逻辑,确保无效价格值被正确处理并显示为默认值
- 更新数据库查询中的条件判断,改进UNION查询的逻辑结构
- 添加对adviceTypes参数的有效性验证,确保查询条件的正确执行
2026-01-15 15:13:09 +08:00
chenjinyang
bea74aeac2 使用element-plus进行提示替换HTML原生弹窗 2026-01-15 15:01:05 +08:00
chenjinyang
634a1f45f9 根据LIS分组开发手册完成功能 2026-01-15 14:36:54 +08:00
8f1ad3307c refactor(doctorstation): 优化医生站医嘱查询SQL逻辑
- 将原有的条件判断逻辑重构为更清晰的choose/when/otherwise结构
- 修复了adviceTypes参数为空或未指定时的SQL执行问题
- 通过trim标签处理UNION ALL连接避免多余关键字
- 添加otherwise分支确保无adviceTypes时返回正确空结果集
- 保持了原有的所有功能逻辑和数据映射关系不变
- 提高了SQL查询的可读性和维护性
2026-01-15 13:42:36 +08:00
d8080fa22d 挂号补单功能的完善 2026-01-14 12:56:39 +08:00
chenjinyang
e8783d9f8f 修复叫号显示屏跳转异常问题 2026-01-14 10:44:35 +08:00
d8c4348341 挂号补单功能的完善 2026-01-14 10:12:25 +08:00
wangjian963
8e61490005 修复门诊医生站检验申请单的就诊卡号无法获取到对应的值的问题 2026-01-13 17:47:51 +08:00
f5f4e3c48e fix(charge): 修复收费模块中的数值计算和空指针异常问题
- 修复金额计算精度问题,使用Number转换和toFixed(2)确保数值准确性
- 添加安全访问操作符(?.)避免空指针异常导致页面崩溃
- 修复数组过滤和查找操作的空值处理逻辑
- 优化错误消息显示,提供更友好的用户提示
- 修复模板文件路径引用问题,确保打印功能正常工作
- 统一金额计算逻辑,避免因数据类型不一致导致的计算错误
2026-01-13 17:30:17 +08:00
0f013715b8 fix(charge): 修复合同列表空值访问导致的门诊登记页面异常 2026-01-13 17:06:52 +08:00
fb9722d328 fix(charge): 修复合同列表空值访问导致的门诊登记页面异常 2026-01-13 17:06:43 +08:00
6f9192d30d fix(charge): 修复医保支付金额计算的安全访问问题
- 在 cliniccharge 组件中为所有金额查询添加可选链操作符防止空指针异常
- 在住院管理收费结算组件中修复金额格式化导致的显示问题
- 统一处理患者信息字段的空值情况避免页面渲染错误
- 修正金额计算逻辑确保数值精度和显示准确性
2026-01-13 17:02:27 +08:00
f2b5b90f34 Merge remote-tracking branch 'origin/develop' into develop 2026-01-13 17:01:29 +08:00
py
a2cbd5e583 测试:科室预约工作时间维护 2026-01-13 17:00:31 +08:00
d3df46858b fix(charge): 修复医保支付计算中的潜在空指针异常
- 在 chargeDialog.vue 中为所有 param.detail.find() 调用添加可选链操作符
- 修复了基金支付总额、个人负担总金额和其他支付类型的空指针风险
- 解决了基本医保统筹基金支出等各项支付类型的潜在运行时错误
- 在微信刷卡支付逻辑中同样应用可选链操作符保护
- 修复了 FULAMT_OWNPAY_AMT 计算中的运算符优先级问题

feat(hospitalRecord): 动态替换打印模板中的医院名称

- 在 MedicationDetails.vue 中引入并使用 userStore 获取医院名称
- 修改处置模板打印逻辑以动态替换 {{HOSPITAL_NAME}} 占位符
- 更新处方模板打印功能以支持医院名称的动态替换
- 激活之前被注释掉的模板文件导入语句
- 移除硬编码的医院名称,实现模板的动态化配置
2026-01-13 16:58:43 +08:00
47a7a945bc Merge remote-tracking branch 'origin/develop' into develop 2026-01-13 15:27:01 +08:00
0a56c0dcf0 feat(store): 更新用户模块状态管理以支持租户配置
- 调整导入语句顺序以符合代码风格规范
- 添加tenantName字段用于存储租户名称
- 添加optionMap字段用于存储租户配置项映射
- 修改getInfo方法以从optionMap优先获取医院名称配置
- 添加tenantName赋值逻辑以支持租户名称显示
- 移除已废弃的用户个人资料相关组件文件
2026-01-13 15:26:46 +08:00
15d32134e2 挂号补单功能的完善 2026-01-13 14:48:18 +08:00
eff98ea5eb Merge remote-tracking branch 'origin/develop' into develop 2026-01-13 14:41:36 +08:00
a47306825a docs(requirement): 添加手术室维护界面需求文档
- 创建手术室维护界面PRD文档
- 定义页面概述、核心功能和用户价值
- 设计整体布局和页面区域详细描述
- 规范交互功能和数据结构说明
- 说明开发实现要点和注意事项
- 移除中医诊断主诊断功能实现说明文档
- 移除公告通知弹窗功能说明文档
- 移除手术人员字段不显示问题解决方案文档
- 移除手术和麻醉信息Redis缓存实现说明文档
- 移除手术室管理添加类型和所属科室字段说明文档
2026-01-13 14:41:27 +08:00
276 changed files with 15769 additions and 9457 deletions

104
check_display_order.sql Normal file
View File

@@ -0,0 +1,104 @@
-- 检查流水号display_order是否按“科室+医生+当天”正确递增
--
-- 说明:
-- 1. display_order 存的是纯数字1, 2, 3...),不带时间戳前缀
-- 2. 时间戳前缀(如 20260109是在前端显示时加上的
-- 3. 后端用 Redis key "ORG-{科室ID}-DOC-{医生ID}" 按天自增
--
-- 如何判断逻辑是否正确:
-- 同一科室、同一医生、同一天的记录display_order 应该递增1, 2, 3...
-- 不同科室、不同医生、不同天的记录,可能都是 1这是正常的
-- ========================================
-- 查询1按“科室+医生+日期”分组,看每组内的 display_order 是否递增
-- ========================================
SELECT
DATE(start_time) AS ,
organization_id AS ID,
registrar_id AS ID,
COUNT(*) AS ,
MIN(display_order) AS ,
MAX(display_order) AS ,
STRING_AGG(display_order::text, ', ' ORDER BY start_time) AS ,
STRING_AGG(id::text, ', ' ORDER BY start_time) AS ID列表
FROM adm_encounter
WHERE delete_flag = '0'
AND start_time >= CURRENT_DATE - INTERVAL '7 days' -- 只看最近7天
AND display_order IS NOT NULL
GROUP BY DATE(start_time), organization_id, registrar_id
ORDER BY DESC, ID, ID;
-- ========================================
-- 查询2详细查看每条记录看同组内的序号是否连续
-- ========================================
SELECT
id AS ID,
DATE(start_time) AS ,
organization_id AS ID,
registrar_id AS ID,
start_time AS ,
display_order AS ,
-- 计算:同组内的序号应该是 1, 2, 3...,看是否有重复或跳号
ROW_NUMBER() OVER (
PARTITION BY DATE(start_time), organization_id, registrar_id
ORDER BY start_time
) AS ,
CASE
WHEN display_order = ROW_NUMBER() OVER (
PARTITION BY DATE(start_time), organization_id, registrar_id
ORDER BY start_time
) THEN '✓ 正常'
ELSE '✗ 异常'
END AS
FROM adm_encounter
WHERE delete_flag = '0'
AND start_time >= CURRENT_DATE - INTERVAL '7 days'
AND display_order IS NOT NULL
ORDER BY DATE(start_time) DESC, organization_id, registrar_id, start_time;
-- ========================================
-- 查询3只看今天的数据最直观
-- ========================================
SELECT
id AS ID,
organization_id AS ID,
registrar_id AS ID,
start_time AS ,
display_order AS
FROM adm_encounter
WHERE delete_flag = '0'
AND DATE(start_time) = CURRENT_DATE
AND display_order IS NOT NULL
ORDER BY organization_id, registrar_id, start_time;
-- ========================================
-- 查询4发现问题 - 找出同组内 display_order 重复的记录
-- ========================================
WITH ranked AS (
SELECT
id,
DATE(start_time) AS reg_date,
organization_id,
registrar_id,
start_time,
display_order,
ROW_NUMBER() OVER (
PARTITION BY DATE(start_time), organization_id, registrar_id
ORDER BY start_time
) AS should_be_order
FROM adm_encounter
WHERE delete_flag = '0'
AND start_time >= CURRENT_DATE - INTERVAL '7 days'
AND display_order IS NOT NULL
)
SELECT
reg_date AS ,
organization_id AS ID,
registrar_id AS ID,
COUNT(*) AS ,
STRING_AGG(id::text || '->' || display_order::text, ', ') AS
FROM ranked
WHERE display_order != should_be_order
GROUP BY reg_date, organization_id, registrar_id
ORDER BY reg_date DESC;

View File

@@ -1,179 +0,0 @@
# 中医诊断主诊断功能实现说明
## 问题描述
中医诊断在添加时无法设置主诊断标记,导致保存后无法正确标识主诊断。
## 问题原因
`addDiagnosisDialog.vue` 中保存中医诊断时,没有传递 `maindiseFlag`(主诊断标记)字段到后端。
## 解决方案
### 1. 前端修改
#### 1.1 添加主诊断UIaddDiagnosisDialog.vue
在诊断详情区域为每个中医诊断添加了主诊断复选框:
```vue
<el-checkbox
v-model="item.isMain"
label="主诊断"
:true-label="true"
:false-label="false"
border
size="small"
style="margin-right: 10px;"
@change="(value) => handleMaindise(value, index)"
/>
```
#### 1.2 添加主诊断逻辑处理
**新增诊断时的默认行为:**
- 第一个添加的中医诊断自动设置为主诊断
- 后续添加的诊断默认不是主诊断
**主诊断唯一性校验:**
```javascript
function handleMaindise(value, index) {
if (value) {
// 检查是否已有其他主诊断
let mainCount = 0;
tcmDiagonsisList.value.forEach((item, idx) => {
if (item.isMain && idx !== index) {
mainCount++;
}
});
if (mainCount > 0) {
// 取消当前选择
tcmDiagonsisList.value[index].isMain = false;
proxy.$modal.msgWarning('只能有一条主诊断');
return;
}
// 更新保存列表中的主诊断标记
const syndromeGroupNo = tcmDiagonsisList.value[index].syndromeGroupNo;
tcmDiagonsisSaveList.value.forEach((item, idx) => {
if (item.syndromeGroupNo === syndromeGroupNo) {
// 每个证候组有两条记录(病和证),只有第一条(病)设置主诊断标记
if (idx % 2 === 0 || tcmDiagonsisSaveList.value[idx - 1]?.syndromeGroupNo !== syndromeGroupNo) {
item.maindiseFlag = 1;
}
}
});
} else {
// 取消主诊断
const syndromeGroupNo = tcmDiagonsisList.value[index].syndromeGroupNo;
tcmDiagonsisSaveList.value.forEach((item) => {
if (item.syndromeGroupNo === syndromeGroupNo) {
item.maindiseFlag = 0;
}
});
}
}
```
#### 1.3 保存时包含主诊断字段
**新增诊断时:**
```javascript
tcmDiagonsisSaveList.value.push({
definitionId: row.id,
ybNo: row.ybNo,
syndromeGroupNo: timestamp.value,
verificationStatusEnum: 4,
medTypeCode: '11',
maindiseFlag: isFirstDiagnosis ? 1 : 0, // 添加主诊断标记
});
```
**修改诊断时:**
```javascript
tcmDiagonsisSaveList.value.push({
conditionId: item.conditionId,
updateId: updateIds[0],
definitionId: item.illnessDefinitionId,
ybNo: item.ybNo,
syndromeGroupNo: item.syndromeGroupNo,
verificationStatusEnum: 4,
medTypeCode: '11',
diagSrtNo: item.diagSrtNo,
maindiseFlag: isMain ? 1 : 0, // 保留原有的主诊断标记
});
```
#### 1.4 诊断列表显示diagnosis.vue
在获取中医诊断列表时,正确读取并显示主诊断标记:
```javascript
form.value.diagnosisList.push({
name: item.name + '-' + res.data.symptom[index].name,
diagSrtNo: item.diagSrtNo,
ybNo: item.ybNo,
medTypeCode: item.medTypeCode,
syndromeGroupNo: item.syndromeGroupNo,
typeName: '中医诊断',
conditionId: item.conditionId,
symptomConditionId: res.data.symptom[index].conditionId,
updateId: item.encounterDiagnosisId + '-' + res.data.symptom[index].encounterDiagnosisId,
illnessDefinitionId: item.definitionId,
symptomDefinitionId: res.data.symptom[index].definitionId,
symptomYbNo: res.data.symptom[index].ybNo,
maindiseFlag: item.maindiseFlag || 0, // 添加主诊断标记
});
```
### 2. 后端支持
后端已经支持 `maindiseFlag` 字段的保存和读取:
**SaveDiagnosisChildParam.java**
```java
/**
* 主诊断标记 (1:是,0:否)
*/
private Integer maindiseFlag;
```
**DoctorStationChineseMedicalAppServiceImpl.java**
```java
encounterDiagnosis.setMaindiseFlag(saveDiagnosisChildParam.getMaindiseFlag());
```
## 业务规则
1. **主诊断标记位置**:主诊断标记在"病"上(每个病-证组合的第一条记录)
2. **主诊断唯一性**:中医诊断只能有一个主诊断
3. **与西医诊断的关系**:中医诊断和西医诊断可以各有一个主诊断(互不冲突)
4. **默认行为**:第一个添加的中医诊断自动设置为主诊断
## 修改文件清单
1. `openhis-ui-vue3/src/views/doctorstation/components/diagnosis/addDiagnosisDialog.vue`
- 添加主诊断复选框UI
- 添加主诊断逻辑处理函数
- 修改保存数据时包含 maindiseFlag 字段
2. `openhis-ui-vue3/src/views/doctorstation/components/diagnosis/diagnosis.vue`
- 修改获取中医诊断列表时读取 maindiseFlag 字段
- 修改传递给对话框的数据包含 maindiseFlag 字段
## 测试要点
1. ✅ 新增中医诊断时,第一个诊断自动设置为主诊断
2. ✅ 可以手动勾选/取消主诊断复选框
3. ✅ 只能有一个主诊断(尝试勾选第二个时会提示错误)
4. ✅ 保存后主诊断标记正确保存到数据库
5. ✅ 刷新页面后主诊断标记正确显示
6. ✅ 修改已有诊断时,主诊断标记正确回显
7. ✅ 中医诊断和西医诊断的主诊断互不影响
## 注意事项
1. 中医诊断是"病-证"成对出现的,主诊断标记只设置在"病"上
2. 证候记录的 maindiseFlag 始终为 0
3. 主诊断唯一性校验只在中医诊断内部进行,不影响西医诊断
## 完成时间
2026年1月9日

View File

@@ -1,178 +0,0 @@
# 公告通知弹窗功能说明
## 功能概述
用户登录后,系统会自动弹出公告通知窗口,显示未读的系统公告和通知。
## 功能特性
### 1. 自动弹出
- 登录后 1 秒自动加载公告列表
- 如果有未读公告,自动弹出弹窗显示
- 延迟加载避免影响页面初始渲染
### 2. 优先级显示
- **高优先级**1红色背景 `#fff1f0`,红色文字 `#ff4d4f`
- **中优先级**2橙色背景 `#fff7e6`,橙色文字 `#faad14`
- **低优先级**3灰色背景 `#f0f2f5`,灰色文字 `#909399`
### 3. 排序规则
- 按优先级升序排列(高 -> 中 -> 低)
- 相同优先级按创建时间降序排列
### 4. 已读状态
- 未读公告:黄色背景高亮显示
- 已读公告:默认白色背景
- 点击公告自动标记为已读
### 5. 分类显示
- **通知**1蓝色图标
- **紧急**2红色警告图标
- **信息**3绿色信息图标
- **成功**4紫色成功图标
## 文件结构
```
src/
├── components/
│ ├── NoticePopup/
│ │ └── index.vue # 登录后自动弹窗组件
│ └── NoticePanel/
│ └── index.vue # 手动打开的公告面板
├── layout/
│ └── index.vue # 主布局,引入 NoticePopup
└── views/
└── system/
└── notice/
└── index.vue # 公告管理页面
```
## API 接口
### 前端 API
```javascript
// 获取用户公告列表
getUserNotices()
// 标记为已读
markAsRead(noticeId)
// 全部标记为已读
markAllAsRead(noticeIds)
// 获取未读数量
getUnreadCount()
```
### 后端接口
```java
// GET /system/notice/public/notice
// 获取当前用户的公告列表(含已读状态)
// GET /system/notice/public/unread/count
// 获取未读公告数量
// POST /system/notice/public/read/{noticeId}
// 标记公告为已读
// POST /system/notice/public/read/all
// 批量标记为已读
```
## 数据库字段
### sys_notice 表新增字段
```sql
-- 优先级字段
priority VARCHAR(1) DEFAULT '3'
-- 发布状态字段
publish_status VARCHAR(1) DEFAULT '0'
```
## 使用说明
### 1. 数据库迁移
执行 SQL 脚本添加必要的字段:
```bash
# 添加优先级字段
ALTER TABLE sys_notice ADD COLUMN priority VARCHAR(1) DEFAULT '3';
# 添加发布状态字段
ALTER TABLE sys_notice ADD COLUMN publish_status VARCHAR(1) DEFAULT '0';
```
### 2. 后台管理
`系统管理 > 公告管理` 中:
1. 点击"新增"创建公告
2. 选择优先级:高/中/低
3. 选择公告类型:通知/紧急/信息/成功
4. 填写标题和内容
5. 点击"发布"按钮
### 3. 用户端显示
- 登录后自动弹出未读公告
- 点击顶部导航栏铃铛图标可手动打开
- 点击公告查看详情
- 支持全部标记为已读
## 样式说明
### 弹窗样式
- 宽度800px
- 高度:最大 600px
- 标题栏:渐变紫色背景 `linear-gradient(135deg, #667eea 0%, #764ba2 100%)`
- 左右分栏布局
### 列表样式
- 列表宽度380px
- 滚动区域:最大高度 500px
- 未读高亮:黄色背景 `#fffbe6`
- 激活项:蓝色左边框 `#1890ff`
### 详情样式
- 自适应宽度
- 标题字号18px
- 内容字号14px
- 行高1.8
## 注意事项
1. **权限控制**
- 只有已发布的公告才会显示
- 只有正常状态的公告才会显示
2. **性能优化**
- 使用延迟加载1秒
- 使用虚拟滚动el-scrollbar
- 按需加载详情
3. **用户体验**
- 支持点击空白处关闭
- 支持ESC键关闭
- 未读状态醒目标识
- 优先级颜色区分明显
## 故障排查
### 弹窗不显示
1. 检查后端接口 `/system/notice/public/notice` 是否正常返回
2. 检查是否有未读公告
3. 检查浏览器控制台是否有错误
4. 清除浏览器缓存重试
### 样式错乱
1. 检查 Element Plus 版本是否兼容
2. 检查样式是否被其他 CSS 覆盖
3. 使用浏览器开发者工具检查样式
### 数据不更新
1. 检查后端返回的数据格式
2. 检查 API 调用是否成功
3. 检查响应拦截器处理
## 版本信息
- 创建日期2025-12-30
- 功能版本v1.0
- 前端框架Vue 3 + Element Plus
- 后端框架Spring Boot + MyBatis Plus

View File

@@ -1,254 +0,0 @@
# 手术人员字段不显示问题解决方案
## 问题描述
主刀医生、麻醉医生、助手1、助手2、执行科这些字段在手术查看页面中没有显示数据。
## 问题原因
这些字段在数据库中可能为 **null 或空值**,虽然保存了 ID`main_surgeon_id`),但没有保存对应的姓名(如 `main_surgeon_name`)。
## 解决步骤
### 步骤 1检查数据库中字段的实际值
执行以下 SQL 查看当前数据:
```sql
SELECT
id,
surgery_no,
main_surgeon_id,
main_surgeon_name,
anesthetist_id,
anesthetist_name,
assistant_1_id,
assistant_1_name,
assistant_2_id,
assistant_2_name,
operating_room_id,
operating_room_name,
org_id,
org_name
FROM public.cli_surgery
WHERE delete_flag = '0'
ORDER BY create_time DESC
LIMIT 5;
```
**请告诉我结果**:特别是 `main_surgeon_name``anesthetist_name``assistant_1_name``assistant_2_name``operating_room_name``org_name` 这些字段的值。
### 步骤 2检查用户表结构
执行以下 SQL 查看用户表的结构:
```sql
SELECT
column_name,
data_type
FROM information_schema.columns
WHERE table_name = 'sys_user'
AND column_name IN ('user_id', 'nick_name', 'user_name', 'practitioner_id')
ORDER BY column_name;
```
**目的**确定人员ID和姓名的对应关系。
### 步骤 3填充人员姓名字段推荐方法
使用以下 SQL 脚本填充人员姓名:
```sql
-- 填充主刀医生姓名
UPDATE public.cli_surgery s
SET main_surgeon_name = u.nick_name
FROM public.sys_user u
WHERE s.main_surgeon_id = u.user_id
AND s.main_surgeon_name IS NULL
AND s.delete_flag = '0';
-- 填充麻醉医生姓名
UPDATE public.cli_surgery s
SET anesthetist_name = u.nick_name
FROM public.sys_user u
WHERE s.anesthetist_id = u.user_id
AND s.anesthetist_name IS NULL
AND s.delete_flag = '0';
-- 填充助手1姓名
UPDATE public.cli_surgery s
SET assistant_1_name = u.nick_name
FROM public.sys_user u
WHERE s.assistant_1_id = u.user_id
AND s.assistant_1_name IS NULL
AND s.delete_flag = '0';
-- 填充助手2姓名
UPDATE public.cli_surgery s
SET assistant_2_name = u.nick_name
FROM public.sys_user u
WHERE s.assistant_2_id = u.user_id
AND s.assistant_2_name IS NULL
AND s.delete_flag = '0';
-- 填充手术室名称
UPDATE public.cli_surgery s
SET operating_room_name = r.name
FROM public.cli_operating_room r
WHERE s.operating_room_id = r.id
AND s.operating_room_name IS NULL
AND s.delete_flag = '0';
-- 填充执行科室名称
UPDATE public.cli_surgery s
SET org_name = o.name
FROM public.adm_organization o
WHERE s.org_id = o.id
AND s.org_name IS NULL
AND s.delete_flag = '0';
```
### 步骤 4验证更新结果
执行以下 SQL 验证是否更新成功:
```sql
SELECT
id,
surgery_no,
main_surgeon_id,
main_surgeon_name,
anesthetist_id,
anesthetist_name,
assistant_1_id,
assistant_1_name,
assistant_2_id,
assistant_2_name,
operating_room_id,
operating_room_name,
org_id,
org_name
FROM public.cli_surgery
WHERE delete_flag = '0'
ORDER BY create_time DESC
LIMIT 5;
```
**预期结果**:所有 `*_name` 字段都应该有值。
### 步骤 5刷新前端页面
1. 刷新手术管理页面
2. 点击某个手术记录的"查看"按钮
3. 检查详情对话框中是否显示这些字段
## 前端代码检查
### 1. 检查详情对话框显示
打开 `surgerymanage/index.vue` 文件,查看详情对话框部分:
```vue
<el-descriptions-item label="主刀医生">{{ viewData.mainSurgeonName }}</el-descriptions-item>
<el-descriptions-item label="麻醉医生">{{ viewData.anesthetistName }}</el-descriptions-item>
<el-descriptions-item label="助手1">{{ viewData.assistant1Name }}</el-descriptions-item>
<el-descriptions-item label="助手2">{{ viewData.assistant2Name }}</el-descriptions-item>
<el-descriptions-item label="手术室">{{ viewData.operatingRoomName }}</el-descriptions-item>
<el-descriptions-item label="执行科室">{{ viewData.orgName }}</el-descriptions-item>
```
**确认**:这些字段名是否正确(注意驼峰命名)。
### 2. 检查浏览器控制台
1. 打开浏览器开发者工具F12
2. 切换到 Console 标签
3. 点击"查看"按钮
4. 查看是否有 JavaScript 错误
### 3. 检查 Network 响应
1. 切换到 Network 标签
2. 点击"查看"按钮
3. 找到 `/clinical-manage/surgery/surgery-detail` 请求
4. 查看响应内容
**检查**:响应数据中是否包含这些字段,值是什么。
## 常见问题
### 问题 1UPDATE SQL 执行失败
**症状**:报错 "relation does not exist" 或 "column does not exist"
**解决**
1. 检查表名是否正确sys_user 或 adm_practitioner
2. 检查字段名是否正确user_id 或 practitioner_id
### 问题 2UPDATE 后字段仍为 null
**症状**UPDATE 执行成功,但字段仍为 null
**原因**:关联表中没有对应的记录
**解决**检查人员ID是否存在于人员表中
```sql
-- 检查主刀医生ID是否存在
SELECT s.main_surgeon_id, u.nick_name
FROM public.cli_surgery s
LEFT JOIN public.sys_user u ON s.main_surgeon_id = u.user_id
WHERE s.main_surgeon_id IS NOT NULL
AND u.user_id IS NULL
LIMIT 5;
```
### 问题 3前端仍然不显示
**症状**:数据库中有值,但前端不显示
**原因**
1. 前端字段名不匹配
2. 前端数据绑定有问题
**解决**
1. 检查 MyBatis XML 映射是否正确
2. 检查后端返回的 JSON 数据结构
3. 检查前端变量名是否正确
## 后续改进建议
### 1. 保存时自动填充姓名
在前端或后端保存手术信息时根据选择的医生ID自动查询并填充姓名字段。
### 2. 提供人员选择功能
在前端提供医生、科室等选择下拉框而不是手动输入ID。
### 3. 添加数据完整性校验
在保存前检查如果选择了人员ID必须填充对应的姓名字段。
## 相关文件
1. **检查和填充脚本**`e:/his/检查和填充手术人员字段.sql`
2. **填充脚本**`e:/his/填充手术人员字段姓名.sql`
3. **MyBatis 映射**`e:/his/openhis-server-new/openhis-application/src/main/resources/mapper/clinicalmanage/SurgeryMapper.xml`
## 验证清单
- [ ] 数据库查询显示字段为 null
- [ ] 执行了填充 SQL 脚本
- [ ] 验证更新后字段有值
- [ ] 刷新前端页面
- [ ] 详情对话框中正确显示
## 联系支持
如果以上步骤都无法解决问题,请提供:
1. **步骤 1 的查询结果**:当前数据库中这些字段的值
2. **步骤 2 的查询结果**sys_user 表的结构
3. **UPDATE SQL 执行结果**:是否有错误,更新了多少条记录
4. **步骤 4 的验证结果**:更新后的字段值
5. **浏览器控制台错误**:是否有 JavaScript 错误
6. **Network 响应数据**:后端返回的完整数据

View File

@@ -1,120 +0,0 @@
# 手术和麻醉信息Redis缓存实现说明
## 概述
为提高手术和麻醉信息的查询性能,已将手术信息缓存到Redis中。接口查询时先从Redis缓存获取,如果没有则从数据库查询并更新到Redis缓存。
## 实现细节
### 1. Redis缓存Key定义
`openhis-common/src/main/java/com/openhis/common/utils/RedisKeys.java` 中定义了以下缓存Key:
```java
// 单个手术信息缓存
public static String getSurgeryKey(Long surgeryId)
// 按患者ID查询的手术列表缓存
public static String getSurgeryListByPatientKey(Long patientId)
// 按就诊ID查询的手术列表缓存
public static String getSurgeryListByEncounterKey(Long encounterId)
```
### 2. 缓存实现
#### 2.1 SurgeryServiceImpl (Domain层)
- **getSurgeryById(Long id)**: 根据手术ID查询单个手术信息
- 先从Redis缓存获取
- 缓存未命中则从数据库查询
- 查询结果存入Redis缓存(30分钟过期)
- **getSurgeryListByPatientId(Long patientId)**: 根据患者ID查询手术列表
- 先从Redis缓存获取
- 缓存未命中则从数据库查询
- 查询结果存入Redis缓存(30分钟过期)
- **getSurgeryListByEncounterId(Long encounterId)**: 根据就诊ID查询手术列表
- 先从Redis缓存获取
- 缓存未命中则从数据库查询
- 查询结果存入Redis缓存(30分钟过期)
- **insertSurgery(Surgery surgery)**: 新增手术信息
- 插入成功后清除相关缓存
- **updateSurgery(Surgery surgery)**: 更新手术信息
- 更新成功后清除相关缓存
- **deleteSurgery(Long id)**: 删除手术信息
- 删除成功后清除相关缓存
- **updateSurgeryStatus(Long id, Integer statusEnum)**: 更新手术状态
- 更新成功后清除相关缓存
#### 2.2 SurgeryAppServiceImpl (Application层)
- **getSurgeryDetail(Long id)**: 根据ID查询手术详情
- 先从Redis缓存获取
- 缓存未命中则从数据库查询
- 查询结果存入Redis缓存(30分钟过期)
- **addSurgery(SurgeryDto surgeryDto)**: 新增手术信息
- 插入成功后清除相关缓存
- **updateSurgery(SurgeryDto surgeryDto)**: 更新手术信息
- 更新成功后清除相关缓存
- **deleteSurgery(Long id)**: 删除手术信息
- 删除成功后清除相关缓存
- **updateSurgeryStatus(Long id, Integer statusEnum)**: 更新手术状态
- 更新成功后清除相关缓存
### 3. 缓存清除策略
当手术信息发生变化时(新增、更新、删除),会清除以下相关缓存:
1. 单个手术信息缓存
2. 患者手术列表缓存
3. 就诊手术列表缓存
### 4. 缓存配置
- **缓存时间**: 30分钟
- **时间单位**: TimeUnit.MINUTES
- **序列化**: 使用RedisTemplate默认序列化方式
## 关于麻醉信息
当前项目中,麻醉信息是手术表(`cli_surgery`)中的字段,包括:
- 麻醉医生ID (anesthetistId)
- 麻醉医生姓名 (anesthetistName)
- 麻醉方式编码 (anesthesiaTypeEnum)
- 麻醉费用 (anesthesiaFee)
这些字段已经包含在手术实体的缓存中,无需单独实现麻醉信息的缓存。
## 使用示例
### 查询手术信息(自动使用缓存)
```java
// 自动从缓存获取,未命中则查询数据库
Surgery surgery = surgeryService.getSurgeryById(surgeryId);
```
### 更新手术信息(自动清除缓存)
```java
// 更新数据库,同时清除相关缓存
surgeryService.updateSurgery(surgery);
```
### 手动清除缓存(如需要)
```java
String cacheKey = RedisKeys.getSurgeryKey(surgeryId);
redisCache.deleteObject(cacheKey);
```
## 性能优化建议
1. 对于频繁访问的手术信息,缓存命中率高,可显著提升查询性能
2. 对于不常访问的手术信息,30分钟缓存时间可避免占用过多Redis内存
3. 如需调整缓存时间,可修改代码中的 `30, TimeUnit.MINUTES` 参数
4. 如需更精细的缓存控制,可考虑使用不同的缓存时间策略(如根据手术状态设置不同过期时间)
## 监控建议
建议监控以下指标:
- Redis缓存命中率
- Redis内存使用情况
- 查询响应时间对比(缓存命中 vs 缓存未命中)

View File

@@ -1,256 +0,0 @@
# 手术室管理添加类型和所属科室字段功能说明
## 概述
本次更新为手术室管理模块添加了"类型"和"所属科室"字段,优化了手术室信息的分类管理。
**数据库类型**PostgreSQL
## 功能特点
### 1. 手术室类型
支持四种手术室类型:
- **急诊手术室**:用于急诊手术的手术室
- **择期手术室**:用于择期手术的手术室(默认类型)
- **日间手术室**:用于日间手术的手术室
- **复合手术室**:用于复合手术的手术室
### 2. 所属科室
每个手术室可以关联到具体的科室,便于科室级别的资源管理。
## 修改内容
### 前端修改Vue3
#### 1. 手术室列表页面 (`operatingroom/index.vue`)
**列表表格新增列**
- 类型列:显示手术室类型(急诊手术室、择期手术室等)
- 所属科室列:显示手术室所属的科室名称
**新增/修改对话框新增字段**
- 类型选择器:下拉选择手术室类型
- 所属科室选择器:可搜索的科室下拉框
**查询表单保持原样**
- 仍支持按手术室名称和状态查询
**查看对话框新增显示**
- 类型信息
- 所属科室信息
#### 2. 表单数据结构
```javascript
const form = ref({
id: undefined,
busNo: undefined,
name: undefined,
roomTypeEnum: undefined, // 新增:手术室类型
organizationId: undefined, // 已有所属科室ID
organizationName: undefined, // 已有:所属科室名称
locationDescription: undefined,
equipmentConfig: undefined,
capacity: 1,
statusEnum: 1,
displayOrder: 0,
remark: undefined
})
```
#### 3. 类型选项配置
```javascript
const roomTypeOptions = ref([
{ value: 1, label: '急诊手术室' },
{ value: 2, label: '择期手术室' },
{ value: 3, label: '日间手术室' },
{ value: 4, label: '复合手术室' }
])
```
### 后端修改Java
#### 1. 实体类 (`OperatingRoom.java`)
**新增字段**
```java
/** 手术室类型 */
@Dict(dictCode = "operating_room_type")
private Integer roomTypeEnum;
private String roomTypeEnum_dictText;
/** 所属机构ID */
private Long organizationId;
/** 所属机构名称 */
private String organizationName;
```
#### 2. DTO类 (`OperatingRoomDto.java`)
**新增字段**
```java
/** 手术室类型 */
@Dict(dictCode = "operating_room_type")
private Integer roomTypeEnum;
private String roomTypeEnum_dictText;
/** 所属机构ID */
@JsonSerialize(using = ToStringSerializer.class)
private Long organizationId;
/** 机构名称 */
private String organizationName;
```
#### 3. Service实现类 (`OperatingRoomAppServiceImpl.java`)
**查询列表方法优化**
- 添加类型字段的枚举值转换逻辑
- 根据类型编码设置对应的中文描述
**详情查询方法优化**
- 添加类型字段的枚举值转换
- 查询所属科室的名称并回显
### 数据库修改
#### SQL脚本文件`add_operating_room_type_fields.sql`PostgreSQL版本
**1. 添加字段**
```sql
ALTER TABLE public.adm_operating_room
ADD COLUMN room_type_enum INTEGER DEFAULT 2;
COMMENT ON COLUMN public.adm_operating_room.room_type_enum IS
'手术室类型1-急诊手术室2-择期手术室3-日间手术室4-复合手术室';
```
**2. 更新现有数据**
```sql
UPDATE public.adm_operating_room
SET room_type_enum = 2
WHERE room_type_enum IS NULL;
```
**3. 添加索引**
```sql
CREATE INDEX idx_room_type ON public.adm_operating_room(room_type_enum);
CREATE INDEX idx_org_id ON public.adm_operating_room(organization_id);
```
**4. 字典数据**
- 新增字典类型:`operating_room_type`(手术室类型)
- 新增字典项:
- 急诊手术室1
- 择期手术室2
- 日间手术室3
- 复合手术室4
**PostgreSQL特定语法说明**
- 使用 `public.adm_operating_room` 替代 `` `adm_operating_room` ``
- 使用 `COMMENT ON COLUMN` 替代 `COMMENT``ALTER TABLE`
- 使用 `nextval()` 和序列来生成字典类型ID
- 使用 `information_schema.columns` 获取列信息
- 使用 `CASE WHEN` 语句进行条件判断
## 部署步骤
### 1. 数据库部署
执行SQL脚本PostgreSQL
```bash
psql -U postgres -d his_database -f add_operating_room_type_fields.sql
```
或者使用 pgAdmin 等图形化工具执行SQL脚本。
### 2. 后端部署
重启后端服务,使新的代码生效。
### 3. 前端部署
重新编译并部署前端代码:
```bash
npm run build
```
## 使用说明
### 新增手术室
1. 进入手术室管理页面
2. 点击"新增手术室"按钮
3. 填写手术室信息:
- 手术室名称(必填)
- 类型(可选,默认为择期手术室)
- 所属科室(必填)
- 位置描述
- 设备配置
- 容纳人数
- 状态(默认为启用)
- 显示顺序
- 备注
4. 点击"确定"保存
### 修改手术室
1. 在手术室列表中找到要修改的记录
2. 点击"编辑"按钮
3. 修改相关信息(包括类型和所属科室)
4. 点击"确定"保存
### 查看手术室详情
1. 在手术室列表中点击"查看"按钮
2. 查看完整的手术室信息,包括类型和所属科室
### 查询手术室
- 按手术室名称模糊查询
- 按状态筛选(启用/停用)
## 注意事项
1. **数据迁移**:现有手术室的类型默认设置为"择期手术室"2可以根据实际需要调整。
2. **科室关联**:所属科室是必填字段,需要在科室管理中先配置好科室信息。
3. **类型字典**:手术室类型字典已自动创建,可以在系统字典管理中进行维护。
4. **索引优化**:已为类型和科室字段添加索引,提升查询性能。
5. **兼容性**:此次修改保持了向后兼容性,不影响现有功能。
## 验证清单
- [ ] 数据库字段添加成功
- [ ] 字典数据创建成功
- [ ] 前端列表正确显示类型和所属科室
- [ ] 新增手术室时可选择类型和所属科室
- [ ] 修改手术室时可更新类型和所属科室
- [ ] 查看手术室详情时正确显示类型和所属科室
- [ ] 类型下拉选项显示正确
- [ ] 所属科室选择器可正常搜索和选择
- [ ] 查询功能正常工作
- [ ] 没有语法错误和运行时错误
## 回滚方案
如需撤销本次修改请执行SQL脚本中的回滚语句PostgreSQL
```sql
DROP INDEX idx_room_type ON public.adm_operating_room;
DROP INDEX idx_org_id ON public.adm_operating_room;
DELETE FROM public.sys_dict_data WHERE dict_type = 'operating_room_type';
DELETE FROM public.sys_dict_type WHERE dict_type = 'operating_room_type';
ALTER TABLE public.adm_operating_room DROP COLUMN room_type_enum;
```
## 技术支持
如有问题,请联系技术支持团队。

View File

@@ -1,215 +0,0 @@
# 手术申请医生科室字段保存问题解决方案
## 问题确认
数据库中只保存了 ID 字段(`apply_doctor_id``apply_dept_id`),但没有保存名称字段(`apply_doctor_name``apply_dept_name`)。
## 根本原因
**数据库表中缺少 `apply_doctor_name``apply_dept_name` 这两个字段!**
虽然 MyBatis 映射文件和实体类都配置了这些字段但如果数据库表中不存在这些列MyBatis 在插入时会静默忽略这些字段(不会报错),导致只有 ID 被保存。
## 解决步骤
### 步骤 1执行数据库迁移脚本必须
使用 Navicat Premium 17 执行以下 SQL
```sql
-- 方法1使用 IF NOT EXISTS 语法(推荐)
ALTER TABLE public.cli_surgery ADD COLUMN IF NOT EXISTS apply_doctor_name VARCHAR(100);
COMMENT ON COLUMN public.cli_surgery.apply_doctor_name IS '申请医生姓名';
ALTER TABLE public.cli_surgery ADD COLUMN IF NOT EXISTS apply_dept_name VARCHAR(100);
COMMENT ON COLUMN public.cli_surgery.apply_dept_name IS '申请科室名称';
-- 验证字段是否添加成功
SELECT column_name, data_type, character_maximum_length
FROM information_schema.columns
WHERE table_name = 'cli_surgery'
AND column_name IN ('apply_doctor_name', 'apply_dept_name');
```
**预期结果**
```
apply_doctor_name | character varying | 100
apply_dept_name | character varying | 100
```
### 步骤 2重启后端服务
执行数据库迁移后,必须重启后端服务以重新加载表结构。
### 步骤 3新增手术并查看日志
1. 打开后端控制台或日志文件
2. 在前端新增一条手术记录
3. 查看后端日志,应该能看到:
```
设置申请医生信息 - doctorId: 123, doctorName: 张医生, deptId: 456, deptName: 普外科
前端提交的数据 - applyDoctorId: 123, applyDoctorName: 张医生, applyDeptId: 456, applyDeptName: 普外科
准备插入手术记录 - applyDoctorId: 123, applyDoctorName: 张医生, applyDeptId: 456, deptName: 普外科
准备插入手术记录 - applyDoctorId: 123, applyDoctorName: 张医生, applyDeptId: 456, deptName: 普外科
插入后查询结果 - applyDoctorId: 123, applyDoctorName: 张医生, applyDeptId: 456, deptName: 普外科
手术记录插入成功 - surgeryId: 1234567890123456789, surgeryNo: OP202501051234
```
**关键检查点**
- `准备插入手术记录` 这行日志中,`applyDoctorName``applyDeptName` 必须有值(不能为 null
- `插入后查询结果` 这行日志中,这两个字段也必须有值
### 步骤 4验证数据库
执行以下 SQL 查询最新插入的记录:
```sql
SELECT
id,
surgery_no,
apply_doctor_id,
apply_doctor_name,
apply_dept_id,
apply_dept_name,
surgery_name,
create_time
FROM public.cli_surgery
WHERE delete_flag = '0'
ORDER BY create_time DESC
LIMIT 1;
```
**预期结果**
- `apply_doctor_id`有值例如123
- `apply_doctor_name`:有值(例如:张医生)
- `apply_dept_id`有值例如456
- `apply_dept_name`:有值(例如:普外科)
### 步骤 5测试前端显示
1. 刷新手术管理页面
2. 查看列表中是否显示申请医生和申请科室列
3. 点击"查看"或"编辑"按钮,检查详情对话框是否显示这些信息
## 常见问题和解决
### 问题 1执行 SQL 后报错 "column does not exist"
**原因**:数据库表结构可能不同,或者表名不是 `cli_surgery`
**解决**:先执行以下 SQL 检查表名:
```sql
SELECT table_name
FROM information_schema.tables
WHERE table_name LIKE '%surgery%'
AND table_schema = 'public';
```
### 问题 2执行 SQL 后字段仍然不存在
**原因**:可能是权限问题或 SQL 语法问题
**解决**:尝试使用更简单的方式:
```sql
-- 先检查表结构
\d public.cli_surgery
-- 手动添加字段(如果不存在)
-- 注意:如果字段已存在,这个语句会报错,这是正常的
ALTER TABLE public.cli_surgery ADD COLUMN apply_doctor_name VARCHAR(100);
ALTER TABLE public.cli_surgery ADD COLUMN apply_dept_name VARCHAR(100);
```
### 问题 3字段添加成功但插入时仍然为空
**原因**MyBatis 或 MyBatis-Plus 配置问题
**解决**
1. 检查实体类字段是否有 `@TableField` 注解
2. 检查字段名是否与数据库列名一致
3. 查看后端日志中的 `插入后查询结果`
### 问题 4后端日志显示字段为 null
**原因**:后端代码中 `applyDoctorName``applyDeptName` 被设置为 null
**解决**
1. 检查 `SecurityUtils.getLoginUser().getUser().getNickName()` 是否返回 null
2. 检查 `SecurityUtils.getLoginUser().getOrgId()` 是否返回 null
3. 检查 `organizationService.getById(orgId)` 是否返回 null
## 验证清单
- [ ] 数据库迁移脚本已执行
- [ ] 数据库字段已添加(步骤 1 验证 SQL 有结果)
- [ ] 后端服务已重启
- [ ] 后端日志显示 `准备插入手术记录` 且字段有值
- [ ] 后端日志显示 `插入后查询结果` 且字段有值
- [ ] 数据库查询显示字段有值(步骤 4
- [ ] 前端列表正确显示
- [ ] 前端详情正确显示
## 调试 SQL 脚本
如果需要手动测试插入功能,可以执行:
```sql
-- 测试插入(确保字段存在)
INSERT INTO public.cli_surgery (
surgery_no,
patient_id,
encounter_id,
apply_doctor_id,
apply_doctor_name,
apply_dept_id,
apply_dept_name,
surgery_name,
status_enum,
delete_flag,
create_time,
update_time
) VALUES (
'TEST202501050002',
(SELECT id FROM public.adm_patient WHERE delete_flag = '0' LIMIT 1),
(SELECT id FROM public.adm_encounter WHERE delete_flag = '0' LIMIT 1),
999,
'手动测试医生',
999,
'手动测试科室',
'手动测试手术',
0,
'0',
NOW(),
NOW()
);
-- 查询刚才插入的数据
SELECT
surgery_no,
apply_doctor_id,
apply_doctor_name,
apply_dept_id,
apply_dept_name,
surgery_name
FROM public.cli_surgery
WHERE surgery_no = 'TEST202501050002';
-- 清理测试数据
-- DELETE FROM public.cli_surgery WHERE surgery_no = 'TEST202501050002';
```
## 联系支持
如果以上步骤都无法解决问题,请提供:
1. **数据库表结构查询结果**
```sql
\d public.cli_surgery
```
2. **后端日志**:特别是 `准备插入手术记录` 和 `插入后查询结果` 这两行
3. **数据库查询结果**:执行步骤 4 中的 SQL告诉我结果
4. **错误信息**:如果有任何错误提示

View File

@@ -1,194 +0,0 @@
# 手术申请医生科室数据保存问题排查指南
## 问题现象
新增手术后,列表页面和编辑查看页面没有显示申请医生名称和科室名称。
## 排查步骤
### 步骤1检查数据库字段是否存在
执行以下 SQL 检查字段是否已添加:
```sql
SELECT column_name, data_type
FROM information_schema.columns
WHERE table_name = 'cli_surgery'
AND column_name IN ('apply_doctor_name', 'apply_dept_name');
```
**预期结果**:应该返回两条记录
```
apply_doctor_name | character varying
apply_dept_name | character varying
```
**如果结果为空**:说明字段未添加,需要执行迁移脚本。
### 步骤2检查数据库迁移脚本是否执行
执行迁移脚本(如果未执行):
```sql
-- 检查并添加申请医生姓名字段
DO $$
BEGIN
IF NOT EXISTS (
SELECT 1
FROM information_schema.columns
WHERE table_name = 'cli_surgery'
AND column_name = 'apply_doctor_name'
) THEN
ALTER TABLE public.cli_surgery ADD COLUMN apply_doctor_name VARCHAR(100);
COMMENT ON COLUMN public.cli_surgery.apply_doctor_name IS '申请医生姓名';
END IF;
END $$;
-- 检查并添加申请科室名称字段
DO $$
BEGIN
IF NOT EXISTS (
SELECT 1
FROM information_schema.columns
WHERE table_name = 'cli_surgery'
AND column_name = 'apply_dept_name'
) THEN
ALTER TABLE public.cli_surgery ADD COLUMN apply_dept_name VARCHAR(100);
COMMENT ON COLUMN public.cli_surgery.apply_dept_name IS '申请科室名称';
END IF;
END $$;
```
### 步骤3重启后端服务
执行数据库迁移后,必须重启后端服务。
### 步骤4新增手术并查看后端日志
1. 打开后端控制台或日志文件
2. 在前端新增一条手术记录
3. 查看后端日志,应该能看到以下信息:
```
设置申请医生信息 - doctorId: 123, doctorName: 张医生, deptId: 456, deptName: 普外科
前端提交的数据 - applyDoctorId: 123, applyDoctorName: 张医生, applyDeptId: 456, applyDeptName: 普外科
准备插入手术记录 - applyDoctorId: 123, applyDoctorName: 张医生, applyDeptId: 456, deptName: 普外科
手术记录插入成功 - surgeryId: 1234567890123456789, surgeryNo: OP202501051234
```
**如果看不到这些日志**:说明代码没有执行到这里,检查是否有异常抛出。
**如果看到 "前端提交的数据 - applyDoctorName: null"**:说明前端提交的数据为空,需要检查前端代码。
### 步骤5检查数据库中是否保存成功
执行以下 SQL 查询最新插入的记录:
```sql
SELECT
id,
surgery_no,
patient_id,
apply_doctor_id,
apply_doctor_name,
apply_dept_id,
apply_dept_name,
surgery_name,
status_enum,
create_time
FROM public.cli_surgery
WHERE delete_flag = '0'
ORDER BY create_time DESC
LIMIT 5;
```
**如果 apply_doctor_name 和 apply_dept_name 字段为空**:说明数据没有保存成功。
**如果字段有值**:说明保存成功,问题出在前端显示。
### 步骤6检查前端 API 响应
1. 打开浏览器开发者工具F12
2. 切换到 Network 标签
3. 新增手术
4. 找到 `/clinical-manage/surgery/surgery-page` 请求
5. 点击查看响应内容
检查响应数据中是否包含 `applyDoctorName``applyDeptName` 字段。
**如果响应中没有这些字段**:说明 MyBatis 映射有问题,检查 XML 配置。
**如果响应中有这些字段但值为 null**说明数据库中为空回到步骤5。
### 步骤7检查前端表格显示
查看前端代码中的表格列配置:
```vue
<el-table-column label="申请医生" align="center" prop="applyDoctorName" width="100" />
<el-table-column label="申请科室" align="center" prop="applyDeptName" width="120" show-overflow-tooltip />
```
确保 `prop` 属性与后端返回的字段名一致(注意大小写)。
## 常见问题和解决方案
### 问题1数据库字段未添加
**症状**:后端报错 "column apply_doctor_name does not exist"
**解决**:执行数据库迁移脚本
### 问题2后端日志显示 applyDoctorName 为 null
**症状**:日志中 "前端提交的数据 - applyDoctorName: null"
**原因**前端提交数据时disabled 字段没有被包含
**解决**:检查前端 submitForm 函数,确保手动设置了这些字段
### 问题3数据库中有值但前端不显示
**症状**:数据库查询有值,前端响应也有值,但表格不显示
**原因**
1. 前端 prop 属性名与后端字段名不一致(大小写问题)
2. 前端数据未正确绑定
**解决**
1. 检查 prop 属性名,确保与后端返回的 JSON 字段名一致
2. 检查浏览器控制台是否有 JavaScript 错误
### 问题4MyBatis 映射未生效
**症状**:后端保存成功,但查询时字段为 null
**原因**XML 映射文件未正确配置
**解决**
1. 检查 SurgeryMapper.xml 中的 resultMap 配置
2. 检查 SQL 查询中是否包含这些字段
3. 重启后端服务
## 验证清单
- [ ] 数据库迁移脚本已执行
- [ ] 数据库字段已添加步骤1
- [ ] 后端服务已重启
- [ ] 后端日志显示申请医生信息步骤4
- [ ] 数据库中已保存数据步骤5
- [ ] 前端 API 响应包含这些字段步骤6
- [ ] 前端表格正确显示步骤7
## 附加 SQL 脚本
### 查看统计信息
```sql
SELECT
COUNT(*) as total_count,
COUNT(apply_doctor_name) as has_doctor_name_count,
COUNT(apply_dept_name) as has_dept_name_count
FROM public.cli_surgery
WHERE delete_flag = '0';
```
### 手动更新测试数据
如果需要手动更新已有的测试数据:
```sql
UPDATE public.cli_surgery
SET apply_doctor_name = '测试医生',
apply_dept_name = '测试科室'
WHERE apply_doctor_name IS NULL
AND delete_flag = '0';
```
## 联系支持
如果以上步骤都无法解决问题,请提供以下信息:
1. 数据库字段查询结果步骤1
2. 后端日志截图步骤4
3. 数据库查询结果步骤5
4. 浏览器 Network 响应截图步骤6
5. 浏览器 Console 错误信息

View File

@@ -1,351 +0,0 @@
# 手术管理模块开发说明
## 模块概述
手术管理模块是一个完整的医疗手术管理系统涵盖从手术排期、执行到记录的全流程管理。本模块基于经典的Spring Boot + Vue3前后端分离架构开发。
## 功能特性
### 1. 手术信息管理
- 手术基本信息录入(手术名称、编码、类型、等级)
- 患者信息关联
- 就诊信息关联
- 手术部位描述
### 2. 手术团队管理
- 主刀医生选择
- 麻醉医生选择
- 助手1/助手2选择
- 巡回护士选择
- 麻醉方式选择
### 3. 手术状态管理
- 待排期
- 已排期
- 手术中
- 已完成
- 已取消
- 暂停
### 4. 手术时间管理
- 计划手术时间
- 实际开始时间
- 实际结束时间
### 5. 诊断信息管理
- 术前诊断
- 术后诊断
- 手术经过描述
- 术后医嘱
- 并发症描述
### 6. 手术费用管理
- 手术费用
- 麻醉费用
- 总费用自动计算
### 7. 手术切口管理
- 切口等级I级、II级、III级、IV级
- 愈合等级(甲级、乙级、丙级)
## 技术架构
### 后端技术栈
- Spring Boot 2.x
- MyBatis Plus
- PostgreSQL 12+
- JDK 1.8+
### 前端技术栈
- Vue 3.x
- Element Plus
- Axios
- Vite
## 目录结构
```
openh-is/
├── openhis-server-new/ # 后端项目
│ ├── openhis-domain/ # 领域层
│ │ └── src/main/java/com/openhis/
│ │ ├── clinical/
│ │ │ ├── domain/
│ │ │ │ └── Surgery.java # 手术实体类
│ │ │ ├── mapper/
│ │ │ │ └── SurgeryMapper.java # 手术Mapper接口
│ │ │ └── service/
│ │ │ ├── ISurgeryService.java # 手术Service接口
│ │ │ └── impl/
│ │ │ └── SurgeryServiceImpl.java # 手术Service实现
│ │ └── common/ # 公共模块
│ │ └── src/main/java/com/openhis/common/
│ │ └── enums/ # 枚举类
│ │ ├── SurgeryTypeEnum.java # 手术类型枚举
│ │ ├── SurgeryStatusEnum.java # 手术状态枚举
│ │ ├── SurgeryLevelEnum.java # 手术等级枚举
│ │ ├── AnesthesiaTypeEnum.java # 麻醉方式枚举
│ │ ├── IncisionLevelEnum.java # 切口等级枚举
│ │ └── HealingLevelEnum.java # 愈合等级枚举
│ │
│ ├── openhis-application/ # 应用层
│ │ └── src/main/java/com/openhis/web/clinicalmanage/
│ │ ├── controller/
│ │ │ └── SurgeryController.java # 手术控制器
│ │ ├── dto/
│ │ │ └── SurgeryDto.java # 手术数据传输对象
│ │ ├── appservice/
│ │ │ ├── ISurgeryAppService.java # 手术应用服务接口
│ │ │ └── impl/
│ │ │ └── SurgeryAppServiceImpl.java # 手术应用服务实现
│ │ └── mapper/
│ │ └── SurgeryAppMapper.java # 手术应用Mapper
│ │
│ └── src/main/resources/mapper/
│ ├── clinical/
│ │ └── SurgeryMapper.xml # 手术Mapper XML
│ └── clinicalmanage/
│ └── SurgeryMapper.xml # 手术应用Mapper XML
├── openhis-ui-vue3/ # 前端项目
│ └── src/
│ ├── api/
│ │ └── surgerymanage.js # 手术API接口
│ └── views/
│ └── surgerymanage/
│ └── index.vue # 手术管理页面
└── surgery_manage_init.sql # 数据库初始化脚本
```
## 数据库设计
### 主表cli_surgery手术管理表
| 字段名 | 类型 | 说明 |
|--------|------|------|
| id | bigint | 主键ID |
| surgery_no | varchar(50) | 手术编号(唯一) |
| patient_id | bigint | 患者ID |
| patient_name | varchar(100) | 患者姓名 |
| encounter_id | bigint | 就诊ID |
| surgery_name | varchar(200) | 手术名称 |
| surgery_code | varchar(100) | 手术编码 |
| surgery_type_enum | int2 | 手术类型 |
| surgery_level | int2 | 手术等级 |
| status_enum | int2 | 手术状态 |
| planned_time | timestamp | 计划手术时间 |
| actual_start_time | timestamp | 实际开始时间 |
| actual_end_time | timestamp | 实际结束时间 |
| main_surgeon_id | bigint | 主刀医生ID |
| main_surgeon_name | varchar(100) | 主刀医生姓名 |
| anesthetist_id | bigint | 麻醉医生ID |
| anesthetist_name | varchar(100) | 麻醉医生姓名 |
| anesthesia_type_enum | int2 | 麻醉方式 |
| body_site | varchar(200) | 手术部位 |
| preoperative_diagnosis | text | 术前诊断 |
| postoperative_diagnosis | text | 术后诊断 |
| surgery_fee | numeric(10,2) | 手术费用 |
| anesthesia_fee | numeric(10,2) | 麻醉费用 |
| total_fee | numeric(10,2) | 总费用 |
### 字典表
手术管理模块包含以下字典类型:
- surgery_status手术状态
- surgery_type手术类型
- surgery_level手术等级
- anesthesia_type麻醉方式
- incision_level切口等级
- healing_level愈合等级
## 安装部署
### 1. 数据库初始化
执行SQL脚本初始化数据库表和字典数据
```bash
psql -U postgres -d his_database -f surgery_manage_init.sql
```
或者使用psql客户端执行
```sql
\i /path/to/surgery_manage_init.sql
```
### 2. 后端配置
1. 将后端代码复制到对应目录
2. 修改数据库连接配置application.yml
3. 启动Spring Boot应用
### 3. 前端配置
1. 将前端代码复制到对应目录
2. 配置API接口地址.env.development
3. 启动前端开发服务器
```bash
npm install
npm run dev
```
## API接口说明
### 1. 分页查询手术列表
**接口地址:** `GET /clinical-manage/surgery/surgery-page`
**请求参数:**
```json
{
"pageNo": 1,
"pageSize": 10,
"surgeryNo": "SS20251230001",
"surgeryName": "阑尾切除术",
"patientName": "张三",
"statusEnum": 1,
"surgeryTypeEnum": 2
}
```
### 2. 查询手术详情
**接口地址:** `GET /clinical-manage/surgery/surgery-detail`
**请求参数:**
```
id: 手术ID
```
### 3. 新增手术
**接口地址:** `POST /clinical-manage/surgery/surgery`
**请求参数:**
```json
{
"patientId": 1,
"surgeryName": "阑尾切除术",
"surgeryCode": "ICD-9-CM:47.09",
"surgeryTypeEnum": 2,
"surgeryLevel": 2,
"plannedTime": "2025-12-31 09:00:00",
"mainSurgeonId": 10,
"anesthetistId": 11,
"anesthesiaTypeEnum": 3,
"bodySite": "腹部"
}
```
### 4. 修改手术
**接口地址:** `PUT /clinical-manage/surgery/surgery`
**请求参数:** 同新增手术需包含id
### 5. 删除手术
**接口地址:** `DELETE /clinical-manage/surgery/surgery`
**请求参数:**
```
id: 手术ID
```
### 6. 更新手术状态
**接口地址:** `PUT /clinical-manage/surgery/surgery-status`
**请求参数:**
```
id: 手术ID
statusEnum: 状态值
```
## 前端页面功能
### 1. 查询功能
- 支持按手术编号、手术名称、患者姓名模糊查询
- 支持按手术状态、手术类型精确查询
- 支持按计划时间范围查询
### 2. 新增功能
- 完整的手术信息录入表单
- 患者下拉选择
- 医生/护士下拉选择
- 费用自动计算
### 3. 编辑功能
- 仅待排期和已排期状态的手术可编辑
- 手术中或已完成的手术不可编辑
### 4. 状态流转
- 已排期 → 手术中
- 手术中 → 已完成
- 待排期/已排期 → 已取消
### 5. 删除功能
- 仅待排期和已排期状态的手术可删除
- 已完成的手术不能删除
## 扩展开发建议
### 1. 手术排期管理
- 可增加手术排期日历视图
- 手术室资源冲突检测
- 手术排队优先级管理
### 2. 手术统计报表
- 手术量统计
- 手术类型分布
- 手术成功率统计
- 手术费用统计
### 3. 手术文档管理
- 手术知情同意书
- 手术安全核查表
- 手术记录单
- 麻醉记录单
### 4. 手术质控管理
- 手术质量评估
- 并发症统计
- 术后恢复跟踪
- 手术质量指标管理
## 注意事项
1. **手术编号生成**手术编号采用自动生成机制格式为SS + 10位数字
2. **权限控制**:需要配置相应的菜单权限和操作权限
3. **数据校验**:新增手术时必须选择患者和主刀医生
4. **状态流转**:手术状态的流转需要符合业务逻辑
5. **费用计算**:总费用自动计算,不允许手动修改
## 常见问题
### Q1: 手术编号重复怎么办?
A: 手术编号是系统自动生成的唯一编号不会重复。如果需要自定义编号需要修改SurgeryServiceImpl中的生成逻辑。
### Q2: 如何添加新的手术类型?
A: 在数据库sys_dict_data表中添加新的surgery_type字典数据即可。
### Q3: 手术开始后还能修改信息吗?
A: 根据业务规则,手术开始后不允许修改基本信息,但可以补充术后诊断等信息。
### Q4: 如何实现手术室资源管理?
A: 可以新增手术室管理模块,建立手术排期与手术室的关联关系,实现资源冲突检测。
## 版本历史
- v1.0.0 (2025-12-30)
- 初始版本发布
- 实现手术基本管理功能
- 实现手术状态流转
- 实现手术团队管理
## 联系方式
如有问题或建议,请联系开发团队。

View File

@@ -1,160 +0,0 @@
# 门诊就诊记录SQL查询优化建议
## 当前查询分析
### 主要查询表
```sql
SELECT
enc.id as encounterId,
pt.name,
pt.id_card,
pt.bus_no as patientBusNo,
enc.bus_no as encounterBusNo,
pt.gender_enum,
pt.phone,
enc.create_time as encounterTime,
enc.status_enum as subjectStatusEnum,
org.name as organizationName,
prac.name as doctorName
FROM adm_encounter AS enc
LEFT JOIN adm_organization AS org ON enc.organization_id = org.ID AND org.delete_flag = '0'
LEFT JOIN adm_encounter_participant AS ep
ON enc.ID = ep.encounter_id AND ep.type_code = #{participantType} AND ep.delete_flag = '0'
LEFT JOIN adm_practitioner AS prac ON ep.practitioner_id = prac.ID AND prac.delete_flag = '0'
LEFT JOIN adm_patient AS pt ON enc.patient_id = pt.ID AND pt.delete_flag = '0'
```
### 常见查询条件
1. `enc.delete_flag = '0'`
2. `enc.tenant_id = ?`
3. `pt.name LIKE ?`
4. `pt.id_card LIKE ?`
5. `pt.bus_no LIKE ?`
6. `enc.bus_no LIKE ?`
7. `pt.gender_enum = ?`
8. `enc.status_enum = ?`
9. `prac.name LIKE ?`
10. `pt.phone LIKE ?`
11. `enc.create_time BETWEEN ? AND ?`
## 索引优化建议
### 1. adm_encounter 表索引
```sql
-- 复合索引:提高查询性能
CREATE INDEX idx_encounter_tenant_delete_status ON adm_encounter(tenant_id, delete_flag, status_enum);
-- 时间范围查询索引
CREATE INDEX idx_encounter_create_time ON adm_encounter(create_time);
-- 业务编号查询索引
CREATE INDEX idx_encounter_bus_no ON adm_encounter(bus_no);
-- 患者ID关联索引
CREATE INDEX idx_encounter_patient_id ON adm_encounter(patient_id);
```
### 2. adm_patient 表索引
```sql
-- 姓名模糊查询索引
CREATE INDEX idx_patient_name ON adm_patient(name);
-- 身份证号查询索引
CREATE INDEX idx_patient_id_card ON adm_patient(id_card);
-- 业务编号查询索引
CREATE INDEX idx_patient_bus_no ON adm_patient(bus_no);
-- 电话查询索引
CREATE INDEX idx_patient_phone ON adm_patient(phone);
-- 复合索引:常用查询条件
CREATE INDEX idx_patient_delete_gender ON adm_patient(delete_flag, gender_enum);
```
### 3. adm_encounter_participant 表索引
```sql
-- 复合索引:提高连接性能
CREATE INDEX idx_ep_encounter_type ON adm_encounter_participant(encounter_id, type_code, delete_flag);
-- 参与者ID索引
CREATE INDEX idx_ep_practitioner ON adm_encounter_participant(practitioner_id);
```
### 4. adm_practitioner 表索引
```sql
-- 姓名查询索引
CREATE INDEX idx_practitioner_name ON adm_practitioner(name);
-- 复合索引:常用查询条件
CREATE INDEX idx_practitioner_delete_tenant ON adm_practitioner(delete_flag, tenant_id);
```
### 5. adm_organization 表索引
```sql
-- 主键关联索引
CREATE INDEX idx_organization_id_delete ON adm_organization(id, delete_flag);
```
## 查询优化建议
### 1. 添加查询统计信息收集
```sql
-- 定期分析表统计信息
ANALYZE TABLE adm_encounter;
ANALYZE TABLE adm_patient;
ANALYZE TABLE adm_encounter_participant;
ANALYZE TABLE adm_practitioner;
ANALYZE TABLE adm_organization;
```
### 2. 考虑分区表(针对大数据量)
如果 `adm_encounter` 表数据量超过100万条考虑按时间分区
```sql
-- 按月分区
PARTITION BY RANGE (YEAR(create_time) * 100 + MONTH(create_time))
(
PARTITION p202501 VALUES LESS THAN (202501),
PARTITION p202502 VALUES LESS THAN (202502),
-- ... 更多分区
);
```
### 3. 添加覆盖索引Covering Index
对于常用查询字段,创建覆盖索引避免回表:
```sql
CREATE INDEX idx_encounter_cover ON adm_encounter(
tenant_id, delete_flag, create_time,
status_enum, bus_no, patient_id
) INCLUDE (organization_id);
```
## 执行计划检查
建议定期检查查询执行计划:
```sql
EXPLAIN ANALYZE
SELECT -- 完整查询语句
FROM adm_encounter AS enc
-- ... 连接条件
WHERE enc.delete_flag = '0'
AND enc.tenant_id = 1
-- ... 其他条件
ORDER BY enc.create_time DESC;
```
## 监控建议
1. **慢查询监控**监控执行时间超过1秒的查询
2. **索引使用监控**:定期检查未使用的索引
3. **表空间监控**:监控表增长和碎片情况
4. **连接性能监控**监控JOIN操作的性能
## 实施步骤
1. 在测试环境创建建议的索引
2. 执行查询性能测试
3. 分析执行计划,确认索引有效性
4. 在生产环境非高峰期创建索引
5. 监控生产环境性能变化
6. 定期维护和优化索引

View File

@@ -0,0 +1,287 @@
## 手术室维护界面PRD文档
### 一、页面概述
**页面名称**:手术室维护界面
**页面目标**:提供手术室基础数据的维护功能,包括新增、编辑、启用/停用手术室信息,为手术安排提供基础数据支持
**适用场景**:医院管理员需要新增、修改、启用/停用手术室信息时使用
**页面类型**:列表页+表单页(含模态框)
**原型图地址:**https://static.pm-ai.cn/prototype/20260104/ee5d222231effefcb39624d1646a2e20/index.html
**核心功能**
1. 手术室列表展示与查询
2. 新增手术室信息
3. 编辑现有手术室信息
4. 启用/停用手术室状态
5. 数据有效性校验
**用户价值**
- 管理员可集中管理所有手术室基础信息
- 确保手术安排时能获取准确的手术室数据
- 通过状态管理控制手术室可用性
**流程图:**
![](media/6a369a41c55f8727aa574bf43fa7500b.png)
```mermaid
flowchart TD
A[手术室维护界面] --> B[手术室列表展示]
B --> C[新增手术室]
B --> D[编辑手术室]
B --> E[启用/停用手术室]
B --> F[查询手术室]
C --> G[点击新增按钮]
G --> H[打开新增模态框]
H --> I[填写表单字段]
I --> J{必填字段校验}
J -->|通过| K[提交数据]
J -->|不通过| L[提示请填写所有必填项]
K --> M[表格新增数据行]
D --> N[点击修改按钮]
N --> O[打开编辑模态框]
O --> P[修改表单字段]
P --> Q{必填字段校验}
Q -->|通过| R[保存数据]
Q -->|不通过| S[提示请填写所有必填项]
R --> T[更新表格对应行]
E --> U[点击启用/停用按钮]
U --> V{二次确认}
V -->|确认| W[切换状态标签]
V -->|取消| X[取消操作]
W --> Y[更新按钮状态]
F --> Z[输入查询条件]
Z --> AA[筛选表格数据]
K --> AB{房间号重复校验}
AB -->|不重复| AC[提示房间号已存在]
AB -->|重复| AD[更新按钮状态]
```
### 二、整体布局分析
**页面宽度**:自适应布局
**主要区域划分**
1. 页头区域15%高度)
2. 表格展示区85%高度)
**布局特点**:上下布局,表格采用固定表头+滚动内容区设计
**响应式要求**:移动端适配时改为纵向堆叠布局,操作按钮组变为纵向排列
### 三、页面区域详细描述
#### 1. 页头区域
**区域位置**:页面顶部
**区域尺寸**高度60px宽度100%
**区域功能**:展示标题和主要操作入口
**包含元素**
- **标题文本**
- 元素类型H1标题
- 显示内容:"手术室列表"
- 样式特征1.75rem/600字重深灰色(#333)
- **新增按钮**
- 元素类型:主要操作按钮
- 显示内容:"新增"(带+图标)
- 交互行为:点击触发新增模态框
- 样式特征:蓝色背景(#5a7cff)白色文字8px圆角悬停上浮1px
#### 2. 表格展示区(手术室列表表格)
**区域位置**:页头下方
**区域尺寸**高度自适应宽度100%
**区域功能**:展示手术室数据并支持行级操作
**包含元素**
- **数据表格**
- 展示方式:固定表头表格
- 数据字段:
- 房间号:文本 - OR01 - 不可操作
- 手术室名称:文本 - 第一手术室 - 不可操作
- 类型:文本 - 普通/日间/复合 - 不可操作
- 所属科室:文本 - 外科 - 不可操作
- 状态:标签 - 有效/无效 - 通过操作按钮切换
- 操作功能:每行包含"修改"和"状态切换(停用-黄色/启用-绿色)"按钮
- **表格样式**
- 表头:浅灰色背景(#f8f9fa)大写字母14px字号
- 行悬停:浅灰色背景(#f8f9fa)
- 状态标签:
- 有效:绿色背景+文字(#28a745)
- 无效:灰色背景+文字(#6c757d)
#### 3. 新增手术室弹窗
**区域位置**:页面居中模态弹窗
**区域功能**:收集新增手术室所需信息
**包含元素**
- 表单字段:
1. 房间号输入框
2. 类型:文本输入
3. 必填:是
4. 示例值OR04
5. 校验规则:非空校验
6. 手术室名称输入框
- 类型:文本输入
- 必填:是
- 示例值:第四手术室
1. 手术室类型下拉框
- 类型:单选下拉
- 选项:普通/日间/复合/特殊
- 默认值:普通
1. 所属科室下拉框
- 类型:单选下拉
- 必填:是
- 选项:外科/妇产科等8个科室
- 默认提示:"请选择科室"
- 操作按钮:
- 取消按钮(灰色边框)
- 确认按钮(蓝色填充)
- 校验逻辑:必填字段非空校验
- 成功反馈:提示"手术室添加成功"
- 失败反馈:提示"请填写所有必填项"
#### 4. 编辑手术室弹窗
**区域位置**:页面居中模态弹窗
**区域功能**:修改现有手术室信息
**包含元素**
- 表单字段(同新增弹窗,带初始值)
- 操作按钮:
- 取消按钮
- 保存按钮
- 校验逻辑:同新增弹窗
- 成功反馈:提示"手术室信息已更新"
### 四、交互功能详细说明
#### 1. 新增手术室
**功能描述**:添加新的手术室记录
**触发条件**:点击页头"新增"按钮
**操作流程**
1. 打开新增模态框
2. 填写必填字段(房间号、名称、科室)
3. 点击确认提交插入his_or_room表
4. 表格末尾新增数据行
**异常处理**
- 必填项为空时弹出"请填写所有必填项"提示
- 房间号重复需在后端校验并提示
#### 2. 编辑手术室
**功能描述**:修改现有手术室信息
**触发条件**:点击行内"修改"按钮
**操作流程**
1. 打开编辑模态框(自动填充当前行数据)
2. 用户修改数据
3. 点击"保存"时校验并更新对应行数据
**状态保持**:记录当前编辑行索引确保数据更新准确
#### 3. 状态切换
**功能描述**:启用/停用手术室
**触发条件**:点击"停用"或"启用"按钮
**操作流程**
1. 弹出二次确认对话框
2. 用户确认后切换状态标签
3. 按钮变为相反操作(停用↔启用)
4. 、停用手术室
- **步骤**
1. 查询需要停用的手术室记录。
2. 将 valid_flag 设置为 0无效
- **示例**
UPDATE his_or_room
SET valid_flag = '0'
WHERE room_code = 'OR06';
5\. 启用手术室
**步骤**
1. 查询需要启用的手术室记录。
1. 将 valid_flag 设置为 1有效
- **示例**
UPDATE his_or_room
SET valid_flag = '1'
WHERE room_code = 'OR06';
**防误操作**:所有状态变更需二次确认
### 五、数据结构说明HIS_OR_ROOM手术室字典表
| **字段名称** | **数据类型** | **是否为空** | **说明/典型值** | **外键/来源** |
|--------------|--------------|--------------|-----------------|-------------------------------|
| room_id | VARCHAR(10) | N | 主键 | 自增主键 |
| room_code | VARCHAR(10) | N | 手术室房间号 | 自定义编码,如 OR01、OR02 |
| room_name | VARCHAR(100) | N | 手术室名称 | 如 "第一手术室"、"第二手术室" |
| room_type | VARCHAR(10) | N | 手术室类型 | 普通、日间、复合 |
| dept_code | VARCHAR(10) | N | 所属科室 | FK → 科室管理的科室代码 |
| valid_flag | CHAR(1) | N | 是否有效 | 1有效0无效 |
| created_time | DATETIME | N | 创建时间 | 默认当前时间 |
| updated_time | DATETIME | N | 更新时间 | 默认当前时间,自动更新 |
### 六、开发实现要点
**样式规范**
- 主色调:#5a7cff(按钮/交互元素)
- 辅助色:#7b8a8b(次要文本)
- 字体:
- 标题1.75rem/600字重
- 正文0.875rem/400字重
- 间距系统:
- 卡片内边距24px
- 表单字段间距16px
**技术要求**
**注意事项**
1. 数据安全:
- 所有变更操作需记录操作日志
- 停用状态的手术室需在前端标记不可预约
2. 性能优化:
- 表格数据分页加载
- 模态框使用懒加载

View File

@@ -0,0 +1,387 @@
## 门诊医生站开立会诊申请单界面PRD文档
### 一、页面概述
**页面名称**:门诊医生站开立会诊申请单界面**页面目标**:帮助门诊医生完成会诊申请单的创建、编辑、提交和作废操作,实现多科室会诊流程的电子化管理**适用场景**
1. 门诊医生需要邀请其他科室专家进行会诊时
2. 会诊申请单需要修改或补充信息时
3. 会诊流程需要跟踪管理时
**页面类型**:表单页+列表页复合型界面
**核心功能**
1. 会诊申请单的新增、保存、提交、作废功能
2. 会诊科室/专家可视化选择
3. 申请单数据表格展示与交互
4. 表单数据自动填充与校验
5. 申请单打印输出
**用户价值**
- 规范会诊申请流程,减少纸质单据使用
- 通过智能填充减少医生重复录入
- 实时查看会诊申请状态(新开/已提交/已确认/已签名/已完成/已取消)
原型图地址https://static.pm-ai.cn/prototype/20260115/4eb1bd5367f9d5610b32c0ecc6c793f5/index.html
流程图:
```mermaid
flowchart TD
%% ---------- 开始 ----------
START(["开始"]) --> A["医生进入会诊申请单界面"]
%% ---------- 操作选择 ----------
A --> B{"操作选择"}
B -->|"打印"| C["选择已有申请单"]
B -->|"提交/取消提交"| D{"校验状态为“已提交”?"}
B -->|"删除"| E["弹出确认对话框"]
B -->|"结束"| F{"校验状态为“已提交”?"}
B -->|"编辑"| G["修改表单内容"]
B -->|"新增"| H["清空表单(保留患者信息)"]
%% ---------- 打印分支 ----------
C --> I["高亮选中行"]
I --> J["生成打印视图"]
J --> K["输出打印样式"]
K --> L(["取消"])
%% ---------- 提交/取消提交分支 ----------
D -->|"不通过"| M["提示“请完善必填信息”"]
D -->|"通过"| N["更新状态为“已提交/新开”"]
%% ---------- 删除分支 ----------
E --> O{"确认?"}
O -->|"是"| P["标记状态为“已取消”"]
O -->|"否"| L
%% ---------- 结束分支 ----------
F -->|"不通过"| Q["提示“请先提交申请”"]
F -->|"通过"| R["标记状态为“已完成”"]
%% ---------- 编辑分支 ----------
G --> S{"校验必填字段"}
S -->|"不通过"| M
S -->|"通过"| T["保存到表格"]
%% ---------- 新增/保存通用路径 ----------
H --> U["填写表单"]
U --> V["选择会诊科室/专家"]
V --> W["自动填充邀请对象"]
W --> X["填写病史及目的"]
X --> Y["点击保存"]
Y --> Z{"校验必填字段"}
Z -->|"不通过"| M
Z -->|"通过"| AA["生成会诊申请记录"]
AA --> AB["保存到表格"]
AB --> AC["新增/更新记录"]
%% ---------- 循环 ----------
AC --> A
N --> A
P --> A
R --> A
T --> A
M --> A
Q --> A
L --> A
```
### 二、整体布局分析
**页面宽度**自适应宽度主内容区采用7:3比例分割
**主要区域划分**
1. 顶部操作栏48px固定高度
2. 会诊申请单列表区(高度自适应)
3. 主内容区分左右结构7:3比例
- 左侧:会诊申请单表单区
- 右侧:会诊科室/专家选择区
**布局特点**:响应式上下+左右混合布局,主要对齐方式为左对齐
### 三、页面区域详细描述
#### 1. 顶部操作栏区域
**区域位置**:页面顶部固定位置**区域尺寸**高度48px宽度100%**区域功能**:提供全局操作功能入口**包含元素**
- **打印按钮**
- 元素类型:操作按钮
- 显示内容:“打印”
- 交互行为点击后生成A4打印视图自动适配医院抬头格式
- 样式特征:绿色背景(\#13C2C2)圆角4px32px高度
- **新增按钮**
- 元素类型:操作按钮
- 显示内容:“新增”
- 交互行为:点击清空表单(保留当前患者基本信息)
- 样式特征:蓝色背景(\#1890FF)
- **结束按钮**
- 元素类型:危险操作按钮
- 显示内容:“结束”
- 交互行为:点击结束已提交的会诊流程,标记申请单状态为"已结束",禁用后续操作
- 样式特征:红色背景(\#FF4D4F)
- 限制条件:需先选中已提交的会诊单
- **保存按钮**
- 元素类型:主要操作按钮
- 显示内容:“保存”
- 交互行为:点击保存当前表单数据,校验必填字段后保存至表格,自动生成时间戳
- 样式特征:绿色背景(\#52C41A)
#### 2. 会诊申请单列表区
**区域位置**:顶部操作栏下方**区域尺寸**高度自适应宽度100%**区域功能**:展示当前医生的会诊申请记录**包含元素**
- **申请单表格**
- 展示方式:带边框表格
- 数据字段:
- 序号:文本 - 自增序号 - 不可操作
- 急:布尔 - ✓表示紧急 - 不可操作
- 申请单号:文本 - CS20260105001 - 不可操作
- 会诊时间:日期 - 2026-01-05 15:08 - 不可操作
- 邀请对象:文本 - 吴院长 - 不可操作
- 申请科室:文本 - 内科 - 不可操作
- 申请医师:文本 - 张医生 - 不可操作
- 申请时间:日期 - 2026-01-05 15:08 - 不可操作
- 提交状态:布尔 - 复选框 - 仅查看
- 结束状态:布尔 - 复选框 - 仅查看
- 操作功能:
- - o 提交/取消提交按钮
```
样式要求:蓝色小按钮,禁用状态显示灰色
```
```
交互行为:切换提交状态,需二次确认
```
```
o 删除图标
```
```
样式要求红色垃圾桶图标hover时放大10%
```
```
交互行为:弹出确认对话框后作废该记录
```
[删除]**将状态改为“已取消”****
UPDATE ConsultationRequest
SET ConsultationStatus = 50,cancelnatureDate = <作废会诊时间>
WHERE ConsultationID = <会诊申请单ID> and ConsultationStatus <> 40 ;
- 交互特性:
- 行点击选中效果(蓝色高亮+左侧边框)
- 行hover浅灰色背景
- 提交按钮状态联动(切换提交状态,需二次确认)
#### 3. 会诊申请单表单区
**区域位置**:主内容区左侧**区域尺寸**占主内容区70%宽度**区域功能**:会诊申请单的详细表单填写**包含元素**
- **基础信息区**
- 申请单号只读文本【保存】时自动生成规则CS+年月日时分秒+4位随机数
- 申请时间:只读文本,自动获取系统当前时间
- 病人信息:病人姓名/性别/年龄/就诊卡号/申请医师/申请科室(不可编辑),自动获取当前患者档案信息。
- **会诊信息区**
- 会诊时间:时间控件可编辑
- 紧急标识:复选框控件
- 申请医师:默认当前登录医生
- 申请科室:默认当前医生登录的开单科室
- 门诊诊断:自动获取医生开立的门诊诊断(主诊断)
- **病史及目的**
- 多行文本域最小高度100px
- **会诊邀请**
- 会诊邀请对象:支持多选(逗号分隔)-》(可从右侧会诊邀请对象选择)
- **会诊记录区**
- 会诊意见:只读文本域
- 会诊确认参加医师:只读字段
- 所属医生、代表科室、签名医生、签名时间:只读字段
#### 4. 会诊邀请对象选择区(侧边栏)
**区域位置**:主内容区右侧**区域尺寸**占主内容区30%宽度**区域功能**:快速选择会诊科室和专家**包含元素**
- **会诊科室列表**
- 展示方式:带边框可滚动列表
- 交互行为:选择科室后动态加载对应专家
- **会诊专家列表**
- 展示方式:带边框可滚动列表
- 交互行为:点击专家自动填入会诊邀请对象字段(防重复:已选专家提示"请勿重复选择"
- 特殊逻辑:支持多选(自动用逗号分隔)
### 四、交互功能详细说明
#### 1. 会诊申请单提交流程
**功能描述**:完成会诊申请单的提交操作**触发条件**:点击表格行的"提交"按钮**操作流程**
1. 医生点击行内"提交"按钮
2. 系统校验必填字段(会诊时间、邀请对象)
3. 提交状态复选框变为已勾选
4. 按钮文字变为"取消提交"
5. 禁用该行编辑功能
【提交】**将状态从“新开”改为“已提交”**
UPDATE ConsultationRequest
SET ConsultationStatus = 10,ConfirmingPhysician = <提交会诊医生姓名> ,ConfirmingPhysicianID = <提交会诊医生ID> ,ConfirmingDate = <提交会诊时间>
WHERE ConsultationID = <会诊申请单ID> and ConsultationStatus = 0 ;
【取消提交】**将状态从“已提交”改为“新开”**
UPDATE ConsultationRequest
SET ConsultationStatus = 0,ConfirmingPhysician = '',ConfirmingPhysicianID = '',ConfirmingDate = ''
WHERE ConsultationID = <会诊申请单ID> and ConsultationStatus = 10 ;
**异常处理**
- 必填字段缺失:弹出"请完善会诊时间和邀请对象信息"
- 重复提交:提示"该申请已提交,请勿重复操作"
#### 2. 会诊流程结束功能
**功能描述**:标记会诊流程已结束**触发条件**:选中已提交的申请单后点击顶部"结束"按钮**操作流程**
1. 医生选中已提交的申请单(行高亮)
2. 点击顶部"结束"按钮
3. 系统校验提交状态为已提交
4. 结束状态复选框变为已勾选
5. 禁用该行的取消提交功能
【结束】**将状态从“已签名”改为“已完成”**
UPDATE ConsultationRequest
SET ConsultationStatus = 40,Signature = <结束会诊医生姓名> ,SignatureDate=<结束会诊时间>
WHERE ConsultationID = <会诊申请单ID> and ConsultationStatus = 30 ;
**异常处理**
- 未选中记录:提示"请先选择要结束的会诊申请"
- 未提交记录:提示"请先提交该会诊申请"
#### 3. 申请单保存功能
**功能描述**:保存会诊申请单数据**触发条件**:点击顶部"保存"按钮**操作流程**
1. 系统自动生成申请单号(如为空)
2. 保存当前表单所有字段值
3. 新增记录插入表格末尾
4. 已有记录更新对应行数据
【保存】
①、写入门诊医嘱表(医嘱状态为新开,医嘱名称为"门诊会诊"
②、写入门诊会诊申请单表ConsultationRequest
**数据校验**
- 必填字段:病人姓名、会诊时间、申请科室、会诊时间、会诊邀请对象、简要病史及会诊目的
- 未选会诊对象:提示"请至少选择1位会诊专家"
- 过期时间:提示"会诊时间不能早于当前时间"
#### 4. 会诊邀请对象选择联动
**触发方式**:点击科室列表项
**数据联动**
1. 根据选中会诊科室过滤会诊专家列表
2. 记忆已选专家(跨科室切换时不丢失)
**技术要点**
- 使用对象存储会诊科室-会诊专家映射关系
- 采用事件委托处理动态生成的列表项
### 五、数据结构说明
门诊会诊申请单表ConsultationRequest
| **字段名称** | **数据类型** | **长度** | **描述** | **取值范围** |
|-----------------------------| ------------ | -------- |----------------| --------------------------------------------------------- |
| **PatientID** | Text | 20 | 患者唯一标识 | 患者就诊卡号 (取值患者档案) |
| **ConsultationID** | Text | 20 | 会诊申请单唯一标识 | 系统自动生成的唯一编号生成规则CS+年月日时分秒+4位随机数 |
| **VisitID** | BIGINT | 20 | 门诊就诊流水号(逻辑外键) | 取值于本次门诊就诊记录表的主键 |
| **OrderID** | BIGINT | 20 | 门诊医嘱表主键(一对一外键) | 门诊医嘱表 |
| **PatientName** | Text | 50 | 患者姓名 | 患者的姓名 (取值患者档案) |
| **Gender** | Text | 10 | 患者性别 | 男/女/其他 (取值患者档案) |
| **Age** | Integer | - | 患者年龄 | 取值患者档案 |
| **Department** | Text | 50 | 申请会诊的科室 | 当前科室名称 |
| **RequestingPhysician** | Text | 50 | 申请会诊的医生 | 当前医生姓名 |
| **ConsultationrequestDate** | DateTime | - | 会诊申请时间 | YYYY-MM-DD HH:MM:SS
| **ConsultationPurpose** | Text | 255 | 简要病史及会诊目的 | 文本描述,自定义编辑 |
| **ProvisionalDiagnosis** | Text | 255 | 门诊诊断 | 文本描述,自动获取医生开立的门诊诊断(主诊断) |
| **ConsultationDate** | DateTime | - | 会诊时间 | YYYY-MM-DD HH:MM:SS |
| **ConsultationStatus** | Text | 20 | 会诊状态 | 新开/已提交/已确认/已签名/已完成/已取消 |
| **ConsultationUrgency** | Text | 20 | 是否紧急 | 勾选框:一般/紧急 |
| **ConsultationOpinion** | Text | 255 | 会诊意见 | 文本描述 |
| **ConfirmingPhysician** | Text | 50 | 提交会诊的医生 | 医生姓名 |
| **ConfirmingPhysicianID** | Text | 20 | 提交会诊的医生ID | 医生唯一标识 |
| **ConfirmingDate** | DateTime | - | 提交会诊日期 | YYYY-MM-DD HH:MM:SS |
| **Signature** | Text | 50 | 结束会诊医生 | 医生姓名 |
| **SignatureDate** | DateTime | - | 结束会诊日期 | YYYY-MM-DD HH:MM:SS |
| **cancelnatureDate** | DateTime | - | 作废会诊日期 | YYYY-MM-DD HH:MM:SS |
| InvitedObject | Text | 50 | 会诊邀请对象 | |
**诊状态用于记录会诊申请在不同阶段的状态,以下是常见的会诊状态及其说明:**
| **状态名称** | **状态值** | **描述** |
| ------------ | ---------- | ---------------------------------------------------------------------- |
| **新开** | 0 | 会诊申请单已保存 |
| **已提交** | 10 | 会诊申请已提交,但尚未被会诊医生确认。 |
| **已确认** | 20 | 会诊医生已确认会诊申请,并准备进行会诊。 |
| **已签名** | 30 | 会诊完成后进行签名 |
| **已完成** | 40 | 会诊已经完成,会诊意见已记录。 |
| **已取消** | 50 | 会诊申请被取消,可能由于患者情况变化或其他原因,申请医生进行作废操作。 |
**门诊医嘱表在相关会诊操作步骤的相关事务**
把“门诊会诊申请”当成**一种特殊医嘱**OrderType = 'Consult')由系统**在同一事务内**自动插入 门诊医嘱表,再挂到 `ConsultationRequest` **注意:按照现有系统的门诊医嘱表进行设置相关字段的值**
| **节点** | **是否自动** | **说明** |
| --------------------- | ------------ | --------------------------------------------------------------------------------------------------- |
| 医生点击【保存】 | ✅ | 后台事务:先插门诊医嘱表(医嘱状态为“新开”),再插`ConsultationRequest`.Status=0 |
| 医生点击【提交】 | ✅ | 仅更新两表状态 → 门诊医嘱表的医嘱状态和`ConsultationRequest.Status=10` (已提交),不重复生成医嘱 |
| 医生点击【作废/删除】 | ✅ | 自动将门诊医嘱表的医嘱状态字段置为“作废”,级联`ConsultationRequest.Status=50` |
| 医生点击【结束】 | ✅ | 将 门诊医嘱表的医嘱状态字段置为“已完成”,同时写`ConsultationRequest.Status=40` |
### 六、开发实现要点
**样式规范**
- **主色调**\#1890FF操作按钮
- **辅助色**\#13C2C2打印、\#52C41A保存、\#FF4D4F结束
- **字体规范**14px/1.5,中文字体优先使用"PingFang SC"
- **间距系统**16px基准表单行间距12px
- **组件样式**
- 按钮4px圆角32px高度
- 输入框4px圆角1px \#D9D9D9边框
- 表格行:选中状态\#E6F7FF背景+左侧3px蓝色边框
**技术要求**
- **浏览器兼容**支持Chrome/Firefox/Edge最新版
- **性能要求**:表单提交响应时间\<1秒
**注意事项**
1. 时间字段需统一处理为YYYY-MM-DD HH:mm:ss格式
2. 申请单号生成需加锁防止重复
3. 移动端需优化表格横向滚动体验
4. 打印功能需特殊样式处理(隐藏操作按钮)

View File

@@ -0,0 +1,310 @@
## 门诊医生站会诊申请确认界面PRD文档
### 一、页面概述
**页面名称**:门诊医生站会诊申请确认界面
**页面目标**:帮助医生完成会诊申请的确认、签名和打印操作,展示会诊申请详细信息
**适用场景**:医生在收到会诊申请后,查看申请信息并给出会诊意见
**页面类型**:表单页+列表页复合型页面
**核心功能**
1. 会诊申请单列表展示与选择
2. 会诊确认与取消确认功能
3. 签名功能
4. 会诊记录单打印
5. 会诊意见编辑与保存
**用户价值**
- 规范会诊申请流程
- 电子化确认和签名提高效率
- 完整记录会诊意见便于后续诊疗
- 打印功能满足纸质存档需求
**原型图地址:**https://static.pm-ai.cn/prototype/20260115/7c45e175239257e0f04c9081bf2ca204/index.html
**流程图:**
```mermaid
flowchart TD
Start(["医生进入会诊申请确认界面"]) --> LoadList["加载会诊申请列表"]
LoadList --> HasUntreated{"是否有未处理申请?"}
HasUntreated -- "否" --> ShowNoTip["显示无申请提示"]
HasUntreated -- "是" --> SelectApp["医生选择会诊申请"]
SelectApp --> ShowDetail["显示会诊申请详情"]
ShowDetail --> EditOpinion["医生编辑会诊意见"]
EditOpinion --> ConfirmClick{"点击确认按钮?"}
ConfirmClick -- "否" --> SignClick{"点击签名按钮?"}
ConfirmClick -- "是" --> ValidateConfirm{"校验必填字段"}
ValidateConfirm -- "不通过" --> TipFill["提示\n请先填写会诊意见"]
ValidateConfirm -- "通过" --> CheckConfirmed{"是否已确认?"}
CheckConfirmed -- "是" --> UpdateConfirmed["更新状态为\n已确认"]
UpdateConfirmed --> AutoFill["自动填充医生科室信息"]
AutoFill --> DisableCancel["禁用取消确认功能"]
CheckConfirmed -- "否" --> KeepState["保持当前状态"]
SignClick -- "否" --> PrintClick{"点击打印按钮?"}
SignClick -- "是" --> ValidateSign{"校验通过?"}
ValidateSign -- "不通过" --> TipConfirmFirst["提示\n请先确认会诊申请"]
ValidateSign -- "通过" --> UpdateSigned["更新状态为\n已签名"]
UpdateSigned --> RecordSign["记录签名医生和时间"]
PrintClick -- "否" --> RefreshClick{"点击刷新按钮?"}
PrintClick -- "是" --> GenPrintView["生成打印优化视图"]
GenPrintView --> BrowserPrint["调用浏览器打印功能"]
RefreshClick -- "是" --> LoadList
RefreshClick -- "否" --> KeepState
TipFill --> EditOpinion
TipConfirmFirst --> EditOpinion
KeepState --> End(["结束"])
BrowserPrint --> End
DisableCancel --> End
```
### 二、整体布局分析
**页面宽度**:自适应布局
**主要区域划分**
1. 顶部标签导航高度48px
2. 操作按钮区高度36px+间距)
3. 会诊申请列表区(高度自适应)
4. 会诊记录单表单区(高度自适应)
**布局特点**:上下布局,采用网格系统对齐,左侧对齐为主
### 三、页面区域详细描述
#### 1. 顶部标签导航区域
**区域位置**:页面顶部
**区域尺寸**高度48px宽度100%
**区域功能**:页面导航标识
**包含元素**
- **会诊确认标签**
- 元素类型:文本标签
- 显示内容:“会诊确认”
- 交互行为:无点击交互(当前页面)
- 样式特征蓝色下划线16px字体700字重
#### 2. 操作按钮区域
**区域位置**:标签导航下方
**区域尺寸**高度36px宽度100%
**区域功能**:提供页面主要操作入口
**包含元素**
- **打印按钮**
- 元素类型:操作按钮
- 显示内容:“打印”
- 交互行为:点击触发打印会诊记录单
- 样式特征绿色背景白色文字圆角6px
- **刷新按钮**
- 元素类型:操作按钮
- 显示内容:“刷新”
- 交互行为:点击重新加载页面数据
- 样式特征:白色背景,灰色边框,黑色文字
- **确认按钮**
- 元素类型:状态切换按钮
- 显示内容:“确认”/“取消确认”
- 交互行为:
- 点击后变为"取消确认"状态(红色样式)
- 已签名时禁用取消操作
- 样式特征:蓝色背景,白色文字
- 限制条件:需选中表格行才可操作
- **签名按钮**
- 元素类型:操作按钮
- 显示内容:“签名”
- 交互行为:
- 需先确认才能签名
- 签名后自动记录签名时间和签名医生
- 样式特征:蓝色背景,白色文字
- 限制条件:需先完成确认操作
#### 3. 会诊申请列表区域
**区域位置**:按钮区域下方
**区域尺寸**高度自适应宽度100%
**区域功能**:展示待处理的会诊申请列表
**包含元素**
- **申请列表表格** 取值于门诊会诊申请单表ConsultationRequest
- 检索要求:医生登录门诊医生站打开会诊申请确认界面时只能检索出当前登录医生姓名包含在会诊邀请对象内(只能查看自己受会诊邀请对象)
- 展示方式:带斑马纹表格
- 表头字段:
- 序号 \| 紧急 \| 申请单号 \| 病人姓名 \| 会诊时间 \| 邀请对象 \| 申请科室 \| 申请医师 \| 申请时间 \| 确认 \| 签名
- 数据字段:
- 序号:文本 - 自动编号 - “1” - 不可操作
- 紧急:复选框 - 布尔值 - 未勾选 - 可操作
- 申请单号:文本 - 字符串 - “CS20250812001” - 不可操作
- 病人姓名:文本 - 字符串 - “陈明” - 不可操作
- 会诊时间:日期 - 日期时间 - “2025-08-12 17:48” - 不可操作
- 邀请对象:文本 - 字符串 - “演示测试” - 不可操作
- 申请科室:文本 - 字符串 - “内科” - 不可操作
- 申请医师:文本 - 字符串 - “徐斌” - 不可操作
- 申请时间:日期 - 日期时间 - “2025-08-12 17:48” - 不可操作
- 确认:复选框 - 布尔值 - 勾选框 不可操作
- 签名:复选框 - 布尔值 - 勾选框 不可操作
- 操作功能:点击行选中查看会诊申请详情
- 样式特征:斑马纹交替背景,悬停高亮
#### 4. 会诊记录单表单区域
**区域位置**:列表区域下方
**区域尺寸**高度自适应宽度100%
**区域功能**:展示和编辑会诊详细信息
**包含元素**
- **基础信息区**
- 布局方式8列网格
- 包含字段:
- 病人姓名/性别/年龄/就诊卡号
- 申请单号/申请科室
- 会诊时间/紧急标志
- 会诊邀请对象
- 提交医生/提交时间
- **病史及目的区**
- 元素类型:文本区域
- 显示内容:患者主诉和会诊目的
- 交互行为:只读展示
- **会诊确认参加医师**
- **会诊意见区**
- 元素类型:可编辑文本域
- 显示内容:会诊意见文本
- 交互行为:支持多行编辑
- 样式特征浅灰色背景120px最小高度
- **确认/签名信息区**
- 包含字段:
- 所属医生/代表科室(确认后自动填充当前医生和科室)
- 签名医生/签名时间(自动填充签名医生和签名时间(系统当前时间))
### 四、交互功能详细说明
#### 1. 会诊申请选择功能
**触发方式**:点击表格行
**执行流程**
1. 高亮选中行(浅蓝色背景)
2. 同步该行数据到下方表单
3. 根据确认状态更新按钮文字
4. 加载存储的会诊意见到文本域
**异常处理**
- 无选中行时禁用确认/签名按钮
- 已签名行禁止取消确认
#### 2. 会诊确认功能
**触发方式**:点击确认按钮
**执行流程**
1. 校验必填字段(会诊意见、会诊确认参加医师)
2. 保存会诊意见等相关内容到行数据写入门诊会诊申请确认表ConsultationConfirmation
3. 勾选确认复选框
4. 更新按钮为"取消确认"状态
5. 所属医生和代表科室(自动填充当前医生和科室)
**异常处理**
- 未填写会诊意见时提示"请先填写会诊意见"
- 保存失败时保持原状态并提示错误
#### 2. 电子签名功能
**功能描述**:医生对确认的会诊进行电子签名
**触发条件**:已确认的会诊申请点击"签名"按钮
**操作流程**
1. 医生确认会诊申请
2. 点击"签名"按钮
3. 校验确认状态
4. 表格中"签名"列复选框被勾选
5. 自动记录签名医生(当前用户)
6. 自动填充签名时间为系统时间
7. 禁用取消确认功能
**成功反馈**:表单区显示签名信息
**失败处理**:提示"请先确认会诊申请"
#### 3. 打印会诊记录单
**功能描述**:打印格式化的会诊记录
**触发条件**:点击"打印"按钮
**操作流程**
1. 点击"打印"按钮
2. 系统生成打印优化视图
3. 调用浏览器打印功能
**特殊处理**:隐藏交互元素,优化打印布局
### 五、数据结构说明
**门诊会诊申请确认表(**ConsultationConfirmation****
| **字段名称** | **数据类型** | **长度** | **描述** | **约束/说明** |
|-----------------------------|--------------|----------|--------------------|------------------------------------------------------------------------------------|
| **ConsultationID** | INTEGER | 20 | 会诊申请单唯一标识 | FOREIGN KEY REFERENCES ConsultationRequest(ConsultationID) |
| **ConfirmingPhysicianID** | TEXT | -20 | 确认会诊的医生ID | 操作【确认】按钮的当前医生ID |
| **ConfirmingPhysicianName** | TEXT | -20 | 确认会诊的医生姓名 | 操作【确认】按钮的当前医生姓名 |
| **ConfirmingDeptName** | TEXT | 20 | 代表科室 | 操作【确认】按钮的当前开单科室 |
| **ConfirmingDate** | DateTime | - | 确认会诊的日期 | 操作【确认】按钮当前系统时间 |
| **ConsultationStatus** | TEXT | 20 | 会诊状态 | CHECK (ConsultationStatus IN ('已确认', '取消确认', '已签名', '已完成')), NOT NULL |
| **ConsultationOpinion** | TEXT | 500 | 会诊意见 | |
| **ConfirmingPhysician** | TEXT | 100 | 会诊确认参加医师 | |
| **Signature** | TEXT | 20 | 签名医生 | |
| **SignatureDate** | DateTime | - | 签名时间 | - |
ConsultationConfirmation.ConsultationStatu会诊状态
| **状态值** | **状态名** | **描述** |
|------------|------------|-----------------------------------|
| **0** | 取消确认 | 作废 |
| **20** | 已确认 | 会诊医生已查看/同意,可写初步意见 |
| **30** | 已签名 | 已电子签名,意见最终生效 |
| **40** | 已完成 | 会诊报告已回写,流程关闭 |
**按钮涉及的事务**
| **按钮** | **涉及表** | **执行事务** | **锁/并发** | **成功状态** | **失败处理** |
|--------------|----------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------|------------------|--------------------------|
| **确认** | 1、ConsultationRequest<br>2、门诊医嘱<br>3、ConsultationConfirmation | 1、ConsultationRequest.ConsultationStatus =20<br>2、医嘱 状态='已执行'<br>3、写入ConsultationConfirmation表相关的数据 | SELECT ... FOR UPDATE | 已提交 → 已确认 | 任何异常 → 整体 ROLLBACK |
| **取消确认** | 1、ConsultationRequest<br>2、门诊医嘱<br>3、ConsultationConfirmation | 1、ConsultationRequest.ConsultationStatus =10<br>2、医嘱 状态='已提交'<br>3、ConsultationConfirmation. ConsultationStatus = 0 | 同上 | 已确认→ 取消确认 | 同上回滚 |
| **签名** | 1、ConsultationRequest<br>2、门诊医嘱<br>3、ConsultationConfirmation | 1、ConsultationRequest.ConsultationStatus =30<br>2、医嘱 Status='已完成'<br>3、写入ConsultationConfirmation. Signature, SignatureDate,ConsultationStatus =30 | 同上 | 已确认 → 已签名 | 同上回滚 |
### 六、开发实现要点
**样式规范**
- **主色调**\#4A89DC按钮蓝色
- **辅助色**\#4CAF50成功绿色
- **字体规范**14px/1.5 常规16px 标题
- **间距系统**8px基础间距24px区块间距
- **组件样式**
- 按钮6px圆角1px边框
- 输入框4px圆角1px \#E0E0E0边框
**技术要求**
- **浏览器兼容**Chrome/Firefox/Edge最新版
- **性能要求**:列表加载时间\<1s
**注意事项**
1. 确认和签名状态需要联动控制
2. 打印功能需要特殊样式处理
3. 时间字段需统一使用YYYY-MM-DD HH:mm:ss格式
4. 移动端需优化表单布局

View File

@@ -0,0 +1,267 @@
## 门诊会诊申请管理界面PRD文档
### 一、页面概述
**页面名称**:门诊会诊申请管理界面
**页面目标**:提供会诊申请的全流程管理功能,包括申请记录查询、编辑申请、查看详情、状态变更等核心操作
**适用场景**:门诊医生需要查看会诊申请或管理已有申请记录时使用
**页面类型**:列表页+表单弹窗复合型页面
**核心功能**
1. 多条件组合筛选会诊申请记录
2. 会诊申请表格展示与操作(编辑/查看/删除)
3. 会诊申请单的填写与提交
4. 会诊状态标记(提交/结束)
**用户价值**:规范会诊申请流程,减少纸质单据流转,提高多科室协作效率
原型图地址https://static.pm-ai.cn/prototype/20260116/aed1f102d614677f100c0d1fe3104999/index.html
**流程图:**
```mermaid
flowchart TD
Start([Start]) --> A[进入门诊会诊申请管理界面]
A --> B{用户操作类型}
B -->|筛选查询| C[设置筛选条件]
B -->|编辑申请| D[点击编辑按钮]
B -->|查看详情| E[点击查看按钮]
B -->|删除申请| G[点击删除按钮]
C --> H{验证筛选条件}
H -->|有效| I[展示筛选结果]
H -->|无效| J[显示错误提示]
J --> C
I --> K[用户浏览列表]
D --> L{检查会诊状态}
L -->|未结束| M[打开编辑弹窗]
L -->|已结束| N[提示不可编辑]
N --> O[关闭弹窗]
M --> P[修改表单内容]
P --> Q{表单验证}
Q -->|通过| R[保存修改]
Q -->|不通过| S[标红错误字段]
S --> P
E --> T{检查会诊状态}
T -->|未结束| U[打开只读弹窗]
T -->|已结束| U
G --> Z{删除验证}
Z -->|可删除| AA[确认删除]
Z -->|不可删除| AB[提示删除失败]
AB --> K
AA --> AC[更新状态为已取消]
AC --> AD[更新列表显示]
R --> AD
AD --> K
K --> AE([End])
```
### 二、整体布局分析
**页面宽度**:自适应布局
**主要区域划分**
1. 顶部筛选区高度自适应约80px
2. 表格展示区(高度自适应,占主要空间)
3. 底部页码区固定高度56px
**布局特点**:上下布局+弹性布局,采用左右对齐方式
### 三、页面区域详细描述
#### 1. 顶部筛选区
**区域位置**:页面顶部
**区域尺寸**100%宽度,高度自适应
**区域功能**:提供多维度筛选和快速搜索功能
**包含元素**
- **时间类型选择器**
- 元素类型:下拉选择框
- 显示内容:默认"会诊时间",可选"申请时间"
- 交互行为:点击展开下拉选项
- 样式特征宽度120px高度32px圆角4px
- **时间范围选择器**(开始/结束时间)
- 元素类型:日期时间输入框
- 显示内容placeholder提示"开始时间"/“结束时间”
- 交互行为:点击弹出日期选择面板
- 样式特征宽度180px高度32px
- **申请科室/申请医生选择器**
- 元素类型带datalist的输入框
- 显示内容placeholder提示"选择或输入科室/医生"
- 交互行为:输入时显示匹配选项
- 数据来源:动态生成申请科室/医生候选列表取值于门诊会诊申请单表ConsultationRequest.Department/ RequestingPhysician
- **会诊状态筛选器**
- 元素类型:下拉选择框
- 可选值:全部/未提交/提交/结束
- 默认值:全部
- **病人姓名搜索框**
- 元素类型:文本输入框
- 显示内容placeholder提示"病人姓名"
- 交互行为:支持模糊搜索
- **操作按钮组**
- 查询按钮
- 样式:蓝色背景,带搜索图标
- 交互:触发筛选条件应用
- 重置按钮
- 样式:灰色背景,带刷新图标
- 交互:清空所有筛选条件
- 打印按钮
- 样式:深灰色背景,带打印图标
- 交互:调起浏览器打印功能
#### 2. 表格展示区
**区域位置**:页面中部
**区域尺寸**100%宽度,高度自适应
**区域功能**:展示会诊申请列表数据,支持行内操作
**包含元素**
取值于门诊会诊申请单表ConsultationRequest和门诊会诊申请单表ConsultationRequest)
- **数据表格**
- 展示方式11列固定表头表格
- 数据字段:
- ID文本 - 15 -申请单号
- 急:复选框 - 布尔值 - 示例false 不可编辑
- 病人姓名:文本 - 朱某某 - 红色高亮
- 会诊时间:日期 - 2026-01-05 15:08
- 申请科室:文本 - 内科
- 邀请对象:文本 - 吴院长
- 申请时间:日期 - 2026-01-05 15:08
- 申请医师:文本 - 演示测试
- 提交:复选框 - 布尔值 - 示例false
- 结束:复选框 - 布尔值 - 示例false
- 操作功能:
- 编辑按钮(✏️):点击打开编辑弹窗
- 查看按钮(👁️):点击打开只读弹窗
- 删除按钮(🗑️):点击确认删除
- 【删除】将状态改为“已取消”
- UPDATE ConsultationRequest
- SET ConsultationStatus = 50,cancelnatureDate = \<作废会诊时间\>
- WHERE ConsultationID = \<会诊申请单ID\> and ConsultationStatus \<\> 40 ;
- 交互行为:
- 行悬停效果:浅蓝色背景
- 复选框点击:即时更新状态(需防抖处理)
#### 3. 底部页码区
**区域位置**:页面底部
**区域尺寸**100%宽度固定高度56px
**区域功能**:分页控制和数据统计
**包含元素**
- **总数统计**总数统计文本“总数15”
- **分页控制器**
- 上一页按钮(\<
- 当前页按钮1active状态
- 下一页按钮(\>
- 交互反馈hover时边框变蓝
#### 4. 会诊申请弹窗(模态框)
**触发方式**:点击表格行操作列的编辑/查看按钮
**区域功能**:展示/编辑会诊申请详细信息
**包含元素**
- 头部区域
- 标题:“会诊申请单”
- 关闭按钮(×图标)
- 表单区域(分两栏布局)
- 基础信息区:
- 申请单号(只读)
- 申请时间(不可编辑)
- 病人姓名(不可编辑)
- 性别/年龄(不可编辑)
- 就诊卡号(不可编辑)
- 会诊信息区:
- 会诊时间(日期时间选择器)
- 申请医师(不可编辑)
- 紧急程度(复选框)
- 申请科室(不可编辑)
- 门诊诊断(不可编辑)
- 会诊邀请对象
- 会诊确认参加医师
- 所属医生
- 代表科室
- 签名医生
- 签名时间
- 文本域:
- 病史及会诊目的(多行文本)
- 会诊意见(多行文本)
- 底部按钮区:
- 取消按钮(左对齐)
- 保存按钮(右对齐,蓝色)
### 四、交互功能详细说明
#### 1. 会诊申请编辑功能
**功能描述**:修改已有会诊申请信息
**触发条件**:点击表格行中的"✏️"按钮
**操作流程**
1. 检查会诊状态是否为"结束",若已结束则提示不可编辑
2. 弹出会诊申请编辑弹窗,填充当前行数据的会诊申请和确认相关的数据
3. 用户修改表单内容(必填字段校验)
4. 点击"保存"按钮提交修改
**异常处理**
- 必填字段为空时,标红提示
- 保存失败时显示toast提示"保存失败,请重试"
#### 2. 会诊申请查看功能
**功能描述**:查看会诊申请详细信息
**触发条件**:点击表格行中的"👁️"按钮
**操作流程**
1. 弹出只读弹窗,显示完整申请信息
2. 所有字段禁用编辑
3. 仅显示"取消"按钮用于关闭弹窗
#### 3. 数据筛选功能
**功能描述**:多条件组合查询会诊记录
**触发条件**:点击"查询"按钮
**数据过滤逻辑**
- 时间范围:根据选择的时间类型(会诊/申请)进行筛选
- 申请科室/申请医生:支持模糊匹配
- 会诊状态筛选:支持多选逻辑(未提交/提交/结束)
1. 收集所有筛选条件值
2. 发起异步请求(示例中为前端过滤)
3. 更新表格数据展示
**异常处理**
- 时间范围不合法:提示"结束时间不能早于开始时间"
- 无查询结果:显示空白表格+提示文字
**性能优化**:前端本地缓存数据,减少服务器请求
### 五、数据结构说明
门诊会诊申请单表ConsultationRequest和门诊会诊申请单表ConsultationRequest)
### 六、开发实现要点
**样式规范**
- **主色调**\#5D9CEC按钮/交互元素)
- **辅助色**\#8E8E8E次要按钮
- **字体规范**14px/1.5主要内容16px/1.5(标题)
- **间距系统**16px元素间距24px区块间距
- **组件样式**
- 按钮圆角6px内边距0 16px
- 输入框1px实线边框\#D9D9D9圆角4px
**技术要求**
- **浏览器兼容**支持Chrome/Firefox/Edge最新版
- **性能要求**:列表数据筛选响应时间\<200ms
**注意事项**
1. 状态变更逻辑:已结束的记录不可编辑
2. 时间字段需要做时区转换处理
3. 申请科室/申请医生选择器需要支持拼音首字母检索

View File

@@ -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费用项管理表
①、术中费用仍走“门诊就诊管理”的就诊IDadm_encounter.id = adm_charge_item.encounter_id
2\. 为了事后能追溯“这些费用是术中发生的”,在费用项管理表明细上加一个 “来源业务单据SourceBillNo” 字段adm_charge_item.generate_source_enum = 2帐单生成来源为手术计费SourceBillNo = 手术申请单号)。
3\. 其他内容按照《门诊划价》的业务数据流程走。

View File

@@ -1,2 +0,0 @@
<h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">OpenHis v0.0.1</h1>

View File

@@ -21,13 +21,15 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<version>3.11.0</version>
<configuration>
<source>17</source>
<target>17</target>
<encoding>UTF-8</encoding>
<compilerArgs>
<arg>-parameters</arg>
<arg>--add-modules</arg>
<arg>java.base</arg>
</compilerArgs>
<annotationProcessorPaths>
<path>

View File

@@ -54,6 +54,12 @@
<artifactId>oshi-core</artifactId>
</dependency>
<!-- spring security 安全认证 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- 系统模块-->
<dependency>
<groupId>com.core</groupId>
@@ -65,6 +71,12 @@
<artifactId>core-common</artifactId>
</dependency>
<!-- MyBatis-Plus 支持 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<!-- JSQLParser - 用于MyBatis Plus -->
<dependency>
<groupId>com.github.jsqlparser</groupId>

View File

@@ -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();
}
}

View File

@@ -18,6 +18,12 @@
<dependencies>
<!-- MyBatis-Plus 支持 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<!-- velocity代码生成使用模板 -->
<dependency>
<groupId>org.apache.velocity</groupId>
@@ -36,6 +42,24 @@
<artifactId>druid-spring-boot-starter</artifactId>
</dependency>
<!-- Lombok 支持 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- JSON工具类 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!-- Jackson 注解支持 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>
</dependencies>
</project>

View File

@@ -23,6 +23,12 @@
<dependencies>
<!-- MyBatis-Plus 支持 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<!-- 通用工具-->
<dependency>
<groupId>com.core</groupId>

View File

@@ -64,6 +64,11 @@
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity-engine-core</artifactId>
</dependency>
<!-- rabbitMQ -->
<!-- <dependency>
<groupId>org.springframework.boot</groupId>

View File

@@ -28,7 +28,10 @@ import com.openhis.web.datadictionary.dto.DiagnosisTreatmentDto;
import com.openhis.web.datadictionary.dto.DiagnosisTreatmentSelParam;
import com.openhis.web.datadictionary.mapper.ActivityDefinitionManageMapper;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
@@ -45,6 +48,8 @@ import java.util.List;
@Service
public class LisConfigManageAppServiceImpl implements ILisConfigManageAppService {
private static final Logger log = LoggerFactory.getLogger(LisConfigManageAppServiceImpl.class);
@Resource
private ActivityDefinitionManageMapper activityDefinitionManageMapper;
@Resource
@@ -120,31 +125,73 @@ public class LisConfigManageAppServiceImpl implements ILisConfigManageAppServic
}
@Override
@Transactional
public R<?> saveAll(LisConfigManageDto manageDto) {
//先全部删除项目下详情
activityDefDeviceDefMapper.delete(new QueryWrapper<ActivityDefDeviceDef>().eq("activity_definition_id", manageDto.getId()));
activityDefObservationDefMapper.delete(new QueryWrapper<ActivityDefObservationDef>().eq("activity_definition_id", manageDto.getId()));
activityDefSpecimenDefMapper.delete(new QueryWrapper<ActivityDefSpecimenDef>().eq("activity_definition_id", manageDto.getId()));
Integer tenantId = SecurityUtils.getLoginUser().getTenantId();
// 根据ID查询【诊疗目录】详情
DiagnosisTreatmentDto diseaseTreatmentOne = activityDefinitionManageMapper.getDiseaseTreatmentOne(manageDto.getId(), tenantId);
manageDto.getActivityDefDeviceDefs().forEach(activityDefDeviceDef -> {
activityDefDeviceDef.setActivityDefinitionId(manageDto.getId());
activityDefDeviceDef.setActivityDefinitionName(diseaseTreatmentOne.getName());
activityDefDeviceDefMapper.insert(activityDefDeviceDef);
});
manageDto.getActivityDefObservationDefs().forEach(activityDefObservationDef -> {
activityDefObservationDef.setActivityDefinitionId(manageDto.getId());
activityDefObservationDef.setActivityDefinitionName(diseaseTreatmentOne.getName());
activityDefObservationDefMapper.insert(activityDefObservationDef);
});
manageDto.getActivityDefSpecimenDefs().forEach(activityDefSpecimenDef -> {
activityDefSpecimenDef.setActivityDefinitionId(manageDto.getId());
activityDefSpecimenDef.setActivityDefinitionName(diseaseTreatmentOne.getName());
activityDefSpecimenDefMapper.insert(activityDefSpecimenDef);
});
return R.ok();
try {
// 先全部删除项目下详情
activityDefDeviceDefMapper.delete(new QueryWrapper<ActivityDefDeviceDef>().eq("activity_definition_id", manageDto.getId()));
activityDefObservationDefMapper.delete(new QueryWrapper<ActivityDefObservationDef>().eq("activity_definition_id", manageDto.getId()));
activityDefSpecimenDefMapper.delete(new QueryWrapper<ActivityDefSpecimenDef>().eq("activity_definition_id", manageDto.getId()));
// 获取租户ID并验证
Integer tenantId = null;
try {
tenantId = SecurityUtils.getLoginUser().getTenantId();
} catch (Exception e) {
log.warn("获取租户ID失败使用默认值", e);
}
// 根据ID查询【诊疗目录】详情
DiagnosisTreatmentDto diseaseTreatmentOne = activityDefinitionManageMapper.getDiseaseTreatmentOne(manageDto.getId(), tenantId);
if (diseaseTreatmentOne == null) {
log.warn("未找到诊疗目录id={}, tenantId={}", manageDto.getId(), tenantId);
// 即使未找到诊疗目录也继续保存使用ID作为名称
String activityDefinitionName = String.valueOf(manageDto.getId());
manageDto.getActivityDefDeviceDefs().forEach(activityDefDeviceDef -> {
activityDefDeviceDef.setActivityDefinitionId(manageDto.getId());
activityDefDeviceDef.setActivityDefinitionName(activityDefinitionName);
activityDefDeviceDefMapper.insert(activityDefDeviceDef);
});
manageDto.getActivityDefObservationDefs().forEach(activityDefObservationDef -> {
activityDefObservationDef.setActivityDefinitionId(manageDto.getId());
activityDefObservationDef.setActivityDefinitionName(activityDefinitionName);
activityDefObservationDefMapper.insert(activityDefObservationDef);
});
manageDto.getActivityDefSpecimenDefs().forEach(activityDefSpecimenDef -> {
activityDefSpecimenDef.setActivityDefinitionId(manageDto.getId());
activityDefSpecimenDef.setActivityDefinitionName(activityDefinitionName);
activityDefSpecimenDefMapper.insert(activityDefSpecimenDef);
});
} else {
// 正常保存
manageDto.getActivityDefDeviceDefs().forEach(activityDefDeviceDef -> {
activityDefDeviceDef.setActivityDefinitionId(manageDto.getId());
activityDefDeviceDef.setActivityDefinitionName(diseaseTreatmentOne.getName());
activityDefDeviceDefMapper.insert(activityDefDeviceDef);
});
manageDto.getActivityDefObservationDefs().forEach(activityDefObservationDef -> {
activityDefObservationDef.setActivityDefinitionId(manageDto.getId());
activityDefObservationDef.setActivityDefinitionName(diseaseTreatmentOne.getName());
activityDefObservationDefMapper.insert(activityDefObservationDef);
});
manageDto.getActivityDefSpecimenDefs().forEach(activityDefSpecimenDef -> {
activityDefSpecimenDef.setActivityDefinitionId(manageDto.getId());
activityDefSpecimenDef.setActivityDefinitionName(diseaseTreatmentOne.getName());
activityDefSpecimenDefMapper.insert(activityDefSpecimenDef);
});
}
log.info("保存检验项目设置成功id={}, deviceCount={}, observationCount={}, specimenCount={}",
manageDto.getId(),
manageDto.getActivityDefDeviceDefs().size(),
manageDto.getActivityDefObservationDefs().size(),
manageDto.getActivityDefSpecimenDefs().size());
return R.ok("保存成功");
} catch (Exception e) {
log.error("保存检验项目设置失败id={}, error={}", manageDto.getId(), e.getMessage(), e);
return R.fail("保存失败:" + e.getMessage());
}
}
@Override

View File

@@ -22,6 +22,8 @@ import com.openhis.web.Inspection.dto.ObservationDefManageDto;
import com.openhis.web.Inspection.dto.ObservationDefManageInitDto;
import com.openhis.web.Inspection.dto.ObservationDefSelParam;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import javax.servlet.http.HttpServletRequest;
@@ -42,6 +44,8 @@ import java.util.stream.Stream;
@RequiredArgsConstructor
public class ObservationManageAppServiceImpl implements IObservationManageAppService
{
private static final Logger log = LoggerFactory.getLogger(ObservationManageAppServiceImpl.class);
private final ObservationDefinitionMapper observationDefinitionMapper;
private final IObservationDefinitionService observationDefinitionService;
@@ -88,9 +92,23 @@ public class ObservationManageAppServiceImpl implements IObservationManageAppSer
@Override
public R<?> updateOrAddObservationDef(ObservationDefinition Observation) {
Observation.setDeleteFlag(DelFlag.NO.getCode());
observationDefinitionService.saveOrUpdate(Observation);
return R.ok(" 添加成功");
try {
Observation.setDeleteFlag(DelFlag.NO.getCode());
boolean result = observationDefinitionService.saveOrUpdate(Observation);
if (result) {
log.info("保存检验项目成功name={}, code={}, id={}",
Observation.getName(), Observation.getCode(), Observation.getId());
return R.ok("添加成功");
} else {
log.warn("保存检验项目失败name={}, code={}",
Observation.getName(), Observation.getCode());
return R.fail("添加失败:保存操作未成功");
}
} catch (Exception e) {
log.error("保存检验项目异常name={}, code={}, error={}",
Observation.getName(), Observation.getCode(), e.getMessage(), e);
return R.fail("添加失败:" + e.getMessage());
}
}
@Override

View File

@@ -13,14 +13,6 @@ import java.util.Map;
*/
public interface ITicketAppService {
/**
* 查询号源列表
*
* @param params 查询参数
* @return 号源列表
*/
R<?> listTicket(Map<String, Object> params);
/**
* 预约号源
*

View File

@@ -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;
/**
* 查询号源列表
*
* @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);
}
private static final Logger log = LoggerFactory.getLogger(TicketAppServiceImpl.class);
/**
* 预约号源
@@ -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) {
return R.fail("参数错误");
if (params.get("slotId") != null) {
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) {
if (ticketId == null) {
public R<?> cancelTicket(Long slotId) {
if (slotId == null) {
return R.fail("参数错误");
}
try {
int result = ticketService.cancelTicket(ticketId);
return R.ok(result > 0 ? "取消成功" : "取消失败");
ticketService.cancelTicket(slotId);
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() {
// 创建固定的测试数据,用于验证前端是否能展示数据
List<TicketDto> testTickets = new ArrayList<>();
// 创建5条测试数据
for (int i = 1; i <= 5; i++) {
TicketDto dto = new TicketDto();
dto.setSlot_id((long) i);
dto.setBusNo("TEST0000" + i);
dto.setDepartment("内科");
dto.setDoctor("张三");
dto.setTicketType("expert");
dto.setDateTime("08:00-08:50");
dto.setStatus("未预约");
dto.setFee("150");
dto.setAppointmentDate(new Date());
testTickets.add(dto);
// 1. 从 AppService 获取排班数据
R<?> response = doctorScheduleAppService.getDoctorScheduleList();
// 获取返回的 List 数据 (假设 R.ok 里的数据是 List<DoctorSchedule>)
List<DoctorSchedule> scheduleList = (List<DoctorSchedule>) response.getData();
// 2. 转换数据为 TicketDto
List<TicketDto> tickets = new ArrayList<>();
if (scheduleList != null) {
for (DoctorSchedule schedule : scheduleList) {
TicketDto dto = new TicketDto();
// 基础信息映射
dto.setSlot_id(Long.valueOf(schedule.getId())); // Integer 转 Long
dto.setBusNo(String.valueOf(schedule.getId())); // 生成一个业务编号
dto.setDepartment(String.valueOf(schedule.getDeptId())); // 如果有科室名建议关联查询这里暂填ID
dto.setDoctor(schedule.getDoctor());
// 号源类型处理:根据挂号项目判断是普通号还是专家号
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("total", testTickets.size());
result.put("list", tickets);
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);
}

View File

@@ -21,28 +21,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);
}
/**
* 查询所有号源(用于测试)

View File

@@ -23,7 +23,7 @@ public interface IOrganizationAppService {
* @param request 请求数据
* @return 机构树分页列表
*/
Page<OrganizationDto> getOrganizationTree(Integer pageNo, Integer pageSize, String name, Integer typeEnum, Integer classEnum,
Page<OrganizationDto> getOrganizationTree(Integer pageNo, Integer pageSize, String name, Integer typeEnum, String classEnum,
String sortField, String sortOrder, HttpServletRequest request);
/**

View File

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.core.common.utils.AssignSeqUtil;
import com.core.common.utils.ChineseConvertUtils;
import com.core.common.utils.DictUtils;
import com.core.common.utils.StringUtils;
import com.openhis.administration.domain.OperatingRoom;
import com.openhis.administration.mapper.OperatingRoomMapper;
@@ -78,23 +79,12 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
e.setStatusEnum_dictText(e.getStatusEnum() != null && e.getStatusEnum() == 1 ? "启用" : "停用");
// 类型
if (e.getRoomTypeEnum() != null) {
switch (e.getRoomTypeEnum()) {
case 1:
e.setRoomTypeEnum_dictText("急诊手术室");
break;
case 2:
e.setRoomTypeEnum_dictText("择期手术室");
break;
case 3:
e.setRoomTypeEnum_dictText("日间手术室");
break;
case 4:
e.setRoomTypeEnum_dictText("复合手术室");
break;
default:
e.setRoomTypeEnum_dictText("未知");
break;
}
e.setRoomTypeEnum_dictText(DictUtils.getDictLabel("operating_room_type", String.valueOf(e.getRoomTypeEnum())));
}
// 如果有机构ID查询机构名称
if (e.getOrganizationId() != null) {
String orgName = commonService.getOrgNameById(e.getOrganizationId());
e.setOrganizationName(orgName);
}
// 拼音码
e.setPyStr(ChineseConvertUtils.toPinyinFirstLetter(e.getName()));
@@ -127,23 +117,7 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
// 类型描述
if (operatingRoom.getRoomTypeEnum() != null) {
switch (operatingRoom.getRoomTypeEnum()) {
case 1:
operatingRoomDto.setRoomTypeEnum_dictText("急诊手术室");
break;
case 2:
operatingRoomDto.setRoomTypeEnum_dictText("择期手术室");
break;
case 3:
operatingRoomDto.setRoomTypeEnum_dictText("日间手术室");
break;
case 4:
operatingRoomDto.setRoomTypeEnum_dictText("复合手术室");
break;
default:
operatingRoomDto.setRoomTypeEnum_dictText("未知");
break;
}
operatingRoomDto.setRoomTypeEnum_dictText(DictUtils.getDictLabel("operating_room_type", String.valueOf(operatingRoom.getRoomTypeEnum())));
}
// 如果有机构ID查询机构名称
@@ -168,6 +142,11 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
return R.fail("手术室名称不能为空");
}
// 校验房间号不能为空
if (StringUtils.isEmpty(operatingRoomDto.getBusNo())) {
return R.fail("房间号不能为空");
}
// 去除空格
String name = operatingRoomDto.getName().replaceAll("[  ]", "");
operatingRoomDto.setName(name);
@@ -177,13 +156,14 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
return R.fail("" + name + "】已存在");
}
// 判断房间号是否已存在
if (isExistBusNo(operatingRoomDto.getBusNo(), null)) {
return R.fail("房间号【" + operatingRoomDto.getBusNo() + "】已存在");
}
OperatingRoom operatingRoom = new OperatingRoom();
BeanUtils.copyProperties(operatingRoomDto, operatingRoom);
// 生成编码
String code = assignSeqUtil.getSeq(AssignSeqEnum.OPERATING_ROOM_BUS_NO.getPrefix(), 3);
operatingRoom.setBusNo(code);
// 拼音码
operatingRoom.setPyStr(ChineseConvertUtils.toPinyinFirstLetter(operatingRoomDto.getName()));
// 五笔码
@@ -215,6 +195,11 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
return R.fail("手术室名称不能为空");
}
// 校验房间号不能为空
if (StringUtils.isEmpty(operatingRoomDto.getBusNo())) {
return R.fail("房间号不能为空");
}
// 去除空格
String name = operatingRoomDto.getName().replaceAll("[  ]", "");
operatingRoomDto.setName(name);
@@ -224,6 +209,11 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
return R.fail("" + name + "】已存在");
}
// 判断房间号是否已存在(排除自己)
if (isExistBusNo(operatingRoomDto.getBusNo(), operatingRoomDto.getId())) {
return R.fail("房间号【" + operatingRoomDto.getBusNo() + "】已存在");
}
OperatingRoom operatingRoom = new OperatingRoom();
BeanUtils.copyProperties(operatingRoomDto, operatingRoom);
@@ -331,4 +321,20 @@ public class OperatingRoomAppServiceImpl implements IOperatingRoomAppService {
}
return operatingRoomService.count(queryWrapper) > 0;
}
/**
* 判断房间号是否已存在
*
* @param busNo 房间号
* @param excludeId 排除的ID
* @return 是否存在
*/
private boolean isExistBusNo(String busNo, Long excludeId) {
LambdaQueryWrapper<OperatingRoom> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(OperatingRoom::getBusNo, busNo);
if (excludeId != null) {
queryWrapper.ne(OperatingRoom::getId, excludeId);
}
return operatingRoomService.count(queryWrapper) > 0;
}
}

View File

@@ -39,7 +39,7 @@ public class OrganizationAppServiceImpl implements IOrganizationAppService {
private AssignSeqUtil assignSeqUtil;
@Override
public Page<OrganizationDto> getOrganizationTree(Integer pageNo, Integer pageSize, String name, Integer typeEnum, Integer classEnum,
public Page<OrganizationDto> getOrganizationTree(Integer pageNo, Integer pageSize, String name, Integer typeEnum, String classEnum,
String sortField, String sortOrder, HttpServletRequest request) {
// 创建查询条件
LambdaQueryWrapper<Organization> queryWrapper = new LambdaQueryWrapper<>();
@@ -51,8 +51,24 @@ public class OrganizationAppServiceImpl implements IOrganizationAppService {
if (typeEnum != null) {
queryWrapper.eq(Organization::getTypeEnum, typeEnum);
}
if (classEnum != null) {
queryWrapper.eq(Organization::getClassEnum, classEnum);
if (StringUtils.isNotEmpty(classEnum)) {
// 对于多选,需要处理逗号分隔的值
queryWrapper.and(wrapper -> {
String[] classEnums = classEnum.split(",");
for (String cls : classEnums) {
String trimmedCls = cls.trim();
// 使用OR连接多个条件来匹配逗号分隔的值
wrapper.or().and(subWrapper -> {
subWrapper.eq(Organization::getClassEnum, trimmedCls)
.or()
.likeRight(Organization::getClassEnum, trimmedCls + ",")
.or()
.likeLeft(Organization::getClassEnum, "," + trimmedCls)
.or()
.like(Organization::getClassEnum, "," + trimmedCls + ",");
});
}
});
}
// 创建Page对象
@@ -89,7 +105,7 @@ public class OrganizationAppServiceImpl implements IOrganizationAppService {
OrganizationDto node = new OrganizationDto();
BeanUtils.copyProperties(record, node);
node.setTypeEnum_dictText(EnumUtils.getInfoByValue(OrganizationType.class, node.getTypeEnum()));
node.setClassEnum_dictText(EnumUtils.getInfoByValue(OrganizationClass.class, node.getClassEnum()));
node.setClassEnum_dictText(formatClassEnumDictText(node.getClassEnum()));
node.setActiveFlag_dictText(EnumUtils.getInfoByValue(AccountStatus.class, node.getActiveFlag()));
// 将当前节点加入映射
nodeMap.put(bNo, node);
@@ -130,7 +146,7 @@ public class OrganizationAppServiceImpl implements IOrganizationAppService {
OrganizationDto organizationDto = new OrganizationDto();
BeanUtils.copyProperties(organization, organizationDto);
organizationDto.setTypeEnum_dictText(EnumUtils.getInfoByValue(OrganizationType.class, organizationDto.getTypeEnum()));
organizationDto.setClassEnum_dictText(EnumUtils.getInfoByValue(OrganizationClass.class, organizationDto.getClassEnum()));
organizationDto.setClassEnum_dictText(formatClassEnumDictText(organizationDto.getClassEnum()));
organizationDto.setActiveFlag_dictText(EnumUtils.getInfoByValue(AccountStatus.class, organizationDto.getActiveFlag()));
return R.ok(organizationDto, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, new Object[] {"机构信息查询"}));
@@ -221,6 +237,35 @@ public class OrganizationAppServiceImpl implements IOrganizationAppService {
: R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, new Object[] {"机构信息停用"}));
}
/**
* 格式化多选的分类字典文本
*/
private String formatClassEnumDictText(String classEnum) {
if (StringUtils.isEmpty(classEnum)) {
return "";
}
String[] classEnums = classEnum.split(",");
List<String> dictTexts = new ArrayList<>();
for (String cls : classEnums) {
String trimmedCls = cls.trim();
if (StringUtils.isNotEmpty(trimmedCls)) {
try {
Integer enumValue = Integer.parseInt(trimmedCls);
String dictText = EnumUtils.getInfoByValue(OrganizationClass.class, enumValue);
if (dictText != null) {
dictTexts.add(dictText);
}
} catch (NumberFormatException e) {
// 如果转换失败,跳过该值
}
}
}
return String.join(",", dictTexts);
}
/**
* 校验字段是否为指定类中的有效属性
*/

View File

@@ -54,7 +54,7 @@ public class OrganizationController {
@RequestParam(value = "pageSize", defaultValue = "100") Integer pageSize,
@RequestParam(value = "name", required = false) String name,
@RequestParam(value = "typeEnum", required = false) Integer typeEnum,
@RequestParam(value = "classEnum", required = false) Integer classEnum,
@RequestParam(value = "classEnum", required = false) String classEnum,
@RequestParam(value = "sortField", required = false) String sortField,
@RequestParam(value = "sortOrder", required = false) String sortOrder, HttpServletRequest request) {
Page<OrganizationDto> organizationTree =

View File

@@ -3,6 +3,7 @@
*/
package com.openhis.web.basedatamanage.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
@@ -39,7 +40,8 @@ public class OrganizationDto {
private String typeEnum_dictText;
/** 机构分类枚举 */
private Integer classEnum;
@JsonFormat(shape = JsonFormat.Shape.STRING)
private String classEnum;
private String classEnum_dictText;
/** 拼音码 */

View File

@@ -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);
}
}

View File

@@ -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 {
@@ -76,6 +81,9 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
@Resource
IPatientIdentifierService patientIdentifierService;
@Resource
TriageCandidateExclusionService triageCandidateExclusionService;
/**
* 门诊挂号 - 查询患者信息
@@ -157,7 +165,7 @@ public class OutpatientRegistrationAppServiceImpl implements IOutpatientRegistra
@Override
public List<OrgMetadata> getOrgMetadata() {
List<Organization> list =
iOrganizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
iOrganizationService.getList(OrganizationType.DEPARTMENT.getValue(), String.valueOf(OrganizationClass.CLINIC.getValue()));
List<OrgMetadata> orgMetadataList = new ArrayList<>();
OrgMetadata orgMetadata;
for (Organization organization : list) {
@@ -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()));

View File

@@ -141,4 +141,9 @@ public class CurrentDayEncounterDto {
*/
private String identifierNo;
/**
* 流水号(就诊当日序号)
*/
private Integer displayOrder;
}

View File

@@ -4,7 +4,7 @@ import com.core.common.core.domain.R;
import com.openhis.check.domain.LisGroupInfo;
public interface ILisGroupInfoAppService {
R<?> getLisGroupInfoList();
R<?> getLisGroupInfoList(Integer pageNum, Integer pageSize);
R<?> add(LisGroupInfo lisGroupInfo);

View File

@@ -1,6 +1,7 @@
package com.openhis.web.check.appservice.impl;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.openhis.check.domain.LisGroupInfo;
import com.openhis.check.service.ILisGroupInfoService;
@@ -17,11 +18,14 @@ public class LisGroupInfoAppServiceImpl implements ILisGroupInfoAppService {
@Resource
private ILisGroupInfoService lisGroupInfoService;
@Override
public R<?> getLisGroupInfoList() {
List<LisGroupInfo> list = lisGroupInfoService.list();
public R<?> getLisGroupInfoList(Integer pageNum, Integer pageSize) {
Page<LisGroupInfo> page = new Page<>(pageNum, pageSize);
Page<LisGroupInfo> list = lisGroupInfoService.page(page);
return R.ok(list);
}
@Override
public R<?> add(LisGroupInfo lisGroupInfo) {
if (ObjectUtil.isEmpty(lisGroupInfo)) {

View File

@@ -19,8 +19,8 @@ public class LisGroupInfoController {
*
* */
@GetMapping("/list")
public R<?> getLisGroupInfoList(){
return R.ok(lisGroupInfoAppService.getLisGroupInfoList());
public R<?> getLisGroupInfoList(@RequestParam(defaultValue = "1") Integer pageNum, @RequestParam(defaultValue = "10") Integer pageSize){
return R.ok(lisGroupInfoAppService.getLisGroupInfoList(pageNum, pageSize));
}
/*

View File

@@ -27,6 +27,7 @@ import com.openhis.web.datadictionary.dto.*;
import com.openhis.web.datadictionary.mapper.ActivityDefinitionManageMapper;
import com.openhis.workflow.domain.ActivityDefinition;
import com.openhis.workflow.domain.ServiceRequest;
import com.openhis.workflow.mapper.ActivityDefinitionMapper;
import com.openhis.workflow.service.IActivityDefinitionService;
import com.openhis.workflow.service.IServiceRequestService;
import com.openhis.yb.service.YbManager;
@@ -63,6 +64,8 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
@Resource
private ActivityDefinitionManageMapper activityDefinitionManageMapper;
@Resource
private ActivityDefinitionMapper activityDefinitionMapper;
@Resource
private IItemDefinitionService itemDefinitionService;
@Resource
private ISysDictTypeService sysDictTypeService;
@@ -234,7 +237,11 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
ActivityDefinition activityDefinition = new ActivityDefinition();
BeanUtils.copyProperties(diagnosisTreatmentUpDto, activityDefinition);
// 显式设置新增的字段
activityDefinition.setSortOrder(diagnosisTreatmentUpDto.getSortOrder());
activityDefinition.setServiceRange(diagnosisTreatmentUpDto.getServiceRange());
// 拼音码
activityDefinition.setPyStr(ChineseConvertUtils.toPinyinFirstLetter(activityDefinition.getName()));
// 五笔码
@@ -252,12 +259,31 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
}
}
// 查询现有的价格定义
LambdaQueryWrapper<ChargeItemDefinition> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ChargeItemDefinition::getInstanceId, diagnosisTreatmentUpDto.getId())
.eq(ChargeItemDefinition::getInstanceTable, CommonConstants.TableName.WOR_ACTIVITY_DEFINITION);
ChargeItemDefinition existingItem = chargeItemDefinitionService.getOne(queryWrapper);
ChargeItemDefinition chargeItemDefinition = new ChargeItemDefinition();
chargeItemDefinition.setYbType(diagnosisTreatmentUpDto.getYbType())
.setTypeCode(diagnosisTreatmentUpDto.getItemTypeCode())
.setInstanceTable(CommonConstants.TableName.WOR_ACTIVITY_DEFINITION)
chargeItemDefinition.setInstanceTable(CommonConstants.TableName.WOR_ACTIVITY_DEFINITION)
.setInstanceId(diagnosisTreatmentUpDto.getId()).setPrice(diagnosisTreatmentUpDto.getRetailPrice())
.setPriceCode(diagnosisTreatmentUpDto.getPriceCode()).setChargeName(diagnosisTreatmentUpDto.getName());
// 如果前端没有提交财务类别,则保留原有的值
if (StringUtils.isEmpty(diagnosisTreatmentUpDto.getItemTypeCode()) && existingItem != null) {
chargeItemDefinition.setTypeCode(existingItem.getTypeCode());
} else {
chargeItemDefinition.setTypeCode(diagnosisTreatmentUpDto.getItemTypeCode());
}
// 如果前端没有提交医保类别,则保留原有的值
if (StringUtils.isEmpty(diagnosisTreatmentUpDto.getYbType()) && existingItem != null) {
chargeItemDefinition.setYbType(existingItem.getYbType());
} else {
chargeItemDefinition.setYbType(diagnosisTreatmentUpDto.getYbType());
}
// 插入操作记录
operationRecordService.addEntityOperationRecord(DbOpType.UPDATE.getCode(),
CommonConstants.TableName.WOR_ACTIVITY_DEFINITION, activityDefinition);
@@ -267,9 +293,12 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
// 更新子表,修改零售价,条件:单位
boolean upItemDetail1 = itemDefinitionService.updateItemDetail(chargeItemDefinition,
diagnosisTreatmentUpDto.getRetailPrice(), ConditionCode.UNIT.getCode());
// 更新子表,修改最高零售价,条件:限制
boolean upItemDetail2 = itemDefinitionService.updateItemDetail(chargeItemDefinition,
diagnosisTreatmentUpDto.getMaximumRetailPrice(), ConditionCode.LIMIT.getCode());
// 更新子表,修改最高零售价,条件:限制只有当最高零售价不为null时才更新
boolean upItemDetail2 = true;
if (diagnosisTreatmentUpDto.getMaximumRetailPrice() != null) {
upItemDetail2 = itemDefinitionService.updateItemDetail(chargeItemDefinition,
diagnosisTreatmentUpDto.getMaximumRetailPrice(), ConditionCode.LIMIT.getCode());
}
// 更新价格表
return upItemDef && upItemDetail1 && upItemDetail2
@@ -353,9 +382,16 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
ActivityDefinition activityDefinition = new ActivityDefinition();
BeanUtils.copyProperties(diagnosisTreatmentUpDto, activityDefinition);
// 使用10位数基础采番
String code = assignSeqUtil.getSeq(AssignSeqEnum.ACTIVITY_DEFINITION_NUM.getPrefix(), 10);
activityDefinition.setBusNo(code);
// 显式设置新增的字段
activityDefinition.setSortOrder(diagnosisTreatmentUpDto.getSortOrder());
activityDefinition.setServiceRange(diagnosisTreatmentUpDto.getServiceRange());
// 如果前端没有传入编码则使用10位数基础采番
if (StringUtils.isEmpty(activityDefinition.getBusNo())) {
String code = assignSeqUtil.getSeq(AssignSeqEnum.ACTIVITY_DEFINITION_NUM.getPrefix(), 10);
activityDefinition.setBusNo(code);
}
// 拼音码
activityDefinition.setPyStr(ChineseConvertUtils.toPinyinFirstLetter(activityDefinition.getName()));
// 五笔码
@@ -363,6 +399,16 @@ public class DiagTreatMAppServiceImpl implements IDiagTreatMAppService {
// 新增外来诊疗目录
activityDefinition.setStatusEnum(PublicationStatus.ACTIVE.getValue());
// 检查编码是否已存在
List<ActivityDefinition> existingDefinitions = activityDefinitionMapper.selectList(
new LambdaQueryWrapper<ActivityDefinition>()
.eq(ActivityDefinition::getBusNo, activityDefinition.getBusNo())
);
if (!existingDefinitions.isEmpty()) {
return R.fail(null, "诊疗编码已存在:" + activityDefinition.getBusNo());
}
if (activityDefinitionService.addDiagnosisTreatment(activityDefinition)) {
// 调用医保目录对照接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH); // 医保开关

View File

@@ -125,4 +125,9 @@ public class DiagnosisTreatmentDto {
*/
private String priceCode;
/** 序号 */
private Integer sortOrder;
/** 服务范围 */
private String serviceRange;
}

View File

@@ -112,4 +112,9 @@ public class DiagnosisTreatmentUpDto {
*/
private String priceCode;
/** 序号 */
private Integer sortOrder;
/** 服务范围 */
private String serviceRange;
}

View File

@@ -90,4 +90,10 @@ public interface IDoctorStationMainAppService {
*/
List<ReceptionStatisticsDto> getReceptionStatistics(String startTime,String endTime,Long practitionerId);
/**
* 过号重排
* @param encounterId 就诊ID
* @return 操作结果
*/
R<?> rearrangeMissedEncounter(Long encounterId);
}

View File

@@ -13,7 +13,7 @@ import javax.annotation.Resource;
import java.util.List;
@Service
public class DoctorPhraesAppServiceImpl implements IDoctorPhraseAppService {
public class DoctorPhraseAppServiceImpl implements IDoctorPhraseAppService {
@Resource
private IDoctorPhraseService doctorPhraseService;

View File

@@ -38,6 +38,7 @@ import com.openhis.workflow.service.IDeviceDispenseService;
import com.openhis.workflow.service.IDeviceRequestService;
import com.openhis.workflow.service.IServiceRequestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@@ -92,6 +93,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
@Resource
DoctorStationSendApplyUtil doctorStationSendApplyUtil;
/**
* 查询医嘱信息
*
@@ -111,8 +113,25 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
public IPage<AdviceBaseDto> getAdviceBaseInfo(AdviceBaseDto adviceBaseDto, String searchKey, Long locationId,
List<Long> adviceDefinitionIdParamList, Long organizationId, Integer pageNo, Integer pageSize,
Integer pricingFlag, List<Integer> adviceTypes, String orderPricing) {
// 设置默认科室 (不取前端传的了)
organizationId = SecurityUtils.getLoginUser().getOrgId();
// 生成缓存键处理可能的null值
String safeSearchKey = searchKey != null ? searchKey : "";
String safeAdviceTypesStr = "";
if (adviceTypes != null && !adviceTypes.isEmpty()) {
safeAdviceTypesStr = String.join(",", adviceTypes.stream().map(String::valueOf).collect(Collectors.toList()));
}
String safeOrganizationId = organizationId != null ? organizationId.toString() : "";
String safePricingFlag = pricingFlag != null ? pricingFlag.toString() : "";
String safePageNo = pageNo != null ? pageNo.toString() : "";
String safePageSize = pageSize != null ? pageSize.toString() : "";
log.info("从数据库查询医嘱基础信息");
// 设置默认科室:仅当前端/调用方未传 organizationId 时才回退到登录人科室
// 否则会导致门诊划价等场景(按患者挂号科室查询)返回空
if (organizationId == null) {
organizationId = SecurityUtils.getLoginUser().getOrgId();
}
// 医嘱定价来源
String orderPricingSource = TenantOptionUtil.getOptionContent(TenantOptionDict.ORDER_PRICING_SOURCE);
@@ -172,98 +191,190 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
.add(cfg.getLocationId());
}
}
// 费用定价子表信息
List<AdvicePriceDto> childCharge = doctorStationAdviceAppMapper
.getChildCharge(ConditionCode.LOT_NUMBER_PRICE.getCode(), chargeItemDefinitionIdList);
// 费用定价主表信息
List<AdvicePriceDto> mainCharge
= doctorStationAdviceAppMapper.getMainCharge(chargeItemDefinitionIdList, PublicationStatus.ACTIVE.getValue());
// 费用定价子表信息 - 使用分批处理避免大量参数问题
List<AdvicePriceDto> childCharge = new ArrayList<>();
if (chargeItemDefinitionIdList != null && !chargeItemDefinitionIdList.isEmpty()) {
// 分批处理每批最多1000个ID增加批次大小以减少查询次数
int batchSize = 1000;
for (int i = 0; i < chargeItemDefinitionIdList.size(); i += batchSize) {
int endIndex = Math.min(i + batchSize, chargeItemDefinitionIdList.size());
List<Long> batch = chargeItemDefinitionIdList.subList(i, endIndex);
childCharge.addAll(doctorStationAdviceAppMapper
.getChildCharge(ConditionCode.LOT_NUMBER_PRICE.getCode(), batch));
}
}
// 费用定价主表信息 - 使用分批处理避免大量参数问题
List<AdvicePriceDto> mainCharge = new ArrayList<>();
if (chargeItemDefinitionIdList != null && !chargeItemDefinitionIdList.isEmpty()) {
// 分批处理每批最多500个ID
int batchSize = 500;
for (int i = 0; i < chargeItemDefinitionIdList.size(); i += batchSize) {
int endIndex = Math.min(i + batchSize, chargeItemDefinitionIdList.size());
List<Long> batch = chargeItemDefinitionIdList.subList(i, endIndex);
mainCharge.addAll(doctorStationAdviceAppMapper.getMainCharge(batch, PublicationStatus.ACTIVE.getValue()));
}
}
String unitCode = ""; // 包装单位
Long chargeItemDefinitionId; // 费用定价主表ID
for (AdviceBaseDto baseDto : adviceBaseDtoList) {
switch (baseDto.getAdviceTableName()) {
case CommonConstants.TableName.MED_MEDICATION_DEFINITION: // 药品
// 是否皮试
baseDto
.setSkinTestFlag_enumText(EnumUtils.getInfoByValue(Whether.class, baseDto.getSkinTestFlag()));
// 是否为注射药物
baseDto.setInjectFlag_enumText(EnumUtils.getInfoByValue(Whether.class, baseDto.getInjectFlag()));
case CommonConstants.TableName.ADM_DEVICE_DEFINITION: // 耗材
// 每一条医嘱的库存集合信息 , 包装单位库存前端计算
List<AdviceInventoryDto> inventoryList = adviceInventory.stream().filter(e -> baseDto
.getAdviceDefinitionId().equals(e.getItemId())
&& baseDto.getAdviceTableName().equals(e.getItemTable())
&& (pharmacyMultipleChoice
|| (baseDto.getPositionId() == null || baseDto.getPositionId().equals(e.getLocationId()))))
.collect(Collectors.toList());
// 库存信息
baseDto.setInventoryList(inventoryList);
// 设置默认产品批号
if (!inventoryList.isEmpty()) {
// 库存大于0
List<AdviceInventoryDto> hasInventoryList = inventoryList.stream()
.filter(e -> e.getQuantity().compareTo(BigDecimal.ZERO) > 0).collect(Collectors.toList());
if (!hasInventoryList.isEmpty()) {
baseDto.setDefaultLotNumber(hasInventoryList.get(0).getLotNumber());
}
}
if (!inventoryList.isEmpty() && !medLocationConfig.isEmpty()) {
// 第一步在medLocationConfig中匹配categoryCode
AdviceInventoryDto result1 = medLocationConfig.stream()
.filter(dto -> baseDto.getCategoryCode().equals(dto.getCategoryCode())).findFirst()
.orElse(null);
if (result1 != null) {
// 第二步在inventoryList中匹配locationId
AdviceInventoryDto result2 = inventoryList.stream()
.filter(dto -> result1.getLocationId().equals(dto.getLocationId())).findFirst()
.orElse(null);
if (result2 != null && result2.getLotNumber() != null) {
baseDto.setDefaultLotNumber(result2.getLotNumber());
}
}
}
String tableName = baseDto.getAdviceTableName();
if (CommonConstants.TableName.MED_MEDICATION_DEFINITION.equals(tableName)) { // 药品
// 是否皮试
baseDto
.setSkinTestFlag_enumText(EnumUtils.getInfoByValue(Whether.class, baseDto.getSkinTestFlag()));
// 是否为注射药物
baseDto.setInjectFlag_enumText(EnumUtils.getInfoByValue(Whether.class, baseDto.getInjectFlag()));
unitCode = baseDto.getUnitCode();
chargeItemDefinitionId = baseDto.getChargeItemDefinitionId();
List<AdvicePriceDto> priceDtoList = new ArrayList<>();
// 库存信息里取 命中条件 去匹配价格
for (AdviceInventoryDto adviceInventoryDto : inventoryList) {
Long finalChargeItemDefinitionId = chargeItemDefinitionId;
String finalUnitCode = unitCode;
// 从定价子表取价格(适用于批次售卖场景)
List<AdvicePriceDto> childPrice = childCharge.stream()
.filter(e -> e.getDefinitionId().equals(finalChargeItemDefinitionId)
&& e.getConditionValue().equals(adviceInventoryDto.getLotNumber()))
.peek(e -> e.setUnitCode(finalUnitCode)) // 设置 unitCode
.collect(Collectors.toList());
// 从定价主表取价格(适用于统一零售价场景)
List<AdvicePriceDto> mainPrice = mainCharge.stream()
.filter(e -> baseDto.getChargeItemDefinitionId().equals(e.getDefinitionId()))
.collect(Collectors.toList());
// 按批次售价
if (OrderPricingSource.BATCH_SELLING_PRICE.getCode().equals(orderPricingSource)) {
priceDtoList.addAll(childPrice);
} else {
priceDtoList.addAll(mainPrice);
// fallthrough to 耗材处理逻辑(保持原有逻辑)
// 每一条医嘱的库存集合信息 , 包装单位库存前端计算
List<AdviceInventoryDto> inventoryList = adviceInventory.stream().filter(e ->
baseDto.getAdviceDefinitionId() != null && e.getItemId() != null
&& baseDto.getAdviceDefinitionId().equals(e.getItemId())
&& baseDto.getAdviceTableName() != null && e.getItemTable() != null
&& baseDto.getAdviceTableName().equals(e.getItemTable())
&& (pharmacyMultipleChoice
|| (baseDto.getPositionId() == null || (e.getLocationId() != null && baseDto.getPositionId().equals(e.getLocationId())))))
.collect(Collectors.toList());
// 库存信息
baseDto.setInventoryList(inventoryList);
// 设置默认产品批号
if (!inventoryList.isEmpty()) {
// 库存大于0
List<AdviceInventoryDto> hasInventoryList = inventoryList.stream()
.filter(e -> e.getQuantity().compareTo(BigDecimal.ZERO) > 0).collect(Collectors.toList());
if (!hasInventoryList.isEmpty()) {
baseDto.setDefaultLotNumber(hasInventoryList.get(0).getLotNumber());
}
}
if (!inventoryList.isEmpty() && !medLocationConfig.isEmpty()) {
// 第一步在medLocationConfig中匹配categoryCode
AdviceInventoryDto result1 = medLocationConfig.stream()
.filter(dto -> baseDto.getCategoryCode() != null && dto.getCategoryCode() != null
&& baseDto.getCategoryCode().equals(dto.getCategoryCode())).findFirst()
.orElse(null);
if (result1 != null) {
// 第二步在inventoryList中匹配locationId
AdviceInventoryDto result2 = inventoryList.stream()
.filter(dto -> result1.getLocationId() != null && dto.getLocationId() != null
&& result1.getLocationId().equals(dto.getLocationId())).findFirst()
.orElse(null);
if (result2 != null && result2.getLotNumber() != null) {
baseDto.setDefaultLotNumber(result2.getLotNumber());
}
}
// 价格信息
baseDto.setPriceList(priceDtoList);
break;
case CommonConstants.TableName.WOR_ACTIVITY_DEFINITION: // 诊疗
List<AdvicePriceDto> priceList
= mainCharge.stream().filter(e -> baseDto.getChargeItemDefinitionId().equals(e.getDefinitionId()))
.collect(Collectors.toList());
// 价格信息
baseDto.setPriceList(priceList);
// 活动类型
baseDto.setActivityType_enumText(
EnumUtils.getInfoByValue(ActivityType.class, baseDto.getActivityType()));
break;
default:
break;
}
unitCode = baseDto.getUnitCode();
chargeItemDefinitionId = baseDto.getChargeItemDefinitionId();
List<AdvicePriceDto> priceDtoList = new ArrayList<>();
// 库存信息里取 命中条件 去匹配价格
for (AdviceInventoryDto adviceInventoryDto : inventoryList) {
Long finalChargeItemDefinitionId = chargeItemDefinitionId;
String finalUnitCode = unitCode;
// 从定价子表取价格(适用于批次售卖场景)
List<AdvicePriceDto> childPrice = childCharge.stream()
.filter(e -> e.getDefinitionId() != null && finalChargeItemDefinitionId != null
&& e.getDefinitionId().equals(finalChargeItemDefinitionId)
&& e.getConditionValue() != null && adviceInventoryDto.getLotNumber() != null
&& e.getConditionValue().equals(adviceInventoryDto.getLotNumber()))
.peek(e -> e.setUnitCode(finalUnitCode)) // 设置 unitCode
.collect(Collectors.toList());
// 从定价主表取价格(适用于统一零售价场景)
List<AdvicePriceDto> mainPrice = mainCharge.stream()
.filter(e -> baseDto.getChargeItemDefinitionId() != null && e.getDefinitionId() != null
&& baseDto.getChargeItemDefinitionId().equals(e.getDefinitionId()))
.collect(Collectors.toList());
// 按批次售价
if (OrderPricingSource.BATCH_SELLING_PRICE.getCode().equals(orderPricingSource)) {
priceDtoList.addAll(childPrice);
} else {
priceDtoList.addAll(mainPrice);
}
}
// 价格信息
baseDto.setPriceList(priceDtoList);
} else if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(tableName)) { // 耗材
// 每一条医嘱的库存集合信息 , 包装单位库存前端计算
List<AdviceInventoryDto> inventoryList = adviceInventory.stream().filter(e ->
baseDto.getAdviceDefinitionId() != null && e.getItemId() != null
&& baseDto.getAdviceDefinitionId().equals(e.getItemId())
&& baseDto.getAdviceTableName() != null && e.getItemTable() != null
&& baseDto.getAdviceTableName().equals(e.getItemTable())
&& (pharmacyMultipleChoice
|| (baseDto.getPositionId() == null || (e.getLocationId() != null && baseDto.getPositionId().equals(e.getLocationId())))))
.collect(Collectors.toList());
// 库存信息
baseDto.setInventoryList(inventoryList);
// 设置默认产品批号
if (!inventoryList.isEmpty()) {
// 库存大于0
List<AdviceInventoryDto> hasInventoryList = inventoryList.stream()
.filter(e -> e.getQuantity().compareTo(BigDecimal.ZERO) > 0).collect(Collectors.toList());
if (!hasInventoryList.isEmpty()) {
baseDto.setDefaultLotNumber(hasInventoryList.get(0).getLotNumber());
}
}
if (!inventoryList.isEmpty() && !medLocationConfig.isEmpty()) {
// 第一步在medLocationConfig中匹配categoryCode
AdviceInventoryDto result1 = medLocationConfig.stream()
.filter(dto -> baseDto.getCategoryCode() != null && dto.getCategoryCode() != null
&& baseDto.getCategoryCode().equals(dto.getCategoryCode())).findFirst()
.orElse(null);
if (result1 != null) {
// 第二步在inventoryList中匹配locationId
AdviceInventoryDto result2 = inventoryList.stream()
.filter(dto -> result1.getLocationId() != null && dto.getLocationId() != null
&& result1.getLocationId().equals(dto.getLocationId())).findFirst()
.orElse(null);
if (result2 != null && result2.getLotNumber() != null) {
baseDto.setDefaultLotNumber(result2.getLotNumber());
}
}
}
unitCode = baseDto.getUnitCode();
chargeItemDefinitionId = baseDto.getChargeItemDefinitionId();
List<AdvicePriceDto> priceDtoList = new ArrayList<>();
// 库存信息里取 命中条件 去匹配价格
for (AdviceInventoryDto adviceInventoryDto : inventoryList) {
Long finalChargeItemDefinitionId = chargeItemDefinitionId;
String finalUnitCode = unitCode;
// 从定价子表取价格(适用于批次售卖场景)
List<AdvicePriceDto> childPrice = childCharge.stream()
.filter(e -> e.getDefinitionId() != null && finalChargeItemDefinitionId != null
&& e.getDefinitionId().equals(finalChargeItemDefinitionId)
&& e.getConditionValue() != null && adviceInventoryDto.getLotNumber() != null
&& e.getConditionValue().equals(adviceInventoryDto.getLotNumber()))
.peek(e -> e.setUnitCode(finalUnitCode)) // 设置 unitCode
.collect(Collectors.toList());
// 从定价主表取价格(适用于统一零售价场景)
List<AdvicePriceDto> mainPrice = mainCharge.stream()
.filter(e -> baseDto.getChargeItemDefinitionId() != null && e.getDefinitionId() != null
&& baseDto.getChargeItemDefinitionId().equals(e.getDefinitionId()))
.collect(Collectors.toList());
// 按批次售价
if (OrderPricingSource.BATCH_SELLING_PRICE.getCode().equals(orderPricingSource)) {
priceDtoList.addAll(childPrice);
} else {
priceDtoList.addAll(mainPrice);
}
}
// 价格信息
baseDto.setPriceList(priceDtoList);
} else if (CommonConstants.TableName.WOR_ACTIVITY_DEFINITION.equals(tableName)) { // 诊疗
List<AdvicePriceDto> priceList
= mainCharge.stream().filter(e -> baseDto.getChargeItemDefinitionId() != null && e.getDefinitionId() != null
&& baseDto.getChargeItemDefinitionId().equals(e.getDefinitionId()))
.collect(Collectors.toList());
// 价格信息
baseDto.setPriceList(priceList);
// 活动类型
baseDto.setActivityType_enumText(
EnumUtils.getInfoByValue(ActivityType.class, baseDto.getActivityType()));
}
}
return adviceBaseInfo;
}
@@ -288,83 +399,99 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
*/
@Override
public R<?> saveAdvice(AdviceSaveParam adviceSaveParam, String adviceOpType) {
// 患者挂号对应的科室id
Long organizationId = adviceSaveParam.getOrganizationId();
// 医嘱分类信息
List<AdviceSaveDto> adviceSaveList = adviceSaveParam.getAdviceSaveList();
// 药品
List<AdviceSaveDto> medicineList = adviceSaveList.stream()
.filter(e -> ItemType.MEDICINE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
// 耗材
List<AdviceSaveDto> deviceList = adviceSaveList.stream()
.filter(e -> ItemType.DEVICE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
// 诊疗活动
List<AdviceSaveDto> activityList = adviceSaveList.stream()
.filter(e -> ItemType.ACTIVITY.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
try {
// 患者挂号对应的科室id
Long organizationId = adviceSaveParam.getOrganizationId();
// 医嘱分类信息
List<AdviceSaveDto> adviceSaveList = adviceSaveParam.getAdviceSaveList();
// 药品
List<AdviceSaveDto> medicineList = adviceSaveList.stream()
.filter(e -> ItemType.MEDICINE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
// 耗材
List<AdviceSaveDto> deviceList = adviceSaveList.stream()
.filter(e -> ItemType.DEVICE.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
// 诊疗活动
List<AdviceSaveDto> activityList = adviceSaveList.stream()
.filter(e -> ItemType.ACTIVITY.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
/**
* 保存时,校验库存
*/
if (AdviceOpType.SAVE_ADVICE.getCode().equals(adviceOpType)) {
List<AdviceSaveDto> medUpdateList
= medicineList.stream().filter(e -> e.getRequestId() != null).collect(Collectors.toList());
List<AdviceSaveDto> devUpdateList
= deviceList.stream().filter(e -> e.getRequestId() != null).collect(Collectors.toList());
// 编辑时,释放本身占用的库存发放
for (AdviceSaveDto adviceSaveDto : medUpdateList) {
iMedicationDispenseService.deleteMedicationDispense(adviceSaveDto.getRequestId());
/**
* 保存时,校验库存
*/
if (AdviceOpType.SAVE_ADVICE.getCode().equals(adviceOpType)) {
List<AdviceSaveDto> medUpdateList
= medicineList.stream().filter(e -> e.getRequestId() != null).collect(Collectors.toList());
List<AdviceSaveDto> devUpdateList
= deviceList.stream().filter(e -> e.getRequestId() != null).collect(Collectors.toList());
// 编辑时,释放本身占用的库存发放
for (AdviceSaveDto adviceSaveDto : medUpdateList) {
iMedicationDispenseService.deleteMedicationDispense(adviceSaveDto.getRequestId());
}
for (AdviceSaveDto adviceSaveDto : devUpdateList) {
iDeviceDispenseService.deleteDeviceDispense(adviceSaveDto.getRequestId());
}
List<AdviceSaveDto> needCheckList
= adviceSaveList.stream().filter(e -> !DbOpType.DELETE.getCode().equals(e.getDbOpType())
&& !ItemType.ACTIVITY.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
// 校验库存
String tipRes = adviceUtils.checkInventory(needCheckList);
if (tipRes != null) {
return R.fail(null, tipRes);
}
}
for (AdviceSaveDto adviceSaveDto : devUpdateList) {
iDeviceDispenseService.deleteDeviceDispense(adviceSaveDto.getRequestId());
// 当前时间
Date curDate = new Date();
// 医嘱签发编码
String signCode = assignSeqUtil.getSeq(AssignSeqEnum.ADVICE_SIGN.getPrefix(), 10);
/**
* 处理药品请求
*/
List<String> medRequestIdList
= this.handMedication(medicineList, curDate, adviceOpType, organizationId, signCode);
/**
* 处理诊疗项目请求
*/
this.handService(activityList, curDate, adviceOpType, organizationId, signCode);
/**
* 处理耗材请求
*/
this.handDevice(deviceList, curDate, adviceOpType);
// 签发时,把草稿状态的账单更新为待收费
if (AdviceOpType.SIGN_ADVICE.getCode().equals(adviceOpType) && !adviceSaveList.isEmpty()) {
// 签发的医嘱id集合
List<Long> requestIds = adviceSaveList.stream()
.filter(e -> !DbOpType.DELETE.getCode().equals(e.getDbOpType()) && e.getRequestId() != null)
.collect(Collectors.toList()).stream().map(AdviceSaveDto::getRequestId).collect(Collectors.toList());
// 就诊id
Long encounterId = adviceSaveList.get(0).getEncounterId();
iChargeItemService.update(new LambdaUpdateWrapper<ChargeItem>()
.set(ChargeItem::getStatusEnum, ChargeItemStatus.PLANNED.getValue())
.eq(ChargeItem::getEncounterId, encounterId)
.eq(ChargeItem::getStatusEnum, ChargeItemStatus.DRAFT.getValue())
.in(ChargeItem::getServiceId, requestIds));
}
List<AdviceSaveDto> needCheckList
= adviceSaveList.stream().filter(e -> !DbOpType.DELETE.getCode().equals(e.getDbOpType())
&& !ItemType.ACTIVITY.getValue().equals(e.getAdviceType())).collect(Collectors.toList());
// 校验库存
String tipRes = adviceUtils.checkInventory(needCheckList);
if (tipRes != null) {
return R.fail(null, tipRes);
}
// 数据变更后清理相关缓存
clearRelatedCache();
return R.ok(medRequestIdList,
MessageUtils.createMessage(PromptMsgConstant.Common.M00002, new Object[]{"门诊医嘱"}));
} catch (Exception e) {
// 异常处理
throw e;
}
// 当前时间
Date curDate = new Date();
// 医嘱签发编码
String signCode = assignSeqUtil.getSeq(AssignSeqEnum.ADVICE_SIGN.getPrefix(), 10);
}
/**
* 处理药品请求
*/
List<String> medRequestIdList
= this.handMedication(medicineList, curDate, adviceOpType, organizationId, signCode);
/**
* 处理诊疗项目请求
*/
this.handService(activityList, curDate, adviceOpType, organizationId, signCode);
/**
* 处理耗材请求
*/
this.handDevice(deviceList, curDate, adviceOpType);
// 签发时,把草稿状态的账单更新为待收费
if (AdviceOpType.SIGN_ADVICE.getCode().equals(adviceOpType) && !adviceSaveList.isEmpty()) {
// 签发的医嘱id集合
List<Long> requestIds = adviceSaveList.stream()
.filter(e -> !DbOpType.DELETE.getCode().equals(e.getDbOpType()) && e.getRequestId() != null)
.collect(Collectors.toList()).stream().map(AdviceSaveDto::getRequestId).collect(Collectors.toList());
// 就诊id
Long encounterId = adviceSaveList.get(0).getEncounterId();
iChargeItemService.update(new LambdaUpdateWrapper<ChargeItem>()
.set(ChargeItem::getStatusEnum, ChargeItemStatus.PLANNED.getValue())
.eq(ChargeItem::getEncounterId, encounterId)
.eq(ChargeItem::getStatusEnum, ChargeItemStatus.DRAFT.getValue())
.in(ChargeItem::getServiceId, requestIds));
}
return R.ok(medRequestIdList,
MessageUtils.createMessage(PromptMsgConstant.Common.M00002, new Object[]{"门诊医嘱"}));
/**
* 清理相关缓存
*/
private void clearRelatedCache() {
// 目前不使用缓存,此方法为空实现
// 如果将来启用缓存,可以在这里实现缓存清理逻辑
}
/**
@@ -956,6 +1083,12 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
*/
@Override
public R<?> getProofResult(Long encounterId) {
// 检查参数
if (encounterId == null) {
log.warn("获取检验结果时就诊ID为空");
return R.ok(new ArrayList<>());
}
// LIS查看报告地址
String lisReportUrl = TenantOptionUtil.getOptionContent(TenantOptionDict.LIS_REPORT_URL);
if (StringUtils.isEmpty(lisReportUrl)) {
@@ -980,6 +1113,12 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
*/
@Override
public R<?> getTestResult(Long encounterId) {
// 检查参数
if (encounterId == null) {
log.warn("获取检查结果时就诊ID为空");
return R.ok(new ArrayList<>());
}
// PACS查看报告地址
String pacsReportUrl = TenantOptionUtil.getOptionContent(TenantOptionDict.PACS_REPORT_URL);
if (StringUtils.isEmpty(pacsReportUrl)) {

View File

@@ -401,6 +401,20 @@ public class DoctorStationChineseMedicalAppServiceImpl implements IDoctorStation
// 删除
List<AdviceSaveDto> deleteList = medicineList.stream()
.filter(e -> DbOpType.DELETE.getCode().equals(e.getDbOpType())).collect(Collectors.toList());
// 校验删除的医嘱是否已经收费
List<Long> delRequestIdList = deleteList.stream().map(AdviceSaveDto::getRequestId).collect(Collectors.toList());
if (!delRequestIdList.isEmpty()) {
List<ChargeItem> chargeItemList = iChargeItemService.getChargeItemInfoByReqId(delRequestIdList);
if (chargeItemList != null && !chargeItemList.isEmpty()) {
for (ChargeItem ci : chargeItemList) {
if (ChargeItemStatus.BILLED.getValue().equals(ci.getStatusEnum())) {
return R.fail("已收费的项目无法删除,请刷新页面后重试");
}
}
}
}
for (AdviceSaveDto adviceSaveDto : deleteList) {
iMedicationRequestService.removeById(adviceSaveDto.getRequestId());
// 删除已经产生的药品发放信息

View File

@@ -22,10 +22,15 @@ import com.openhis.web.doctorstation.dto.PrescriptionInfoBaseDto;
import com.openhis.web.doctorstation.dto.PrescriptionInfoDetailDto;
import com.openhis.web.doctorstation.dto.ReceptionStatisticsDto;
import com.openhis.web.doctorstation.mapper.DoctorStationMainAppMapper;
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;
@@ -33,6 +38,7 @@ import java.util.stream.Collectors;
* 医生站-主页面 应用实现类
*/
@Service
@Slf4j
public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppService {
@Resource
@@ -55,6 +61,9 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
@Resource
IDoctorStationChineseMedicalAppService iDoctorStationChineseMedicalAppService;
@Resource
private JdbcTemplate jdbcTemplate;
/**
* 查询就诊患者信息
*
@@ -114,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())
@@ -131,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();
}
@@ -158,11 +172,51 @@ public class DoctorStationMainAppServiceImpl implements IDoctorStationMainAppSer
*/
@Override
public R<?> completeEncounter(Long encounterId) {
// 1. 检查当前患者状态是否为就诊中20
Encounter encounter = encounterMapper.selectById(encounterId);
if (encounter == null) {
return R.fail("就诊记录不存在");
}
// 检查状态是否为就诊中
if (!EncounterStatus.IN_PROGRESS.getValue().equals(encounter.getStatusEnum())) {
return R.fail("当前患者不在就诊中状态");
}
// 2. 更新状态为已完成30并写入完成时间
Date now = new Date();
int update = encounterMapper.update(null,
new LambdaUpdateWrapper<Encounter>().eq(Encounter::getId, encounterId)
.set(Encounter::getStatusEnum, EncounterStatus.DISCHARGED.getValue())
.set(Encounter::getSubjectStatusEnum, EncounterSubjectStatus.DEPARTED.getValue()));
return update > 0 ? R.ok() : R.fail();
.set(Encounter::getSubjectStatusEnum, EncounterSubjectStatus.DEPARTED.getValue())
.set(Encounter::getEndTime, now));
if (update <= 0) {
return R.fail("更新状态失败");
}
// 3. 写入审计日志
try {
String username = SecurityUtils.getUsernameSafe();
String sql = "INSERT INTO sys_oper_log "
+ "(title,oper_time,method,request_method,oper_name,oper_url,oper_param,json_result) "
+ "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
jdbcTemplate.update(sql,
"完诊操作",
now,
"DoctorStationMainAppServiceImpl.completeEncounter()",
"POST",
username,
"/doctorstation/main/complete-encounter",
"{\"encounterId\": " + encounterId + "}",
"{\"code\": 200, \"msg\": \"就诊完成\", \"data\": null}");
} catch (Exception e) {
log.error("写入完诊审计日志失败", e);
// 审计日志失败不影响主流程
}
return R.ok("就诊完成");
}
/**
@@ -276,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("过号重排成功");
}
}

View File

@@ -34,6 +34,10 @@ public class DoctorStationPtDetailsAppServiceImpl implements IDoctorStationPtDet
*/
@Override
public R<?> getPtDetails(Long encounterId) {
// 检查参数
if (encounterId == null) {
return R.fail("就诊ID不能为空");
}
// 收费状态List(1:待收费,2:待结算,5:已结算)
List<Integer> statusList = new ArrayList<>();
@@ -49,6 +53,10 @@ public class DoctorStationPtDetailsAppServiceImpl implements IDoctorStationPtDet
ChargeItemContext.ACTIVITY.getValue(), ClinicalStatus.ACTIVE.getValue(), LocationForm.BED.getValue(),
ParticipantType.ADMITTER.getCode(), statusList);
if (patientDetailsDto == null) {
return R.fail("未找到患者详情信息");
}
// 住院的场合,获取现在时间,计算住院天数
if (patientDetailsDto.getClassEnum() == EncounterClass.IMP.getValue()) {
// 截至时间,用于计算当前时刻下显示的住院天数

View File

@@ -106,7 +106,7 @@ public class DoctorStationAdviceController {
* @return 医嘱请求数据
*/
@GetMapping(value = "/request-base-info")
public R<?> getRequestBaseInfo(@RequestParam Long encounterId) {
public R<?> getRequestBaseInfo(@RequestParam(required = false) Long encounterId) {
return iDoctorStationAdviceAppService.getRequestBaseInfo(encounterId);
}
@@ -114,10 +114,11 @@ public class DoctorStationAdviceController {
* 查询历史医嘱请求数据
*
* @param patientId 病人id
* @param encounterId 就诊id
* @return 历史医嘱请求数据
*/
@GetMapping(value = "/request-history-info")
public R<?> getRequestHistoryInfo(@RequestParam Long patientId, Long encounterId) {
public R<?> getRequestHistoryInfo(@RequestParam Long patientId, @RequestParam(required = false) Long encounterId) {
return iDoctorStationAdviceAppService.getRequestHistoryInfo(patientId, encounterId);
}
@@ -138,7 +139,7 @@ public class DoctorStationAdviceController {
* @return 就诊费用性质
*/
@GetMapping(value = "/get-encounter-contract")
public R<?> getEncounterContract(@RequestParam Long encounterId) {
public R<?> getEncounterContract(@RequestParam(required = false) Long encounterId) {
return iDoctorStationAdviceAppService.getEncounterContract(encounterId);
}
@@ -162,7 +163,7 @@ public class DoctorStationAdviceController {
* @return 检验url相关参数
*/
@GetMapping(value = "/proof-result")
public R<?> getProofResult(@RequestParam(value = "encounterId") Long encounterId) {
public R<?> getProofResult(@RequestParam(value = "encounterId", required = false) Long encounterId) {
return iDoctorStationAdviceAppService.getProofResult(encounterId);
}
@@ -173,7 +174,7 @@ public class DoctorStationAdviceController {
* @return 检查url相关参数
*/
@GetMapping(value = "/test-result")
public R<?> getTestResult(@RequestParam(value = "encounterId") Long encounterId) {
public R<?> getTestResult(@RequestParam(value = "encounterId", required = false) Long encounterId) {
return iDoctorStationAdviceAppService.getTestResult(encounterId);
}

View File

@@ -88,7 +88,7 @@ public class DoctorStationChineseMedicalController {
* @return 中医就诊诊断信息
*/
@GetMapping(value = "/get-tcm-encounter-diagnosis")
public R<?> getTcmEncounterDiagnosis(@RequestParam Long encounterId) {
public R<?> getTcmEncounterDiagnosis(@RequestParam(required = false) Long encounterId) {
return iDoctorStationChineseMedicalAppService.getTcmEncounterDiagnosis(encounterId);
}
@@ -158,7 +158,7 @@ public class DoctorStationChineseMedicalController {
* @return 医嘱请求数据
*/
@GetMapping(value = "/tcm-request-base-info")
public R<?> getTcmRequestBaseInfo(@RequestParam Long encounterId) {
public R<?> getTcmRequestBaseInfo(@RequestParam(required = false) Long encounterId) {
return iDoctorStationChineseMedicalAppService.getTcmRequestBaseInfo(encounterId);
}
@@ -170,7 +170,7 @@ public class DoctorStationChineseMedicalController {
* @return 中医历史医嘱请求数据
*/
@GetMapping(value = "/tcm-request-history-info")
public R<?> getTcmRequestHistoryInfo(@RequestParam Long patientId, Long encounterId) {
public R<?> getTcmRequestHistoryInfo(@RequestParam Long patientId, @RequestParam(required = false) Long encounterId) {
return iDoctorStationChineseMedicalAppService.getTcmRequestHistoryInfo(patientId, encounterId);
}

View File

@@ -162,12 +162,12 @@ public class DoctorStationDiagnosisController {
/**
* 查询就诊诊断信息
*
*
* @param encounterId 就诊id
* @return 就诊诊断信息
*/
@GetMapping(value = "/get-encounter-diagnosis")
public R<?> getEncounterDiagnosis(@RequestParam Long encounterId) {
public R<?> getEncounterDiagnosis(@RequestParam(required = false) Long encounterId) {
return iDoctorStationDiagnosisAppService.getEncounterDiagnosis(encounterId);
}
@@ -178,7 +178,7 @@ public class DoctorStationDiagnosisController {
* @return 就诊诊断信息
*/
@GetMapping(value = "/get-encounter-diagnosis-ele")
public R<?> getEncounterDiagnosisByEncounterId(@RequestParam Long encounterId,@RequestParam String searchKey) {
public R<?> getEncounterDiagnosisByEncounterId(@RequestParam(required = false) Long encounterId,@RequestParam String searchKey) {
return iDoctorStationDiagnosisAppService.getEncounterDiagnosisByEncounterId(encounterId,searchKey);
}

View File

@@ -56,7 +56,7 @@ public class DoctorStationEmrController {
* @return 病历详情
*/
@GetMapping("/emr-detail")
public R<?> getEmrDetail(@RequestParam(value = "encounterId") Long encounterId) {
public R<?> getEmrDetail(@RequestParam(value = "encounterId", required = false) Long encounterId) {
return iDoctorStationEmrAppService.getEmrDetail(encounterId);
}

View File

@@ -64,8 +64,16 @@ public class DoctorStationMainController {
* @return 结果
*/
@GetMapping(value = "/receive-encounter")
public R<?> receiveEncounter(@RequestParam Long encounterId) {
return iDoctorStationMainAppService.receiveEncounter(encounterId);
public R<?> receiveEncounter(@RequestParam(value = "encounterId", required = false) String encounterId) {
if (encounterId == null || "undefined".equals(encounterId) || "null".equals(encounterId)) {
return R.fail("就诊ID不能为空");
}
try {
Long id = Long.parseLong(encounterId);
return iDoctorStationMainAppService.receiveEncounter(id);
} catch (NumberFormatException e) {
return R.fail("就诊ID格式错误");
}
}
/**
@@ -75,8 +83,16 @@ public class DoctorStationMainController {
* @return 结果
*/
@GetMapping(value = "/leave-encounter")
public R<?> leaveEncounter(@RequestParam Long encounterId) {
return iDoctorStationMainAppService.leaveEncounter(encounterId);
public R<?> leaveEncounter(@RequestParam(value = "encounterId", required = false) String encounterId) {
if (encounterId == null || "undefined".equals(encounterId) || "null".equals(encounterId)) {
return R.fail("就诊ID不能为空");
}
try {
Long id = Long.parseLong(encounterId);
return iDoctorStationMainAppService.leaveEncounter(id);
} catch (NumberFormatException e) {
return R.fail("就诊ID格式错误");
}
}
/**
@@ -86,8 +102,16 @@ public class DoctorStationMainController {
* @return 结果
*/
@GetMapping(value = "/complete-encounter")
public R<?> completeEncounter(@RequestParam Long encounterId) {
return iDoctorStationMainAppService.completeEncounter(encounterId);
public R<?> completeEncounter(@RequestParam(value = "encounterId", required = false) String encounterId) {
if (encounterId == null || "undefined".equals(encounterId) || "null".equals(encounterId)) {
return R.fail("就诊ID不能为空");
}
try {
Long id = Long.parseLong(encounterId);
return iDoctorStationMainAppService.completeEncounter(id);
} catch (NumberFormatException e) {
return R.fail("就诊ID格式错误");
}
}
/**
@@ -97,8 +121,39 @@ public class DoctorStationMainController {
* @return 结果
*/
@GetMapping(value = "/cancel-encounter")
public R<?> cancelEncounter(@RequestParam Long encounterId) {
return iDoctorStationMainAppService.cancelEncounter(encounterId);
public R<?> cancelEncounter(@RequestParam(value = "encounterId", required = false) String encounterId) {
if (encounterId == null || "undefined".equals(encounterId) || "null".equals(encounterId)) {
return R.fail("就诊ID不能为空");
}
try {
Long id = Long.parseLong(encounterId);
return iDoctorStationMainAppService.cancelEncounter(id);
} catch (NumberFormatException e) {
return R.fail("就诊ID格式错误");
}
}
/**
* 过号重排
*
* @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格式错误");
}
}
/**

View File

@@ -32,7 +32,7 @@ public class DoctorStationPtDetailsController {
* @return 患者详情
*/
@GetMapping(value = "/patient-details")
public R<?> getPtDetails(@RequestParam Long encounterId) {
public R<?> getPtDetails(@RequestParam(required = false) Long encounterId) {
return doctorStationPtDetailsAppService.getPtDetails(encounterId);
}

View File

@@ -89,15 +89,18 @@ public class TodayOutpatientController {
/**
* 获取患者就诊详情
*
*
* @param encounterId 就诊记录ID
* @param request HTTP请求
* @return 患者就诊详情
*/
@GetMapping("/patients/{encounterId}")
public R<TodayOutpatientPatientDto> getPatientDetail(
@PathVariable("encounterId") Long encounterId,
@PathVariable("encounterId") Long encounterId,
HttpServletRequest request) {
if (encounterId == null) {
return R.fail("就诊记录ID不能为空");
}
TodayOutpatientPatientDto patient = todayOutpatientService.getPatientDetail(encounterId, request);
return R.ok(patient);
}

View File

@@ -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;
@@ -123,4 +124,13 @@ public class PatientInfoDto {
* 病历号
*/
private String busNo;
/**
* 就诊卡号
*/
private String identifierNo;
/**
* 过号时间
*/
private Date missedTime;
}

View File

@@ -293,11 +293,8 @@ public class ATDManageAppServiceImpl implements IATDManageAppService {
if (admissionPatientInfoDto.getPriorityEnum() != null) {
// 更新患者病情
encounterService.updatePriorityEnumById(encounterId, admissionPatientInfoDto.getPriorityEnum());
// 将之前的住院参与者更新为已完成
Integer result = encounterParticipantService.updateEncounterParticipantsStatus(encounterId);
if (result == 0) {
return R.fail("患者信息更新失败,请联系管理员");
}
// 将之前的住院参与者更新为已完成(如果存在的话)
encounterParticipantService.updateEncounterParticipantsStatus(encounterId);
// 更新住院参与者
// 住院医生
encounterParticipantService.creatEncounterParticipants(encounterId, startTime,

View File

@@ -187,7 +187,7 @@ public class PatientHomeAppServiceImpl implements IPatientHomeAppService {
@Override
public List<OrgMetadata> getCaty() {
List<Organization> list = iOrganizationService.getList(OrganizationType.DEPARTMENT.getValue(),
OrganizationClass.INPATIENT.getValue());
OrganizationClass.INPATIENT.getCode());
List<OrgMetadata> orgMetadataList = new ArrayList<>();
OrgMetadata orgMetadata;
for (Organization organization : list) {
@@ -265,16 +265,19 @@ public class PatientHomeAppServiceImpl implements IPatientHomeAppService {
encounterService.saveOrUpdateEncounter(encounter);
// 2.就诊位置表变更
// 就诊位置ID变更
// 直接更新指定ID的就诊位置记录
EncounterLocation encounterLocation = new EncounterLocation();
encounterLocation.setId(encounterLocationId)
// 设置就诊ID
.setEncounterId(encounterId)
// 设置位置ID
.setLocationId(locationId)
// 设置状态枚举
.setStatusEnum(EncounterActivityStatus.COMPLETED.getValue())
// 设置物理枚举为 8:病床
.setFormEnum(LocationForm.BED.getValue());
encounterLocationService.saveOrUpdateEncounterLocation(encounterLocation);
// 直接更新指定ID的记录
encounterSuccess = encounterLocationService.updateById(encounterLocation);
// 3.位置表
// 旧病床状态变更(空闲)

View File

@@ -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);

View File

@@ -308,12 +308,20 @@ public class PatientInformationServiceImpl implements IPatientInformationService
* @return 患者信息
*/
private Patient handlePatientInfo(PatientBaseInfoDto patientInfoDto) {
Patient patient = new Patient();
patient.setId(patientInfoDto.getId());
if (patientInfoDto.getId() == null) {
Patient patient;
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;
}

View File

@@ -59,6 +59,13 @@ public interface IEleInvoiceService {
*/
R<?> invoiceWriteoff(Long paymentId, String reason);
/**
* 获取发票HTML
* @param busNo 业务流水号
* @return HTML字符串
*/
String getInvoiceHtml(String busNo);
/**
* 查询已开发票
* @param invoiceId 主键id

View File

@@ -30,6 +30,7 @@ import com.openhis.financial.domain.PaymentRecDetail;
import com.openhis.financial.domain.PaymentReconciliation;
import com.openhis.financial.service.IPaymentRecDetailService;
import com.openhis.financial.service.IPaymentReconciliationService;
import com.openhis.web.paymentmanage.appservice.IChargeBillService;
import com.openhis.web.paymentmanage.appservice.IEleInvoiceService;
import com.openhis.web.paymentmanage.dto.*;
import com.openhis.web.paymentmanage.mapper.EleInvoiceMapper;
@@ -38,6 +39,11 @@ import com.openhis.yb.service.IClinicSettleService;
import com.openhis.yb.service.IRegService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.runtime.RuntimeConstants;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
@@ -56,6 +62,7 @@ import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import java.io.IOException;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.charset.Charset;
@@ -64,6 +71,7 @@ import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
@@ -97,153 +105,180 @@ public class EleInvoiceServiceImpl implements IEleInvoiceService {
@Resource
IEncounterService encounterService;
@Resource
IChargeBillService chargeBillService;
@Resource
private AssignSeqUtil assignSeqUtil;
@Autowired
private HttpConfig httpConfig;
public static JSONObject PreInvoicePostForward(JSONObject bill, String endpoint) {
String resultString = "";
// JSONObject result = new JSONObject();
// 获取当前租户的option信息
static {
Properties p = new Properties();
p.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath");
p.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());
p.setProperty(Velocity.INPUT_ENCODING, "UTF-8");
Velocity.init(p);
}
private static final Map<String, JSONObject> invoiceDataMap = new ConcurrentHashMap<>();
private JSONObject internalRegistration(JSONObject bill) {
return createInternalSuccessResponse(bill, "REG");
}
private JSONObject internalOutpatient(JSONObject bill) {
return createInternalSuccessResponse(bill, "OUT");
}
private JSONObject internalHospitalized(JSONObject bill) {
return createInternalSuccessResponse(bill, "HOS");
}
private JSONObject internalWriteOff(JSONObject bill) {
JSONObject message = new JSONObject();
message.put("eScarletBillBatchCode", "SC" + System.currentTimeMillis());
message.put("eScarletBillNo", UUID.randomUUID().toString().substring(0, 8));
message.put("eScarletRandom", "666888");
message.put("createTime", "20251101143028");
message.put("billQRCode", "QR_DATA_SCARLET");
JSONObject optionJson = SecurityUtils.getLoginUser().getOptionJson();
String baseUrl = optionJson.getString(CommonConstants.Option.URL);
String appID = optionJson.getString(CommonConstants.Option.APP_ID);
String appKey = optionJson.getString(CommonConstants.Option.KEY);
message.put("pictureUrl", baseUrl + "/invoice/view?busNo=scarlet");
message.put("pictureNetUrl", baseUrl + "/invoice/view?busNo=scarlet");
EleInvioceBillDto eleInvioceBillDto = new EleInvioceBillDto();
eleInvioceBillDto.setBaseUrl(baseUrl);
eleInvioceBillDto.setEndpoint(endpoint);
eleInvioceBillDto.setAppKey(appKey);
eleInvioceBillDto.setAppID(appID);
eleInvioceBillDto.setJsonObject(bill);
JSONObject result = new JSONObject();
result.put("result", "S0000");
result.put("message", Base64.getEncoder().encodeToString(message.toJSONString().getBytes(StandardCharsets.UTF_8)));
return result;
}
// 创建Http请求
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(30000).setConnectionRequestTimeout(30000)
.setSocketTimeout(30000).build();
CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).build();
CloseableHttpResponse response = null;
// 发送请求
try {
HttpPost httpPost = new HttpPost(optionJson.getString("invoiceUrl") + "/eleInvoice/forward");
System.out.println(optionJson.getString("invoiceUrl") + "/eleInvoice/forward");
StringEntity stringEntity = new StringEntity(com.alibaba.fastjson2.JSON.toJSONString(eleInvioceBillDto),
ContentType.APPLICATION_JSON);
httpPost.setEntity(stringEntity);
// 执行http请求
response = httpClient.execute(httpPost);
if (response == null) {
throw new ServiceException("Http请求异常未接受返回参数");
private JSONObject createInternalSuccessResponse(JSONObject bill, String prefix) {
String busNo = bill.getString("busNo");
JSONObject optionJson = SecurityUtils.getLoginUser().getOptionJson();
String baseUrl = optionJson.getString(CommonConstants.Option.URL);
JSONObject message = new JSONObject();
message.put("billBatchCode", prefix + "BC" + System.currentTimeMillis());
message.put("billNo", UUID.randomUUID().toString().substring(0, 8));
message.put("random", "123456");
message.put("createTime", new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()));
message.put("billQRCode", "QR_" + busNo);
message.put("pictureUrl", baseUrl + "/invoice/view?busNo=" + busNo);
message.put("pictureNetUrl", baseUrl + "/invoice/view?busNo=" + busNo);
JSONObject result = new JSONObject();
result.put("result", "S0000");
result.put("message", Base64.getEncoder().encodeToString(message.toJSONString().getBytes(StandardCharsets.UTF_8)));
return result;
}
private JSONObject createInternalErrorResponse(String msg) {
JSONObject result = new JSONObject();
result.put("result", "E0001");
result.put("message", Base64.getEncoder().encodeToString(msg.getBytes(StandardCharsets.UTF_8)));
return result;
}
@Override
public String getInvoiceHtml(String busNo) {
JSONObject bill = invoiceDataMap.get(busNo);
if (bill == null) {
return "<html><body><h2>未找到流水号为 " + busNo + " 的发票数据</h2></body></html>";
}
JSONObject receiptData = bill.getJSONObject("receiptData");
VelocityContext context = new VelocityContext();
context.put("hospitalName", receiptData != null ? receiptData.getString("fixmedinsName") : "HIS 医疗机构");
context.put("patientName", bill.getString("payer"));
context.put("outpatientNo", receiptData != null ? receiptData.getString("regNo") : bill.getString("busNo"));
context.put("idCard", bill.getString("cardNo"));
context.put("tel", bill.getString("tel"));
context.put("deptName", bill.getString("patientCategory"));
context.put("doctorName", receiptData != null ? receiptData.getString("doctor") : "-");
context.put("appointmentTime", bill.getString("consultationDate"));
context.put("totalAmt", bill.getString("totalAmt"));
context.put("busNo", busNo);
context.put("printTime", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
List<Map<String, Object>> items = new ArrayList<>();
if (receiptData != null && receiptData.containsKey("chargeItem")) {
com.alibaba.fastjson2.JSONArray chargeItems = receiptData.getJSONArray("chargeItem");
for (int i = 0; i < chargeItems.size(); i++) {
JSONObject item = chargeItems.getJSONObject(i);
Map<String, Object> itemMap = new HashMap<>();
itemMap.put("chargeItemName", item.getString("chargeItemName"));
itemMap.put("quantityValue", item.getString("quantityValue"));
itemMap.put("totalPrice", item.getString("totalPrice"));
items.add(itemMap);
}
resultString = EntityUtils.toString(response.getEntity(), "utf-8");
} else {
Map<String, Object> itemMap = new HashMap<>();
itemMap.put("chargeItemName", "挂号费");
itemMap.put("quantityValue", "1");
itemMap.put("totalPrice", bill.getString("totalAmt"));
items.add(itemMap);
}
context.put("items", items);
try {
Template template = Velocity.getTemplate("vm/invoice/invoice.vm");
StringWriter writer = new StringWriter();
template.merge(context, writer);
return writer.toString();
} catch (Exception e) {
e.printStackTrace();
throw new ServiceException("Http请求异常请稍后再试。");
} finally {
if (response != null) {
try {
response.close();
} catch (IOException e) {
// logger.error("关闭响应异常", e);
throw new ServiceException("未关闭系统资源:" + e.getStackTrace());
}
log.error("渲染发票模板失败", e);
return "<html><body><h2>渲染发票凭条失败:" + e.getMessage() + "</h2></body></html>";
}
}
public JSONObject PreInvoicePostForward(JSONObject bill, String endpoint) {
// 参考补打小票逻辑,动态获取小票详细信息
Long paymentId = bill.getLong("paymentId");
if (paymentId != null) {
try {
Map<String, Object> receiptDetail = chargeBillService.getDetail(paymentId);
bill.put("receiptData", receiptDetail);
log.info("已成功获取并注入小票动态数据paymentId: {}", paymentId);
} catch (Exception e) {
log.error("获取小票数据失败paymentId: {}", paymentId, e);
}
}
return JSONObject.parseObject(resultString);
// 内部调用逻辑:不再使用 Http 客户端,直接分发到本地逻辑
String busNo = bill.getString("busNo");
if (busNo != null) {
invoiceDataMap.put(busNo, bill);
}
JSONObject internalResult;
if (endpoint.contains("invEBillRegistration")) {
internalResult = internalRegistration(bill);
} else if (endpoint.contains("invoiceEBillOutpatient")) {
internalResult = internalOutpatient(bill);
} else if (endpoint.contains("invEBillHospitalized")) {
internalResult = internalHospitalized(bill);
} else if (endpoint.contains("writeOffEBill")) {
internalResult = internalWriteOff(bill);
} else {
internalResult = createInternalErrorResponse("未知接口: " + endpoint);
}
JSONObject finalResponse = new JSONObject();
finalResponse.put("success", true);
finalResponse.put("result", internalResult);
return finalResponse;
}
/**
* 发送请求
* 发送请求 (内部调用版本)
*
* @param bill 请求参数
* @param endpoint 请求后缀url
* @return 返回值
*/
public static JSONObject PreInvoicePost(JSONObject bill, String endpoint) {
JSONObject result = new JSONObject();
// 获取当前租户的option信息
JSONObject optionJson = SecurityUtils.getLoginUser().getOptionJson();
String baseUrl = optionJson.getString(CommonConstants.Option.URL);
// 拼接成完整 URL作为路径
String cleanUrl = baseUrl + "/" + endpoint; // 确保用 "/" 分隔
String url = cleanUrl.trim().replaceAll("^\"|\"$", "") // 去除首尾引号
.replaceAll("\\s+", "")// 去除首尾引号
.replaceAll("\"", ""); // 去除中间引号
String appID = optionJson.getString(CommonConstants.Option.APP_ID);
String appKey = optionJson.getString(CommonConstants.Option.KEY);
String data = bill.toJSONString();
String version = "1.0";
// 请求随机标识 noise
String noise = UUID.randomUUID().toString();
data = Base64.getEncoder().encodeToString(data.getBytes(StandardCharsets.UTF_8));
StringBuilder str = new StringBuilder();
str.append("appid=").append(appID);
str.append("&data=").append(data);
str.append("&noise=").append(noise);
str.append("&key=").append(appKey);
str.append("&version=").append(version);
String sign = DigestUtils.md5Hex(str.toString().getBytes(Charset.forName("UTF-8"))).toUpperCase();
Map<String, String> map = new HashMap<>();
map.put("appid", appID);
map.put("data", data);
map.put("noise", noise);
map.put("sign", sign);
map.put("version", version);
try {
HttpPost httpPost = new HttpPost(url);
CloseableHttpClient client = HttpClients.createDefault();
String respContent = null;
// 请求参数转JOSN字符串
StringEntity entity = new StringEntity(new ObjectMapper().writeValueAsString(map), "utf-8");
entity.setContentEncoding("UTF-8");
entity.setContentType("application/json");
httpPost.setEntity(entity);
HttpResponse resp = client.execute(httpPost);
if (resp.getStatusLine().getStatusCode() == 200) {
String rev = EntityUtils.toString(resp.getEntity());
// System.out.println("返回串--》"+rev);
Map resultData = new ObjectMapper().readValue(rev, Map.class);
String rdata = resultData.get("data").toString();
String rnoise = resultData.get("noise").toString();
// 1、拼接返回验签参数
StringBuilder str1 = new StringBuilder();
str1.append("appid=").append(appID);
str1.append("&data=").append(rdata);
str1.append("&noise=").append(rnoise);
str1.append("&key=").append(appKey);
str1.append("&version=").append(version);
// 3.MD5加密 生成sign
String rmd5 = DigestUtils.md5Hex(str1.toString().getBytes(Charset.forName("UTF-8"))).toUpperCase();
String rsign = resultData.get("sign").toString();
System.out.println("验签-》" + (StringUtils.equals(rsign, rmd5)));
String busData
= new String(Base64.getDecoder().decode(resultData.get("data").toString()), StandardCharsets.UTF_8);
System.out.println("返回业务数据--》" + busData);
Map busDataMap = new ObjectMapper().readValue(busData, Map.class);
System.out
.println("业务信息解密--》" + new String(Base64.getDecoder().decode(busDataMap.get("message").toString()),
StandardCharsets.UTF_8));
JSONObject resobj = JSONObject.parseObject(busData);
result.put("success", true);
result.put("result", resobj);
} else {
result.put("msg", "web响应失败!");
result.put("success", false);
}
} catch (Exception e) {
result.put("msg", e.getMessage());
result.put("success", false);
}
return result;
public JSONObject PreInvoicePost(JSONObject bill, String endpoint) {
return PreInvoicePostForward(bill, endpoint);
}
/**
@@ -339,6 +374,7 @@ public class EleInvoiceServiceImpl implements IEleInvoiceService {
// --------------------请求业务参数 data--------------------START
JSONObject bill = commomSet(patientInfo, paymentInfo, clinicSettle);
bill.put("paymentId", paymentId);
// ------票据信息------
// busType 业务标识 String 20 是 06标识挂号
@@ -580,6 +616,7 @@ public class EleInvoiceServiceImpl implements IEleInvoiceService {
// --------------------请求业务参数 data--------------------START
JSONObject bill = commomSet(patientInfo, paymentInfo, clinicSettle);
bill.put("paymentId", paymentId);
// ------票据信息------
// busType 业务标识 String 20 是 直接填写业务系统内部编码值由医疗平台配置对照例如附录5 业务标识列表
@@ -890,6 +927,7 @@ public class EleInvoiceServiceImpl implements IEleInvoiceService {
// --------------------请求业务参数 data--------------------START
JSONObject bill = commomSet(patientInfo, paymentInfo, clinicSettle);
bill.put("paymentId", paymentId);
// ------票据信息------
// busType 业务标识 String 20 是 直接填写业务系统内部编码值由医疗平台配置对照例如附录5 业务标识列表

View File

@@ -1818,6 +1818,10 @@ public class PaymentRecServiceImpl implements IPaymentRecService {
// 保存就诊信息
Encounter encounter = new Encounter();
BeanUtils.copyProperties(encounterFormData, encounter);
// 将挂号医生ID提前塞入 encounter 的 registrarId便于生成“科室+医生+当日”序号
if (encounterParticipantFormData.getPractitionerId() != null) {
encounter.setRegistrarId(encounterParticipantFormData.getPractitionerId());
}
encounter.setBusNo(outpatientRegistrationSettleParam.getBusNo());
// 就诊ID
Long encounterId = iEncounterService.saveEncounterByRegister(encounter);

View File

@@ -41,22 +41,23 @@ public class EleInvoiceController {
public R<?> invoiceReissue(@RequestBody MakeInvoiceDto makeInvoiceDto) {
// 付款成功后,开具发票
R<?> result = eleInvoiceService.invoiceReissue(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
R<?> eleResult = null;
if (result.getCode() == 200) {
if (result.getData() == YbEncounterClass.REG.getValue()) {
// 付款成功后,开具发票
R<?> eleResult = eleInvoiceService.invoiceRegMake(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
eleResult = eleInvoiceService.invoiceRegMake(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
if (eleResult.getCode() != 200) {
return R.ok(" 挂号电子发票开具失败 :" + eleResult.getMsg());
}
} else if (result.getData() == YbEncounterClass.AMB.getValue()) {
// 付款成功后,开具发票
R<?> eleResult = eleInvoiceService.invoiceMZMake(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
eleResult = eleInvoiceService.invoiceMZMake(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
if (eleResult.getCode() != 200) {
return R.ok(" 门诊电子发票开具失败 :" + eleResult.getMsg());
}
} else if (result.getData() == YbEncounterClass.IMP.getValue()) {
// 付款成功后,开具发票
R<?> eleResult = eleInvoiceService.invoiceZYMake(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
eleResult = eleInvoiceService.invoiceZYMake(makeInvoiceDto.getPaymentId(), makeInvoiceDto.getEncounterId());
if (eleResult.getCode() != 200) {
return R.ok(" 住院电子发票开具失败 :" + eleResult.getMsg());
}
@@ -64,7 +65,11 @@ public class EleInvoiceController {
return R.ok("电子发票类型不明确!");
}
}
Map detail = iChargeBillService.getDetail(makeInvoiceDto.getPaymentId());
Map<String, Object> detail = iChargeBillService.getDetail(makeInvoiceDto.getPaymentId());
if (eleResult != null && eleResult.getCode() == 200 && eleResult.getData() instanceof Invoice) {
Invoice invoice = (Invoice) eleResult.getData();
detail.put("pictureUrl", invoice.getPictureUrl());
}
return R.ok(detail);
}
@@ -95,10 +100,18 @@ public class EleInvoiceController {
public R<?> invoiceOpen(@RequestParam("invoiceId") String invoiceId) {
// 退款成功后,开具发票
Invoice invoice = eleInvoiceService.getInvoiceById(Long.parseLong(invoiceId));
if(invoice ==null){
if (invoice == null) {
throw new ServiceException("未查询到发票信息");
}
return R.ok(invoice.getPictureUrl());
}
/**
* 获取发票HTML凭条预览
*/
@GetMapping(value = "/view", produces = "text/html;charset=UTF-8")
@ResponseBody
public String viewInvoice(@RequestParam("busNo") String busNo) {
return eleInvoiceService.getInvoiceHtml(busNo);
}
}

View File

@@ -6,6 +6,7 @@ package com.openhis.web.paymentmanage.controller;
import com.core.common.core.domain.R;
import com.core.common.enums.TenantOptionDict;
import com.core.web.util.TenantOptionUtil;
import com.openhis.administration.domain.Invoice;
import com.openhis.financial.domain.PaymentReconciliation;
import com.openhis.web.chargemanage.dto.OutpatientRegistrationAddParam;
import com.openhis.web.chargemanage.dto.OutpatientRegistrationSettleParam;
@@ -92,10 +93,12 @@ public class PaymentReconciliationController {
if (eleResult.getCode() != 200) {
// 因收费成功前端需要关闭弹窗此处信息仅用于提示所以返回ok
return R.ok(detail, " 收费成功,电子发票开具失败 :" + eleResult.getMsg());
} else if (eleResult.getData() instanceof Invoice) {
Invoice invoice = (Invoice) eleResult.getData();
detail.put("pictureUrl", invoice.getPictureUrl());
}
return R.ok(detail);
}
// Map detail = iChargeBillService.getDetail(paymentRecon.getId());
}
return result;
}
@@ -194,7 +197,11 @@ public class PaymentReconciliationController {
if (eleResult.getCode() != 200) {
// 因收费成功前端需要关闭弹窗此处信息仅用于提示所以返回ok
return R.ok(detail, " 收费成功,电子发票开具失败 :" + eleResult.getMsg());
} else if (eleResult.getData() instanceof Invoice) {
Invoice invoice = (Invoice) eleResult.getData();
detail.put("pictureUrl", invoice.getPictureUrl());
}
return R.ok(detail);
}
}
return result;
@@ -233,6 +240,9 @@ public class PaymentReconciliationController {
if (eleResult.getCode() != 200) {
// 因收费成功前端需要关闭弹窗此处信息仅用于提示所以返回ok
return R.ok(detail, " 收费成功,电子发票开具失败 :" + eleResult.getMsg());
} else if (eleResult.getData() instanceof Invoice) {
Invoice invoice = (Invoice) eleResult.getData();
detail.put("pictureUrl", invoice.getPictureUrl());
}
return R.ok(detail);
}
@@ -260,8 +270,9 @@ public class PaymentReconciliationController {
// 因取消付款成功前端需要关闭弹窗此处信息仅用于提示所以返回ok
return R.ok(null, " 取消付款成功,电子发票开具失败 :" + eleResult.getMsg());
}
return R.ok("取消结算成功");
}
return R.ok("取消结算失败,请确认");
return R.fail("取消结算失败,请确认");
}
/**

View File

@@ -57,15 +57,15 @@ public class PharmacyWarehouseProfitLossOrderServiceImpl implements IPharmacyWar
// 单据分类
List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
// supplyCategoryOption.add(new
// PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.GENERAL_PROFIT_AND_LOSS.getValue(),
// SupplyCategory.GENERAL_PROFIT_AND_LOSS.getInfo()));
// supplyCategoryOption.add(new
// PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getValue(),
// SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getInfo()));
// supplyCategoryOption.add(new
// PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PREPARATION_CONSUMPTION.getValue(),
// SupplyCategory.PREPARATION_CONSUMPTION.getInfo()));
supplyCategoryOption.add(new
PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.GENERAL_PROFIT_AND_LOSS.getValue(),
SupplyCategory.GENERAL_PROFIT_AND_LOSS.getInfo()));
supplyCategoryOption.add(new
PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getValue(),
SupplyCategory.STOCKTAKING_PROFIT_AND_LOSS.getInfo()));
supplyCategoryOption.add(new
PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PREPARATION_CONSUMPTION.getValue(),
SupplyCategory.PREPARATION_CONSUMPTION.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -56,11 +56,11 @@ public class PharmacyWarehousePurchaseOrderServiceImpl implements IPharmacyWareh
// 单据分类
List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
// SupplyCategory.NORMAL.getInfo()));
// supplyCategoryOption.add(new
// PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PURCHASE_PLAN_GENERATION.getValue(),
// SupplyCategory.PURCHASE_PLAN_GENERATION.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.STOCK_SUPPLY.getValue(),
SupplyCategory.STOCK_SUPPLY.getInfo()));
supplyCategoryOption.add(new
PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NON_STOCK.getValue(),
SupplyCategory.NON_STOCK.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -56,8 +56,8 @@ public class PharmacyWarehouseReturnOrderServiceImpl implements IPharmacyWarehou
// 单据分类
List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
// SupplyCategory.NORMAL.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
SupplyCategory.NORMAL.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -56,8 +56,8 @@ public class PharmacyWarehouseReturnToWarehouseOrderServiceImpl implements IPhar
// 单据分类
List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
// SupplyCategory.NORMAL.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.NORMAL.getValue(),
SupplyCategory.NORMAL.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -57,18 +57,16 @@ public class PharmacyWarehouseStockInOrderServiceImpl implements IPharmacyWareho
// 单据分类
List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
// supplyCategoryOption
// .add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getValue(),
// SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getInfo()));
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
// SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getValue(), SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getInfo()));
// supplyCategoryOption
// .add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getValue(),
// SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getInfo()));
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
// SupplyCategory.OTHER_DRUGS_WAREHOUSING.getValue(), SupplyCategory.OTHER_DRUGS_WAREHOUSING.getInfo()));
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
// SupplyCategory.DONATED_DRUGS_WAREHOUSING.getValue(), SupplyCategory.DONATED_DRUGS_WAREHOUSING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getValue(),
SupplyCategory.PURCHASED_DRUGS_WAREHOUSING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getValue(), SupplyCategory.HOMEMADE_DRUGS_WAREHOUSING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getValue(),
SupplyCategory.CONSIGNMENT_DRUGS_WAREHOUSING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
SupplyCategory.OTHER_DRUGS_WAREHOUSING.getValue(), SupplyCategory.OTHER_DRUGS_WAREHOUSING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
SupplyCategory.DONATED_DRUGS_WAREHOUSING.getValue(), SupplyCategory.DONATED_DRUGS_WAREHOUSING.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -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(),
// SupplyCategory.IN_HOSPITAL_OUTBOUND.getInfo()));
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getValue(),
// SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getInfo()));
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OTHER_OUTBOUND.getValue(),
// SupplyCategory.OTHER_OUTBOUND.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.IN_HOSPITAL_OUTBOUND.getValue(),
SupplyCategory.IN_HOSPITAL_OUTBOUND.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getValue(),
SupplyCategory.OUT_OF_HOSPITAL_OUTBOUND.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(SupplyCategory.OTHER_OUTBOUND.getValue(),
SupplyCategory.OTHER_OUTBOUND.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -57,10 +57,10 @@ public class PharmacyWarehouseStocktakingOrderServiceImpl implements IPharmacyWa
// 单据分类
List<PharmacyWarehouseInitDto.IntegerOption> supplyCategoryOption = new ArrayList<>();
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
// SupplyCategory.GENERAL_STOCKTAKING.getValue(), SupplyCategory.GENERAL_STOCKTAKING.getInfo()));
// supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
// SupplyCategory.MONTHLY_STOCKTAKING.getValue(), SupplyCategory.MONTHLY_STOCKTAKING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
SupplyCategory.GENERAL_STOCKTAKING.getValue(), SupplyCategory.GENERAL_STOCKTAKING.getInfo()));
supplyCategoryOption.add(new PharmacyWarehouseInitDto.IntegerOption(
SupplyCategory.MONTHLY_STOCKTAKING.getValue(), SupplyCategory.MONTHLY_STOCKTAKING.getInfo()));
purchaseOrderInitDto.setSupplyCategoryOptions(supplyCategoryOption);

View File

@@ -94,7 +94,7 @@ public class MedicalDeviceDispenseAppServiceImpl implements IMedicalDeviceDispen
// 获取科室下拉选列表
List<Organization> organizationList
= organizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
= organizationService.getList(OrganizationType.DEPARTMENT.getValue(), String.valueOf(OrganizationClass.CLINIC.getValue()));
List<DispenseInitDto.DepartmentOption> organizationOptions = organizationList.stream()
.map(organization -> new DispenseInitDto.DepartmentOption(organization.getId(), organization.getName()))
.collect(Collectors.toList());

View File

@@ -130,7 +130,7 @@ public class ReturnMedicineAppServiceImpl implements IReturnMedicineAppService {
// 获取科室下拉选列表
List<Organization> organizationList
= iOrganizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
= iOrganizationService.getList(OrganizationType.DEPARTMENT.getValue(), String.valueOf(OrganizationClass.CLINIC.getValue()));
List<ReturnMedicineInitDto.DepartmentOption> organizationOptions = organizationList.stream().map(
organization -> new ReturnMedicineInitDto.DepartmentOption(organization.getId(), organization.getName()))
.collect(Collectors.toList());

View File

@@ -127,7 +127,7 @@ public class WesternMedicineDispenseAppServiceImpl implements IWesternMedicineDi
// 获取科室下拉选列表
List<Organization> organizationList
= organizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
= organizationService.getList(OrganizationType.DEPARTMENT.getValue(), String.valueOf(OrganizationClass.CLINIC.getValue()));
List<DispenseInitDto.DepartmentOption> organizationOptions = organizationList.stream()
.map(organization -> new DispenseInitDto.DepartmentOption(organization.getId(), organization.getName()))
.collect(Collectors.toList());

View File

@@ -221,6 +221,11 @@ public class RequestFormManageAppServiceImpl implements IRequestFormManageAppSer
*/
@Override
public List<RequestFormQueryDto> getRequestForm(Long encounterId, String typeCode) {
// 检查参数
if (encounterId == null) {
return new java.util.ArrayList<>(); // 返回空列表而不是查询数据库
}
List<RequestFormQueryDto> requestFormList = requestFormManageAppMapper.getRequestForm(encounterId, typeCode);
for (RequestFormQueryDto requestFormQueryDto : requestFormList) {
// 查询处方详情

View File

@@ -70,12 +70,15 @@ public class RequestFormManageController {
/**
* 查询检查申请单
*
*
* @param encounterId 就诊id
* @return 检查申请单
*/
@GetMapping(value = "/get-check")
public R<?> getCheckRequestForm(@RequestParam Long encounterId) {
public R<?> getCheckRequestForm(@RequestParam(required = false) Long encounterId) {
if (encounterId == null) {
return R.fail("就诊ID不能为空");
}
return R.ok(iRequestFormManageAppService.getRequestForm(encounterId, ActivityDefCategory.TEST.getCode()));
}
@@ -86,7 +89,10 @@ public class RequestFormManageController {
* @return 检验申请单
*/
@GetMapping(value = "/get-inspection")
public R<?> getInspectionRequestForm(@RequestParam Long encounterId) {
public R<?> getInspectionRequestForm(@RequestParam(required = false) Long encounterId) {
if (encounterId == null) {
return R.fail("就诊ID不能为空");
}
return R.ok(iRequestFormManageAppService.getRequestForm(encounterId, ActivityDefCategory.PROOF.getCode()));
}
@@ -97,7 +103,10 @@ public class RequestFormManageController {
* @return 输血申请单
*/
@GetMapping(value = "/get-blood-transfusion")
public R<?> getBloodTransfusionRequestForm(@RequestParam Long encounterId) {
public R<?> getBloodTransfusionRequestForm(@RequestParam(required = false) Long encounterId) {
if (encounterId == null) {
return R.fail("就诊ID不能为空");
}
return R.ok(iRequestFormManageAppService.getRequestForm(encounterId, ActivityDefCategory.METACHYSIS.getCode()));
}
@@ -108,7 +117,10 @@ public class RequestFormManageController {
* @return 手术申请单
*/
@GetMapping(value = "/get-surgery")
public R<?> getSurgeryRequestForm(@RequestParam Long encounterId) {
public R<?> getSurgeryRequestForm(@RequestParam(required = false) Long encounterId) {
if (encounterId == null) {
return R.fail("就诊ID不能为空");
}
return R.ok(iRequestFormManageAppService.getRequestForm(encounterId, ActivityDefCategory.PROCEDURE.getCode()));
}

View File

@@ -45,6 +45,10 @@ public class IPrintReportAppServiceImpl implements IPrintReportAppService {
*/
@Override
public R<?> disposalPrint(Long encounterId) {
// 检查参数
if (encounterId == null) {
return R.ok(new java.util.ArrayList<>()); // 返回空列表而不是错误
}
List<DisposalDto> disposalList = printReportMapper.getDisposalList(encounterId);
@@ -71,6 +75,10 @@ public class IPrintReportAppServiceImpl implements IPrintReportAppService {
*/
@Override
public R<?> checkApplicationPrint(Long encounterId) {
// 检查参数
if (encounterId == null) {
return R.ok(new java.util.ArrayList<>()); // 返回空列表而不是错误
}
List<CkInspAppDto> checkList =
printReportMapper.getCheckInspectionList(encounterId, YbRxItemTypeCode.MEDICAL_IMAGING.getValue());
@@ -98,6 +106,11 @@ public class IPrintReportAppServiceImpl implements IPrintReportAppService {
*/
@Override
public R<?> inspectionApplicationPrint(Long encounterId) {
// 检查参数
if (encounterId == null) {
return R.ok(new java.util.ArrayList<>()); // 返回空列表而不是错误
}
List<CkInspAppDto> inspectionList =
printReportMapper.getCheckInspectionList(encounterId, YbRxItemTypeCode.LAB_TEST.getValue());
@@ -125,6 +138,10 @@ public class IPrintReportAppServiceImpl implements IPrintReportAppService {
*/
@Override
public R<?> prescriptionPrint(String prescriptionNo, Long encounterId) {
// 检查参数
if (encounterId == null) {
return R.ok(new java.util.ArrayList<>()); // 返回空列表而不是错误
}
List<PrescriptionPrintDto> list = printReportMapper.getPrescriptionList(prescriptionNo, encounterId);
// 获取所属医院id

View File

@@ -52,7 +52,7 @@ public class RegisterReportAppServiceImpl implements IRegisterReportAppService {
RegisterReportInitDto initDto = new RegisterReportInitDto();
// 查询科室列表
List<Organization> organizationList =
organizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
organizationService.getList(OrganizationType.DEPARTMENT.getValue(), String.valueOf(OrganizationClass.CLINIC.getValue()));
// 科室
List<RegisterReportInitDto.longCommonStatusOption> departmentOptions = organizationList.stream()
.map(organization -> new RegisterReportInitDto.longCommonStatusOption(organization.getId(),

View File

@@ -34,7 +34,7 @@ public class PrintReportController {
* @return 处置单信息
*/
@GetMapping(value = "/disposal-print")
public R<?> disposalPrint(@RequestParam Long encounterId) {
public R<?> disposalPrint(@RequestParam(required = false) Long encounterId) {
return printReportService.disposalPrint(encounterId);
}
@@ -46,7 +46,7 @@ public class PrintReportController {
* @return 检验申请单信息
*/
@GetMapping(value = "/check-print")
public R<?> checkApplicationPrint(@RequestParam Long encounterId) {
public R<?> checkApplicationPrint(@RequestParam(required = false) Long encounterId) {
return printReportService.checkApplicationPrint(encounterId);
}
@@ -57,7 +57,7 @@ public class PrintReportController {
* @return 检验申请单信息
*/
@GetMapping(value = "/inspection-print")
public R<?> inspectionApplicationPrint(@RequestParam Long encounterId) {
public R<?> inspectionApplicationPrint(@RequestParam(required = false) Long encounterId) {
return printReportService.inspectionApplicationPrint(encounterId);
}
@@ -69,7 +69,7 @@ public class PrintReportController {
* @return 处方单信息
*/
@GetMapping(value = "/prescription-print")
public R<?> prescriptionPrint(@RequestParam String prescriptionNo, @RequestParam Long encounterId) {
public R<?> prescriptionPrint(@RequestParam String prescriptionNo, @RequestParam(required = false) Long encounterId) {
return printReportService.prescriptionPrint(prescriptionNo, encounterId);
}

View File

@@ -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);
}

View File

@@ -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++;
}
}
}

View File

@@ -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);
}
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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>

View File

@@ -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>

View File

@@ -112,6 +112,7 @@
ON T1.context_enum = #{activity}
AND T1.product_id = T2.id
AND T2.delete_flag = '0'
AND T2.status_enum = 1
LEFT JOIN med_medication_definition AS T3
ON T1.context_enum = #{medication}
AND T1.product_id = T3.id
@@ -205,6 +206,7 @@
ON T1.context_enum = #{activity}
AND T1.product_id = T2.id
AND T2.delete_flag = '0'
AND T2.status_enum = 1
LEFT JOIN med_medication_definition AS T3
ON T1.context_enum = #{medication}
AND T1.product_id = T3.id

View File

@@ -46,6 +46,7 @@
<select id="getCurrentDayEncounter" resultType="com.openhis.web.chargemanage.dto.CurrentDayEncounterDto">
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,
@@ -66,10 +67,11 @@
T9.payment_id AS paymentId,
T9.picture_url AS pictureUrl,
T9.birth_date AS birthDate,
T9.identifier_no AS identifierNo
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,
@@ -90,6 +92,7 @@
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'
@@ -129,6 +132,8 @@
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

View File

@@ -31,7 +31,9 @@
T3.maximum_retail_price,
T3.chrgitm_lv,
T3.children_json,
T3.pricing_flag
T3.pricing_flag,
T3.sort_order,
T3.service_range
FROM
(
SELECT
@@ -61,7 +63,9 @@
T2.price as retail_price,
T4.amount as maximum_retail_price,
T1.children_json,
T1.pricing_flag
T1.pricing_flag,
T1.sort_order,
T1.service_range
FROM wor_activity_definition T1
LEFT JOIN adm_charge_item_definition T2 ON T1.id = T2.instance_id
LEFT JOIN adm_charge_item_definition T5 ON T5.instance_id = T1.id AND T5.instance_table = 'wor_activity_definition'
@@ -120,7 +124,9 @@
) as maximum_retail_price,
T1.chrgitm_lv,
T1.children_json,
T1.pricing_flag
T1.pricing_flag,
T1.sort_order,
T1.service_range
FROM wor_activity_definition T1
LEFT JOIN adm_charge_item_definition T2 ON T1.id = T2.instance_id
<where>

View File

@@ -43,207 +43,250 @@
abi.restricted_scope,
abi.dosage_instruction,
abi.chrgitm_lv
from (
<if test="adviceTypes == null or adviceTypes.contains(1)">
(SELECT
DISTINCT ON (T1.ID)
T1.tenant_id,
1 AS advice_type,
T1.bus_no AS bus_no,
T1.category_code AS category_code,
T1.pharmacology_category_code AS pharmacology_category_code,
T1.part_percent AS part_percent,
T1.unit_conversion_ratio AS unit_conversion_ratio,
T1.part_attribute_enum AS part_attribute_enum,
T1.tho_part_attribute_enum AS tho_part_attribute_enum,
T1.skin_test_flag AS skin_test_flag,
T1.inject_flag AS inject_flag,
T1.ID AS advice_definition_id,
T1.NAME AS advice_name,
T1.bus_no AS advice_bus_no,
T1.py_str AS py_str,
T1.wb_str AS wb_str,
T1.yb_no AS yb_no,
T1.merchandise_name AS product_name,
0 AS activity_type,
T1.unit_code AS unit_code,
T1.min_unit_code AS min_unit_code,
T2.total_volume AS volume,
T2.method_code AS method_code,
T2.rate_code AS rate_code,
T2.org_id AS org_id,
T2.location_id AS location_id,
CAST(T2.dose AS TEXT) AS dose,
T2.dose_unit_code AS dose_unit_code,
T3.NAME AS supplier,
T3.id AS supplier_id,
T1.manufacturer_text AS manufacturer,
T5.id AS charge_item_definition_id,
T5.instance_table AS advice_table_name,
T6.def_location_id AS position_id,
t1.restricted_flag AS restricted_flag,
t1.restricted_scope AS restricted_scope,
T1.dosage_instruction AS dosage_instruction,
T1.chrgitm_lv as chrgitm_lv
FROM med_medication_definition AS t1
INNER JOIN med_medication AS T2 ON T2.medication_def_id = T1.ID
AND T2.delete_flag = '0' AND T2.status_enum = #{statusEnum}
LEFT JOIN adm_supplier AS T3
ON T3.ID = T1.supply_id
AND T3.delete_flag = '0'
LEFT JOIN adm_charge_item_definition AS T5 ON T5.instance_id = T1.ID
AND T5.delete_flag = '0' AND T5.status_enum = #{statusEnum}
LEFT JOIN adm_organization_location AS T6
ON T6.distribution_category_code = T1.category_code
AND T6.delete_flag = '0' AND T6.item_code = '1' AND T6.organization_id = #{organizationId} AND
(CURRENT_TIME :: time (6) BETWEEN T6.start_time AND T6.end_time)
WHERE T1.delete_flag = '0'
AND T2.status_enum = #{statusEnum}
<if test="pricingFlag ==1">
AND 1 = 2
FROM (
<!-- 确保至少有一个查询被执行以避免语法错误 -->
<if test="adviceTypes != null and !adviceTypes.isEmpty() and (adviceTypes.contains(1) or adviceTypes.contains(2) or adviceTypes.contains(3))">
<!-- 如果有有效的adviceTypes则执行对应的查询 -->
<if test="adviceTypes.contains(1)">
(SELECT
DISTINCT ON (T1.ID)
T1.tenant_id,
1 AS advice_type,
T1.bus_no AS bus_no,
T1.category_code AS category_code,
T1.pharmacology_category_code AS pharmacology_category_code,
T1.part_percent AS part_percent,
T1.unit_conversion_ratio AS unit_conversion_ratio,
T1.part_attribute_enum AS part_attribute_enum,
T1.tho_part_attribute_enum AS tho_part_attribute_enum,
T1.skin_test_flag AS skin_test_flag,
T1.inject_flag AS inject_flag,
T1.ID AS advice_definition_id,
T1.NAME AS advice_name,
T1.bus_no AS advice_bus_no,
T1.py_str AS py_str,
T1.wb_str AS wb_str,
T1.yb_no AS yb_no,
T1.merchandise_name AS product_name,
0 AS activity_type,
T1.unit_code AS unit_code,
T1.min_unit_code AS min_unit_code,
T2.total_volume AS volume,
T2.method_code AS method_code,
T2.rate_code AS rate_code,
T2.org_id AS org_id,
T2.location_id AS location_id,
CAST(T2.dose AS TEXT) AS dose,
T2.dose_unit_code AS dose_unit_code,
T3.NAME AS supplier,
T3.id AS supplier_id,
T1.manufacturer_text AS manufacturer,
T5.id AS charge_item_definition_id,
T5.instance_table AS advice_table_name,
T6.def_location_id AS position_id,
t1.restricted_flag AS restricted_flag,
t1.restricted_scope AS restricted_scope,
T1.dosage_instruction AS dosage_instruction,
T1.chrgitm_lv as chrgitm_lv
FROM med_medication_definition AS t1
INNER JOIN med_medication AS T2 ON T2.medication_def_id = T1.ID
AND T2.delete_flag = '0' AND T2.status_enum = #{statusEnum}
LEFT JOIN adm_supplier AS T3
ON T3.ID = T1.supply_id
AND T3.delete_flag = '0'
LEFT JOIN adm_charge_item_definition AS T5 ON T5.instance_id = T1.ID
AND T5.delete_flag = '0' AND T5.status_enum = #{statusEnum}
LEFT JOIN adm_organization_location AS T6
ON T6.distribution_category_code = T1.category_code
AND T6.delete_flag = '0' AND T6.item_code = '1' AND T6.organization_id = #{organizationId} AND
(CURRENT_TIME :: time (6) BETWEEN T6.start_time AND T6.end_time)
WHERE T1.delete_flag = '0'
AND T2.status_enum = #{statusEnum}
<if test="pricingFlag ==1">
AND 1 = 2
</if>
<if test="adviceDefinitionIdParamList != null and !adviceDefinitionIdParamList.isEmpty()">
AND T1.id IN
<foreach collection="adviceDefinitionIdParamList" item="itemId" open="(" separator="," close=")">
#{itemId}
</foreach>
</if>
AND T5.instance_table = #{medicationTableName}
)
<if test="adviceTypes.contains(2) or adviceTypes.contains(3)">UNION ALL</if>
</if>
<if test="adviceDefinitionIdParamList != null and !adviceDefinitionIdParamList.isEmpty()">
AND T1.id IN
<foreach collection="adviceDefinitionIdParamList" item="itemId" open="(" separator="," close=")">
#{itemId}
</foreach>
<if test="adviceTypes.contains(2)">
(SELECT
DISTINCT ON (T1.ID)
T1.tenant_id,
2 AS advice_type,
T1.bus_no AS bus_no,
T1.category_code AS category_code,
'' AS pharmacology_category_code,
T1.part_percent AS part_percent,
0 AS unit_conversion_ratio,
null AS part_attribute_enum,
null AS tho_part_attribute_enum,
null AS skin_test_flag,
null AS inject_flag,
T1.ID AS advice_definition_id,
T1.NAME AS advice_name,
T1.bus_no AS advice_bus_no,
T1.py_str AS py_str,
T1.wb_str AS wb_str,
T1.yb_no AS yb_no,
'' AS product_name,
0 AS activity_type,
T1.unit_code AS unit_code,
T1.min_unit_code AS min_unit_code,
T1.SIZE AS volume,
'' AS method_code,
'' AS rate_code,
T1.org_id AS org_id,
T1.location_id AS location_id,
'' AS dose,
'' AS dose_unit_code,
T2.NAME AS supplier,
T2.id AS supplier_id,
T1.manufacturer_text AS manufacturer,
T4.id AS charge_item_definition_id,
T4.instance_table AS advice_table_name,
T5.def_location_id AS position_id,
0 AS restricted_flag,
'' AS restricted_scope,
'' AS dosage_instruction,
T1.chrgitm_lv as chrgitm_lv
FROM adm_device_definition AS T1
LEFT JOIN adm_supplier AS T2
ON T2.ID = T1.supply_id
AND T2.delete_flag = '0'
LEFT JOIN adm_charge_item_definition AS T4 ON T4.instance_id = T1.ID
AND T4.delete_flag = '0' AND T4.status_enum = #{statusEnum}
LEFT JOIN adm_organization_location AS T5 ON T5.distribution_category_code = T1.category_code
AND T5.delete_flag = '0' AND T5.item_code = '2' AND T5.organization_id = #{organizationId} AND
(CURRENT_TIME :: time (6) BETWEEN T5.start_time AND T5.end_time)
WHERE T1.delete_flag = '0'
<if test="adviceDefinitionIdParamList != null and !adviceDefinitionIdParamList.isEmpty()">
AND T1.id IN
<foreach collection="adviceDefinitionIdParamList" item="itemId" open="(" separator="," close=")">
#{itemId}
</foreach>
</if>
AND T4.instance_table = #{deviceTableName}
AND T1.status_enum = #{statusEnum}
)
<if test="adviceTypes.contains(3)">UNION ALL</if>
</if>
<if test="adviceTypes.contains(3)">
(SELECT
DISTINCT ON (T1.ID)
T1.tenant_id,
3 AS advice_type,
T1.bus_no AS bus_no,
T1.category_code AS category_code,
'' AS pharmacology_category_code,
1 AS part_percent,
0 AS unit_conversion_ratio,
null AS part_attribute_enum,
null AS tho_part_attribute_enum,
null AS skin_test_flag,
null AS inject_flag,
T1.ID AS advice_definition_id,
T1.NAME AS advice_name,
T1.bus_no AS advice_bus_no,
T1.py_str AS py_str,
T1.wb_str AS wb_str,
T1.yb_no AS yb_no,
'' AS product_name,
T1.type_enum AS activity_type,
'' AS unit_code,
'' AS min_unit_code,
'' AS volume,
'' AS method_code,
'' AS rate_code,
T1.org_id AS org_id,
T1.location_id AS location_id,
'' AS dose,
'' AS dose_unit_code,
'' AS supplier,
null AS supplier_id,
'' AS manufacturer,
T2.ID AS charge_item_definition_id,
T2.instance_table AS advice_table_name,
T3.organization_id AS position_id,
0 AS restricted_flag,
'' AS restricted_scope,
'' AS dosage_instruction,
T1.chrgitm_lv as chrgitm_lv
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 = #{statusEnum}
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)
<if test="organizationId != null">
AND T3.organization_id = #{organizationId}
</if>
WHERE T1.delete_flag = '0'
<if test="pricingFlag != null and pricingFlag == 1">
AND (T1.pricing_flag = #{pricingFlag} OR T1.pricing_flag IS NULL)
</if>
<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>
AND T5.instance_table = #{medicationTableName}
)
</if>
<if test="adviceTypes == null or adviceTypes.contains(1)">
<if test="adviceTypes == null or adviceTypes.contains(2) or adviceTypes.contains(3)">UNION ALL</if>
</if>
<if test="adviceTypes == null or adviceTypes.contains(2)">
(SELECT
DISTINCT ON (T1.ID)
T1.tenant_id,
2 AS advice_type,
T1.bus_no AS bus_no,
T1.category_code AS category_code,
'' AS pharmacology_category_code,
T1.part_percent AS part_percent,
0 AS unit_conversion_ratio,
null AS part_attribute_enum,
null AS tho_part_attribute_enum,
null AS skin_test_flag,
null AS inject_flag,
T1.ID AS advice_definition_id,
T1.NAME AS advice_name,
T1.bus_no AS advice_bus_no,
T1.py_str AS py_str,
T1.wb_str AS wb_str,
T1.yb_no AS yb_no,
'' AS product_name,
0 AS activity_type,
T1.unit_code AS unit_code,
T1.min_unit_code AS min_unit_code,
T1.SIZE AS volume,
'' AS method_code,
'' AS rate_code,
T1.org_id AS org_id,
T1.location_id AS location_id,
'' AS dose,
'' AS dose_unit_code,
T2.NAME AS supplier,
T2.id AS supplier_id,
T1.manufacturer_text AS manufacturer,
T4.id AS charge_item_definition_id,
T4.instance_table AS advice_table_name,
T5.def_location_id AS position_id,
0 AS restricted_flag,
'' AS restricted_scope,
'' AS dosage_instruction,
T1.chrgitm_lv as chrgitm_lv
FROM adm_device_definition AS T1
LEFT JOIN adm_supplier AS T2
ON T2.ID = T1.supply_id
AND T2.delete_flag = '0'
LEFT JOIN adm_charge_item_definition AS T4 ON T4.instance_id = T1.ID
AND T4.delete_flag = '0' AND T4.status_enum = #{statusEnum}
LEFT JOIN adm_organization_location AS T5 ON T5.distribution_category_code = T1.category_code
AND T5.delete_flag = '0' AND T5.item_code = '2' AND T5.organization_id = #{organizationId} AND
(CURRENT_TIME :: time (6) BETWEEN T5.start_time AND T5.end_time)
WHERE T1.delete_flag = '0'
<if test="adviceDefinitionIdParamList != null and !adviceDefinitionIdParamList.isEmpty()">
AND T1.id IN
<foreach collection="adviceDefinitionIdParamList" item="itemId" open="(" separator="," close=")">
#{itemId}
</foreach>
</if>
AND T4.instance_table = #{deviceTableName}
AND T1.status_enum = #{statusEnum}
)
</if>
<if test="adviceTypes == null or adviceTypes.contains(2)">
<if test="adviceTypes == null or adviceTypes.contains(3)">UNION ALL</if>
</if>
<if test="adviceTypes == null or adviceTypes.contains(3)">
(SELECT
DISTINCT ON (T1.ID)
T1.tenant_id,
3 AS advice_type,
T1.bus_no AS bus_no,
T1.category_code AS category_code,
'' AS pharmacology_category_code,
1 AS part_percent,
0 AS unit_conversion_ratio,
null AS part_attribute_enum,
null AS tho_part_attribute_enum,
null AS skin_test_flag,
null AS inject_flag,
T1.ID AS advice_definition_id,
T1.NAME AS advice_name,
T1.bus_no AS advice_bus_no,
T1.py_str AS py_str,
T1.wb_str AS wb_str,
T1.yb_no AS yb_no,
'' AS product_name,
T1.type_enum AS activity_type,
'' AS unit_code,
'' AS min_unit_code,
'' AS volume,
'' AS method_code,
'' AS rate_code,
T1.org_id AS org_id,
T1.location_id AS location_id,
'' AS dose,
'' AS dose_unit_code,
'' AS supplier,
null AS supplier_id,
'' AS manufacturer,
T2.ID AS charge_item_definition_id,
T2.instance_table AS advice_table_name,
T3.organization_id AS position_id,
0 AS restricted_flag,
'' AS restricted_scope,
'' AS dosage_instruction,
T1.chrgitm_lv as chrgitm_lv
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 = #{statusEnum}
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="pricingFlag ==1">
AND (T1.pricing_flag = #{pricingFlag} OR T1.pricing_flag IS NULL)
</if>
<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}
)
<!-- 如果没有有效的adviceTypes提供一个空的默认查询以避免语法错误 -->
<if test="adviceTypes == null or adviceTypes.isEmpty() or (!adviceTypes.contains(1) and !adviceTypes.contains(2) and !adviceTypes.contains(3))">
SELECT
mmd.tenant_id,
CAST(0 AS INTEGER) AS advice_type,
CAST('' AS VARCHAR) AS bus_no,
CAST('' AS VARCHAR) AS category_code,
CAST('' AS VARCHAR) AS pharmacology_category_code,
CAST(0 AS NUMERIC) AS part_percent,
CAST(0 AS NUMERIC) AS unit_conversion_ratio,
CAST(0 AS INTEGER) AS part_attribute_enum,
CAST(0 AS INTEGER) AS tho_part_attribute_enum,
CAST(0 AS INTEGER) AS skin_test_flag,
CAST(0 AS INTEGER) AS inject_flag,
CAST(0 AS BIGINT) AS advice_definition_id,
CAST('' AS VARCHAR) AS advice_name,
CAST('' AS VARCHAR) AS advice_bus_no,
CAST('' AS VARCHAR) AS py_str,
CAST('' AS VARCHAR) AS wb_str,
CAST('' AS VARCHAR) AS yb_no,
CAST('' AS VARCHAR) AS product_name,
CAST(0 AS INTEGER) AS activity_type,
CAST('' AS VARCHAR) AS unit_code,
CAST('' AS VARCHAR) AS min_unit_code,
CAST(0 AS NUMERIC) AS volume,
CAST('' AS VARCHAR) AS method_code,
CAST('' AS VARCHAR) AS rate_code,
CAST(0 AS BIGINT) AS org_id,
CAST(0 AS BIGINT) AS location_id,
CAST('' AS VARCHAR) AS dose,
CAST('' AS VARCHAR) AS dose_unit_code,
CAST('' AS VARCHAR) AS supplier,
CAST(0 AS BIGINT) AS supplier_id,
CAST('' AS VARCHAR) AS manufacturer,
CAST(0 AS BIGINT) AS charge_item_definition_id,
CAST('' AS VARCHAR) AS advice_table_name,
CAST(0 AS BIGINT) AS position_id,
CAST(0 AS INTEGER) AS restricted_flag,
CAST('' AS VARCHAR) AS restricted_scope,
CAST('' AS VARCHAR) AS dosage_instruction,
CAST(0 AS INTEGER) AS chrgitm_lv
FROM med_medication_definition mmd
WHERE 1 = 0 -- 仍然确保不返回任何行,但使用真实表确保类型正确
</if>
) AS abi
${ew.customSqlSegment}
@@ -355,20 +398,18 @@
T1.condition_value,
T1.condition_code,
T1.amount AS price
FROM
adm_charge_item_def_detail AS T1
LEFT JOIN adm_charge_item_definition AS T2 ON T2.ID = T1.definition_id
AND T2.delete_flag = '0'
WHERE
T1.delete_flag = '0'
AND T1.condition_code = #{conditionCode}
FROM adm_charge_item_def_detail AS T1
INNER JOIN adm_charge_item_definition AS T2 ON T2.ID = T1.definition_id
WHERE T1.delete_flag = '0'
AND T2.delete_flag = '0'
AND T1.condition_code = #{conditionCode}
<if test="chargeItemDefinitionIdList != null and !chargeItemDefinitionIdList.isEmpty()">
AND T1.definition_id IN
<foreach collection="chargeItemDefinitionIdList" item="itemId" open="(" separator="," close=")">
#{itemId}
</foreach>
</if>
ORDER BY T1.priority DESC
ORDER BY T1.priority DESC, T1.definition_id
</select>
<select id="getMainCharge" resultType="com.openhis.web.doctorstation.dto.AdvicePriceDto">

View File

@@ -23,7 +23,9 @@
T10.reception_time,
T10.practitioner_user_id,
T10.jz_practitioner_user_id,
T10.bus_no
T10.bus_no,
T10.identifier_no,
T10.missed_time
from
(
SELECT T1.tenant_id AS tenant_id,
@@ -48,7 +50,9 @@
T1.create_time AS register_time,
T1.reception_time AS reception_time,
T1.organization_id AS org_id,
T8.bus_no AS bus_no
T8.bus_no AS bus_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'
@@ -67,6 +71,20 @@
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 T9 ON T8.id = T9.patient_id
WHERE
T1.delete_flag = '0'
<!-- 当前登录账号ID 和 当前登录账号所属的科室ID 用于控制数据权限 -->

View File

@@ -224,28 +224,7 @@
</select>
<select id="selectAdmissionPatientInfo"
resultType="com.openhis.web.inhospitalnursestation.dto.AdmissionPatientInfoDto">
WITH locations AS (SELECT ael.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,
SELECT DISTINCT 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
ON bed.encounter_id = ae.id
AND bed.form_enum = #{bed}
LEFT JOIN locations AS house
ON house.encounter_id = ae.id
AND house.form_enum = #{house}
LEFT JOIN locations AS ward
ON ward.encounter_id = ae.id
AND ward.form_enum = #{ward}
LEFT JOIN practitioners AS primaryNurse
ON primaryNurse.encounter_id = ae.id
AND primaryNurse.type_code = #{primaryNurse}
LEFT JOIN practitioners AS attendingDoctor
ON attendingDoctor.encounter_id = ae.id
AND attendingDoctor.type_code = #{attendingDoctor}
LEFT JOIN practitioners AS admittingDoctor
ON admittingDoctor.encounter_id = ae.id
AND admittingDoctor.type_code = #{admittingDoctor}
LEFT JOIN practitioners AS chiefDoctor
ON chiefDoctor.encounter_id = ae.id
AND chiefDoctor.type_code = #{chiefDoctor}
LEFT JOIN (
SELECT ael.encounter_id,
ael.start_time,
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 = #{bed}
LIMIT 1
) AS bed ON bed.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 = #{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,
STRING_AGG(ccd.name, ', ') AS condition_names
FROM adm_encounter_diagnosis aed
INNER JOIN cli_condition cc
ON cc.id = aed.condition_id
AND cc.delete_flag = '0'
INNER JOIN cli_condition_definition ccd
ON ccd.id = cc.definition_id
AND ccd.delete_flag = '0'
WHERE aed.delete_flag = '0'
GROUP BY aed.encounter_id) AS diagnosis
ON ae.id = diagnosis.encounter_id
LEFT JOIN (
SELECT aed.encounter_id,
STRING_AGG(ccd.name, ', ') AS condition_names
FROM adm_encounter_diagnosis aed
INNER JOIN cli_condition cc ON cc.id = aed.condition_id AND cc.delete_flag = '0'
INNER JOIN cli_condition_definition ccd ON ccd.id = cc.definition_id AND ccd.delete_flag = '0'
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,

View File

@@ -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,
T1.active_flag,
T1.temp_flag,
T1."name" AS patientName, -- 患者姓名
T1.name_json,
T1.bus_no AS patientNo, -- 病历号
T1.gender_enum, -- 患者性别
T1.birth_date,
T1.deceased_date,
T1.marital_status_enum,
T1.prfs_enum,
T1.phone, -- 患者手机号
COALESCE(NULLIF(T1.address, ''), '') AS address, -- 处理空地址
T1.address_province,
T1.address_city,
T1.address_district,
T1.address_street,
T1.address_json,
T1.nationality_code,
T1.id_card,
T1.py_str,
T1.wb_str,
T1.blood_abo,
T1.blood_rh,
T1.work_company,
T1.native_place,
T1.country_code,
T1.link_name,
T1.link_relation_code,
T1.link_telcom,
T1.link_jsons,
T1.tenant_id,
T2.bus_no AS hospitalNo, -- 住院号
T2.id AS encounterId, -- 就诊ID
T2.priority_enum, -- 护理级别
T2.status_enum, -- 患者状态
T2.organization_id,-- 入院科室
T2.start_time AS admissionDate, -- 入院日期
T2.end_time AS dischargeDate, -- 出院日期
T2.class_enum, -- 就诊类别
Doctor.name AS responsibleDoctor, -- 责任医生
Nurse.name AS responsibleNurse, -- 责任护士
T6.type_code, -- 费别
T7.status_enum AS surgeryStatusEnum, -- 手术状态
T8.start_time AS surgeryStartTime, -- 手术开始时间
T8.end_time AS surgeryEndTime, -- 手术结束时间
T9.id AS encounterLocationId, -- 就诊位置ID
T9.location_id, -- 床位号
T11."name" AS caty, -- 入院科室
T12."name" AS mainDiagnosis -- 主要诊断
FROM adm_patient AS T1
LEFT JOIN adm_encounter T2
ON T1.id = T2.patient_id -- 患者ID
AND T2.delete_flag = '0'
AND T2.class_enum = '1' -- 仅选择住院患者
-- 获取责任医生
LEFT JOIN (
SELECT
encounter_id,
practitioner_id,
"name",
ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY practitioner_id) as rn
FROM (
SELECT
T3.encounter_id,
T4."name",
T3.practitioner_id
FROM adm_encounter_participant T3
LEFT JOIN adm_practitioner T4
ON T3.practitioner_id = T4.id
AND T4.delete_flag = '0'
WHERE T3.type_code = '9' -- 责任医生类型
AND T3.delete_flag = '0'
) sub
) Doctor ON T2.id = Doctor.encounter_id AND Doctor.rn = 1
-- 获取责任护士
LEFT JOIN (
SELECT
encounter_id,
practitioner_id,
"name",
ROW_NUMBER() OVER (PARTITION BY encounter_id ORDER BY practitioner_id) as rn
FROM (
SELECT
T3.encounter_id,
T4."name",
T3.practitioner_id
FROM adm_encounter_participant T3
LEFT JOIN adm_practitioner T4
ON T3.practitioner_id = T4.id
AND T4.delete_flag = '0'
WHERE T3.type_code = '2' -- 责任护士类型
AND T3.delete_flag = '0'
) sub
) Nurse ON T2.id = Nurse.encounter_id AND Nurse.rn = 1
LEFT JOIN adm_encounter_diagnosis T5
ON T2.id = T5.encounter_id -- 就诊ID
AND T5.maindise_flag = 1
AND T5.delete_flag = '0'
LEFT JOIN adm_account T6
ON T2.id = T6.encounter_id -- 就诊ID
AND T6.delete_flag = '0'
LEFT JOIN cli_procedure T7
ON T1.id = T7.patient_id -- 患者ID
AND T7.delete_flag = '0'
LEFT JOIN cli_procedure_performer T8
ON T7.id = T8.procedure_id -- 手术ID
AND T8.delete_flag = '0'
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'
LEFT JOIN wor_service_request T13
ON T2.id = T13.encounter_id
AND T7.base_service_req_id = T13.id
AND T13.delete_flag = '0'
LEFT JOIN wor_service_request_detail T14
ON T13.id = T14.service_req_id
AND T14.type_code = '3'
AND T14.delete_flag = '0'
<where>
T1.delete_flag = '0'
-- 患者ID
<if test="patientId != null">
AND T1.id = #{patientId}
</if>
id,
active_flag,
temp_flag,
patientName,
name_json,
patientNo,
gender_enum,
birth_date,
deceased_date,
marital_status_enum,
prfs_enum,
phone,
address,
address_province,
address_city,
address_district,
address_street,
address_json,
nationality_code,
id_card,
py_str,
wb_str,
blood_abo,
blood_rh,
work_company,
native_place,
country_code,
link_name,
link_relation_code,
link_telcom,
link_jsons,
tenant_id,
hospitalNo,
encounterId,
priority_enum,
status_enum,
organization_id,
admissionDate,
dischargeDate,
class_enum,
responsibleDoctor,
responsibleNurse,
type_code,
surgeryStatusEnum,
surgeryStartTime,
surgeryEndTime,
encounterLocationId,
location_id,
caty,
mainDiagnosis
FROM (
SELECT
patient_base.*,
ROW_NUMBER() OVER (PARTITION BY patient_base.id ORDER BY patient_base.encounterId) as rn
FROM (
SELECT DISTINCT
T1.id,
T1.active_flag,
T1.temp_flag,
T1."name" AS patientName, -- 患者姓名
T1.name_json,
T1.bus_no AS patientNo, -- 病历号
T1.gender_enum, -- 患者性别
T1.birth_date,
T1.deceased_date,
T1.marital_status_enum,
T1.prfs_enum,
T1.phone, -- 患者手机号
COALESCE(NULLIF(T1.address, ''), '') AS address, -- 处理空地址
T1.address_province,
T1.address_city,
T1.address_district,
T1.address_street,
T1.address_json,
T1.nationality_code,
T1.id_card,
T1.py_str,
T1.wb_str,
T1.blood_abo,
T1.blood_rh,
T1.work_company,
T1.native_place,
T1.country_code,
T1.link_name,
T1.link_relation_code,
T1.link_telcom,
T1.link_jsons,
T1.tenant_id,
T2.bus_no AS hospitalNo, -- 住院号
T2.id AS encounterId, -- 就诊ID
T2.priority_enum, -- 护理级别
T2.status_enum, -- 患者状态
T2.organization_id,-- 入院科室
T2.start_time AS admissionDate, -- 入院日期
T2.end_time AS dischargeDate, -- 出院日期
T2.class_enum, -- 就诊类别
-- 获取责任医生(使用子查询确保只返回一个值)
(SELECT p."name"
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'
ORDER BY ep.practitioner_id
LIMIT 1) AS responsibleDoctor,
-- 获取责任护士(使用子查询确保只返回一个值)
(SELECT p."name"
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'
ORDER BY ep.practitioner_id
LIMIT 1) AS responsibleNurse,
T6.type_code, -- 费别
T7.status_enum AS surgeryStatusEnum, -- 手术状态
T8.start_time AS surgeryStartTime, -- 手术开始时间
T8.end_time AS surgeryEndTime, -- 手术结束时间
T9.id AS encounterLocationId, -- 就诊位置ID
T9.location_id, -- 床位号
T11."name" AS caty, -- 入院科室
T12."name" AS mainDiagnosis -- 主要诊断
FROM adm_patient AS T1
INNER JOIN adm_encounter T2 -- 改为INNER JOIN确保患者有就诊记录
ON T1.id = T2.patient_id -- 患者ID
AND T2.delete_flag = '0'
AND T2.class_enum = '1' -- 仅选择住院患者
LEFT JOIN adm_encounter_diagnosis T5
ON T2.id = T5.encounter_id -- 就诊ID
AND T5.maindise_flag = 1
AND T5.delete_flag = '0'
LEFT JOIN adm_account T6
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">
AND T9.status_enum = 2
</if>
-- 在科
<if test="statusEnum == 1">
AND T9.status_enum = 2
</if>
-- 待出院
<if test="statusEnum == 3">
AND T2.status_enum = 4
</if>
-- 待出院
<if test="statusEnum == 3">
AND T2.status_enum = 4
</if>
-- 危重
<if test="statusEnum == 4">
AND T2.priority_enum = 1
</if>
-- 危重
<if test="statusEnum == 4">
AND T2.priority_enum = 1
</if>
-- 手术
<if test="statusEnum == 5">
AND T14.type_code = '3'
</if>
-- 欠费
<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 Doctor.name like concat('%', #{searchKey}, '%')
-- 责任护士
OR Nurse.name like concat('%', #{searchKey}, '%')
-- 手术
<if test="statusEnum == 5">
AND EXISTS (
SELECT 1
FROM wor_service_request_detail wsrd
INNER JOIN wor_service_request wsr ON wsrd.service_req_id = wsr.id
WHERE wsr.encounter_id = T2.id
AND wsrd.type_code = '3'
AND wsr.delete_flag = '0'
AND wsrd.delete_flag = '0'
)
</if>
</where>
</if>
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>
<!-- 科室空床查询-->

View File

@@ -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

View File

@@ -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>

View File

@@ -0,0 +1,68 @@
<html>
<head>
<style>
body { font-family: 'Microsoft YaHei', sans-serif; width: 350px; margin: 0 auto; padding: 20px; border: 1px solid #ccc; background: #fff; }
.header { text-align: center; }
.hospital-name { font-size: 20px; font-weight: bold; margin-bottom: 5px; }
.title { font-size: 16px; margin-bottom: 10px; }
.time { font-size: 12px; color: #666; margin-bottom: 15px; }
.section { border-top: 1px solid #000; padding-top: 10px; margin-top: 10px; }
.section-title { font-weight: bold; text-decoration: underline; margin-bottom: 10px; font-size: 14px; }
.item { display: flex; font-size: 13px; margin-bottom: 5px; }
.label { width: 90px; color: #333; }
.value { flex: 1; font-weight: 500; }
table { width: 100%; border-collapse: collapse; margin-top: 10px; font-size: 13px; }
th { text-align: left; border-bottom: 1px dashed #ccc; padding-bottom: 5px; color: #666; }
td { padding: 5px 0; }
.total { text-align: right; font-weight: bold; border-top: 1px solid #000; padding-top: 10px; margin-top: 10px; font-size: 15px; }
.footer { margin-top: 20px; font-size: 11px; color: #666; line-height: 1.5; }
.qr-code { text-align: center; margin-top: 15px; }
.serial-no { text-align: left; margin-top: 10px; font-size: 12px; font-weight: bold; border-top: 1px dashed #ccc; padding-top: 10px; }
</style>
</head>
<body>
<div class='header'>
<div class='hospital-name'>$hospitalName</div>
<div class='title'>门诊预约挂号凭条</div>
<div class='time'>打印时间:$printTime</div>
</div>
<div class='section'>
<div class='section-title'>患者基本信息</div>
<div class='item'><div class='label'>患者姓名:</div><div class='value'>$patientName</div></div>
<div class='item'><div class='label'>门诊号:</div><div class='value'>$outpatientNo</div></div>
<div class='item'><div class='label'>身份证号:</div><div class='value'>#if($idCard)$idCard#else-#end</div></div>
<div class='item'><div class='label'>联系电话:</div><div class='value'>#if($tel)$tel#else-#end</div></div>
</div>
<div class='section'>
<div class='section-title'>预约详情</div>
<div class='item'><div class='label'>就诊科室:</div><div class='value'>#if($deptName)$deptName#else-#end</div></div>
<div class='item'><div class='label'>医生姓名:</div><div class='value'>$doctorName</div></div>
<div class='item'><div class='label'>预约时间:</div><div class='value'>#if($appointmentTime)$appointmentTime#else-#end</div></div>
<div class='item'><div class='label'>就诊地点:</div><div class='value'>门诊大楼内</div></div>
<div class='item'><div class='label'>预约状态:</div><div class='value'><span style='color:green;'>☑ 已 预</span></div></div>
</div>
<div class='section'>
<div class='section-title'>费用信息</div>
<table>
<tr><th>项目</th><th>数量</th><th>单价</th><th>金额</th></tr>
#foreach($item in $items)
<tr>
<td>$item.chargeItemName</td>
<td>$item.quantityValue</td>
<td>¥$item.totalPrice</td>
<td>¥$item.totalPrice</td>
</tr>
#end
</table>
<div class='total'>合计:¥$totalAmt</div>
<div class='item' style='margin-top:10px;'><div class='label'>支付方式:</div><div class='value'>线上支付 (已支付)</div></div>
</div>
<div class='footer'>
温馨提示请至少提前30分钟到达取号过时自动取消。服务时间8:00-17:00
</div>
<div class='qr-code'>
<img src='https://api.qrserver.com/v1/create-qr-code/?size=100x100&data=$busNo' width='100' height='100' />
</div>
<div class='serial-no'>流水号:$busNo</div>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More