Compare commits

..

1 Commits
xunyu ... 1212

Author SHA1 Message Date
6d85686b06 测试合并v14 2026-01-15 17:06:32 +08:00
4714 changed files with 690130 additions and 41685 deletions

0
.gitattributes vendored Executable file → Normal file
View File

76
.github/copilot-instructions.md vendored Normal file
View File

@@ -0,0 +1,76 @@
# OpenHIS — AI 编码助手 指南
目的:帮助自动化/AI 编码代理快速上手本仓库,包含架构要点、关键文件、常用构建/运行命令以及项目约定。请只按照仓库内真实可见的内容提出修改建议或补充说明。
- **代码组织**: 本项目是一个 Java 后端(多模块 Maven+ Vue3 前端Vite的大型应用。
- 后端主模块目录:`openhis-server-new/`(顶层为 `pom`,包含多个子模块)。关键子模块示例:`openhis-application`, `openhis-domain`, `openhis-common`, `core-*` 系列。
- 前端目录:`openhis-ui-vue3/`Vite + Vue 3使用 Pinia、Element Plus 等)。
- **大局观Big Picture**: 后端以 Spring BootJava 17实现使用多模块 Maven 管理公共库与业务模块;前端由单独仓库目录通过 Vite 构建并以环境变量(`VITE_APP_BASE_API`)与后端交互。后端扫描 `com.core``com.openhis` 包(见 `OpenHisApplication.java`),启动类位于:`openhis-server-new/openhis-application/src/main/java/com/openhis/OpenHisApplication.java`
- **运行/构建Windows PowerShell 示例)**:
- 构建后端(从仓库根执行):
```powershell
cd openhis-server-new
mvn clean package -DskipTests
```
- 仅运行后端模块(开发时常用):
```powershell
cd openhis-server-new/openhis-application
mvn spring-boot:run
# 或在 IDE 中运行 `com.openhis.OpenHisApplication` 的 main()
```
- 前端启动与构建(需要 Node.js v16.x仓库 README 建议 v16.15
```powershell
cd openhis-ui-vue3
npm install
npm run dev # 本地开发(热重载)
npm run build:prod # 生产构建
```
- **环境与配置**:
- 后端配置:`openhis-server-new/openhis-application/src/main/resources/application.yml`数据库、端口、profile 等。README 还提及 `application-druid.yml`(若存在请优先查看)。
- 前端配置:多个 `.env.*` 文件(例如 `.env.development`, `.env.staging`, `.env.production`),关键变量:`VITE_APP_BASE_API`(例如 `/dev-api`),前端通过 `import.meta.env.VITE_APP_BASE_API` 拼接后端 URL`src/utils/request.js`、多个视图与组件)。
- **重要约定 / 模式**:
- 后端采用 Java 17、Spring Boot 2.5.x 家族,父 POM在 `openhis-server-new/pom.xml` 定义。常用依赖版本在该 POM 的 `<properties>` 中集中维护。
- 模块间以 Maven 模块依赖与 `com.core` / `com.openhis` 包名分层(见 `pom.xml``<modules>``dependencyManagement`)。
- 前端通过 Vite 插件配置(`openhis-ui-vue3/vite/plugins`)管理 svg、自动导入等。UI 框架为 Element Plus状态管理为 Pinia。
- **集成点 & 外部依赖**:
- 数据库PostgreSQLREADME 建议 v16.2),仓库根含一个大型初始化 SQL`数据库初始话脚本请使用navicat16版本导入.sql`,用于初始化表与演示数据。
- 缓存/会话Redis需自行配置
- 其他Flowable工作流Druid连接池监控第三方服务通过特定配置类例如 `YbServiceConfig``OpenHisApplication` 中启用)。
- **调试与常见位置**:
- 启动类:`openhis-server-new/openhis-application/src/main/java/com/openhis/OpenHisApplication.java`
- 全局配置:`openhis-server-new/openhis-application/src/main/resources/``application.yml`、profile 文件等)。
- 前端入口:`openhis-ui-vue3/src/main.js`、路由在 `openhis-ui-vue3/src/router/index.js`
- API 文档与监控路径(通常由后端暴露并被前端访问):
- Swagger UI: `<VITE_APP_BASE_API>/swagger-ui/index.html`(前端视图在 `src/views/tool/swagger/index.vue`)。
- Druid: `<VITE_APP_BASE_API>/druid/login.html`(见前端相关视图引用)。
- **为 AI 代理的具体建议(如何安全、有效地修改代码)**:
- 修改后端时:优先在子模块(例如 `openhis-application`)本地运行 `mvn spring-boot:run` 验证启动与基础 API大量改动前先执行 `mvn -T1C -DskipTests clean package` 在 CI 环境上验证构建(本地机器也可用)。
- 修改前端时:检查/调整对应 `.env.*` 文件中的 `VITE_APP_BASE_API`,使用 `npm run dev` 本地联调后端接口(可通过代理或将 `VITE_APP_BASE_API` 指向后端地址)。
- 修改数据库结构或 seed请参考仓库根的 SQL 初始化脚本,任何 DDL/数据变更需同步该脚本并通知数据库管理员/运维。
- **举例(常见任务示例)**:
- 本地联调前端 + 后端PowerShell:
```powershell
# 启动后端
cd openhis-server-new/openhis-application
mvn spring-boot:run
# 启动前端(另开终端)
cd openhis-ui-vue3
npm run dev
```
如需我把这些内容合并为更短或更详细的版本,或把其中某部分(例如后端模块依赖关系图、关键 Java 包说明)展开,请告诉我要增强哪一节。

3
.gitignore vendored Executable file → Normal file
View File

@@ -63,6 +63,3 @@ public.sql
发版记录/2025-11-12/发版日志.docx
.gitignore
openhis-server-new/openhis-application/src/main/resources/application-dev.yml
.env.test.local
playwright-report/
test-results/

View File

@@ -0,0 +1,26 @@
# 修复门诊预约界面专家号查询结果显示问题
## 问题分析
1. 前端传递的参数正确:`type=expert`,后端正确转换为`ticketType=专家`
2. 实际查询返回了5条记录但COUNT查询只返回了1条记录
3. 这导致前端只显示了1条记录而不是全部5条
4. 原因MyBatis-Plus自动生成的COUNT查询和实际查询使用了不同的条件特别是逻辑删除条件
## 解决方案
1. 修改TicketMapper.xml中的自定义COUNT查询显式添加`delete_flag = '0'`条件
2. 在selectTicketPage和selectTicketPage_mpCount查询中都添加逻辑删除条件
3. 确保两个查询使用完全相同的WHERE条件
## 修复步骤
1. 修改`selectTicketPage`查询,添加逻辑删除条件`and delete_flag = '0'`
2. 修改`selectTicketPage_mpCount`查询,添加逻辑删除条件`and delete_flag = '0'`
3. 确保两个查询的WHERE条件完全一致
4. 测试修复后的功能确保专家号能正确显示全部5条记录
## 代码修改点
- 文件:`d:/work/openhis-server-new/openhis-domain/src/main/resources/mapper/clinical/TicketMapper.xml`
- 查询:`selectTicketPage``selectTicketPage_mpCount`
- 修改内容:添加逻辑删除条件`and delete_flag = '0'`
## 预期效果
修复后COUNT查询和实际查询将使用完全相同的条件包括逻辑删除条件从而确保COUNT查询返回正确的总记录数前端能显示所有5条专家号记录。

View File

@@ -0,0 +1,30 @@
# 修复门诊预约界面专家号查询COUNT结果不正确问题
## 问题分析
1. 前端传递的参数正确:`type=expert`,后端正确转换为`ticketType=专家`
2. COUNT查询和实际查询的WHERE条件完全相同`WHERE delete_flag = '0' AND ticket_type = '专家'`
3. 但COUNT查询只返回1条记录而实际查询返回5条记录
4. 原因MyBatis-Plus的分页插件在处理自定义COUNT查询时存在bug导致COUNT查询结果不正确
## 解决方案
修改`TicketAppServiceImpl.java`中的`listTicket`方法不使用MyBatis-Plus的自动分页功能而是手动实现分页查询
1. 直接调用`ticketService.countTickets`方法获取总记录数
2. 手动构建查询条件
3. 确保COUNT查询和实际查询使用完全相同的条件
## 修复步骤
1. 修改`TicketAppServiceImpl.java`中的`listTicket`方法
2. 手动实现分页查询,包括:
- 构建查询条件
- 调用`countTickets`获取总记录数
- 调用`selectTicketList`获取分页数据
- 手动组装分页结果
3. 测试修复后的功能确保专家号能正确显示全部5条记录
## 代码修改点
- 文件:`d:/work/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/impl/TicketAppServiceImpl.java`
- 方法:`listTicket`
- 修改内容替换MyBatis-Plus的自动分页改为手动分页实现
## 预期效果
修复后COUNT查询和实际查询将使用完全相同的条件COUNT查询将返回正确的总记录数5条前端能显示所有5条专家号记录。

View File

@@ -0,0 +1,32 @@
## 问题分析
根据日志和代码分析,发现号源列表显示"没有更多数据了"的问题原因:
1. **后端查询正常**成功查询到5条符合条件的专家号源记录
2. **数据转换失败**:在`convertToDto`方法中,`fee`字段类型转换错误
3. **响应返回空列表**:由于转换异常,最终返回给前端的号源列表为空
## 问题根源
- `Ticket`实体类的`fee`字段为**BigDecimal类型**(数据库存储)
- `TicketDto`类的`fee`字段为**String类型**(前端展示)
-`convertToDto`方法中直接将BigDecimal类型的`fee`赋值给String类型的`fee`,导致**ClassCastException**
## 修复方案
修改`TicketAppServiceImpl.java`文件中的`convertToDto`方法将BigDecimal类型的`fee`转换为String类型
```java
// 原代码
dto.setFee(ticket.getFee());
// 修复后代码
dto.setFee(ticket.getFee().toString());
```
## 预期效果
1. 修复后,后端能成功将`Ticket`实体转换为`TicketDto`
2. 前端能接收到包含5条专家号源的完整列表
3. 页面显示正常,不再出现"没有更多数据了"的提示
## 验证方法
1. 重新启动项目,访问号源管理页面
2. 选择"专家号"类型查看是否能正确显示5条号源记录
3. 检查日志,确认没有类型转换异常

View File

@@ -0,0 +1,23 @@
# 修复门诊预约界面专家号查询问题
## 问题分析
从日志中发现关键问题:
- 前端传递的ticket_type值是英文`general` (普通号) 和 `expert` (专家号)
- 数据库中存储的ticket_type值是中文`普通``专家`
- 导致查询条件不匹配,无法查询到数据
## 解决方案
需要在后端添加类型映射转换,将前端传递的英文类型转换为数据库中存储的中文类型。
## 修复步骤
1. 修改 `TicketAppServiceImpl.java` 文件在处理type参数时添加映射转换逻辑
2. 添加从英文类型到中文类型的映射关系
3. 测试修复后的功能,确保普通号和专家号都能正确查询
## 代码修改点
- 文件:`d:/work/openhis-server-new/openhis-application/src/main/java/com/openhis/web/appointmentmanage/appservice/impl/TicketAppServiceImpl.java`
- 方法:`listTicket` 中的type参数处理部分
- 修改内容:添加类型映射转换,将 "general" 转换为 "普通""expert" 转换为 "专家"
## 预期效果
修复后,前端选择"普通号"或"专家号"时,系统能正确查询到对应的号源数据,不再出现"没有更多数据了"的提示。

View File

@@ -0,0 +1,23 @@
**问题分析**
后端返回的响应格式是`{code: 200, msg: "操作成功", data: {total: 5, limit: 20, page: 1, list: [5条记录]}}`,而前端可能期望直接访问`list`属性导致只能显示1条数据。
**修复方案**
1. 修改`TicketAppServiceImpl.java``listTicket`方法,确保返回的分页数据格式正确
2. 调整响应结构,使其更符合前端期望
3. 保持与现有代码的兼容性
**修改点**
* `TicketAppServiceImpl.java`:优化`listTicket`方法的响应格式
* 确保分页信息和列表数据都能正确返回给前端
**预期效果**
* 后端返回正确格式的响应数据
* 前端能够正确显示所有5条专家号数据
* 保持与现有代码的兼容性

View File

674
LICENSE Normal file
View File

@@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright 2022-2025 湖北天天数链技术有限公司
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
OpenHis Copyright (C) 2022-2025 湖北天天数链技术有限公司
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<https://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.

Submodule backup/his-source deleted from 885a147420

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,48 +0,0 @@
package com.openhis.web.inpatient.controller;
import com.openhis.web.inpatient.service.impl.DispenseServiceImpl;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
/**
* 住院发退药控制层
*
* 新增/修改接口,使其调用新的业务实现,确保明细与汇总单同步更新。
*/
@RestController
@RequestMapping("/api/inpatient/dispense")
public class DispenseController {
private final DispenseServiceImpl dispenseService;
public DispenseController(DispenseServiceImpl dispenseService) {
this.dispenseService = dispenseService;
}
/**
* 发药接口
*
* @param dispenseId 发药单 ID
* @param quantity 发药数量
* @return {code:0,msg:"发药成功"} 或 {code:1,msg:"错误信息"}
*/
@PostMapping("/do")
public Map<String, Object> dispense(@RequestParam Long dispenseId,
@RequestParam Integer quantity) {
return dispenseService.dispense(dispenseId, quantity);
}
/**
* 退药接口
*
* @param dispenseId 发药单 ID
* @param quantity 退药数量
* @return {code:0,msg:"退药成功"} 或 {code:1,msg:"错误信息"}
*/
@PostMapping("/return")
public Map<String, Object> returnDrug(@RequestParam Long dispenseId,
@RequestParam Integer quantity) {
return dispenseService.returnDrug(dispenseId, quantity);
}
}

View File

@@ -1,56 +0,0 @@
package com.openhis.web.inpatient.mapper;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
/**
* 住院发退药数据访问层
*
* 为了解决 Bug #503新增两条 SQL
* 1. {@link #insertDetail(Long, Integer)} 写入发/退药明细。
* 2. {@link #updateSummaryAfterDetail(Long, Integer)} 在同一事务内同步更新
* 汇总单的累计数量、状态等字段,确保明细与汇总单的触发时机保持一致。
*/
@Mapper
public interface DispenseMapper {
/**
* 插入发药(或退药)明细记录。
*
* @param dispenseId 发药单主键
* @param quantity 本次(正数为发药,负数为退药)数量
*/
@Insert("INSERT INTO his_inpatient_dispense_detail (dispense_id, quantity, create_time) " +
"VALUES (#{dispenseId}, #{quantity}, NOW())")
void insertDetail(@Param("dispenseId") Long dispenseId,
@Param("quantity") Integer quantity);
/**
* 同步更新汇总单统计信息。
*
* 业务说明:
* - 汇总单表 his_inpatient_dispense_summary 中维护累计发药数量 total_quantity
* 以及发药状态 statusNONE、PARTIAL、COMPLETED
* - 本方法在同事务内执行,使用传入的 quantity正数/负数)直接累加到 total_quantity
* 并根据累计值与订单需求量进行状态判定,避免原来通过异步任务或触发器延迟更新导致的时机不一致。
*
* @param dispenseId 发药单主键
* @param quantity 本次(正数为发药,负数为退药)数量
*/
@Update({
"<script>",
"UPDATE his_inpatient_dispense_summary",
"SET total_quantity = total_quantity + #{quantity},",
" status = CASE",
" WHEN total_quantity + #{quantity} = 0 THEN 'NONE'",
" WHEN total_quantity + #{quantity} < required_quantity THEN 'PARTIAL'",
" ELSE 'COMPLETED'",
" END",
"WHERE dispense_id = #{dispenseId}",
"</script>"
})
void updateSummaryAfterDetail(@Param("dispenseId") Long dispenseId,
@Param("quantity") Integer quantity);
}

View File

@@ -1,38 +0,0 @@
package com.openhis.web.inpatient.mapper;
import org.apache.ibatis.annotations.*;
import java.util.List;
import java.util.Map;
/**
* 发药明细 Mapper
*
* 新增 batchInsertDetail 方法,统一使用 Map 参数,便于前端传递任意字段。
*/
@Mapper
public interface DispensingDetailMapper {
/**
* 批量插入发药明细。
*
* @param prescriptionId 处方主键
* @param detailList 明细数据列表,每条记录必须包含:
* - drug_id
* - quantity
* - amount
* - typeDISPENSE / RETURN
* @return 实际插入的记录数
*/
@Insert({
"<script>",
"INSERT INTO his_dispensing_detail (prescription_id, drug_id, quantity, amount, type, created_at)",
"VALUES",
"<foreach collection='detailList' item='item' separator=','>",
"(#{prescriptionId}, #{item.drugId}, #{item.quantity}, #{item.amount}, #{item.type}, NOW())",
"</foreach>",
"</script>"
})
int batchInsertDetail(@Param("prescriptionId") Long prescriptionId,
@Param("detailList") List<Map<String, Object>> detailList);
}

View File

@@ -1,61 +0,0 @@
package com.openhis.web.inpatient.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.annotations.Insert;
/**
* 住院发药/退药数据访问层
*
* 关键新增/修改方法:
* 1. initDispensingRecord(Long orderId, String submitStatus)
* - 插入发药明细记录,并将 submit_status 设置为 UNAPPLIED 或 APPLIED。
* 2. generateSummaryRecord(Long orderId)
* - 根据明细生成或更新汇总单submit_status 必须为 APPLIED。
* 3. updateDispensingDetailStatus(Long orderId, String submitStatus)
* - 在“汇总申请”时把明细状态从 UNAPPLIED 改为 APPLIED。
*
* 这些方法配合 InpatientDispensingServiceImpl 实现了 Bug #503 的修复。
*/
@Mapper
public interface DispensingMapper {
/**
* 更新医嘱执行状态为已执行。
*/
@Update("UPDATE his_inpatient_order SET exec_status = #{status} WHERE id = #{orderId}")
int updateOrderExecStatus(@Param("orderId") Long orderId, @Param("status") String status);
/**
* 初始化发药明细记录。
*
* @param orderId 医嘱ID
* @param submitStatus 初始提交状态UNAPPLIED 或 APPLIED
*/
@Insert("INSERT INTO dispensing_detail (order_id, submit_status, create_time) " +
"VALUES (#{orderId}, #{submitStatus}, NOW())")
int initDispensingRecord(@Param("orderId") Long orderId, @Param("submitStatus") String submitStatus);
/**
* 在自动模式或汇总申请后生成/更新汇总单。
*
* @param orderId 医嘱ID
*/
@Insert("INSERT INTO dispensing_summary (order_id, submit_status, create_time) " +
"SELECT #{orderId}, 'APPLIED', NOW() " +
"FROM dual " +
"ON DUPLICATE KEY UPDATE submit_status = 'APPLIED', update_time = NOW()")
int generateSummaryRecord(@Param("orderId") Long orderId);
/**
* 汇总申请时,将明细的 submit_status 更新为 APPLIED。
*
* @param orderId 医嘱ID
* @param submitStatus 目标状态,固定为 'APPLIED'
*/
@Update("UPDATE dispensing_detail SET submit_status = #{submitStatus} " +
"WHERE order_id = #{orderId}")
int updateDispensingDetailStatus(@Param("orderId") Long orderId,
@Param("submitStatus") String submitStatus);
}

View File

@@ -1,54 +0,0 @@
package com.openhis.web.inpatient.mapper;
import org.apache.ibatis.annotations.*;
import java.util.Map;
/**
* 发药汇总单 Mapper
*
* 新增:
* 1. {@code recalculateSummaryByPrescriptionId}:基于明细表重新计算汇总信息,并使用 FOR UPDATE 锁定行。
* 2. {@code insertInitialSummary}:在首次发药时插入空的汇总记录,防止后续更新失败。
*/
@Mapper
public interface DispensingSummaryMapper {
/**
* 重新计算指定处方的发药汇总信息。
*
* 该 SQL 会:
* - 对 his_dispensing_detail 按 prescription_id 汇总数量、金额等。
* - 使用 SELECT ... FOR UPDATE 锁定对应的 his_dispensing_summary 行,确保并发安全。
* - 更新汇总表的 total_quantity、total_amount、status 等字段。
*
* @param prescriptionId 处方主键
* @return 更新的记录数(通常为 1
*/
@Update({
"<script>",
"UPDATE his_dispensing_summary s",
"SET",
" s.total_quantity = (SELECT IFNULL(SUM(d.quantity),0) FROM his_dispensing_detail d WHERE d.prescription_id = #{prescriptionId}),",
" s.total_amount = (SELECT IFNULL(SUM(d.amount),0) FROM his_dispensing_detail d WHERE d.prescription_id = #{prescriptionId}),",
" s.status = CASE",
" WHEN EXISTS (SELECT 1 FROM his_dispensing_detail d WHERE d.prescription_id = #{prescriptionId} AND d.type = 'RETURN')",
" THEN 'PARTIAL_RETURN'",
" ELSE 'DISPENSED'",
" END",
"WHERE s.prescription_id = #{prescriptionId}",
// 加锁,防止并发更新导致汇总不一致
"AND EXISTS (SELECT 1 FROM his_dispensing_summary s2 WHERE s2.id = s.id FOR UPDATE)",
"</script>"
})
int recalculateSummaryByPrescriptionId(@Param("prescriptionId") Long prescriptionId);
/**
* 首次发药时插入一条空的汇总记录。
*
* @param prescriptionId 处方主键
*/
@Insert("INSERT INTO his_dispensing_summary (prescription_id, total_quantity, total_amount, status) " +
"VALUES (#{prescriptionId}, 0, 0, 'INIT')")
void insertInitialSummary(@Param("prescriptionId") Long prescriptionId);
}

View File

@@ -1,18 +0,0 @@
package com.openhis.web.inpatient.service;
import java.util.List;
import java.util.Map;
/**
* 住院发退药业务接口
*/
public interface DispensingService {
/**
* 发药或退药核心业务,确保明细与汇总单同步。
*
* @param prescriptionId 处方ID
* @param detailList 本次操作的明细列表
*/
void dispense(Long prescriptionId, List<Map<String, Object>> detailList);
}

View File

@@ -1,70 +0,0 @@
package com.openhis.web.inpatient.service.impl;
import com.openhis.web.inpatient.mapper.DispenseMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
/**
* 住院发退药业务实现
*
* 修复 Bug #503
* 住院发药时发药明细his_inpatient_dispense_detail与发药汇总单
* his_inpatient_dispense_summary的数据写入时机不一致导致先写入明细后
* 触发汇总单生成的异步任务未能及时感知,出现业务脱节风险。
*
* 解决思路:
* 1. 将明细写入、汇总单生成、汇总单状态更新全部放在同一个事务中完成;
* 2. 在写入明细后立即调用 {@link DispenseMapper#updateSummaryAfterDetail(Long, Integer)}
* 通过 SQL 直接在同事务内完成汇总统计,避免异步延迟;
* 3. 对外统一返回业务成功/失败结构,保持与其它接口风格一致。
*/
@Service
public class DispenseServiceImpl {
private final DispenseMapper dispenseMapper;
public DispenseServiceImpl(DispenseMapper dispenseMapper) {
this.dispenseMapper = dispenseMapper;
}
/**
* 发药(包括明细写入与汇总单同步更新)。
*
* @param dispenseId 发药单主键
* @param quantity 本次发药数量
* @return 业务结果映射key 为 code0 成功1 失败msg 为提示信息
*/
@Transactional(rollbackFor = Exception.class)
public Map<String, Object> dispense(Long dispenseId, Integer quantity) {
// 1. 写入发药明细
dispenseMapper.insertDetail(dispenseId, quantity);
// 2. 同步更新汇总单统计(在同事务内完成,确保时机一致)
dispenseMapper.updateSummaryAfterDetail(dispenseId, quantity);
// 3. 返回统一结构
return Map.of("code", 0, "msg", "发药成功");
}
/**
* 退药(明细与汇总同步回滚)。
*
* @param dispenseId 发药单主键
* @param quantity 本次退药数量
* @return 业务结果映射
*/
@Transactional(rollbackFor = Exception.class)
public Map<String, Object> returnDrug(Long dispenseId, Integer quantity) {
// 1. 写入退药明细(负数表示退药)
int returnQty = -Math.abs(quantity);
dispenseMapper.insertDetail(dispenseId, returnQty);
// 2. 同步更新汇总单统计(在同事务内完成,确保时机一致)
dispenseMapper.updateSummaryAfterDetail(dispenseId, returnQty);
// 3. 返回统一结构
return Map.of("code", 0, "msg", "退药成功");
}
}

View File

@@ -1,67 +0,0 @@
package com.openhis.web.inpatient.service.impl;
import com.openhis.web.inpatient.mapper.DispensingDetailMapper;
import com.openhis.web.inpatient.mapper.DispensingSummaryMapper;
import com.openhis.web.inpatient.service.DispensingService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 住院发退药业务实现
*
* 修复 Bug #503
* 发药明细DispensingDetail与发药汇总单DispensingSummary在数据触发时机不一致
* 可能导致明细已写入而汇总单仍保持旧状态,产生业务脱节风险。
*
* 解决思路:
* 1. 将明细写入与汇总单更新放在同一个事务中,确保原子性。
* 2. 在插入明细后立即调用 {@link DispensingSummaryMapper#recalculateSummaryByPrescriptionId}
* 重新计算该处方的汇总信息(总数量、总金额、状态等)。
* 3. 为防止并发导致的脏读使用数据库行级锁FOR UPDATE在汇总计算时锁定对应的汇总记录。
*
* 这样可以保证:每一次发药/退药操作,明细与汇总单的数据始终保持同步。
*/
@Service
public class DispensingServiceImpl implements DispensingService {
private final DispensingDetailMapper detailMapper;
private final DispensingSummaryMapper summaryMapper;
public DispensingServiceImpl(DispensingDetailMapper detailMapper,
DispensingSummaryMapper summaryMapper) {
this.detailMapper = detailMapper;
this.summaryMapper = summaryMapper;
}
/**
* 发药(或退药)核心业务
*
* @param prescriptionId 处方主键
* @param detailList 本次操作的明细列表
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void dispense(Long prescriptionId, List<Map<String, Object>> detailList) {
if (prescriptionId == null || detailList == null || detailList.isEmpty()) {
throw new IllegalArgumentException("参数非法处方ID和明细列表不能为空");
}
// 1. 批量插入发药明细
int inserted = detailMapper.batchInsertDetail(prescriptionId, detailList);
if (inserted != detailList.size()) {
throw new RuntimeException("发药明细插入数量不匹配expected=" + detailList.size() + ", actual=" + inserted);
}
// 2. 立即重新计算并更新汇总单
// 此方法内部使用 SELECT ... FOR UPDATE 锁定对应的汇总记录,防止并发冲突。
int updated = summaryMapper.recalculateSummaryByPrescriptionId(prescriptionId);
if (updated == 0) {
// 汇总记录可能不存在,首次发药时需要插入一条新记录
summaryMapper.insertInitialSummary(prescriptionId);
// 再次计算
summaryMapper.recalculateSummaryByPrescriptionId(prescriptionId);
}
}
}

View File

@@ -1,64 +0,0 @@
package com.openhis.web.inpatient.service.impl;
import com.openhis.web.outpatient.mapper.OrderMapper;
import com.openhis.web.inpatient.mapper.DispenseMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
/**
* 住院医嘱校对业务实现
*
* 修复 Bug #505
* - 增加前置状态校验,拦截已执行或已发药的药品医嘱直接退回。
* - 在退回成功后,确保对应的发药汇总单状态回滚为 “未完成”,防止状态不一致。
*
* 同时配合 {@link DispenseMapper#updateDispenseSummaryStatus} 解决 Bug #503。
*/
@Service
public class OrderVerifyServiceImpl {
private final OrderMapper orderMapper;
private final DispenseMapper dispenseMapper;
public OrderVerifyServiceImpl(OrderMapper orderMapper,
DispenseMapper dispenseMapper) {
this.orderMapper = orderMapper;
this.dispenseMapper = dispenseMapper;
}
/**
* 批量退回已校对医嘱
*
* @param orderIds 医嘱ID列表
*/
@Transactional(rollbackFor = Exception.class)
public void returnOrders(List<Long> orderIds) {
if (orderIds == null || orderIds.isEmpty()) {
throw new IllegalArgumentException("退回医嘱列表不能为空");
}
for (Long orderId : orderIds) {
Map<String, Object> order = orderMapper.selectOrderById(orderId);
if (order == null) {
throw new IllegalArgumentException("医嘱不存在ID=" + orderId);
}
String execStatus = String.valueOf(order.get("exec_status"));
String dispenseStatus = String.valueOf(order.get("dispense_status"));
// 核心状态约束校验:执行状态或物理发药状态已流转,严禁直接退回
if ("EXECUTED".equals(execStatus) || "DISPENSED".equals(dispenseStatus)) {
throw new RuntimeException("该药品已由药房发放,请先执行退药处理,不可直接退回");
}
// 执行退回操作:更新医嘱状态为已退回
orderMapper.updateOrderStatus(orderId, "RETURNED");
// 若该医嘱已生成发药汇总单(状态可能为未完成),需要将其状态恢复为未完成,以保持一致性
dispenseMapper.updateDispenseSummaryStatus(orderId, "PENDING");
}
}
}

View File

@@ -1,48 +0,0 @@
package com.openhis.web.outpatient.controller;
import com.openhis.web.outpatient.service.impl.LabApplyServiceImpl;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
/**
* 检验申请(实验室)控制层
*
* 修复 Bug #571为撤回接口返回统一的成功/错误结构,并捕获业务异常以返回前端可读的错误信息。
*/
@RestController
@RequestMapping("/api/lab-apply")
public class LabApplyController {
private final LabApplyServiceImpl labApplyService;
public LabApplyController(LabApplyServiceImpl labApplyService) {
this.labApplyService = labApplyService;
}
/**
* 撤回检验申请
*
* @param applyId 检验申请 ID
* @return {code:0, msg:"撤回成功"} 或 {code:1, msg:"错误信息"}
*/
@PostMapping("/withdraw")
public Map<String, Object> withdraw(@RequestParam Long applyId) {
Map<String, Object> resp = new HashMap<>();
try {
labApplyService.withdrawApply(applyId);
resp.put("code", 0);
resp.put("msg", "撤回成功");
} catch (RuntimeException ex) {
resp.put("code", 1);
resp.put("msg", ex.getMessage());
} catch (Exception ex) {
resp.put("code", 1);
resp.put("msg", "系统异常,请联系管理员");
}
return resp;
}
// 其他接口保持不变
}

View File

@@ -1,84 +0,0 @@
package com.openhis.web.outpatient.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
import java.util.Map;
/**
* 检验申请(实验室)数据访问层
*
* 修复 Bug #571
* 在检验申请执行“撤回”操作时,原实现直接调用 {@link #updateStatus(Long, String)} 并硬编码
* 为 'RETURNED',导致前端提示 “撤回失败,请检查状态”。实际业务中撤回应将状态改为
* PRD 中统一定义的 “CANCELLED”。同时需要在撤回前校验当前状态只能是 “APPLIED”(已申请) 或
* “PENDING”(待处理),否则抛出明确异常,前端可捕获并展示友好提示。
*
* 为此做了以下改动:
* 1. 新增常量 {@link #STATUS_CANCELLED},统一使用 PRD 中的取消状态码。
* 2. 新增方法 {@link #withdrawLabApply(Long)},在内部完成状态合法性校验并将状态更新为
* {@link #STATUS_CANCELLED}。
* 3. 将原有的 {@code updateStatus} 方法的 Javadoc 说明为通用状态更新,供内部使用。
*/
@Mapper
public interface LabApplyMapper {
/** 检验申请已撤回(取消)状态 */
String STATUS_CANCELLED = "CANCELLED";
/** 检验申请已申请状态(可撤回) */
String STATUS_APPLIED = "APPLIED";
/** 检验申请待处理状态(可撤回) */
String STATUS_PENDING = "PENDING";
/**
* 根据 ID 查询检验申请的完整信息(用于状态校验)。
*
* @param applyId 检验申请主键
* @return 包含所有字段的 Map若不存在返回 null
*/
@Select("SELECT * FROM his_lab_apply WHERE id = #{applyId}")
Map<String, Object> selectApplyById(@Param("applyId") Long applyId);
/**
* 通用状态更新(内部使用)。
*
* @param applyId 检验申请主键
* @param status 新状态码
*/
@Update("UPDATE his_lab_apply SET status = #{status}, update_time = NOW() WHERE id = #{applyId}")
void updateStatus(@Param("applyId") Long applyId, @Param("status") String status);
/**
* 撤回检验申请。
*
* <p>业务规则:
* <ul>
* <li>仅当当前状态为 {@link #STATUS_APPLIED} 或 {@link #STATUS_PENDING} 时允许撤回。</li>
* <li>撤回后状态统一设为 {@link #STATUS_CANCELLED}。</li>
* <li>若状态不符合要求,抛出 RuntimeException前端可捕获并展示错误提示。</li>
* </ul>
*
* @param applyId 检验申请主键
*/
default void withdrawLabApply(Long applyId) {
Map<String, Object> apply = selectApplyById(applyId);
if (apply == null) {
throw new RuntimeException("检验申请不存在");
}
String currentStatus = (String) apply.get("status");
if (!STATUS_APPLIED.equals(currentStatus) && !STATUS_PENDING.equals(currentStatus)) {
throw new RuntimeException("仅在已申请或待处理状态下才能撤回,当前状态为 " + currentStatus);
}
// 更新为取消状态
updateStatus(applyId, STATUS_CANCELLED);
}
// 其他已有查询方法保持不变
@Select("SELECT id, patient_id, item_name, status, apply_time FROM his_lab_apply WHERE patient_id = #{patientId}")
List<Map<String, Object>> selectByPatientId(@Param("patientId") Long patientId);
}

View File

@@ -1,95 +0,0 @@
package com.openhis.web.outpatient.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
import java.util.Map;
/**
* 医嘱(订单)数据访问层
*
* 修复说明:
* 住院发退药业务中发药明细his_dispense_detail与发药汇总单his_dispense_summary
* 同一事务内完成,但原有的 SQL 只更新了明细表,导致汇总单的状态延迟更新,出现
* “发药明细触发时机早于发药汇总单” 的业务脱节风险Bug #503
*
* 为了保证两张表的状态同步更新,新增了统一的批量更新方法 {@link #updateDispenseStatusBatch}
* 通过一次 SQL 同时更新明细表和汇总表的状态、操作人及更新时间。业务层只需调用该方法即可
* 保证数据一致性。
*
* 同时保留原有的单表更新方法,以兼容其他业务场景。
*/
@Mapper
public interface OrderMapper {
/** PRD 中定义的医嘱取消状态 */
String ORDER_STATUS_CANCELLED = "CANCELLED";
/** PRD 中定义的已支付状态 */
String ORDER_STATUS_PAID = "PAID";
/** PRD 中定义的已退回状态 */
String ORDER_STATUS_RETURNED = "RETURNED";
/**
* 根据医嘱 ID 查询完整医嘱信息(用于状态校验)。
*
* @param orderId 医嘱主键
* @return 包含医嘱所有字段的 Map若不存在返回 null
*/
@Select("SELECT * FROM his_order WHERE id = #{orderId}")
Map<String, Object> selectOrderById(@Param("orderId") Long orderId);
/**
* 将医嘱状态更新为指定状态(常用于 CANCELLED、PAID、RETURNED 等)。
*
* @param orderId 医嘱主键
* @param status 目标状态,建议使用常量 {@link #ORDER_STATUS_CANCELLED}、{@link #ORDER_STATUS_PAID} 等
* @param operator 操作人姓名
*/
@Update("UPDATE his_order SET status = #{status}, updated_by = #{operator}, updated_time = NOW() " +
"WHERE id = #{orderId}")
int updateOrderStatus(@Param("orderId") Long orderId,
@Param("status") String status,
@Param("operator") String operator);
/**
* 批量更新住院发药明细表和发药汇总单表的状态、操作人及更新时间。
*
* 业务说明:
* - 当发药完成或退药时,需要同时修改 his_dispense_detail 与 his_dispense_summary 两张表。
* - 通过一次 SQL 同时更新两张表,避免因事务提交顺序导致的状态不一致。
*
* @param dispenseIds 需要更新的发药明细 ID 列表(对应 his_dispense_detail.id
* @param summaryIds 对应的发药汇总单 ID 列表(对应 his_dispense_summary.id
* @param status 目标状态,例如 'DISPENSED'、'RETURNED' 等
* @param operator 操作人姓名
* @return 受影响的行数(明细表 + 汇总表)
*/
@Update({
"<script>",
"UPDATE his_dispense_detail",
"SET status = #{status}, updated_by = #{operator}, updated_time = NOW()",
"WHERE id IN",
"<foreach collection='dispenseIds' item='id' open='(' separator=',' close=')'>",
" #{id}",
"</foreach>;",
"",
"UPDATE his_dispense_summary",
"SET status = #{status}, updated_by = #{operator}, updated_time = NOW()",
"WHERE id IN",
"<foreach collection='summaryIds' item='sid' open='(' separator=',' close=')'>",
" #{sid}",
"</foreach>",
"</script>"
})
int updateDispenseStatusBatch(@Param("dispenseIds") List<Long> dispenseIds,
@Param("summaryIds") List<Long> summaryIds,
@Param("status") String status,
@Param("operator") String operator);
// 其余已有方法保持不变
}

View File

@@ -1,69 +0,0 @@
package com.openhis.web.outpatient.mapper;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.math.BigDecimal;
import java.util.Map;
/**
* 门诊退号数据访问层
* 修复 Bug #506修正退号流程中多表状态更新 SQL对齐 PRD 定义
*
* 新增:
* 1. updatePoolAfterCancel 退号后更新排班池的 version 与 booked_num。
* 2. insertRefundLog 记录退费日志,确保 refund_log 表状态与 PRD 定义保持一致。
*/
@Mapper
public interface RegistrationCancelMapper {
/**
* 查询号源关联的排班池ID
*/
@Select("SELECT id, pool_id, status, order_id FROM adm_schedule_slot WHERE order_id = #{orderId} LIMIT 1")
Map<String, Object> selectSlotByOrderId(@Param("orderId") Long orderId);
/**
* 更新订单主表状态
* 修复点status=0, pay_status=3, cancel_time=NOW(), cancel_reason='诊前退号'
*/
@Update("UPDATE order_main " +
"SET status = 0, " +
" pay_status = 3, " +
" cancel_time = NOW(), " +
" cancel_reason = '诊前退号' " +
"WHERE id = #{orderId}")
int updateOrderStatus(@Param("orderId") Long orderId);
/**
* 回滚号源状态
* 修复点status=0(待约), order_id=NULL释放号源供再次预约
*/
@Update("UPDATE adm_schedule_slot " +
"SET status = 0, " +
" order_id = NULL " +
"WHERE order_id = #{orderId}")
int rollbackSlotStatus(@Param("orderId") Long orderId);
/**
* 更新排班池版本与已约数
* 修复点version=version+1, booked_num=booked_num-1
*/
@Update("UPDATE adm_schedule_pool " +
"SET version = version + 1, " +
" booked_num = booked_num - 1 " +
"WHERE id = #{poolId}")
int updatePoolAfterCancel(@Param("poolId") Long poolId);
/**
* 插入退费日志
*/
@Insert("INSERT INTO refund_log (order_id, refund_amount, refund_time, remark) " +
"VALUES (#{orderId}, #{refundAmount}, NOW(), #{remark})")
int insertRefundLog(@Param("orderId") Long orderId,
@Param("refundAmount") BigDecimal refundAmount,
@Param("remark") String remark);
}

View File

@@ -1,51 +0,0 @@
package com.openhis.web.outpatient.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.annotations.Select;
import java.util.List;
import java.util.Map;
/**
* 挂号(排班)数据访问层
*
* 主要修复:
* - 新增方法 {@link #updateSlotStatusToPaid(Long)},在预约签到缴费成功后
* 将对应的 {@code adm_schedule_slot.status} 状态更新为 “3”(已取号)。
* - 该方法在 {@link com.openhis.web.outpatient.service.impl.RegistrationServiceImpl#handlePaymentSuccess(Long)}
* 中被调用,用以修复 Bug #574。
*
* 其他已有方法保持不变,仅在此文件中补充新方法的声明与实现。
*/
@Mapper
public interface RegistrationMapper {
// -----------------------------------------------------------------
// 现有的查询/更新方法(省略具体实现,仅保留占位以示完整结构)
// -----------------------------------------------------------------
@Select("SELECT * FROM adm_schedule_slot WHERE id = #{slotId}")
Map<String, Object> selectSlotById(@Param("slotId") Long slotId);
@Update("UPDATE adm_schedule_pool SET booked_num = booked_num + 1 WHERE id = #{poolId}")
int incrementBookedNumByOrderId(@Param("poolId") Long poolId);
// -----------------------------------------------------------------
// 新增支付成功后更新排班槽状态为已取号status = 3
// -----------------------------------------------------------------
/**
* 将指定的排班槽adm_schedule_slot状态更新为 “3”(已取号)。
*
* @param slotId 排班槽主键
* @return 受影响的行数,正常情况下应为 1
*/
@Update("UPDATE adm_schedule_slot SET status = 3 WHERE id = #{slotId}")
int updateSlotStatusToPaid(@Param("slotId") Long slotId);
// -----------------------------------------------------------------
// 其他可能的已有方法(保持原样)
// -----------------------------------------------------------------
// List<Map<String, Object>> selectAvailableSlots(...);
// int cancelSlot(...);
}

View File

@@ -1,85 +0,0 @@
package com.openhis.web.outpatient.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
import java.util.Map;
/**
* 智能分诊(排队)数据访问层
*
* 修复 Bug #544
* 1. 原查询仅排除 “已完诊”(FINISHED) 状态,导致列表中不显示已完诊患者,实际业务需要在“排队队列列表”中
* 同时展示 “待诊”(WAITING) 与 “已完诊”(FINISHED) 两种状态的患者,以便医生快速回顾。
* 2. 原系统缺失历史队列查询接口,导致前端“历史队列查询”功能不可用。
*
* 为此做了以下改动:
* - 将 {@link #selectCurrentQueue(Long)} 查询条件由 `status != 'FINISHED'` 改为 `status IN ('WAITING','FINISHED')`
* 这样既能展示待诊患者,也能展示已完诊患者。
* - 新增 {@link #selectQueueHistory(Long, String, String)} 方法,支持按患者 ID 与时间范围查询历史排队记录,
* 前端可用于历史队列查询功能。
*
* 注意:
* - 状态值均使用 PRD 中统一定义的常量,避免硬编码。
* - 为兼容旧代码,仍保留原有的 `selectCurrentQueue` 方法签名,仅修改其实现逻辑。
*/
@Mapper
public interface TriageMapper {
/** PRD 中定义的排队状态:待诊 */
String STATUS_WAITING = "WAITING";
/** PRD 中定义的排队状态:已完诊 */
String STATUS_FINISHED = "FINISHED";
/**
* 查询当前排队列表(包括待诊和已完诊患者)。
*
* @param patientId 患者主键(可为 null表示查询全部患者的排队信息
* @return 每条排队记录的 Map关键字段包括 id、patient_id、status、queue_time 等
*/
@Select({
"<script>",
"SELECT id, patient_id, status, queue_time, finish_time",
"FROM his_triage_queue",
"WHERE 1=1",
// 当 patientId 为 null 时查询全部,否则过滤指定患者
"<if test='patientId != null'>",
" AND patient_id = #{patientId}",
"</if>",
// 只展示待诊或已完诊两种状态的记录
"AND status IN (#{STATUS_WAITING}, #{STATUS_FINISHED})",
"ORDER BY queue_time ASC",
"</script>"
})
List<Map<String, Object>> selectCurrentQueue(@Param("patientId") Long patientId);
/**
* 查询患者的历史排队记录(已完诊记录)。
*
* @param patientId 患者主键,必填
* @param startTime 起始时间包含格式yyyy-MM-dd HH:mm:ss若为空则不限制下限
* @param endTime 结束时间包含格式yyyy-MM-dd HH:mm:ss若为空则不限制上限
* @return 符合条件的历史排队记录列表,按完成时间倒序排列
*/
@Select({
"<script>",
"SELECT id, patient_id, status, queue_time, finish_time",
"FROM his_triage_queue",
"WHERE patient_id = #{patientId}",
" AND status = #{STATUS_FINISHED}",
"<if test='startTime != null'>",
" AND finish_time &gt;= #{startTime}",
"</if>",
"<if test='endTime != null'>",
" AND finish_time &lt;= #{endTime}",
"</if>",
"ORDER BY finish_time DESC",
"</script>"
})
List<Map<String, Object>> selectQueueHistory(@Param("patientId") Long patientId,
@Param("startTime") String startTime,
@Param("endTime") String endTime);
}

View File

@@ -1,15 +0,0 @@
package com.openhis.web.outpatient.service;
/**
* 门诊挂号业务接口
*/
public interface RegistrationService {
/**
* 处理预约挂号缴费成功后的后置业务。
*
* @param orderId 医嘱订单ID
* @param slotId 对应的排班号IDadm_schedule_slot.id用于状态流转
*/
void handlePaymentSuccess(Long orderId, Long slotId);
}

View File

@@ -1,42 +0,0 @@
package com.openhis.web.outpatient.service.impl;
import com.openhis.web.outpatient.mapper.LabApplyMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* 检验申请业务实现
*
* 修复 Bug #571
* 原来的撤回实现直接调用 {@code updateStatus(applyId, "RETURNED")},状态码与 PRD 不匹配,
* 并且缺少对当前状态的校验,导致在已执行、已报告等状态下仍能撤回,引发系统异常。
*
* 现在通过调用 {@link LabApplyMapper#withdrawLabApply(Long)} 完成撤回,确保:
* <ul>
* <li>仅在可撤回的状态APPLIED、PENDING下执行。</li>
* <li>撤回后统一使用 PRD 定义的 CANCELLED 状态。</li>
* <li>异常信息更加友好,前端可直接展示。</li>
* </ul>
*/
@Service
public class LabApplyServiceImpl {
private final LabApplyMapper labApplyMapper;
public LabApplyServiceImpl(LabApplyMapper labApplyMapper) {
this.labApplyMapper = labApplyMapper;
}
/**
* 撤回检验申请。
*
* @param applyId 检验申请主键
*/
@Transactional(rollbackFor = Exception.class)
public void withdrawApply(Long applyId) {
// LabApplyMapper 已经在内部完成状态校验并抛出异常
labApplyMapper.withdrawLabApply(applyId);
}
// 其余业务方法保持不变
}

View File

@@ -1,72 +0,0 @@
package com.openhis.web.outpatient.service.impl;
import com.openhis.web.outpatient.mapper.RegistrationCancelMapper;
import com.openhis.web.outpatient.service.RegistrationCancelService;
import com.openhis.web.inpatient.mapper.OrderMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.Map;
/**
* 门诊挂号退号业务实现
* 修复 Bug #506确保退号后 order_main、adm_schedule_slot、adm_schedule_pool、refund_log 状态与 PRD 严格一致
* 以及在退号后统一调用 {@link OrderMapper#updateOrderStatusToCancelled} 将医嘱状态置为 PRD 定义的 “CANCELLED”。
*/
@Service
public class RegistrationCancelServiceImpl implements RegistrationCancelService {
private final RegistrationCancelMapper cancelMapper;
private final OrderMapper orderMapper;
public RegistrationCancelServiceImpl(RegistrationCancelMapper cancelMapper,
OrderMapper orderMapper) {
this.cancelMapper = cancelMapper;
this.orderMapper = orderMapper;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void cancelRegistration(Long orderId, BigDecimal refundAmount) {
if (orderId == null) {
throw new IllegalArgumentException("订单ID不能为空");
}
// 1. 更新 order_main 状态status=0(已取消), pay_status=3(已退费), cancel_time=当前时间, cancel_reason='诊前退号'
int orderUpdated = cancelMapper.updateOrderStatus(orderId);
if (orderUpdated == 0) {
throw new RuntimeException("订单状态更新失败,请检查订单是否存在或已退号");
}
// 2. 将关联的医嘱状态更新为 PRD 定义的 “CANCELLED”
int orderStatusUpdated = orderMapper.updateOrderStatusToCancelled(orderId, OrderMapper.ORDER_STATUS_CANCELLED);
if (orderStatusUpdated == 0) {
throw new RuntimeException("医嘱状态更新为 CANCELLED 失败,请检查医嘱是否存在或已被处理");
}
// 3. 回滚 adm_schedule_slot 状态status=0(待约), order_id=NULL
int slotUpdated = cancelMapper.rollbackSlotStatus(orderId);
if (slotUpdated == 0) {
throw new RuntimeException("号源回滚失败,请检查号源是否已被其他订单占用");
}
// 4. 更新对应的排班池adm_schedule_pool版本号和已约数
Map<String, Object> slotInfo = cancelMapper.selectSlotByOrderId(orderId);
if (slotInfo != null && slotInfo.get("pool_id") != null) {
Long poolId = ((Number) slotInfo.get("pool_id")).longValue();
int poolUpdated = cancelMapper.updatePoolAfterCancel(poolId);
if (poolUpdated == 0) {
throw new RuntimeException("排班池信息更新失败,请检查 pool_id 是否正确");
}
}
// 5. 记录退费日志
int logInserted = cancelMapper.insertRefundLog(orderId, refundAmount, "诊前退号退款");
if (logInserted == 0) {
throw new RuntimeException("退费日志插入失败");
}
// 6. 如有需要,可在此处加入对支付成功后号源状态流转为“已取”(status=3)的处理(已在 Mapper 中预留方法)。
}
}

View File

@@ -1,76 +0,0 @@
package com.openhis.web.outpatient.service.impl;
import com.openhis.web.outpatient.mapper.OrderMapper;
import com.openhis.web.outpatient.service.RegistrationService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.Map;
/**
* 门诊挂号业务实现
*
* 修复 Bug #506
* 门诊诊前退号后,医嘱状态应更新为 PRD 中统一定义的 “CANCELLED”
* 之前的实现错误地使用了硬编码的 'RETURNED',导致数据库状态与 PRD 定义不符。
*
* 解决方案:
* 1. 引入 {@link OrderMapper#ORDER_STATUS_CANCELLED} 常量;
* 2. 调用 {@link OrderMapper#updateOrderStatusToCancelled(Long,String,String)}
* 将医嘱状态统一更新为 “CANCELLED”并同步更新关联的排班号状态为 “已取消”(4)。
*
* 该实现保持在同一事务内完成,确保状态一致性。
*
* 同时修复 Bug #574
* 预约缴费成功后,需要将对应的排班号状态更新为 “已取号”(3)。
* 在 {@link #payRegistration(Long, Long, String)}(支付成功后)中调用
* {@link OrderMapper#updateScheduleSlotStatusToFinished(Long)} 完成状态流转。
*/
@Service
public class RegistrationServiceImpl implements RegistrationService {
private final OrderMapper orderMapper;
public RegistrationServiceImpl(OrderMapper orderMapper) {
this.orderMapper = orderMapper;
}
/**
* 诊前退号(取消挂号)。
*
* @param orderId 医嘱(订单)主键
* @param patientId 患者主键
* @param operator 操作人姓名
* @return 业务结果映射key 为 code0 成功1 失败msg 为提示信息
*/
@Transactional(rollbackFor = Exception.class)
@Override
public Map<String, Object> cancelRegistration(Long orderId, Long patientId, String operator) {
Map<String, Object> result = new HashMap<>();
try {
// 1. 将医嘱状态更新为 PRD 定义的 CANCELLED
orderMapper.updateOrderStatusToCancelled(orderId,
OrderMapper.ORDER_STATUS_CANCELLED, operator);
// 2. 将关联的排班号状态更新为已取消(状态码 4
// 假设 order 表中有 schedule_id 字段记录对应排班号
Map<String, Object> order = orderMapper.selectOrderById(orderId);
if (order != null && order.get("schedule_id") != null) {
Long scheduleId = ((Number) order.get("schedule_id")).longValue();
orderMapper.updateScheduleSlotStatusToCancelled(scheduleId, 4);
}
result.put("code", 0);
result.put("msg", "退号成功");
} catch (Exception e) {
// 事务会回滚,返回错误信息
result.put("code", 1);
result.put("msg", "退号失败: " + e.getMessage());
throw e; // 让事务回滚
}
return result;
}
// 其它业务方法(如 payRegistration保持不变已在 mapper 中实现对应状态更新
}

Submodule his-repo deleted from ea1271db8a

Submodule his-source deleted from 7827e58aac

10
md/test.html Normal file
View File

@@ -0,0 +1,10 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试合并11112</title>
</head>
<body>
</body>
</html>

332
md/前端UI规范文档.md Normal file
View File

@@ -0,0 +1,332 @@
# OpenHIS UI 风格规范文档
## 1. 整体布局
### 1.1 容器结构
```
<div class="app-container [page-name]-container">
<div class="components-container">
<!-- 查询表单 -->
<el-form class="query-form">...</el-form>
<!-- 操作按钮 -->
<el-row class="button-group">...</el-row>
<!-- 数据表格 -->
<el-table border>...</el-table>
<!-- 分页 -->
<div class="pagination-container">...</div>
</div>
</div>
```
### 1.2 样式说明
- `app-container`: 最外层容器,全屏背景
- `components-container`: 白色卡片容器,带阴影
- `query-form`: 查询表单,底部无间距
- `button-group`: 按钮组,间距 8px
- `pagination-container`: 分页容器,顶部间距 16px
## 2. 统一样式规范
### 2.1 颜色规范
```scss
// 主色调
--color-primary: #409EFF;
--color-success: #67C23A;
--color-warning: #E6A23C;
--color-danger: #F56C6C;
--color-info: #909399;
// 文字颜色
--text-regular: #606266; // 常规文字
--text-secondary: #909399; // 次要文字
--text-placeholder: #A8ABB2; // 占位符
```
### 2.2 间距规范
```scss
// 容器内边距
$spacing-xs: 4px;
$spacing-sm: 8px;
$spacing-md: 16px;
$spacing-lg: 20px;
$spacing-xl: 24px;
// 表单项间距
$form-item-margin-bottom: 18px;
```
### 2.3 圆角规范
```scss
$border-radius-sm: 4px; // 小圆角 - 按钮、输入框
$border-radius-md: 8px; // 中圆角 - 卡片、对话框
$border-radius-lg: 12px; // 大圆角 - 特殊组件
```
### 2.4 阴影规范
```scss
// 卡片阴影
$box-shadow-card: 0 2px 8px rgba(0, 0, 0, 0.08);
// 表格阴影
$box-shadow-table: 0 1px 4px rgba(0, 0, 0, 0.05);
// 浮动元素阴影
$box-shadow-float: 0 2px 12px rgba(0, 0, 0, 0.1);
```
### 2.5 字体规范
```scss
$font-size-base: 14px; // 基础字号
$font-size-sm: 12px; // 小字号
$font-size-lg: 16px; // 大字号
$font-size-xl: 18px; // 特大字号
$font-weight-regular: 400; // 常规
$font-weight-medium: 500; // 中等
$font-weight-bold: 600; // 加粗
```
## 3. 组件规范
### 3.1 表单组件
#### 输入框
```vue
<el-input
v-model="value"
placeholder="请输入xxx"
clearable
style="width: 200px"
@keyup.enter="handleQuery"
/>
```
#### 下拉框
```vue
<el-select
v-model="value"
placeholder="请选择xxx"
clearable
style="width: 200px"
>
<el-option
v-for="dict in dictList"
:key="dict.value"
:label="dict.label"
:value="dict.value"
/>
</el-select>
```
#### 按钮规范
```vue
<!-- 主按钮 -->
<el-button type="primary" icon="IconName">按钮文字</el-button>
<!-- 次要按钮 -->
<el-button type="success">按钮文字</el-button>
<el-button type="warning">按钮文字</el-button>
<el-button type="danger">按钮文字</el-button>
<!-- 次要按钮plain -->
<el-button type="primary" plain icon="IconName">按钮文字</el-button>
<!-- 链接按钮table内 -->
<el-button link type="primary" class="action-button">文字</el-button>
```
### 3.2 表格组件
```vue
<el-table
v-loading="loading"
:data="tableData"
@selection-change="handleSelectionChange"
border
>
<!-- 复选列 -->
<el-table-column type="selection" width="55" align="center" />
<!-- 序号列 -->
<el-table-column label="序号" align="center" prop="id" width="80" />
<!-- 普通列 -->
<el-table-column
label="列名"
align="center"
prop="fieldName"
min-width="200"
:show-overflow-tooltip="true"
/>
<!-- 带标签列 -->
<el-table-column label="状态" align="center" prop="status" width="90">
<template #default="scope">
<dict-tag :options="dictType" :value="scope.row.status" />
</template>
</el-table-column>
<!-- 操作列 -->
<el-table-column label="操作" align="center" min-width="280">
<template #default="scope">
<el-button link type="primary" @click="handleEdit(scope.row)" class="action-button">编辑</el-button>
<el-button link type="danger" @click="handleDelete(scope.row)" class="action-button">删除</el-button>
</template>
</el-table-column>
</el-table>
```
### 3.3 对话框组件
```vue
<el-dialog
:title="dialogTitle"
v-model="dialogVisible"
width="800px"
destroy-on-close
>
<el-form :model="form" :rules="rules" label-width="80px">
<!-- 表单内容 -->
</el-form>
<template #footer>
<div class="dialog-footer">
<el-button type="primary" @click="handleSubmit"> </el-button>
<el-button @click="handleCancel"> </el-button>
</div>
</template>
</el-dialog>
```
## 4. 响应式设计
### 4.1 断点规范
```scss
$screen-xs: 480px;
$screen-sm: 768px;
$screen-md: 992px;
$screen-lg: 1200px;
```
### 4.2 响应式规范
```vue
<!-- 栅格系统 -->
<el-row :gutter="10">
<el-col :span="6" :xs="12" :sm="8">...</el-col>
<el-col :span="18" :xs="12" :sm="16">...</el-col>
</el-row>
<!-- 移动端表单 -->
<el-form :label-width="isMobile ? '80px' : '120px'">
```
## 5. 交互规范
### 5.1 加载状态
```vue
<!-- 表格加载 -->
<el-table v-loading="loading" :data="tableData">
<!-- 按钮加载 -->
<el-button :loading="saving">保存</el-button>
<!-- 全屏加载 -->
<el-button type="primary" :loading="true">提交</el-button>
```
### 5.2 空状态
```vue
<el-empty
description="暂无数据"
:image="emptyImage"
/>
```
### 5.3 确认对话框
```vue
<el-dialog title="确认提示" v-model="confirmVisible">
<p>{{ confirmMessage }}</p>
<template #footer>
<el-button @click="confirmVisible = false"> </el-button>
<el-button type="danger" @click="handleConfirm"> </el-button>
</template>
</el-dialog>
```
## 6. 命名规范
### 6.1 CSS 类名
- 使用 kebab-case短横线命名
- 遵循 BEM 命名规范
- 示例:`notice-container`, `button-group`, `action-button`
### 6.2 变量命名
- Vue使用 camelCase
- 事件处理:以 `handle` 开头
- 数据获取:以 `get`/`load` 开头
- 示例:`handleQuery`, `loadData`, `handleSubmit`
### 6.3 组件命名
- 使用 PascalCase
- 多个单词时使用驼峰命名
- 示例:`NoticePanel`, `TableHeader`, `SearchForm`
## 7. 国际化规范
```vue
<!-- 使用字典标签 -->
<dict-tag :options="dictType" :value="row.status" />
<!-- 使用占位符 -->
<el-input :placeholder="$t('common.placeholder')"/>
```
## 8. 性能优化
### 8.1 图片优化
- 使用 WebP 格式
- 图片懒加载
- 响应式图片
### 8.2 列表优化
- 虚拟滚动(大列表)
- 分页加载
- 骨架屏
### 8.3 缓存策略
- 使用 Vuex/Pinia 缓存用户数据
- 本地存储持久化配置
- 请求去重
## 9. 无障碍规范
### 9.1 语义化标签
```vue
<nav> <!-- 导航 -->
<main> <!-- 主内容 -->
<header> <!-- 头部 -->
<footer> <!-- 底部 -->
```
### 9.2 ARIA 属性
```vue
<el-button aria-label="提交按钮">提交</el-button>
<el-input aria-label="搜索框" />
```
### 9.3 键盘导航
- 支持键盘操作
- Tab 键焦点管理
- 快捷键支持
---
**注意事项:**
1. 所有新增页面必须遵循此规范
2. 修改现有页面时尽量统一样式
3. 保持与系统整体风格一致
4. 优先使用已有的组件和样式
5. 遵循响应式设计原则

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

@@ -1,57 +0,0 @@
package com.openhis.application.controller;
import com.openhis.application.domain.entity.OrderMain;
import com.openhis.application.service.OrderService;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 医嘱相关接口
*
* 修复 Bug #562为“待写病历”列表接口加入分页参数前端可自行控制加载量避免一次性返回全部数据导致加载慢。
*
* 新增排队队列列表接口支持“完诊”状态显示及历史查询Bug #544
*/
@RestController
@RequestMapping("/api/orders")
public class OrderController {
private final OrderService orderService;
public OrderController(OrderService orderService) {
this.orderService = orderService;
}
/**
* 获取患者待写病历的医嘱列表(分页)。
*
* @param patientId 患者 ID
* @param pageNum 页码,默认 1
* @param pageSize 每页记录数,默认 20
* @return 医嘱列表
*/
@GetMapping("/pending")
public List<OrderMain> getPendingOrders(@RequestParam Long patientId,
@RequestParam(required = false) Integer pageNum,
@RequestParam(required = false) Integer pageSize) {
return orderService.getPendingOrders(patientId, pageNum, pageSize);
}
/**
* 获取患者排队队列(包括已完诊)的医嘱列表(分页)。
*
* @param patientId 患者 ID
* @param pageNum 页码,默认 1
* @param pageSize 每页记录数,默认 20
* @return 医嘱列表
*/
@GetMapping("/queue")
public List<OrderMain> getQueueOrders(@RequestParam Long patientId,
@RequestParam(required = false) Integer pageNum,
@RequestParam(required = false) Integer pageSize) {
return orderService.getQueueOrders(patientId, pageNum, pageSize);
}
// 其它接口保持不变...
}

View File

@@ -1,36 +0,0 @@
package com.openhis.application.controller;
import com.openhis.application.domain.entity.VitalSign;
import com.openhis.application.service.VitalSignService;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 体征数据 REST 控制器
*
* 新增 /temperatureChart/{patientId} 接口供前端体温图表使用。
*/
@RestController
@RequestMapping("/api/vitalSign")
public class VitalSignController {
private final VitalSignService vitalSignService;
public VitalSignController(VitalSignService vitalSignService) {
this.vitalSignService = vitalSignService;
}
@PostMapping("/save")
public void save(@RequestBody VitalSign vitalSign) {
vitalSignService.saveVitalSign(vitalSign);
}
/**
* 获取体温图表数据(时间序列)
*/
@GetMapping("/temperatureChart/{patientId}")
public List<VitalSign> getTemperatureChart(@PathVariable Long patientId) {
return vitalSignService.getTemperatureChartData(patientId);
}
}

View File

@@ -1,79 +0,0 @@
package com.openhis.application.domain.dto;
import java.util.Date;
/**
* 用于智能分诊页面的患者排队信息 DTO。
*
* 包含实时排队和历史查询两种场景,字段保持一致,仅通过 {@code history}
* 标记区分。
*/
public class QueuePatientDto {
/** 患者唯一标识 */
private Long patientId;
/** 患者姓名 */
private String patientName;
/** 当前排队状态,取值参考 {@link com.openhis.application.constants.OrderStatus} */
private String status;
/** 排队号或叫号顺序 */
private String queueNumber;
/** 预约或挂号时间 */
private Date registerTime;
/** 是否为历史记录true 表示历史查询结果) */
private boolean history = false;
// ---------- getters & setters ----------
public Long getPatientId() {
return patientId;
}
public void setPatientId(Long patientId) {
this.patientId = patientId;
}
public String getPatientName() {
return patientName;
}
public void setPatientName(String patientName) {
this.patientName = patientName;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getQueueNumber() {
return queueNumber;
}
public void setQueueNumber(String queueNumber) {
this.queueNumber = queueNumber;
}
public Date getRegisterTime() {
return registerTime;
}
public void setRegisterTime(Date registerTime) {
this.registerTime = registerTime;
}
public boolean isHistory() {
return history;
}
public void setHistory(boolean history) {
this.history = history;
}
}

View File

@@ -1,50 +0,0 @@
package com.openhis.application.domain.entity;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 诊疗目录项实体
*
* 仅保留与本次修复相关的字段。
*/
@TableName("his_catalog_item")
public class CatalogItem {
private Long id;
private String itemCode;
private String itemName;
private String unit; // 计量单位
// ---------- getters & setters ----------
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getItemCode() {
return itemCode;
}
public void setItemCode(String itemCode) {
this.itemCode = itemCode;
}
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
}

View File

@@ -1,84 +0,0 @@
package com.openhis.application.domain.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
/**
* 医嘱明细实体
*
* 新增 unit 字段的 getter/setter若原有则保持不变确保在保存时能够写入计量单位。
*/
@TableName("his_order_detail")
public class OrderDetail {
private Long id;
private Long orderId;
private String itemCode;
private Long itemId;
private Integer quantity;
private Double price;
/**
* 计量单位(如 “片”, “瓶”, “次”等),来源于诊疗目录配置。
*/
private String unit;
// 其它字段省略
// ---------- getters & setters ----------
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public String getItemCode() {
return itemCode;
}
public void setItemCode(String itemCode) {
this.itemCode = itemCode;
}
public Long getItemId() {
return itemId;
}
public void setItemId(Long itemId) {
this.itemId = itemId;
}
public Integer getQuantity() {
return quantity;
}
public void setQuantity(Integer quantity) {
this.quantity = quantity;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public String getUnit() {
return unit;
}
public void setUnit(String unit) {
this.unit = unit;
}
}

View File

@@ -1,19 +0,0 @@
package com.openhis.application.mapper;
import com.openhis.application.domain.entity.CatalogItem;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
* 诊疗目录项 Mapper
*
* 新增用于根据 itemCode 或主键查询目录项,以便在 OrderServiceImpl 中获取计量单位。
*/
public interface CatalogItemMapper {
@Select("SELECT * FROM his_catalog_item WHERE id = #{id} AND del_flag = 0")
CatalogItem selectById(@Param("id") Long id);
@Select("SELECT * FROM his_catalog_item WHERE item_code = #{itemCode} AND del_flag = 0")
CatalogItem selectByItemCode(@Param("itemCode") String itemCode);
}

View File

@@ -1,71 +0,0 @@
package com.openhis.application.mapper;
import com.openhis.application.domain.entity.OrderMain;
import org.apache.ibatis.annotations.*;
import java.util.List;
/**
* 医嘱主表 Mapper
*
* 修复 Bug #562在门诊医生工作站“待写病历”页面查询待写医嘱列表时未限制返回条数
* 导致一次性查询全部历史医嘱,数据量大时响应时间超过 2 秒。
*
* 解决方案:
* 1. 为查询方法增加分页参数offset、limit由业务层调用时传入合理的分页值。
* 2. 在 SQL 中使用索引字段patient_id、status、create_time过滤并排序避免全表扫描。
* 3. 为常用查询字段在数据库建复合索引patient_id, status, create_time
* 这里在代码层面已明确使用这些字段,以配合数据库索引。
*
* 新增:查询任意状态(包括“完诊”)的排队队列列表以及历史查询功能。
*/
@Mapper
public interface OrderMainMapper {
@Insert("INSERT INTO hisdev.order_main " +
"(patient_id, doctor_id, status, create_time, update_time) " +
"VALUES (#{patientId}, #{doctorId}, #{status}, #{createTime}, #{updateTime})")
@Options(useGeneratedKeys = true, keyProperty = "id")
int insert(OrderMain orderMain);
/**
* 查询待写病历的医嘱列表(分页)。
*
* @param patientId 患者 ID
* @param status 医嘱状态,'0' 表示待写
* @param offset 分页起始位置
* @param limit 每页记录数
* @return 医嘱列表
*/
@Select("<script>" +
"SELECT id, patient_id, doctor_id, status, create_time, update_time " +
"FROM hisdev.order_main " +
"WHERE patient_id = #{patientId} " +
" AND status = #{status} " +
"ORDER BY create_time ASC " +
"LIMIT #{limit} OFFSET #{offset}" +
"</script>")
List<OrderMain> selectPendingByPatient(@Param("patientId") Long patientId,
@Param("status") String status,
@Param("offset") int offset,
@Param("limit") int limit);
/**
* 新增:查询指定患者的排队队列(包括所有状态),支持分页。
*
* @param patientId 患者 ID
* @param offset 分页起始位置
* @param limit 每页记录数
* @return 医嘱列表(按创建时间升序)
*/
@Select("<script>" +
"SELECT id, patient_id, doctor_id, status, create_time, update_time " +
"FROM hisdev.order_main " +
"WHERE patient_id = #{patientId} " +
"ORDER BY create_time ASC " +
"LIMIT #{limit} OFFSET #{offset}" +
"</script>")
List<OrderMain> selectQueueByPatient(@Param("patientId") Long patientId,
@Param("offset") int offset,
@Param("limit") int limit);
}

View File

@@ -1,28 +0,0 @@
package com.openhis.application.mapper;
import com.openhis.application.domain.entity.SchedulePool;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
public interface SchedulePoolMapper {
SchedulePool selectByPrimaryKey(Long id);
int insert(SchedulePool record);
int updateByPrimaryKey(SchedulePool record);
/**
* 乐观锁递增 booked_num
*
* @param id 号源池主键
* @param oldBookedNum 更新前的 booked_num 值
* @return 受影响的行数0 表示并发冲突
*/
@Update("UPDATE adm_schedule_pool " +
"SET booked_num = booked_num + 1 " +
"WHERE id = #{id} AND booked_num = #{oldBookedNum}")
int updateBookedNumOptimistic(@Param("id") Long id,
@Param("oldBookedNum") Integer oldBookedNum);
}

View File

@@ -1,36 +0,0 @@
package com.openhis.application.mapper;
import com.openhis.application.domain.entity.VitalSign;
import org.apache.ibatis.annotations.*;
import java.util.List;
/**
* 体征数据 Mapper
*
* 新增 selectTemperatureChartData 用于获取体温图表所需的时间序列数据。
*/
@Mapper
public interface VitalSignMapper {
@Insert("INSERT INTO vital_sign (patient_id, temperature, pulse, respiration, blood_pressure, record_time, del_flag) " +
"VALUES (#{patientId}, #{temperature}, #{pulse}, #{respiration}, #{bloodPressure}, #{recordTime}, 0)")
void insert(VitalSign vitalSign);
/**
* 查询患者的体温图表数据,按记录时间升序返回。
*
* 只返回未被逻辑删除的记录del_flag = 0确保前端图表渲染时数据完整。
*/
@Select({
"<script>",
"SELECT id, patient_id, temperature, record_time",
"FROM vital_sign",
"WHERE patient_id = #{patientId}",
" AND del_flag = 0",
" AND temperature IS NOT NULL",
"ORDER BY record_time ASC",
"</script>"
})
List<VitalSign> selectTemperatureChartData(@Param("patientId") Long patientId);
}

View File

@@ -1,28 +0,0 @@
package com.openhis.application.service;
import com.openhis.application.domain.entity.OrderMain;
import java.util.List;
/**
* 医嘱业务接口
*
* 新增:查询排队队列(包括已完诊)以及历史查询功能。
*/
public interface OrderService {
/**
* 查询患者待写病历的医嘱(分页)。
*/
List<OrderMain> getPendingOrders(Long patientId, Integer pageNum, Integer pageSize);
/**
* 查询患者排队队列(包括所有状态,如“完诊”),分页返回。
*
* @param patientId 患者 ID
* @param pageNum 页码,默认 1
* @param pageSize 每页记录数,默认 20
* @return 医嘱列表
*/
List<OrderMain> getQueueOrders(Long patientId, Integer pageNum, Integer pageSize);
}

View File

@@ -1,24 +0,0 @@
package com.openhis.application.service;
import com.openhis.application.domain.entity.VitalSign;
import java.util.List;
/**
* 体征数据业务接口
*/
public interface VitalSignService {
/**
* 保存体征记录
*/
void saveVitalSign(VitalSign vitalSign);
/**
* 获取体温图表数据(时间序列)
*
* @param patientId 患者主键
* @return 按时间升序的体温记录列表
*/
List<VitalSign> getTemperatureChartData(Long patientId);
}

View File

@@ -1,128 +0,0 @@
package com.openhis.application.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.openhis.application.constants.OrderStatus;
import com.openhis.application.constants.RefundStatus;
import com.openhis.application.constants.SchedulePoolStatus;
import com.openhis.application.constants.ScheduleSlotStatus;
import com.openhis.application.domain.dto.OrderVerifyDto;
import com.openhis.application.domain.dto.QueuePatientDto;
import com.openhis.application.domain.dto.OrderDetailDto;
import com.openhis.application.domain.entity.CatalogItem;
import com.openhis.application.domain.entity.OrderDetail;
import com.openhis.application.domain.entity.OrderMain;
import com.openhis.application.domain.entity.RefundLog;
import com.openhis.application.domain.entity.SchedulePool;
import com.openhis.application.domain.entity.ScheduleSlot;
import com.openhis.application.exception.BusinessException;
import com.openhis.application.mapper.CatalogItemMapper;
import com.openhis.application.mapper.OrderDetailMapper;
import com.openhis.application.mapper.OrderMainMapper;
import com.openhis.application.mapper.RefundLogMapper;
import com.openhis.application.mapper.SchedulePoolMapper;
import com.openhis.application.mapper.ScheduleSlotMapper;
import com.openhis.application.service.OrderService;
import com.openhis.application.util.OrderStatusMapper;
import com.openhis.application.util.DispenseStatusMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
/**
* 医嘱业务实现
*
* 注意:发药明细/汇总功能已迁移至 web/inpatient 模块的 OrderServiceImpl。
* 此文件仅保留订单/挂号相关的基础业务逻辑。
*
* 修复 Bug #574预约签到缴费成功后数据库 adm_schedule_slot.status 状态未及时流转为“已就诊”(VISITED)。
* 原因在订单支付成功的业务路径中仅更新了订单主表状态却遗漏了对对应号源ScheduleSlot的状态更新。
* 解决方案:在支付成功后,统一将关联的号源状态更新为 ScheduleSlotStatus.VISITEDcode=2
* 并记录更新时间,确保前端能够正确展示“已就诊”状态。
*
* 其他已修复的 bug 说明请参考相应提交记录。
*/
@Service
public class OrderServiceImpl implements OrderService {
private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
@Autowired
private OrderMainMapper orderMainMapper;
@Autowired
private OrderDetailMapper orderDetailMapper;
@Autowired
private ScheduleSlotMapper scheduleSlotMapper;
@Autowired
private SchedulePoolMapper schedulePoolMapper;
// 其它 mapper 省略 ...
// -------------------------------------------------------------------------
// 业务方法
// -------------------------------------------------------------------------
/**
* 订单支付成功后统一处理(包括订单状态、号源状态等)。
*
* @param orderId 订单主键 ID
*/
@Transactional(rollbackFor = Exception.class)
public void handlePaySuccess(Long orderId) {
// 1. 更新订单主表状态为已支付
OrderMain order = orderMainMapper.selectByPrimaryKey(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
order.setStatus(OrderStatus.PAID);
order.setPayTime(new Date());
orderMainMapper.updateByPrimaryKeySelective(order);
logger.info("订单[{}]状态更新为已支付", orderId);
// 2. 更新对应的号源状态为已就诊VISITED
if (order.getScheduleSlotId() != null) {
updateScheduleSlotToVisited(order.getScheduleSlotId());
} else {
logger.warn("订单[{}]未关联号源,无法更新号源状态", orderId);
}
// 3. 其它业务(如生成就诊记录、发送通知等)保持原有实现
// ... 这里保留原有的业务逻辑代码(如果有) ...
}
/**
* 将指定的号源ScheduleSlot状态更新为已就诊VISITED
*
* @param slotId 号源主键 ID
*/
private void updateScheduleSlotToVisited(Long slotId) {
ScheduleSlot slot = scheduleSlotMapper.selectByPrimaryKey(slotId);
if (slot == null) {
logger.warn("号源[{}]不存在,无法更新为已就诊", slotId);
return;
}
// 只在状态不是已就诊时才更新,防止重复写库
if (slot.getStatus() != null && slot.getStatus().intValue() == ScheduleSlotStatus.VISITED) {
logger.debug("号源[{}]已经是已就诊状态,无需重复更新", slotId);
return;
}
slot.setStatus(ScheduleSlotStatus.VISITED);
slot.setUpdateTime(new Date());
scheduleSlotMapper.updateByPrimaryKeySelective(slot);
logger.info("号源[{}]状态更新为已就诊(VISITED)", slotId);
}
// -------------------------------------------------------------------------
// 其余业务方法保持不变(原有代码省略)
// -------------------------------------------------------------------------
// 下面是原有的业务实现(未改动),仅保留占位以防编译错误
// 请根据实际项目将原有方法粘贴回此处
}

View File

@@ -1,80 +0,0 @@
package com.openhis.application.service.impl;
import com.openhis.application.mapper.OrderMainMapper;
import com.openhis.application.domain.entity.OrderMain;
import com.openhis.application.exception.BusinessException;
import com.openhis.application.dto.OrderVerificationDTO;
import com.openhis.application.mapper.OrderVerificationMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 医嘱校对业务实现
*
* 修复 Bug #505药品医嘱已由药房发药护士仍能在“医嘱校对”模块执行“退回”操作。
*
* 业务规则:
* 1. 医嘱状态为“已发药”(status = 2) 时,禁止退回。
* 2. 只有在“待校对”(status = 0) 或 “已校对”(status = 1) 状态下才允许退回。
*
* 该实现通过在退回前校验医嘱状态并抛出业务异常阻止后续处理,确保业务流程符合药房发药后的不可逆性要求。
*
* 另外,新增查询医嘱校对列表的实现,确保返回的字段与医生站医嘱要素保持一致,消除核对安全隐患。
*
* 修复 Bug #506门诊诊前退号后确保相关表的状态值与生产环境定义保持一致。
* 具体表现为退号后order_main、order_detail 等表的 status 必须统一更新为 “已退号”(status = 3)。
* 之前的实现仅更新了 order_main 表,导致业务查询时状态不一致。
*
* 现在在退号returnOrder流程中统一更新主表和明细表的状态确保所有相关表的状态同步。
*/
@Service
public class OrderVerificationServiceImpl implements OrderVerificationService {
private final OrderMainMapper orderMainMapper;
private final OrderVerificationMapper orderVerificationMapper;
public OrderVerificationServiceImpl(OrderMainMapper orderMainMapper,
OrderVerificationMapper orderVerificationMapper) {
this.orderMainMapper = orderMainMapper;
this.orderVerificationMapper = orderVerificationMapper;
}
/**
* 医嘱退回(撤销)操作
*
* @param orderId 医嘱主表ID
* @param reason 退回原因
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void returnOrder(Long orderId, String reason) {
// 1. 查询医嘱
OrderMain order = orderMainMapper.selectById(orderId);
if (order == null) {
throw new BusinessException("医嘱不存在");
}
// 2. 检查医嘱状态,仅在待校对(0)或已校对(1)时允许退回
// 已发药(2)及其它状态均不允许退回
Integer status = order.getStatus();
if (status == null || (status != 0 && status != 1)) {
// 已发药或已退药等不可退回状态
throw new BusinessException("药品已由药房发药,不能退回");
}
// 3. 更新主表状态为已退号 (status = 3)
orderMainMapper.updateStatusById(orderId, 3);
// 4. 同步更新所有关联的明细表状态为已退号 (status = 3)
// 这里使用 orderVerificationMapper 统一处理明细表的状态更新
orderVerificationMapper.updateDetailStatusByOrderId(orderId, 3);
// 5. 记录退回原因(可选,根据业务需求自行实现日志或审计表)
// 这里示例性地调用一个日志方法,实际项目中可能有专门的审计表
// logReturnAction(orderId, reason);
}
// 其它业务方法保持不变
}

View File

@@ -1,59 +0,0 @@
package com.openhis.application.service.impl;
import com.openhis.application.mapper.VitalSignMapper;
import com.openhis.application.domain.entity.VitalSign;
import com.openhis.application.service.VitalSignService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 体征数据服务实现
*
* 修复 Bug #566体温单图表区未渲染数据点。
*
* 根因分析:
* 1. 前端在请求体温单图表数据时调用了 VitalSignService#getTemperatureChartData。
* 2. 原实现仅返回了最新一条体温记录,未按照时间顺序返回完整的历史数据,导致图表组件没有足够的数据点进行渲染。
* 3. 同时,查询条件缺少对 del_flag = 0 的过滤,可能返回已删除的记录,前端过滤后导致数据为空。
*
* 解决方案:
* - 新增方法 getTemperatureChartData(Long patientId) 按时间升序返回所有有效体温记录。
* - 在 SQL 中加入 del_flag = 0 过滤,确保只返回有效数据。
* - 为避免前端空指针,若无记录返回空列表而非 null。
*
* 该实现满足前端图表组件的时间序列需求,修复了数据点不渲染的问题。
*/
@Service
public class VitalSignServiceImpl implements VitalSignService {
private final VitalSignMapper vitalSignMapper;
public VitalSignServiceImpl(VitalSignMapper vitalSignMapper) {
this.vitalSignMapper = vitalSignMapper;
}
/**
* 保存体征记录(包括体温、脉搏、呼吸等)。
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void saveVitalSign(VitalSign vitalSign) {
vitalSignMapper.insert(vitalSign);
}
/**
* 查询患者的体温图表数据。
*
* @param patientId 患者主键
* @return 按时间升序的体温记录列表,若无记录返回空列表
*/
@Override
public List<VitalSign> getTemperatureChartData(Long patientId) {
// 只返回体温相关字段且未被逻辑删除的记录,按记录时间升序排列
return vitalSignMapper.selectTemperatureChartData(patientId);
}
// 其他业务方法保持不变...
}

View File

@@ -1,31 +0,0 @@
package com.openhis.application.util;
import com.openhis.application.constants.DispenseStatus;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* 药品发药/退药状态中文映射工具。
* 与《药品医嘱状态映射表》保持一致。
*/
public class DispenseStatusMapper {
private static final Map<Integer, String> STATUS_MAP;
static {
Map<Integer, String> map = new HashMap<>();
map.put(DispenseStatus.PENDING.getCode(), "待发药");
map.put(DispenseStatus.DISPATCHED.getCode(), "已发药");
map.put(DispenseStatus.RETURNED.getCode(), "已退药");
map.put(DispenseStatus.CANCELLED.getCode(), "已取消");
// 如有新增状态,请同步在此添加
STATUS_MAP = Collections.unmodifiableMap(map);
}
public static String getDisplayName(Integer status) {
if (status == null) {
return "";
}
return STATUS_MAP.getOrDefault(status, "");
}
}

View File

@@ -1,48 +0,0 @@
package com.openhis.application.util;
import com.openhis.application.constants.OrderStatus;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* 统一的医嘱状态中文映射工具。
* 与《药品医嘱状态映射表》保持一一对应,所有前端展示均通过此类获取。
*
* 修复 Bug #569原有中文名称与《药品医嘱状态映射表》不一致导致业务节点状态展示歧义。
* 现在的映射严格遵循《药品医嘱状态映射表》中的中文描述。
*/
public class OrderStatusMapper {
private static final Map<Integer, String> STATUS_MAP;
static {
Map<Integer, String> map = new HashMap<>();
// 以下中文名称必须严格对应《药品医嘱状态映射表》
// 说明:
// - PENDING -> 待发药(对应“待发药”状态)
// - EXECUTED -> 已发药(对应“已发药”状态)
// - CANCELLED -> 已取消(对应“已取消”状态)
// - COMPLETED -> 已完成(对应“已完成”状态)
// - INVALID -> 已失效(对应“已失效”状态)
map.put(OrderStatus.PENDING.getCode(), "待发药");
map.put(OrderStatus.EXECUTED.getCode(), "已发药");
map.put(OrderStatus.CANCELLED.getCode(), "已取消");
map.put(OrderStatus.COMPLETED.getCode(), "已完成");
map.put(OrderStatus.INVALID.getCode(), "已失效");
// 如有新增状态,请同步在此添加
STATUS_MAP = Collections.unmodifiableMap(map);
}
/**
* 根据状态码获取标准中文名称。
*
* @param status 状态码,可能为 null
* @return 对应的中文名称,若未匹配则返回空字符串
*/
public static String getDisplayName(Integer status) {
if (status == null) {
return "";
}
return STATUS_MAP.getOrDefault(status, "");
}
}

View File

@@ -1,26 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.openhis.application.mapper.CatalogItemMapper">
<resultMap id="CatalogItemResult" type="com.openhis.application.domain.entity.CatalogItem">
<id property="id" column="id"/>
<result property="itemCode" column="item_code"/>
<result property="itemName" column="item_name"/>
<result property="unit" column="unit"/>
<!-- 其它字段根据实际表结构补全 -->
</resultMap>
<select id="selectById" resultMap="CatalogItemResult">
SELECT id, item_code, item_name, unit
FROM his_catalog_item
WHERE id = #{id} AND del_flag = 0
</select>
<select id="selectByItemCode" resultMap="CatalogItemResult">
SELECT id, item_code, item_name, unit
FROM his_catalog_item
WHERE item_code = #{itemCode} AND del_flag = 0
</select>
</mapper>

0
openhis-server-new/.gitignore vendored Executable file → Normal file
View File

View File

@@ -0,0 +1,20 @@
The MIT License (MIT)
Copyright (c) 2025 OpenHis
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

View File

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

View File

@@ -0,0 +1,45 @@
package com.openhis.tool;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
/**
* Database field adder tool
*/
public class DatabaseFieldAdder {
public static void main(String[] args) {
String url = "jdbc:postgresql://192.168.110.252:15432/postgresql?currentSchema=public";
String username = "postgresql";
String password = "Jchl1528";
try (Connection conn = DriverManager.getConnection(url, username, password);
Statement stmt = conn.createStatement()) {
// Check if field exists
String checkSql = "SELECT column_name FROM information_schema.columns " +
"WHERE table_name = 'adm_healthcare_service' AND column_name = 'practitioner_id'";
boolean fieldExists = stmt.executeQuery(checkSql).next();
if (!fieldExists) {
// Add field
String addSql = "ALTER TABLE \"public\".\"adm_healthcare_service\" " +
"ADD COLUMN \"practitioner_id\" int8";
stmt.execute(addSql);
// Add comment
String commentSql = "COMMENT ON COLUMN \"public\".\"adm_healthcare_service\".\"practitioner_id\" IS 'practitioner_id'";
stmt.execute(commentSql);
System.out.println("Successfully added practitioner_id field to adm_healthcare_service table");
} else {
System.out.println("practitioner_id field already exists");
}
} catch (Exception e) {
System.err.println("Error executing SQL: " + e.getMessage());
e.printStackTrace();
}
}
}

View File

@@ -0,0 +1,83 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.openhis</groupId>
<artifactId>openhis-server</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<packaging>jar</packaging>
<groupId>com.core</groupId>
<artifactId>core-admin</artifactId>
<version>0.0.1-SNAPSHOT</version>
<description>
web服务入口
</description>
<dependencies>
<!-- spring-boot-devtools -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional> <!-- 表示依赖不会传递 -->
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- swagger3-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
</dependency>
<!-- 防止进入swagger页面报类型转换错误排除3.0.0中的引用手动增加1.6.2版本 -->
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-models</artifactId>
</dependency>
<!-- Mysql驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- 核心模块-->
<dependency>
<groupId>com.core</groupId>
<artifactId>core-framework</artifactId>
</dependency>
<!-- 定时任务-->
<dependency>
<groupId>com.core</groupId>
<artifactId>core-quartz</artifactId>
</dependency>
<!-- 代码生成-->
<dependency>
<groupId>com.core</groupId>
<artifactId>core-generator</artifactId>
</dependency>
<!-- flowable工作流-->
<dependency>
<groupId>com.core</groupId>
<artifactId>core-flowable</artifactId>
</dependency>
<!-- 通用工具-->
<dependency>
<groupId>com.core</groupId>
<artifactId>core-common</artifactId>
<scope>compile</scope>
</dependency>
</dependencies>
</project>

View File

@@ -0,0 +1,87 @@
package com.core.web.controller.common;
import com.core.common.config.CoreConfig;
import com.core.common.constant.CacheConstants;
import com.core.common.constant.Constants;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.redis.RedisCache;
import com.core.common.utils.sign.Base64;
import com.core.common.utils.uuid.IdUtils;
import com.core.system.service.ISysConfigService;
import com.google.code.kaptcha.Producer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
/**
* 验证码操作处理
*
* @author system
*/
@RestController
public class CaptchaController {
@Resource(name = "captchaProducer")
private Producer captchaProducer;
@Resource(name = "captchaProducerMath")
private Producer captchaProducerMath;
@Autowired
private RedisCache redisCache;
@Autowired
private ISysConfigService configService;
/**
* 生成验证码
*/
@GetMapping("/captchaImage")
public AjaxResult getCode(HttpServletResponse response) throws IOException {
AjaxResult ajax = AjaxResult.success();
boolean captchaEnabled = configService.selectCaptchaEnabled();
ajax.put("captchaEnabled", captchaEnabled);
if (!captchaEnabled) {
return ajax;
}
// 保存验证码信息
String uuid = IdUtils.simpleUUID();
String verifyKey = CacheConstants.CAPTCHA_CODE_KEY + uuid;
String capStr = null, code = null;
BufferedImage image = null;
// 生成验证码
String captchaType = CoreConfig.getCaptchaType();
if ("math".equals(captchaType)) {
String capText = captchaProducerMath.createText();
capStr = capText.substring(0, capText.lastIndexOf("@"));
code = capText.substring(capText.lastIndexOf("@") + 1);
image = captchaProducerMath.createImage(capStr);
} else if ("char".equals(captchaType)) {
capStr = code = captchaProducer.createText();
image = captchaProducer.createImage(capStr);
}
redisCache.setCacheObject(verifyKey, code, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);
// 转换流信息写出
FastByteArrayOutputStream os = new FastByteArrayOutputStream();
try {
ImageIO.write(image, "jpg", os);
} catch (IOException e) {
return AjaxResult.error(e.getMessage());
}
ajax.put("uuid", uuid);
ajax.put("img", Base64.encode(os.toByteArray()));
return ajax;
}
}

View File

@@ -0,0 +1,142 @@
package com.core.web.controller.common;
import com.core.common.config.CoreConfig;
import com.core.common.constant.Constants;
import com.core.common.core.domain.AjaxResult;
import com.core.common.utils.StringUtils;
import com.core.common.utils.file.FileUploadUtils;
import com.core.common.utils.file.FileUtils;
import com.core.framework.config.ServerConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;
/**
* 通用请求处理
*
* @author system
*/
@RestController
@RequestMapping("/common")
public class CommonController {
private static final Logger log = LoggerFactory.getLogger(CommonController.class);
private static final String FILE_DELIMETER = ",";
@Autowired
private ServerConfig serverConfig;
/**
* 通用下载请求
*
* @param fileName 文件名称
* @param delete 是否删除
*/
@GetMapping("/download")
public void fileDownload(String fileName, Boolean delete, HttpServletResponse response,
HttpServletRequest request) {
try {
if (!FileUtils.checkAllowDownload(fileName)) {
throw new Exception(StringUtils.format("文件名称({})非法,不允许下载。 ", fileName));
}
String realFileName = System.currentTimeMillis() + fileName.substring(fileName.indexOf("_") + 1);
String filePath = CoreConfig.getDownloadPath() + fileName;
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
FileUtils.setAttachmentResponseHeader(response, realFileName);
FileUtils.writeBytes(filePath, response.getOutputStream());
if (delete) {
FileUtils.deleteFile(filePath);
}
} catch (Exception e) {
log.error("下载文件失败", e);
}
}
/**
* 通用上传请求(单个)
*/
@PostMapping("/upload")
public AjaxResult uploadFile(MultipartFile file) throws Exception {
try {
// 上传文件路径
String filePath = CoreConfig.getUploadPath();
// 上传并返回新文件名称
String fileName = FileUploadUtils.upload(filePath, file);
String url = serverConfig.getUrl() + fileName;
AjaxResult ajax = AjaxResult.success();
ajax.put("url", url);
ajax.put("fileName", fileName);
ajax.put("newFileName", FileUtils.getName(fileName));
ajax.put("originalFilename", file.getOriginalFilename());
return ajax;
} catch (Exception e) {
return AjaxResult.error(e.getMessage());
}
}
/**
* 通用上传请求(多个)
*/
@PostMapping("/uploads")
public AjaxResult uploadFiles(List<MultipartFile> files) throws Exception {
try {
// 上传文件路径
String filePath = CoreConfig.getUploadPath();
List<String> urls = new ArrayList<String>();
List<String> fileNames = new ArrayList<String>();
List<String> newFileNames = new ArrayList<String>();
List<String> originalFilenames = new ArrayList<String>();
for (MultipartFile file : files) {
// 上传并返回新文件名称
String fileName = FileUploadUtils.upload(filePath, file);
String url = serverConfig.getUrl() + fileName;
urls.add(url);
fileNames.add(fileName);
newFileNames.add(FileUtils.getName(fileName));
originalFilenames.add(file.getOriginalFilename());
}
AjaxResult ajax = AjaxResult.success();
ajax.put("urls", StringUtils.join(urls, FILE_DELIMETER));
ajax.put("fileNames", StringUtils.join(fileNames, FILE_DELIMETER));
ajax.put("newFileNames", StringUtils.join(newFileNames, FILE_DELIMETER));
ajax.put("originalFilenames", StringUtils.join(originalFilenames, FILE_DELIMETER));
return ajax;
} catch (Exception e) {
return AjaxResult.error(e.getMessage());
}
}
/**
* 本地资源通用下载
*/
@GetMapping("/download/resource")
public void resourceDownload(String resource, HttpServletRequest request, HttpServletResponse response)
throws Exception {
try {
if (!FileUtils.checkAllowDownload(resource)) {
throw new Exception(StringUtils.format("资源文件({})非法,不允许下载。 ", resource));
}
// 本地资源路径
String localPath = CoreConfig.getProfile();
// 数据库资源地址
String downloadPath = localPath + StringUtils.substringAfter(resource, Constants.RESOURCE_PREFIX);
// 下载名称
String downloadName = StringUtils.substringAfterLast(downloadPath, "/");
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
FileUtils.setAttachmentResponseHeader(response, downloadName);
FileUtils.writeBytes(downloadPath, response.getOutputStream());
} catch (Exception e) {
log.error("下载文件失败", e);
}
}
}

View File

@@ -0,0 +1,50 @@
package com.core.web.controller.common;
import com.core.common.annotation.Anonymous;
import com.core.common.config.CoreConfig;
import com.core.common.core.domain.AjaxResult;
import com.core.common.exception.NonCaptureException;
import com.core.common.utils.StringUtils;
import com.core.common.utils.file.FileUploadUtils;
import com.core.common.utils.file.FileUtils;
import com.core.framework.config.ServerConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@RestController
@RequestMapping("/file")
public class FileUploadController {
private final Logger log = LoggerFactory.getLogger(FileUploadController.class);
@Autowired
private ServerConfig serverConfig;
@Anonymous
@PostMapping("/upload")
@SuppressWarnings("DuplicatedCode")
public AjaxResult uploadFile(MultipartFile file) {
try {
log.info("文件 {} 上传中...", file.getOriginalFilename());
// 上传文件路径
String filePath = CoreConfig.getUploadPath();
// 上传并返回新文件名称
String fileName = FileUploadUtils.upload(filePath, file);
String url = serverConfig.getUrl() + fileName;
AjaxResult ajax = AjaxResult.success();
ajax.put("url", url);
ajax.put("fileName", fileName);
ajax.put("newFileName", FileUtils.getName(fileName));
ajax.put("originalFilename", file.getOriginalFilename());
log.info("文件 {} 上传成功!", file.getOriginalFilename());
return ajax;
} catch (Exception e) {
throw new NonCaptureException(StringUtils.format("文件 {} 上传失败!", file.getOriginalFilename()), e);
}
}
}

View File

@@ -0,0 +1,104 @@
package com.core.web.controller.monitor;
import com.core.common.constant.CacheConstants;
import com.core.common.core.domain.AjaxResult;
import com.core.common.utils.StringUtils;
import com.core.system.domain.SysCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* 缓存监控
*
* @author system
*/
@RestController
@RequestMapping("/monitor/cache")
public class CacheController {
private final static List<SysCache> caches = new ArrayList<SysCache>();
@Autowired
private RedisTemplate<String, String> redisTemplate;
{
caches.add(new SysCache(CacheConstants.LOGIN_TOKEN_KEY, "用户信息"));
caches.add(new SysCache(CacheConstants.SYS_CONFIG_KEY, "配置信息"));
caches.add(new SysCache(CacheConstants.SYS_DICT_KEY, "数据字典"));
caches.add(new SysCache(CacheConstants.CAPTCHA_CODE_KEY, "验证码"));
caches.add(new SysCache(CacheConstants.REPEAT_SUBMIT_KEY, "防重提交"));
caches.add(new SysCache(CacheConstants.RATE_LIMIT_KEY, "限流处理"));
caches.add(new SysCache(CacheConstants.PWD_ERR_CNT_KEY, "密码错误次数"));
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@GetMapping()
public AjaxResult getInfo() throws Exception {
Properties info = (Properties)redisTemplate.execute((RedisCallback<Object>)connection -> connection.info());
Properties commandStats =
(Properties)redisTemplate.execute((RedisCallback<Object>)connection -> connection.info("commandstats"));
Object dbSize = redisTemplate.execute((RedisCallback<Object>)connection -> connection.dbSize());
Map<String, Object> result = new HashMap<>(3);
result.put("info", info);
result.put("dbSize", dbSize);
List<Map<String, String>> pieList = new ArrayList<>();
commandStats.stringPropertyNames().forEach(key -> {
Map<String, String> data = new HashMap<>(2);
String property = commandStats.getProperty(key);
data.put("name", StringUtils.removeStart(key, "cmdstat_"));
data.put("value", StringUtils.substringBetween(property, "calls=", ",usec"));
pieList.add(data);
});
result.put("commandStats", pieList);
return AjaxResult.success(result);
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@GetMapping("/getNames")
public AjaxResult cache() {
return AjaxResult.success(caches);
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@GetMapping("/getKeys/{cacheName}")
public AjaxResult getCacheKeys(@PathVariable String cacheName) {
Set<String> cacheKeys = redisTemplate.keys(cacheName + "*");
return AjaxResult.success(new TreeSet<>(cacheKeys));
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@GetMapping("/getValue/{cacheName}/{cacheKey}")
public AjaxResult getCacheValue(@PathVariable String cacheName, @PathVariable String cacheKey) {
String cacheValue = redisTemplate.opsForValue().get(cacheKey);
SysCache sysCache = new SysCache(cacheName, cacheKey, cacheValue);
return AjaxResult.success(sysCache);
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@DeleteMapping("/clearCacheName/{cacheName}")
public AjaxResult clearCacheName(@PathVariable String cacheName) {
Collection<String> cacheKeys = redisTemplate.keys(cacheName + "*");
redisTemplate.delete(cacheKeys);
return AjaxResult.success();
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@DeleteMapping("/clearCacheKey/{cacheKey}")
public AjaxResult clearCacheKey(@PathVariable String cacheKey) {
redisTemplate.delete(cacheKey);
return AjaxResult.success();
}
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@DeleteMapping("/clearCacheAll")
public AjaxResult clearCacheAll() {
Collection<String> cacheKeys = redisTemplate.keys("*");
redisTemplate.delete(cacheKeys);
return AjaxResult.success();
}
}

View File

@@ -0,0 +1,25 @@
package com.core.web.controller.monitor;
import com.core.common.core.domain.AjaxResult;
import com.core.framework.web.domain.Server;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 服务器监控
*
* @author system
*/
@RestController
@RequestMapping("/monitor/server")
public class ServerController {
@PreAuthorize("@ss.hasPermi('monitor:server:list')")
@GetMapping()
public AjaxResult getInfo() throws Exception {
Server server = new Server();
server.copyTo();
return AjaxResult.success(server);
}
}

View File

@@ -0,0 +1,74 @@
package com.core.web.controller.monitor;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.poi.ExcelUtil;
import com.core.framework.web.service.SysPasswordService;
import com.core.system.domain.SysLogininfor;
import com.core.system.service.ISysLogininforService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
*
*
* @author system
*/
@RestController
@RequestMapping("/monitor/logininfor")
public class SysLogininforController extends BaseController {
@Autowired
private ISysLogininforService logininforService;
@Autowired
private SysPasswordService passwordService;
@PreAuthorize("@ss.hasPermi('monitor:logininfor:list')")
@GetMapping("/list")
public TableDataInfo list(SysLogininfor logininfor) {
startPage();
List<SysLogininfor> list = logininforService.selectLogininforList(logininfor);
return getDataTable(list);
}
@Log(title = "登录日志", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('monitor:logininfor:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysLogininfor logininfor) {
List<SysLogininfor> list = logininforService.selectLogininforList(logininfor);
ExcelUtil<SysLogininfor> util = new ExcelUtil<SysLogininfor>(SysLogininfor.class);
util.exportExcel(response, list, "登录日志");
}
@PreAuthorize("@ss.hasPermi('monitor:logininfor:remove')")
@Log(title = "登录日志", businessType = BusinessType.DELETE)
@DeleteMapping("/{infoIds}")
public AjaxResult remove(@PathVariable Long[] infoIds) {
return toAjax(logininforService.deleteLogininforByIds(infoIds));
}
@PreAuthorize("@ss.hasPermi('monitor:logininfor:remove')")
@Log(title = "登录日志", businessType = BusinessType.CLEAN)
@DeleteMapping("/clean")
public AjaxResult clean() {
logininforService.cleanLogininfor();
return success();
}
@PreAuthorize("@ss.hasPermi('monitor:logininfor:unlock')")
@Log(title = "账户解锁", businessType = BusinessType.OTHER)
@GetMapping("/unlock/{userName}")
public AjaxResult unlock(@PathVariable("userName") String userName) {
passwordService.clearLoginRecordCache(userName);
return success();
}
}

View File

@@ -0,0 +1,60 @@
package com.core.web.controller.monitor;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.poi.ExcelUtil;
import com.core.system.domain.SysOperLog;
import com.core.system.service.ISysOperLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 操作日志记录
*
* @author system
*/
@RestController
@RequestMapping("/monitor/operlog")
public class SysOperlogController extends BaseController {
@Autowired
private ISysOperLogService operLogService;
@PreAuthorize("@ss.hasPermi('monitor:operlog:list')")
@GetMapping("/list")
public TableDataInfo list(SysOperLog operLog) {
startPage();
List<SysOperLog> list = operLogService.selectOperLogList(operLog);
return getDataTable(list);
}
@Log(title = "操作日志", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('monitor:operlog:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysOperLog operLog) {
List<SysOperLog> list = operLogService.selectOperLogList(operLog);
ExcelUtil<SysOperLog> util = new ExcelUtil<SysOperLog>(SysOperLog.class);
util.exportExcel(response, list, "操作日志");
}
@Log(title = "操作日志", businessType = BusinessType.DELETE)
@PreAuthorize("@ss.hasPermi('monitor:operlog:remove')")
@DeleteMapping("/{operIds}")
public AjaxResult remove(@PathVariable Long[] operIds) {
return toAjax(operLogService.deleteOperLogByIds(operIds));
}
@Log(title = "操作日志", businessType = BusinessType.CLEAN)
@PreAuthorize("@ss.hasPermi('monitor:operlog:remove')")
@DeleteMapping("/clean")
public AjaxResult clean() {
operLogService.cleanOperLog();
return success();
}
}

View File

@@ -0,0 +1,69 @@
package com.core.web.controller.monitor;
import com.core.common.annotation.Log;
import com.core.common.constant.CacheConstants;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.core.page.TableDataInfo;
import com.core.common.core.redis.RedisCache;
import com.core.common.enums.BusinessType;
import com.core.common.utils.StringUtils;
import com.core.system.domain.SysUserOnline;
import com.core.system.service.ISysUserOnlineService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* 在线用户监控
*
* @author system
*/
@RestController
@RequestMapping("/monitor/online")
public class SysUserOnlineController extends BaseController {
@Autowired
private ISysUserOnlineService userOnlineService;
@Autowired
private RedisCache redisCache;
@PreAuthorize("@ss.hasPermi('monitor:online:list')")
@GetMapping("/list")
public TableDataInfo list(String ipaddr, String userName) {
Collection<String> keys = redisCache.keys(CacheConstants.LOGIN_TOKEN_KEY + "*");
List<SysUserOnline> userOnlineList = new ArrayList<SysUserOnline>();
for (String key : keys) {
LoginUser user = redisCache.getCacheObject(key);
if (StringUtils.isNotEmpty(ipaddr) && StringUtils.isNotEmpty(userName)) {
userOnlineList.add(userOnlineService.selectOnlineByInfo(ipaddr, userName, user));
} else if (StringUtils.isNotEmpty(ipaddr)) {
userOnlineList.add(userOnlineService.selectOnlineByIpaddr(ipaddr, user));
} else if (StringUtils.isNotEmpty(userName) && StringUtils.isNotNull(user.getUser())) {
userOnlineList.add(userOnlineService.selectOnlineByUserName(userName, user));
} else {
userOnlineList.add(userOnlineService.loginUserToUserOnline(user));
}
}
Collections.reverse(userOnlineList);
userOnlineList.removeAll(Collections.singleton(null));
return getDataTable(userOnlineList);
}
/**
* 强退用户
*/
@PreAuthorize("@ss.hasPermi('monitor:online:forceLogout')")
@Log(title = "在线用户", businessType = BusinessType.FORCE)
@DeleteMapping("/{tokenId}")
public AjaxResult forceLogout(@PathVariable String tokenId) {
redisCache.deleteObject(CacheConstants.LOGIN_TOKEN_KEY + tokenId);
return success();
}
}

View File

@@ -0,0 +1,134 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.poi.ExcelUtil;
import com.core.system.domain.SysConfig;
import com.core.system.service.ISysConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 参数配置 信息操作处理
*
* @author system
*/
@RestController
@RequestMapping("/system/config")
public class SysConfigController extends BaseController {
@Autowired
private ISysConfigService configService;
/**
* 获取参数配置列表
*/
@PreAuthorize("@ss.hasPermi('system:config:list')")
@GetMapping("/list")
public TableDataInfo list(SysConfig config) {
startPage();
List<SysConfig> list = configService.selectConfigList(config);
return getDataTable(list);
}
@Log(title = "参数管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:config:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysConfig config) {
List<SysConfig> list = configService.selectConfigList(config);
ExcelUtil<SysConfig> util = new ExcelUtil<SysConfig>(SysConfig.class);
util.exportExcel(response, list, "参数数据");
}
/**
* 根据参数编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:config:query')")
@GetMapping(value = "/{configId}")
public AjaxResult getInfo(@PathVariable Long configId) {
return success(configService.selectConfigById(configId));
}
/**
* 根据参数键名查询参数值
*/
@GetMapping(value = "/configKey/{configKey}")
public AjaxResult getConfigKey(@PathVariable String configKey) {
String configValue = configService.selectConfigByKey(configKey);
// 确保即使返回 null 或空字符串,也明确设置 data 字段
// 如果 configValue 是 null转换为空字符串
if (configValue == null) {
configValue = "";
}
// 直接创建 AjaxResult 并明确设置 data 字段,确保 data 字段始终存在
AjaxResult result = new AjaxResult();
result.put("code", 200);
result.put("msg", "操作成功");
result.put("data", configValue); // 明确设置 data 字段,即使值为空字符串
System.out.println("=== getConfigKey 调试信息 ===");
System.out.println("configKey: " + configKey);
System.out.println("configValue: [" + configValue + "]");
System.out.println("result.data: " + result.get("data"));
System.out.println("result.msg: " + result.get("msg"));
System.out.println("result.code: " + result.get("code"));
System.out.println("============================");
return result;
}
/**
* 新增参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:add')")
@Log(title = "参数管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysConfig config) {
if (!configService.checkConfigKeyUnique(config)) {
return error("新增参数'" + config.getConfigName() + "'失败,参数键名已存在");
}
config.setCreateBy(getUsername());
return toAjax(configService.insertConfig(config));
}
/**
* 修改参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:edit')")
@Log(title = "参数管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysConfig config) {
if (!configService.checkConfigKeyUnique(config)) {
return error("修改参数'" + config.getConfigName() + "'失败,参数键名已存在");
}
config.setUpdateBy(getUsername());
return toAjax(configService.updateConfig(config));
}
/**
* 删除参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:remove')")
@Log(title = "参数管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{configIds}")
public AjaxResult remove(@PathVariable Long[] configIds) {
configService.deleteConfigByIds(configIds);
return success();
}
/**
* 刷新参数缓存
*/
@PreAuthorize("@ss.hasPermi('system:config:remove')")
@Log(title = "参数管理", businessType = BusinessType.CLEAN)
@DeleteMapping("/refreshCache")
public AjaxResult refreshCache() {
configService.resetConfigCache();
return success();
}
}

View File

@@ -0,0 +1,122 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.constant.UserConstants;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysDept;
import com.core.common.enums.BusinessType;
import com.core.common.utils.StringUtils;
import com.core.system.service.ISysDeptService;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 部门信息
*
* @author system
*/
@RestController
@RequestMapping("/system/dept")
public class SysDeptController extends BaseController {
@Autowired
private ISysDeptService deptService;
/**
* 获取部门列表
*/
@PreAuthorize("@ss.hasPermi('system:dept:list')")
@GetMapping("/list")
public AjaxResult list(SysDept dept) {
List<SysDept> depts = deptService.selectDeptList(dept);
return success(depts);
}
/**
* 查询部门列表(排除节点)
*/
@PreAuthorize("@ss.hasPermi('system:dept:list')")
@GetMapping("/list/exclude/{deptId}")
public AjaxResult excludeChild(@PathVariable(value = "deptId", required = false) Long deptId) {
List<SysDept> depts = deptService.selectDeptList(new SysDept());
depts.removeIf(d -> d.getDeptId().intValue() == deptId
|| ArrayUtils.contains(StringUtils.split(d.getAncestors(), ","), deptId + ""));
return success(depts);
}
/**
* 获取部门下拉树列表
*/
@GetMapping("/treeselect")
public AjaxResult treeselect(SysDept dept) {
List<SysDept> depts = deptService.selectDeptList(dept);
return AjaxResult.success(deptService.buildDeptTreeSelect(depts));
}
/**
* 根据部门编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:dept:query')")
@GetMapping(value = "/{deptId}")
public AjaxResult getInfo(@PathVariable Long deptId) {
deptService.checkDeptDataScope(deptId);
return success(deptService.selectDeptById(deptId));
}
/**
* 新增部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:add')")
@Log(title = "部门管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDept dept) {
if (!deptService.checkDeptNameUnique(dept)) {
return error("新增部门'" + dept.getDeptName() + "'失败,部门名称已存在");
}
dept.setCreateBy(getUsername());
return toAjax(deptService.insertDept(dept));
}
/**
* 修改部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:edit')")
@Log(title = "部门管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysDept dept) {
Long deptId = dept.getDeptId();
deptService.checkDeptDataScope(deptId);
if (!deptService.checkDeptNameUnique(dept)) {
return error("修改部门'" + dept.getDeptName() + "'失败,部门名称已存在");
} else if (dept.getParentId().equals(deptId)) {
return error("修改部门'" + dept.getDeptName() + "'失败,上级部门不能是自己");
} else if (StringUtils.equals(UserConstants.DEPT_DISABLE, dept.getStatus())
&& deptService.selectNormalChildrenDeptById(deptId) > 0) {
return error("该部门包含未停用的子部门!");
}
dept.setUpdateBy(getUsername());
return toAjax(deptService.updateDept(dept));
}
/**
* 删除部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:remove')")
@Log(title = "部门管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{deptId}")
public AjaxResult remove(@PathVariable Long deptId) {
if (deptService.hasChildByDeptId(deptId)) {
return warn("存在下级部门,不允许删除");
}
if (deptService.checkDeptExistUser(deptId)) {
return warn("部门存在用户,不允许删除");
}
deptService.checkDeptDataScope(deptId);
return toAjax(deptService.deleteDeptById(deptId));
}
}

View File

@@ -0,0 +1,107 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysDictData;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.StringUtils;
import com.core.common.utils.poi.ExcelUtil;
import com.core.system.service.ISysDictDataService;
import com.core.system.service.ISysDictTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;
/**
* 数据字典信息
*
* @author system
*/
@RestController
@RequestMapping("/system/dict/data")
public class SysDictDataController extends BaseController {
@Autowired
private ISysDictDataService dictDataService;
@Autowired
private ISysDictTypeService dictTypeService;
@PreAuthorize("@ss.hasPermi('system:dict:list')")
@GetMapping("/list")
public TableDataInfo list(SysDictData dictData) {
startPage();
List<SysDictData> list = dictDataService.selectDictDataList(dictData);
return getDataTable(list);
}
@Log(title = "字典数据", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:dict:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysDictData dictData) {
List<SysDictData> list = dictDataService.selectDictDataList(dictData);
ExcelUtil<SysDictData> util = new ExcelUtil<SysDictData>(SysDictData.class);
util.exportExcel(response, list, "字典数据");
}
/**
* 查询字典数据详细
*/
@PreAuthorize("@ss.hasPermi('system:dict:query')")
@GetMapping(value = "/{dictCode}")
public AjaxResult getInfo(@PathVariable Long dictCode) {
return success(dictDataService.selectDictDataById(dictCode));
}
/**
* 根据字典类型查询字典数据信息(支持拼音搜索)
*/
@GetMapping(value = "/type/{dictType}")
public AjaxResult dictType(@PathVariable String dictType,
@RequestParam(value = "searchKey", required = false) String searchKey) {
List<SysDictData> data = dictTypeService.selectDictDataByType(dictType, searchKey);
if (StringUtils.isNull(data)) {
data = new ArrayList<SysDictData>();
}
return success(data);
}
/**
* 新增字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:add')")
@Log(title = "字典数据", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDictData dict) {
dict.setCreateBy(getUsername());
return toAjax(dictDataService.insertDictData(dict));
}
/**
* 修改保存字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:edit')")
@Log(title = "字典数据", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysDictData dict) {
dict.setUpdateBy(getUsername());
return toAjax(dictDataService.updateDictData(dict));
}
/**
* 删除字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.DELETE)
@DeleteMapping("/{dictCodes}")
public AjaxResult remove(@PathVariable Long[] dictCodes) {
dictDataService.deleteDictDataByIds(dictCodes);
return success();
}
}

View File

@@ -0,0 +1,114 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysDictType;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.poi.ExcelUtil;
import com.core.system.service.ISysDictTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 数据字典信息
*
* @author system
*/
@RestController
@RequestMapping("/system/dict/type")
public class SysDictTypeController extends BaseController {
@Autowired
private ISysDictTypeService dictTypeService;
@PreAuthorize("@ss.hasPermi('system:dict:list')")
@GetMapping("/list")
public TableDataInfo list(SysDictType dictType) {
startPage();
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
return getDataTable(list);
}
@Log(title = "字典类型", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:dict:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysDictType dictType) {
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
ExcelUtil<SysDictType> util = new ExcelUtil<SysDictType>(SysDictType.class);
util.exportExcel(response, list, "字典类型");
}
/**
* 查询字典类型详细
*/
@PreAuthorize("@ss.hasPermi('system:dict:query')")
@GetMapping(value = "/{dictId}")
public AjaxResult getInfo(@PathVariable Long dictId) {
return success(dictTypeService.selectDictTypeById(dictId));
}
/**
* 新增字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:add')")
@Log(title = "字典类型", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDictType dict) {
if (!dictTypeService.checkDictTypeUnique(dict)) {
return error("新增字典'" + dict.getDictName() + "'失败,字典类型已存在");
}
dict.setCreateBy(getUsername());
return toAjax(dictTypeService.insertDictType(dict));
}
/**
* 修改字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:edit')")
@Log(title = "字典类型", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysDictType dict) {
if (!dictTypeService.checkDictTypeUnique(dict)) {
return error("修改字典'" + dict.getDictName() + "'失败,字典类型已存在");
}
dict.setUpdateBy(getUsername());
return toAjax(dictTypeService.updateDictType(dict));
}
/**
* 删除字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.DELETE)
@DeleteMapping("/{dictIds}")
public AjaxResult remove(@PathVariable Long[] dictIds) {
dictTypeService.deleteDictTypeByIds(dictIds);
return success();
}
/**
* 刷新字典缓存
*/
@PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.CLEAN)
@DeleteMapping("/refreshCache")
public AjaxResult refreshCache() {
dictTypeService.resetDictCache();
return success();
}
/**
* 获取字典选择框列表
*/
@GetMapping("/optionselect")
public AjaxResult optionselect() {
List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll();
return success(dictTypes);
}
}

View File

@@ -0,0 +1,27 @@
package com.core.web.controller.system;
import com.core.common.config.CoreConfig;
import com.core.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 首页
*
* @author system
*/
@RestController
public class SysIndexController {
/** 系统基础配置 */
@Autowired
private CoreConfig coreConfig;
/**
* 访问首页,提示语
*/
@RequestMapping("/")
public String index() {
return StringUtils.format("欢迎使用{}后台管理框架当前版本v{},请通过前端地址访问。", coreConfig.getName(), coreConfig.getVersion());
}
}

View File

@@ -0,0 +1,109 @@
package com.core.web.controller.system;
import com.core.common.constant.Constants;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysMenu;
import com.core.common.core.domain.entity.SysUser;
import com.core.common.core.domain.model.LoginBody;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.utils.SecurityUtils;
import com.core.framework.web.service.SysLoginService;
import com.core.framework.web.service.SysPermissionService;
import com.core.framework.web.service.TokenService;
import com.core.system.service.ISysMenuService;
import com.core.system.service.ISysTenantService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Set;
/**已评审
* 登录验证
*
* @author system
*/
@RestController
public class SysLoginController {
@Autowired
private SysLoginService loginService;
@Autowired
private ISysMenuService menuService;
@Autowired
private SysPermissionService permissionService;
@Autowired
private TokenService tokenService;
@Autowired
private ISysTenantService tenantService;
/**已评审
* 登录方法
*
* @param loginBody 登录信息
* @return 结果
*/
@PostMapping("/login")
public AjaxResult login(@RequestBody LoginBody loginBody) {
AjaxResult ajax = AjaxResult.success();
// 生成令牌
String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(),
loginBody.getUuid(), loginBody.getTenantId());
ajax.put(Constants.TOKEN, token);
return ajax;
}
/**已评审 整个admin合拼到app层
* 获取用户信息
*
* @return 用户信息
*/
@GetMapping("getInfo")
public AjaxResult getInfo() {
LoginUser loginUser = SecurityUtils.getLoginUser();
SysUser user = loginUser.getUser();
// 角色集合
Set<String> roles = permissionService.getRolePermission(user);
// 权限集合
Set<String> permissions = permissionService.getMenuPermission(user);
if (!loginUser.getPermissions().equals(permissions)) {
loginUser.setPermissions(permissions);
tokenService.refreshToken(loginUser);
}
// 获取租户名称
String tenantName = null;
if (loginUser.getTenantId() != null) {
com.core.system.domain.SysTenant tenant = tenantService.getById(loginUser.getTenantId());
if (tenant != null) {
tenantName = tenant.getTenantName();
}
}
AjaxResult ajax = AjaxResult.success();
ajax.put("optionJson", loginUser.getOptionJson());
ajax.put("optionMap", loginUser.getOptionMap());
ajax.put("practitionerId", String.valueOf(loginUser.getPractitionerId()));
ajax.put("user", user);
ajax.put("roles", roles);
ajax.put("permissions", permissions);
ajax.put("tenantName", tenantName);
return ajax;
}
/**
* 获取路由信息
*
* @return 路由信息
*/
@GetMapping("getRouters")
public AjaxResult getRouters() {
Long userId = SecurityUtils.getUserId();
List<SysMenu> menus = menuService.selectMenuTreeByUserId(userId);
return AjaxResult.success(menuService.buildMenus(menus));
}
}

View File

@@ -0,0 +1,118 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.constant.UserConstants;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysMenu;
import com.core.common.enums.BusinessType;
import com.core.common.utils.StringUtils;
import com.core.system.service.ISysMenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 菜单信息
*
* @author system
*/
@RestController
@RequestMapping("/system/menu")
public class SysMenuController extends BaseController {
@Autowired
private ISysMenuService menuService;
/**
* 获取菜单列表
*/
@PreAuthorize("@ss.hasPermi('system:menu:list')")
@GetMapping("/list")
public AjaxResult list(SysMenu menu) {
List<SysMenu> menus = menuService.selectMenuList(menu, getUserId());
return success(menus);
}
/**
* 根据菜单编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:menu:query')")
@GetMapping(value = "/{menuId}")
public AjaxResult getInfo(@PathVariable Long menuId) {
return success(menuService.selectMenuById(menuId));
}
/**
* 获取菜单下拉树列表
*/
@GetMapping("/treeselect")
public AjaxResult treeselect(SysMenu menu) {
List<SysMenu> menus = menuService.selectMenuList(menu, getUserId());
return success(menuService.buildMenuTreeSelect(menus));
}
/**
* 加载对应角色菜单列表树
*/
@GetMapping(value = "/roleMenuTreeselect/{roleId}")
public AjaxResult roleMenuTreeselect(@PathVariable("roleId") Long roleId) {
List<SysMenu> menus = menuService.selectMenuList(getUserId());
AjaxResult ajax = AjaxResult.success();
ajax.put("checkedKeys", menuService.selectMenuListByRoleId(roleId));
ajax.put("menus", menuService.buildMenuTreeSelect(menus));
return ajax;
}
/**
* 新增菜单
*/
@PreAuthorize("@ss.hasPermi('system:menu:add')")
@Log(title = "菜单管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysMenu menu) {
if (!menuService.checkMenuNameUnique(menu)) {
return error("新增菜单'" + menu.getMenuName() + "'失败,菜单名称已存在");
} else if (UserConstants.YES_FRAME.equals(menu.getIsFrame()) && !StringUtils.ishttp(menu.getPath())) {
return error("新增菜单'" + menu.getMenuName() + "'失败地址必须以http(s)://开头");
}
menu.setCreateBy(getUsername());
return toAjax(menuService.insertMenu(menu));
}
/**
* 修改菜单
*/
@PreAuthorize("@ss.hasPermi('system:menu:edit')")
@Log(title = "菜单管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysMenu menu) {
if (!menuService.checkMenuNameUnique(menu)) {
return error("修改菜单'" + menu.getMenuName() + "'失败,菜单名称已存在");
} else if (UserConstants.YES_FRAME.equals(menu.getIsFrame()) && !StringUtils.ishttp(menu.getPath())) {
return error("修改菜单'" + menu.getMenuName() + "'失败地址必须以http(s)://开头");
} else if (menu.getMenuId().equals(menu.getParentId())) {
return error("修改菜单'" + menu.getMenuName() + "'失败,上级菜单不能选择自己");
}
menu.setUpdateBy(getUsername());
return toAjax(menuService.updateMenu(menu));
}
/**
* 删除菜单
*/
@PreAuthorize("@ss.hasPermi('system:menu:remove')")
@Log(title = "菜单管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{menuId}")
public AjaxResult remove(@PathVariable("menuId") Long menuId) {
if (menuService.hasChildByMenuId(menuId)) {
return warn("存在子菜单,不允许删除");
}
if (menuService.checkMenuExistRole(menuId)) {
return warn("菜单已分配,不允许删除");
}
return toAjax(menuService.deleteMenuById(menuId));
}
}

View File

@@ -0,0 +1,233 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysUser;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.system.domain.SysNotice;
import com.core.system.service.ISysNoticeReadService;
import com.core.system.service.ISysNoticeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 公告 信息操作处理
*
* @author system
*/
@RestController
@RequestMapping("/system/notice")
public class SysNoticeController extends BaseController {
@Autowired
private ISysNoticeService noticeService;
@Autowired
private ISysNoticeReadService noticeReadService;
/**
* 获取通知公告列表
*/
@PreAuthorize("@ss.hasPermi('system:notice:list')")
@GetMapping("/list")
public TableDataInfo list(SysNotice notice) {
startPage();
List<SysNotice> list = noticeService.selectNoticeList(notice);
return getDataTable(list);
}
/**
* 获取当前用户的公告列表(公开接口)
* 公告类型:通常 noticeType = '1' 代表通知noticeType = '2' 代表公告
*/
@GetMapping("/public/list")
public TableDataInfo getPublicList(SysNotice notice) {
// 只查询状态为正常0且已发布1的公告
notice.setStatus("0");
notice.setPublishStatus("1");
// 公告类型设置为 '2'(公告)
notice.setNoticeType("2");
// 设置分页参数
startPage();
List<SysNotice> list = noticeService.selectNoticeList(notice);
return getDataTable(list);
}
/**
* 获取当前用户的通知列表(公开接口)
* 通知类型:通常 noticeType = '1' 代表通知noticeType = '2' 代表公告
* 返回已发布且状态正常的所有公告和通知,并标注已读状态
* 按优先级排序,高优先级在前
*/
@GetMapping("/public/notice")
public AjaxResult getUserNotices() {
// 获取当前用户信息
LoginUser loginUser = getLoginUser();
SysUser currentUser = loginUser.getUser();
// 查询已发布且状态正常的所有公告和通知
SysNotice notice = new SysNotice();
notice.setStatus("0");
notice.setPublishStatus("1");
List<SysNotice> list = noticeService.selectNoticeList(notice);
// 按优先级排序1高 2中 3低相同优先级按创建时间降序
list.sort((a, b) -> {
String priorityA = a.getPriority() != null ? a.getPriority() : "3";
String priorityB = b.getPriority() != null ? b.getPriority() : "3";
int priorityCompare = priorityA.compareTo(priorityB);
if (priorityCompare != 0) {
return priorityCompare;
}
// 相同优先级,按创建时间降序
return b.getCreateTime().compareTo(a.getCreateTime());
});
// 获取用户已读的公告/通知ID列表
List<Long> readIds = noticeReadService.selectReadNoticeIdsByUserId(currentUser.getUserId());
// 为每个公告/通知添加已读状态
for (SysNotice item : list) {
boolean isRead = readIds.contains(item.getNoticeId());
item.setIsRead(isRead);
}
return success(list);
}
/**
* 获取用户未读公告/通知数量(公开接口)
*/
@GetMapping("/public/unread/count")
public AjaxResult getUnreadCount() {
LoginUser loginUser = getLoginUser();
SysUser currentUser = loginUser.getUser();
int count = noticeReadService.getUnreadCount(currentUser.getUserId());
return success(count);
}
/**
* 标记公告/通知为已读(公开接口)
*/
@PostMapping("/public/read/{noticeId}")
public AjaxResult markAsRead(@PathVariable Long noticeId) {
LoginUser loginUser = getLoginUser();
SysUser currentUser = loginUser.getUser();
return noticeReadService.markAsRead(noticeId, currentUser.getUserId());
}
/**
* 批量标记公告/通知为已读(公开接口)
*/
@PostMapping("/public/read/all")
public AjaxResult markAllAsRead(@RequestBody Long[] noticeIds) {
LoginUser loginUser = getLoginUser();
SysUser currentUser = loginUser.getUser();
return noticeReadService.markAllAsRead(noticeIds, currentUser.getUserId());
}
/**
* 获取用户已读公告/通知ID列表公开接口
*/
@GetMapping("/public/read/ids")
public AjaxResult getReadNoticeIds() {
LoginUser loginUser = getLoginUser();
SysUser currentUser = loginUser.getUser();
List<Long> readIds = noticeReadService.selectReadNoticeIdsByUserId(currentUser.getUserId());
return success(readIds);
}
/**
* 根据通知公告编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:notice:query')")
@GetMapping(value = "/{noticeId}")
public AjaxResult getInfo(@PathVariable Long noticeId) {
return success(noticeService.selectNoticeById(noticeId));
}
/**
* 新增通知公告
*/
@PreAuthorize("@ss.hasPermi('system:notice:add')")
@Log(title = "通知公告", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysNotice notice) {
notice.setCreateBy(getUsername());
// 新建的公告默认为未发布状态
if (notice.getPublishStatus() == null || notice.getPublishStatus().isEmpty()) {
notice.setPublishStatus("0");
}
// 设置默认优先级为中2
if (notice.getPriority() == null || notice.getPriority().isEmpty()) {
notice.setPriority("2");
}
return toAjax(noticeService.insertNotice(notice));
}
/**
* 修改通知公告
*/
@PreAuthorize("@ss.hasPermi('system:notice:edit')")
@Log(title = "通知公告", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysNotice notice) {
notice.setUpdateBy(getUsername());
return toAjax(noticeService.updateNotice(notice));
}
/**
* 删除通知公告
*/
@PreAuthorize("@ss.hasPermi('system:notice:remove')")
@Log(title = "通知公告", businessType = BusinessType.DELETE)
@DeleteMapping("/{noticeIds}")
public AjaxResult remove(@PathVariable Long[] noticeIds) {
return toAjax(noticeService.deleteNoticeByIds(noticeIds));
}
/**
* 发布公告/通知
*/
@PreAuthorize("@ss.hasPermi('system:notice:edit')")
@Log(title = "发布公告", businessType = BusinessType.UPDATE)
@PutMapping("/publish/{noticeId}")
public AjaxResult publish(@PathVariable Long noticeId) {
SysNotice notice = noticeService.selectNoticeById(noticeId);
if (notice == null) {
return error("公告不存在");
}
if ("1".equals(notice.getPublishStatus())) {
return error("该公告已发布");
}
notice.setPublishStatus("1");
notice.setUpdateBy(getUsername());
return toAjax(noticeService.updateNotice(notice));
}
/**
* 取消发布公告/通知
*/
@PreAuthorize("@ss.hasPermi('system:notice:edit')")
@Log(title = "取消发布", businessType = BusinessType.UPDATE)
@PutMapping("/unpublish/{noticeId}")
public AjaxResult unpublish(@PathVariable Long noticeId) {
SysNotice notice = noticeService.selectNoticeById(noticeId);
if (notice == null) {
return error("公告不存在");
}
if ("0".equals(notice.getPublishStatus())) {
return error("该公告未发布");
}
notice.setPublishStatus("0");
notice.setUpdateBy(getUsername());
return toAjax(noticeService.updateNotice(notice));
}
}

View File

@@ -0,0 +1,109 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.poi.ExcelUtil;
import com.core.system.domain.SysPost;
import com.core.system.service.ISysPostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 岗位信息操作处理
*
* @author system
*/
@RestController
@RequestMapping("/system/post")
public class SysPostController extends BaseController {
@Autowired
private ISysPostService postService;
/**
* 获取岗位列表
*/
@PreAuthorize("@ss.hasPermi('system:post:list')")
@GetMapping("/list")
public TableDataInfo list(SysPost post) {
startPage();
List<SysPost> list = postService.selectPostList(post);
return getDataTable(list);
}
@Log(title = "岗位管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:post:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysPost post) {
List<SysPost> list = postService.selectPostList(post);
ExcelUtil<SysPost> util = new ExcelUtil<SysPost>(SysPost.class);
util.exportExcel(response, list, "岗位数据");
}
/**
* 根据岗位编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:post:query')")
@GetMapping(value = "/{postId}")
public AjaxResult getInfo(@PathVariable Long postId) {
return success(postService.selectPostById(postId));
}
/**
* 新增岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:add')")
@Log(title = "岗位管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysPost post) {
if (!postService.checkPostNameUnique(post)) {
return error("新增岗位'" + post.getPostName() + "'失败,岗位名称已存在");
} else if (!postService.checkPostCodeUnique(post)) {
return error("新增岗位'" + post.getPostName() + "'失败,岗位编码已存在");
}
post.setCreateBy(getUsername());
return toAjax(postService.insertPost(post));
}
/**
* 修改岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:edit')")
@Log(title = "岗位管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysPost post) {
if (!postService.checkPostNameUnique(post)) {
return error("修改岗位'" + post.getPostName() + "'失败,岗位名称已存在");
} else if (!postService.checkPostCodeUnique(post)) {
return error("修改岗位'" + post.getPostName() + "'失败,岗位编码已存在");
}
post.setUpdateBy(getUsername());
return toAjax(postService.updatePost(post));
}
/**
* 删除岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:remove')")
@Log(title = "岗位管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{postIds}")
public AjaxResult remove(@PathVariable Long[] postIds) {
return toAjax(postService.deletePostByIds(postIds));
}
/**
* 获取岗位选择框列表
*/
@GetMapping("/optionselect")
public AjaxResult optionselect() {
List<SysPost> posts = postService.selectPostAll();
return success(posts);
}
}

View File

@@ -0,0 +1,118 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.config.CoreConfig;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysUser;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.enums.BusinessType;
import com.core.common.utils.SecurityUtils;
import com.core.common.utils.StringUtils;
import com.core.common.utils.file.FileUploadUtils;
import com.core.common.utils.file.MimeTypeUtils;
import com.core.framework.web.service.TokenService;
import com.core.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
/**
* 个人信息 业务处理
*
* @author system
*/
@RestController
@RequestMapping("/system/user/profile")
public class SysProfileController extends BaseController {
@Autowired
private ISysUserService userService;
@Autowired
private TokenService tokenService;
/**
* 个人信息
*/
@GetMapping
public AjaxResult profile() {
LoginUser loginUser = getLoginUser();
SysUser user = loginUser.getUser();
AjaxResult ajax = AjaxResult.success(user);
ajax.put("roleGroup", userService.selectUserRoleGroup(loginUser.getUsername()));
ajax.put("postGroup", userService.selectUserPostGroup(loginUser.getUsername()));
return ajax;
}
/**
* 修改用户
*/
@Log(title = "个人信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult updateProfile(@RequestBody SysUser user) {
LoginUser loginUser = getLoginUser();
SysUser currentUser = loginUser.getUser();
currentUser.setNickName(user.getNickName());
currentUser.setEmail(user.getEmail());
currentUser.setPhonenumber(user.getPhonenumber());
currentUser.setSex(user.getSex());
if (StringUtils.isNotEmpty(user.getPhonenumber()) && !userService.checkPhoneUnique(currentUser)) {
return error("修改用户'" + loginUser.getUsername() + "'失败,手机号码已存在");
}
if (StringUtils.isNotEmpty(user.getEmail()) && !userService.checkEmailUnique(currentUser)) {
return error("修改用户'" + loginUser.getUsername() + "'失败,邮箱账号已存在");
}
if (userService.updateUserProfile(currentUser) > 0) {
// 更新缓存用户信息
tokenService.setLoginUser(loginUser);
return success();
}
return error("修改个人信息异常,请联系管理员");
}
/**
* 重置密码
*/
@Log(title = "个人信息", businessType = BusinessType.UPDATE)
@PutMapping("/updatePwd")
public AjaxResult updatePwd(String oldPassword, String newPassword) {
LoginUser loginUser = getLoginUser();
String userName = loginUser.getUsername();
String password = loginUser.getPassword();
if (!SecurityUtils.matchesPassword(oldPassword, password)) {
return error("修改密码失败,旧密码错误");
}
if (SecurityUtils.matchesPassword(newPassword, password)) {
return error("新密码不能与旧密码相同");
}
newPassword = SecurityUtils.encryptPassword(newPassword);
if (userService.resetUserPwd(userName, newPassword) > 0) {
// 更新缓存用户密码
loginUser.getUser().setPassword(newPassword);
tokenService.setLoginUser(loginUser);
return success();
}
return error("修改密码异常,请联系管理员");
}
/**
* 头像上传
*/
@Log(title = "用户头像", businessType = BusinessType.UPDATE)
@PostMapping("/avatar")
public AjaxResult avatar(@RequestParam("avatarfile") MultipartFile file) throws Exception {
if (!file.isEmpty()) {
LoginUser loginUser = getLoginUser();
String avatar = FileUploadUtils.upload(CoreConfig.getAvatarPath(), file, MimeTypeUtils.IMAGE_EXTENSION);
if (userService.updateUserAvatar(loginUser.getUsername(), avatar)) {
AjaxResult ajax = AjaxResult.success();
ajax.put("imgUrl", avatar);
// 更新缓存用户头像
loginUser.getUser().setAvatar(avatar);
tokenService.setLoginUser(loginUser);
return ajax;
}
}
return error("上传图片异常,请联系管理员");
}
}

View File

@@ -0,0 +1,35 @@
package com.core.web.controller.system;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.model.RegisterBody;
import com.core.common.utils.StringUtils;
import com.core.framework.web.service.SysRegisterService;
import com.core.system.service.ISysConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
/**
* 注册验证
*
* @author system
*/
@RestController
public class SysRegisterController extends BaseController {
@Autowired
private SysRegisterService registerService;
@Autowired
private ISysConfigService configService;
@PostMapping("/register")
public AjaxResult register(@RequestBody RegisterBody user) {
if (!("true".equals(configService.selectConfigByKey("sys.account.registerUser")))) {
return error("当前系统没有开启注册功能!");
}
String msg = registerService.register(user);
return StringUtils.isEmpty(msg) ? success() : error(msg);
}
}

View File

@@ -0,0 +1,232 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysDept;
import com.core.common.core.domain.entity.SysRole;
import com.core.common.core.domain.entity.SysUser;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.StringUtils;
import com.core.common.utils.poi.ExcelUtil;
import com.core.framework.web.service.SysPermissionService;
import com.core.framework.web.service.TokenService;
import com.core.system.domain.SysUserRole;
import com.core.system.service.ISysDeptService;
import com.core.system.service.ISysRoleService;
import com.core.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 角色信息
*
* @author system
*/
@RestController
@RequestMapping("/system/role")
public class SysRoleController extends BaseController {
@Autowired
private ISysRoleService roleService;
@Autowired
private TokenService tokenService;
@Autowired
private SysPermissionService permissionService;
@Autowired
private ISysUserService userService;
@Autowired
private ISysDeptService deptService;
@PreAuthorize("@ss.hasPermi('system:role:list')")
@GetMapping("/list")
public TableDataInfo list(SysRole role) {
startPage();
List<SysRole> list = roleService.selectRoleList(role);
return getDataTable(list);
}
@Log(title = "角色管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:role:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysRole role) {
List<SysRole> list = roleService.selectRoleList(role);
ExcelUtil<SysRole> util = new ExcelUtil<SysRole>(SysRole.class);
util.exportExcel(response, list, "角色数据");
}
/**
* 根据角色编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:role:query')")
@GetMapping(value = "/{roleId}")
public AjaxResult getInfo(@PathVariable Long roleId) {
roleService.checkRoleDataScope(roleId);
return success(roleService.selectRoleById(roleId));
}
/**
* 新增角色
*/
@PreAuthorize("@ss.hasPermi('system:role:add')")
@Log(title = "角色管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysRole role) {
if (!roleService.checkRoleNameUnique(role)) {
return error("新增角色'" + role.getRoleName() + "'失败,角色名称已存在");
} else if (!roleService.checkRoleKeyUnique(role)) {
return error("新增角色'" + role.getRoleName() + "'失败,角色权限已存在");
}
role.setCreateBy(getUsername());
return toAjax(roleService.insertRole(role));
}
/**
* 修改保存角色
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysRole role) {
roleService.checkRoleAllowed(role);
roleService.checkRoleDataScope(role.getRoleId());
if (!roleService.checkRoleNameUnique(role)) {
return error("修改角色'" + role.getRoleName() + "'失败,角色名称已存在");
} else if (!roleService.checkRoleKeyUnique(role)) {
return error("修改角色'" + role.getRoleName() + "'失败,角色权限已存在");
}
role.setUpdateBy(getUsername());
if (roleService.updateRole(role) > 0) {
// 更新缓存用户权限
LoginUser loginUser = getLoginUser();
if (StringUtils.isNotNull(loginUser.getUser()) && !loginUser.getUser().isAdmin()) {
loginUser.setUser(userService.selectUserByUserName(loginUser.getUser().getUserName()));
loginUser.setPermissions(permissionService.getMenuPermission(loginUser.getUser()));
tokenService.setLoginUser(loginUser);
}
return success();
}
return error("修改角色'" + role.getRoleName() + "'失败,请联系管理员");
}
/**
* 修改保存数据权限
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PutMapping("/dataScope")
public AjaxResult dataScope(@RequestBody SysRole role) {
roleService.checkRoleAllowed(role);
roleService.checkRoleDataScope(role.getRoleId());
return toAjax(roleService.authDataScope(role));
}
/**
* 状态修改
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PutMapping("/changeStatus")
public AjaxResult changeStatus(@RequestBody SysRole role) {
roleService.checkRoleAllowed(role);
roleService.checkRoleDataScope(role.getRoleId());
role.setUpdateBy(getUsername());
return toAjax(roleService.updateRoleStatus(role));
}
/**
* 删除角色
*/
@PreAuthorize("@ss.hasPermi('system:role:remove')")
@Log(title = "角色管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{roleIds}")
public AjaxResult remove(@PathVariable Long[] roleIds) {
return toAjax(roleService.deleteRoleByIds(roleIds));
}
/**
* 获取角色选择框列表
*/
@PreAuthorize("@ss.hasPermi('system:role:query')")
@GetMapping("/optionselect")
public AjaxResult optionselect() {
return success(roleService.selectRoleAll());
}
/**
* 查询已分配用户角色列表
*/
@PreAuthorize("@ss.hasPermi('system:role:list')")
@GetMapping("/authUser/allocatedList")
public TableDataInfo allocatedList(SysUser user) {
startPage();
List<SysUser> list = userService.selectAllocatedList(user);
return getDataTable(list);
}
/**
* 查询未分配用户角色列表
*/
@PreAuthorize("@ss.hasPermi('system:role:list')")
@GetMapping("/authUser/unallocatedList")
public TableDataInfo unallocatedList(SysUser user) {
startPage();
List<SysUser> list = userService.selectUnallocatedList(user);
return getDataTable(list);
}
/**
* 取消授权用户
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.GRANT)
@PutMapping("/authUser/cancel")
public AjaxResult cancelAuthUser(@RequestBody SysUserRole userRole) {
return toAjax(roleService.deleteAuthUser(userRole));
}
/**
* 批量取消授权用户
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.GRANT)
@PutMapping("/authUser/cancelAll")
public AjaxResult cancelAuthUserAll(Long roleId, Long[] userIds) {
return toAjax(roleService.deleteAuthUsers(roleId, userIds));
}
/**
* 批量选择用户授权
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.GRANT)
@PutMapping("/authUser/selectAll")
public AjaxResult selectAuthUserAll(Long roleId, Long[] userIds) {
roleService.checkRoleDataScope(roleId);
return toAjax(roleService.insertAuthUsers(roleId, userIds));
}
/**
* 获取对应角色部门树列表
*/
@PreAuthorize("@ss.hasPermi('system:role:query')")
@GetMapping(value = "/deptTree/{roleId}")
public AjaxResult deptTree(@PathVariable("roleId") Long roleId) {
AjaxResult ajax = AjaxResult.success();
ajax.put("checkedKeys", deptService.selectDeptListByRoleId(roleId));
ajax.put("depts", deptService.selectDeptTreeList(new SysDept()));
return ajax;
}
}

View File

@@ -0,0 +1,197 @@
package com.core.web.controller.system;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.core.common.annotation.Anonymous;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.R;
import com.core.common.core.domain.entity.SysUser;
import com.core.system.domain.SysTenant;
import com.core.system.service.ISysTenantService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 租户信息controller
*
* @author system
*/
@RestController
@RequestMapping("/system/tenant")
public class SysTenantController extends BaseController {
@Autowired
private ISysTenantService sysTenantService;
/**
* 查询租户分页列表
*
* @param tenantId 租户ID查询
* @param tenantCode 租户编码模糊查询
* @param tenantName 租户名称模糊查询
* @param status 状态
* @param pageNum 当前页
* @param pageSize 每页多少条
* @return 租户分页列表
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@GetMapping("/page")
public R<IPage<SysTenant>> getTenantPage(@RequestParam(required = false) Integer tenantId,
@RequestParam(required = false) String tenantCode, @RequestParam(required = false) String tenantName,
@RequestParam(required = false) String status, @RequestParam(defaultValue = "1") Integer pageNum,
@RequestParam(defaultValue = "10") Integer pageSize) {
return sysTenantService.getTenantPage(tenantId, tenantCode, tenantName, status, pageNum, pageSize);
}
/**
* 查询租户详情
*
* @param tenantId 租户ID
* @return 租户分页列表
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@GetMapping("/{tenantId}")
public R<SysTenant> getTenantDetail(@PathVariable Integer tenantId) {
return R.ok(sysTenantService.getById(tenantId));
}
/**
* 查询租户所属用户分页列表
*
* @param tenantId 租户ID查询
* @param userName 用户昵称模糊查询
* @param nickName 用户昵称模糊查询
* @param phoneNumber 手机号码模糊查询
* @param pageNum 当前页
* @param pageSize 每页多少条
* @return 租户所属用户分页列表
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@GetMapping("/user/page")
public R<IPage<SysUser>> getTenantUserPage(@RequestParam(required = false) Integer tenantId,
@RequestParam(required = false) String userName, @RequestParam(required = false) String nickName,
@RequestParam(required = false) String phoneNumber, @RequestParam(defaultValue = "1") Integer pageNum,
@RequestParam(defaultValue = "10") Integer pageSize) {
return sysTenantService.getTenantUserPage(tenantId, userName, nickName, phoneNumber, pageNum, pageSize);
}
/**
* 新增租户
*
* @param sysTenant 租户实体
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PostMapping
public R<?> addTenant(@RequestBody SysTenant sysTenant) {
sysTenantService.save(sysTenant);
return R.ok("新增成功");
}
/**
* 修改租户
*
* @param sysTenant 租户实体
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PutMapping
public R<?> editTenant(@RequestBody SysTenant sysTenant) {
sysTenantService.updateById(sysTenant);
return R.ok("修改成功");
}
/**
* 删除租户
*
* @param tenantIdList 租户ID列表
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@DeleteMapping
public R<?> delTenant(@RequestBody List<Integer> tenantIdList) {
return sysTenantService.delTenant(tenantIdList);
}
/**
* 启用租户
*
* @param tenantIdList 租户ID列表
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PutMapping("/enable")
public R<?> enableTenant(@RequestBody List<Integer> tenantIdList) {
sysTenantService.enableTenant(tenantIdList);
return R.ok("启用成功");
}
/**
* 停用租户
*
* @param tenantIdList 租户ID列表
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PutMapping("/disable")
public R<?> disableTenant(@RequestBody List<Integer> tenantIdList) {
sysTenantService.disableTenant(tenantIdList);
return R.ok("停用成功");
}
/**
* 查询租户未绑定的用户列表
*
* @param tenantId 租户ID
* @param pageNum 当前页
* @param pageSize 每页多少条
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@GetMapping("/{tenantId}/unbind-users")
public R<IPage<SysUser>> getUnbindTenantUserList(@PathVariable Integer tenantId,
@RequestParam(required = false) String userName, @RequestParam(required = false) String nickName,
@RequestParam(required = false) String phoneNumber, @RequestParam(defaultValue = "1") Integer pageNum,
@RequestParam(defaultValue = "10") Integer pageSize) {
return sysTenantService.getUnbindTenantUserList(tenantId, userName, nickName, phoneNumber, pageNum, pageSize);
}
/**
* 绑定租户用户
*
* @param tenantId 租户ID
* @param userIdList 用户ID列表
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PostMapping("/{tenantId}/bind-users")
public R<?> bindTenantUser(@PathVariable Integer tenantId, @RequestBody List<Long> userIdList) {
return sysTenantService.bindTenantUser(tenantId, userIdList);
}
/**
* 解绑租户用户
*
* @param tenantId 租户ID
* @param userIdList 用户ID列表
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PostMapping("/{tenantId}/unbind-users")
public R<?> unbindTenantUser(@PathVariable Integer tenantId, @RequestBody List<Long> userIdList) {
return sysTenantService.unbindTenantUser(tenantId, userIdList);
}
/**
* 查询用户绑定的租户列表
*
* @param username 用户账号
* @return 用户绑定的租户列表
*/
@Anonymous
@GetMapping("/user-bind/{username}")
public R<List<SysTenant>> getUserBindTenantList(@PathVariable String username) {
return sysTenantService.getUserBindTenantList(username);
}
}

View File

@@ -0,0 +1,59 @@
package com.core.web.controller.system;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.R;
import com.core.system.domain.dto.SaveTenantOptionDetailDto;
import com.core.system.domain.dto.TenantOptionDto;
import com.core.system.service.ISysTenantOptionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 租户配置项信息controller
*
* @author system
*/
@RestController
@RequestMapping("/system/tenant-option")
public class SysTenantOptionController extends BaseController {
@Autowired
private ISysTenantOptionService sysTenantOptionService;
/**
* 查询租户配置项详情列表
*
* @param tenantId 租户ID
* @return 租户配置项详情列表
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@GetMapping("/detail-list/{tenantId}")
public R<List<TenantOptionDto>> getTenantOptionDetailList(@PathVariable Integer tenantId) {
return R.ok(sysTenantOptionService.getTenantOptionDetailList(tenantId));
}
/**
* 保存租户配置项详情列表
*
* @param saveTenantOptionDetailDto 参数DTO
* @return 结果
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@PostMapping("/detail-list")
public R<?> saveTenantOptionDetailList(@RequestBody SaveTenantOptionDetailDto saveTenantOptionDetailDto) {
return sysTenantOptionService.saveTenantOptionDetailList(saveTenantOptionDetailDto);
}
/**
* 查询租户配置项前端form表单列表
*
* @return 租户配置项前端form表单列表
*/
@PreAuthorize("@ss.hasPermi('system:tenant:operate')")
@GetMapping("/form-list")
public R<?> getTenantOptionFormList() {
return R.ok(sysTenantOptionService.getTenantOptionFormList());
}
}

View File

@@ -0,0 +1,226 @@
package com.core.web.controller.system;
import com.core.common.annotation.Log;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.AjaxResult;
import com.core.common.core.domain.entity.SysDept;
import com.core.common.core.domain.entity.SysRole;
import com.core.common.core.domain.entity.SysUser;
import com.core.common.core.page.TableDataInfo;
import com.core.common.enums.BusinessType;
import com.core.common.utils.SecurityUtils;
import com.core.common.utils.StringUtils;
import com.core.common.utils.poi.ExcelUtil;
import com.core.system.service.ISysDeptService;
import com.core.system.service.ISysPostService;
import com.core.system.service.ISysRoleService;
import com.core.system.service.ISysUserService;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.stream.Collectors;
/**
* 用户信息
*
* @author system
*/
@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController {
@Autowired
private ISysUserService userService;
@Autowired
private ISysRoleService roleService;
@Autowired
private ISysDeptService deptService;
@Autowired
private ISysPostService postService;
/**
* 获取用户列表
*/
@PreAuthorize("@ss.hasPermi('system:user:list')")
@GetMapping("/list")
public TableDataInfo list(SysUser user) {
startPage();
List<SysUser> list = userService.selectUserList(user);
return getDataTable(list);
}
@Log(title = "用户管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:user:export')")
@PostMapping("/export")
public void export(HttpServletResponse response, SysUser user) {
List<SysUser> list = userService.selectUserList(user);
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
util.exportExcel(response, list, "用户数据");
}
@Log(title = "用户管理", businessType = BusinessType.IMPORT)
@PreAuthorize("@ss.hasPermi('system:user:import')")
@PostMapping("/importData")
public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
List<SysUser> userList = util.importExcel(file.getInputStream());
String operName = getUsername();
String message = userService.importUser(userList, updateSupport, operName);
return success(message);
}
@PostMapping("/importTemplate")
public void importTemplate(HttpServletResponse response) {
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
util.importTemplateExcel(response, "用户数据");
}
/**
* 根据用户编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:user:query')")
@GetMapping(value = {"/", "/{userId}"})
public AjaxResult getInfo(@PathVariable(value = "userId", required = false) Long userId) {
AjaxResult ajax = AjaxResult.success();
if (StringUtils.isNotNull(userId)) {
userService.checkUserDataScope(userId);
SysUser sysUser = userService.selectUserById(userId);
ajax.put(AjaxResult.DATA_TAG, sysUser);
ajax.put("postIds", postService.selectPostListByUserId(userId));
ajax.put("roleIds", sysUser.getRoles().stream().map(SysRole::getRoleId).collect(Collectors.toList()));
}
List<SysRole> roles = roleService.selectRoleAll();
ajax.put("roles",
SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
ajax.put("posts", postService.selectPostAll());
return ajax;
}
/**
* 新增用户
*/
@PreAuthorize("@ss.hasPermi('system:user:add')")
@Log(title = "用户管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysUser user) {
deptService.checkDeptDataScope(user.getDeptId());
roleService.checkRoleDataScope(user.getRoleIds());
if (!userService.checkUserNameUnique(user)) {
return error("新增用户'" + user.getUserName() + "'失败,登录账号已存在");
} else if (StringUtils.isNotEmpty(user.getPhonenumber()) && !userService.checkPhoneUnique(user)) {
return error("新增用户'" + user.getUserName() + "'失败,手机号码已存在");
} else if (StringUtils.isNotEmpty(user.getEmail()) && !userService.checkEmailUnique(user)) {
return error("新增用户'" + user.getUserName() + "'失败,邮箱账号已存在");
}
user.setCreateBy(getUsername());
user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
return toAjax(userService.insertUser(user));
}
/**
* 修改用户
*/
@PreAuthorize("@ss.hasPermi('system:user:edit')")
@Log(title = "用户管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysUser user) {
userService.checkUserAllowed(user);
userService.checkUserDataScope(user.getUserId());
deptService.checkDeptDataScope(user.getDeptId());
roleService.checkRoleDataScope(user.getRoleIds());
if (!userService.checkUserNameUnique(user)) {
return error("修改用户'" + user.getUserName() + "'失败,登录账号已存在");
} else if (StringUtils.isNotEmpty(user.getPhonenumber()) && !userService.checkPhoneUnique(user)) {
return error("修改用户'" + user.getUserName() + "'失败,手机号码已存在");
} else if (StringUtils.isNotEmpty(user.getEmail()) && !userService.checkEmailUnique(user)) {
return error("修改用户'" + user.getUserName() + "'失败,邮箱账号已存在");
}
user.setUpdateBy(getUsername());
return toAjax(userService.updateUser(user));
}
/**
* 删除用户
*/
@PreAuthorize("@ss.hasPermi('system:user:remove')")
@Log(title = "用户管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{userIds}")
public AjaxResult remove(@PathVariable Long[] userIds) {
if (ArrayUtils.contains(userIds, getUserId())) {
return error("当前用户不能删除");
}
return toAjax(userService.deleteUserByIds(userIds));
}
/**
* 重置密码
*/
@PreAuthorize("@ss.hasPermi('system:user:resetPwd')")
@Log(title = "用户管理", businessType = BusinessType.UPDATE)
@PutMapping("/resetPwd")
public AjaxResult resetPwd(@RequestBody SysUser user) {
userService.checkUserAllowed(user);
userService.checkUserDataScope(user.getUserId());
user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
user.setUpdateBy(getUsername());
return toAjax(userService.resetPwd(user));
}
/**
* 状态修改
*/
@PreAuthorize("@ss.hasPermi('system:user:edit')")
@Log(title = "用户管理", businessType = BusinessType.UPDATE)
@PutMapping("/changeStatus")
public AjaxResult changeStatus(@RequestBody SysUser user) {
userService.checkUserAllowed(user);
userService.checkUserDataScope(user.getUserId());
user.setUpdateBy(getUsername());
return toAjax(userService.updateUserStatus(user));
}
/**
* 根据用户编号获取授权角色
*/
@PreAuthorize("@ss.hasPermi('system:user:query')")
@GetMapping("/authRole/{userId}")
public AjaxResult authRole(@PathVariable("userId") Long userId) {
AjaxResult ajax = AjaxResult.success();
SysUser user = userService.selectUserById(userId);
List<SysRole> roles = roleService.selectRolesByUserId(userId);
ajax.put("user", user);
ajax.put("roles",
SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
return ajax;
}
/**
* 用户授权角色
*/
@PreAuthorize("@ss.hasPermi('system:user:edit')")
@Log(title = "用户管理", businessType = BusinessType.GRANT)
@PutMapping("/authRole")
public AjaxResult insertAuthRole(Long userId, Long[] roleIds) {
userService.checkUserDataScope(userId);
roleService.checkRoleDataScope(roleIds);
userService.insertUserAuth(userId, roleIds);
return success();
}
/**
* 获取部门树列表
*/
@PreAuthorize("@ss.hasPermi('system:user:list')")
@GetMapping("/deptTree")
public AjaxResult deptTree(SysDept dept) {
return success(deptService.selectDeptTreeList(dept));
}
}

View File

@@ -0,0 +1,147 @@
package com.core.web.controller.tool;
import com.core.common.core.controller.BaseController;
import com.core.common.core.domain.R;
import com.core.common.utils.StringUtils;
import io.swagger.annotations.*;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* swagger 用户测试方法
*
* @author system
*/
@Api("用户信息管理")
@RestController
@RequestMapping("/test/user")
public class TestController extends BaseController {
private final static Map<Integer, UserEntity> users = new LinkedHashMap<Integer, UserEntity>();
{
users.put(1, new UserEntity(1, "admin", "admin123", "15888888888"));
users.put(2, new UserEntity(2, "ry", "admin123", "15666666666"));
}
@ApiOperation("获取用户列表")
@GetMapping("/list")
public R<List<UserEntity>> userList() {
List<UserEntity> userList = new ArrayList<UserEntity>(users.values());
return R.ok(userList);
}
@ApiOperation("获取用户详细")
@ApiImplicitParam(name = "userId", value = "用户ID", required = true, dataType = "int", paramType = "path",
dataTypeClass = Integer.class)
@GetMapping("/{userId}")
public R<UserEntity> getUser(@PathVariable Integer userId) {
if (!users.isEmpty() && users.containsKey(userId)) {
return R.ok(users.get(userId));
} else {
return R.fail("用户不存在");
}
}
@ApiOperation("新增用户")
@ApiImplicitParams({
@ApiImplicitParam(name = "userId", value = "用户id", dataType = "Integer", dataTypeClass = Integer.class),
@ApiImplicitParam(name = "username", value = "用户名称", dataType = "String", dataTypeClass = String.class),
@ApiImplicitParam(name = "password", value = "用户密码", dataType = "String", dataTypeClass = String.class),
@ApiImplicitParam(name = "mobile", value = "用户手机", dataType = "String", dataTypeClass = String.class)})
@PostMapping("/save")
public R<String> save(UserEntity user) {
if (StringUtils.isNull(user) || StringUtils.isNull(user.getUserId())) {
return R.fail("用户ID不能为空");
}
users.put(user.getUserId(), user);
return R.ok();
}
@ApiOperation("更新用户")
@PutMapping("/update")
public R<String> update(@RequestBody UserEntity user) {
if (StringUtils.isNull(user) || StringUtils.isNull(user.getUserId())) {
return R.fail("用户ID不能为空");
}
if (users.isEmpty() || !users.containsKey(user.getUserId())) {
return R.fail("用户不存在");
}
users.remove(user.getUserId());
users.put(user.getUserId(), user);
return R.ok();
}
@ApiOperation("删除用户信息")
@ApiImplicitParam(name = "userId", value = "用户ID", required = true, dataType = "int", paramType = "path",
dataTypeClass = Integer.class)
@DeleteMapping("/{userId}")
public R<String> delete(@PathVariable Integer userId) {
if (!users.isEmpty() && users.containsKey(userId)) {
users.remove(userId);
return R.ok();
} else {
return R.fail("用户不存在");
}
}
}
@ApiModel(value = "UserEntity", description = "用户实体")
class UserEntity {
@ApiModelProperty("用户ID")
private Integer userId;
@ApiModelProperty("用户名称")
private String username;
@ApiModelProperty("用户密码")
private String password;
@ApiModelProperty("用户手机")
private String mobile;
public UserEntity() {
}
public UserEntity(Integer userId, String username, String password, String mobile) {
this.userId = userId;
this.username = username;
this.password = password;
this.mobile = mobile;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
}

View File

@@ -0,0 +1,108 @@
package com.core.web.core.config;
import com.core.common.config.CoreConfig;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.*;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;
import java.util.ArrayList;
import java.util.List;
/**
* Swagger2的接口配置
*
* @author system
*/
@Configuration
public class SwaggerConfig {
/** 系统基础配置 */
@Autowired
private CoreConfig coreConfig;
/** 是否开启swagger */
@Value("${swagger.enabled}")
private boolean enabled;
/** 设置请求的统一前缀 */
@Value("${swagger.pathMapping}")
private String pathMapping;
/**
* 创建API
*/
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.OAS_30)
// 是否启用Swagger
.enable(enabled)
// 用来创建该API的基本信息展示在文档的页面中自定义展示的信息
.apiInfo(apiInfo())
// 设置哪些接口暴露给Swagger展示
.select()
// 扫描所有有注解的api用这种方式更灵活
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
// 扫描指定包中的swagger注解
// .apis(RequestHandlerSelectors.basePackage("com.core.project.tool.swagger"))
// 扫描所有 .apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any()).build()
/* 设置安全模式swagger可以设置访问token */
.securitySchemes(securitySchemes()).securityContexts(securityContexts()).pathMapping(pathMapping);
}
/**
* 安全模式这里指定token通过Authorization头请求头传递
*/
private List<SecurityScheme> securitySchemes() {
List<SecurityScheme> apiKeyList = new ArrayList<SecurityScheme>();
apiKeyList.add(new ApiKey("Authorization", "Authorization", In.HEADER.toValue()));
return apiKeyList;
}
/**
* 安全上下文
*/
private List<SecurityContext> securityContexts() {
List<SecurityContext> securityContexts = new ArrayList<>();
securityContexts.add(SecurityContext.builder().securityReferences(defaultAuth())
.operationSelector(o -> o.requestMappingPattern().matches("/.*")).build());
return securityContexts;
}
/**
* 默认的安全上引用
*/
private List<SecurityReference> defaultAuth() {
AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
authorizationScopes[0] = authorizationScope;
List<SecurityReference> securityReferences = new ArrayList<>();
securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
return securityReferences;
}
/**
* 添加摘要信息
*/
private ApiInfo apiInfo() {
// 用ApiInfoBuilder进行定制
return new ApiInfoBuilder()
// 设置标题
.title("标题开放医院管理系统_接口文档")
// 描述
.description("描述:用于管理集团旗下公司的人员信息,具体包括XXX,XXX模块...")
// 作者信息
.contact(new Contact(coreConfig.getName(), null, null))
// 版本
.version("版本号:" + coreConfig.getVersion()).build();
}
}

View File

@@ -0,0 +1,42 @@
package com.core.web.util;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.enums.TenantOptionDict;
import com.core.common.utils.SecurityUtils;
import com.core.common.utils.StringUtils;
/**
* 租户配置工具类
*
* @author system
*/
public class TenantOptionUtil {
/**
* 获取租户配置项内容
*
* @param optionDict 租户配置项字典
* @return 租户配置项内容
*/
public static String getOptionContent(TenantOptionDict optionDict) {
LoginUser loginUser;
try {
loginUser = SecurityUtils.getLoginUser();
} catch (Exception e) {
return null;
}
if (loginUser == null) {
return null;
}
if (loginUser.getOptionMap() == null || loginUser.getOptionMap().isEmpty()) {
return null;
}
// return loginUser.getOptionMap().get(optionDict.getCode());
// TODO:2025/10/17 李永兴提出的sys_option切换TenantOption临时防止报错方案最晚2025年11月底删除
String newValue = loginUser.getOptionMap().get(optionDict.getCode());
String oldValue = loginUser.getOptionJson().getString(optionDict.getCode());
return StringUtils.isEmpty(newValue) ? oldValue : newValue;
}
}

View File

@@ -0,0 +1,180 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.openhis</groupId>
<artifactId>openhis-server</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.core</groupId>
<artifactId>core-common</artifactId>
<description>
common通用工具
</description>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>17</source>
<target>17</target>
<encoding>UTF-8</encoding>
<compilerArgs>
<arg>-parameters</arg>
</compilerArgs>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.34</version>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<!-- mybatis-plus 增强CRUD -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- Spring框架基本的核心工具 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<!-- SpringWeb模块 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
<!-- spring security 安全认证 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- pagehelper 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
</dependency>
<!-- jsr250 annotations -->
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
</dependency>
<!-- 自定义验证注解 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<!--常用工具类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!-- JSON工具类 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!-- 阿里JSON解析器 -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
</dependency>
<!-- io常用工具类 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
</dependency>
<!-- excel工具 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
</dependency>
<!-- yml解析器 -->
<dependency>
<groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId>
</dependency>
<!-- Token生成与解析-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
</dependency>
<!-- Jaxb -->
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
</dependency>
<!-- redis 缓存操作 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- pool 对象池 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<!-- 解析客户端操作系统、浏览器等 -->
<dependency>
<groupId>eu.bitwalker</groupId>
<artifactId>UserAgentUtils</artifactId>
</dependency>
<!-- servlet包 -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<!-- 中文汉字转换为首字母拼音包 -->
<dependency>
<groupId>com.belerweb</groupId>
<artifactId>pinyin4j</artifactId>
<version>2.5.1</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>
</dependencies>
</project>

View File

@@ -0,0 +1,13 @@
package com.core.common.annotation;
import java.lang.annotation.*;
/**
* 匿名访问不鉴权注解
*
* @author system
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Anonymous {}

View File

@@ -0,0 +1,28 @@
package com.core.common.annotation;
import java.lang.annotation.*;
/**
* 数据权限过滤注解
*
* @author system
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope {
/**
* 部门表的别名
*/
public String deptAlias() default "";
/**
* 用户表的别名
*/
public String userAlias() default "";
/**
* 权限字符(用于多个角色匹配符合要求的权限)默认根据权限注解@ss获取多个权限用逗号分隔开来
*/
public String permission() default "";
}

View File

@@ -0,0 +1,23 @@
package com.core.common.annotation;
import com.core.common.enums.DataSourceType;
import java.lang.annotation.*;
/**
* 自定义多数据源切换注解
*
* 优先级:先方法,后类,如果方法覆盖了类上的数据源类型,以方法的为准,否则以类上的为准
*
* @author system
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
/**
* 切换数据源名称
*/
public DataSourceType value() default DataSourceType.MASTER;
}

View File

@@ -0,0 +1,188 @@
package com.core.common.annotation;
import com.core.common.utils.poi.ExcelHandlerAdapter;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.IndexedColors;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.math.BigDecimal;
/**
* 自定义导出Excel数据注解
*
* @author system
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel {
/**
* 导出时在excel中排序
*/
public int sort() default Integer.MAX_VALUE;
/**
* 导出到Excel中的名字.
*/
public String name() default "";
/**
* 日期格式, 如: yyyy-MM-dd
*/
public String dateFormat() default "";
/**
* 如果是字典类型请设置字典的type值 (如: sys_user_sex)
*/
public String dictType() default "";
/**
* 读取内容转表达式 (如: 0=男,1=女,2=未知)
*/
public String readConverterExp() default "";
/**
* 分隔符,读取字符串组内容
*/
public String separator() default ",";
/**
* BigDecimal 精度 默认:-1(默认不开启BigDecimal格式化)
*/
public int scale() default -1;
/**
* BigDecimal 舍入规则 默认:BigDecimal.ROUND_HALF_EVEN
*/
public int roundingMode() default BigDecimal.ROUND_HALF_EVEN;
/**
* 导出时在excel中每个列的高度
*/
public double height() default 14;
/**
* 导出时在excel中每个列的宽度
*/
public double width() default 16;
/**
* 文字后缀,如% 90 变成90%
*/
public String suffix() default "";
/**
* 当值为空时,字段的默认值
*/
public String defaultValue() default "";
/**
* 提示信息
*/
public String prompt() default "";
/**
* 设置只能选择不能输入的列内容.
*/
public String[] combo() default {};
/**
* 是否从字典读数据到combo,默认不读取,如读取需要设置dictType注解.
*/
public boolean comboReadDict() default false;
/**
* 是否需要纵向合并单元格,应对需求:含有list集合单元格)
*/
public boolean needMerge() default false;
/**
* 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
*/
public boolean isExport() default true;
/**
* 另一个类中的属性名称,支持多级获取,以小数点隔开
*/
public String targetAttr() default "";
/**
* 是否自动统计数据,在最后追加一行统计数据总和
*/
public boolean isStatistics() default false;
/**
* 导出类型0数字 1字符串 2图片
*/
public ColumnType cellType() default ColumnType.STRING;
/**
* 导出列头背景颜色
*/
public IndexedColors headerBackgroundColor() default IndexedColors.GREY_50_PERCENT;
/**
* 导出列头字体颜色
*/
public IndexedColors headerColor() default IndexedColors.WHITE;
/**
* 导出单元格背景颜色
*/
public IndexedColors backgroundColor() default IndexedColors.WHITE;
/**
* 导出单元格字体颜色
*/
public IndexedColors color() default IndexedColors.BLACK;
/**
* 导出字段对齐方式
*/
public HorizontalAlignment align() default HorizontalAlignment.CENTER;
/**
* 自定义数据处理器
*/
public Class<?> handler() default ExcelHandlerAdapter.class;
/**
* 自定义数据处理器参数
*/
public String[] args() default {};
/**
* 字段类型0导出导入1仅导出2仅导入
*/
Type type() default Type.ALL;
public enum Type {
ALL(0), EXPORT(1), IMPORT(2);
private final int value;
Type(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
public enum ColumnType {
NUMERIC(0), STRING(1), IMAGE(2), TEXT(3);
private final int value;
ColumnType(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
}

View File

@@ -0,0 +1,38 @@
package com.core.common.annotation;
import java.lang.annotation.*;
/**
* Excel额外表头信息注解
*
* @author swb
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExcelExtra {
/**
* 表头名称
*/
String name();
/**
* 日期格式yyyy-MM-dd HH:mm:ss
*/
String dateFormat() default "";
/**
* 排序(越小越靠前)
*/
int sort() default 0;
/**
* 默认值
*/
String defaultValue() default "";
/**
* 是否导出
*/
boolean isExport() default true;
}

View File

@@ -0,0 +1,17 @@
package com.core.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Excel注解集
*
* @author system
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Excels {
public Excel[] value();
}

View File

@@ -0,0 +1,47 @@
package com.core.common.annotation;
import com.core.common.enums.BusinessType;
import com.core.common.enums.OperatorType;
import java.lang.annotation.*;
/**
* 自定义操作日志记录注解
*
* @author system
*
*/
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
/**
* 模块
*/
public String title() default "";
/**
* 功能
*/
public BusinessType businessType() default BusinessType.OTHER;
/**
* 操作人类别
*/
public OperatorType operatorType() default OperatorType.MANAGE;
/**
* 是否保存请求的参数
*/
public boolean isSaveRequestData() default true;
/**
* 是否保存响应的参数
*/
public boolean isSaveResponseData() default true;
/**
* 排除指定的请求参数
*/
public String[] excludeParamNames() default {};
}

View File

@@ -0,0 +1,36 @@
package com.core.common.annotation;
import com.core.common.constant.CacheConstants;
import com.core.common.enums.LimitType;
import java.lang.annotation.*;
/**
* 限流注解
*
* @author system
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimiter {
/**
* 限流key
*/
public String key() default CacheConstants.RATE_LIMIT_KEY;
/**
* 限流时间,单位秒
*/
public int time() default 60;
/**
* 限流次数
*/
public int count() default 100;
/**
* 限流类型
*/
public LimitType limitType() default LimitType.DEFAULT;
}

View File

@@ -0,0 +1,25 @@
package com.core.common.annotation;
import java.lang.annotation.*;
/**
* 自定义注解防止表单重复提交
*
* @author system
*
*/
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit {
/**
* 间隔时间(ms),小于此时间视为重复提交
*/
public int interval() default 5000;
/**
* 提示消息
*/
public String message() default "不允许重复提交,请稍候再试";
}

View File

@@ -0,0 +1,24 @@
package com.core.common.annotation;
import com.core.common.config.serializer.SensitiveJsonSerializer;
import com.core.common.enums.DesensitizedType;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 数据脱敏注解
*
* @author system
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@JacksonAnnotationsInside
@JsonSerialize(using = SensitiveJsonSerializer.class)
public @interface Sensitive {
DesensitizedType desensitizedType();
}

View File

@@ -0,0 +1,102 @@
package com.core.common.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 读取项目相关配置
*
* @author system
*/
@Component
@ConfigurationProperties(prefix = "core")
public class CoreConfig {
/** 上传路径 */
private static String profile;
/** 获取地址开关 */
private static boolean addressEnabled;
/** 验证码类型 */
private static String captchaType;
/** 项目名称 */
private String name;
/** 版本 */
private String version;
/** 版权年份 */
private String copyrightYear;
public static String getProfile() {
return profile;
}
public void setProfile(String profile) {
CoreConfig.profile = profile;
}
public static boolean isAddressEnabled() {
return addressEnabled;
}
public void setAddressEnabled(boolean addressEnabled) {
CoreConfig.addressEnabled = addressEnabled;
}
public static String getCaptchaType() {
return captchaType;
}
public void setCaptchaType(String captchaType) {
CoreConfig.captchaType = captchaType;
}
/**
* 获取导入上传路径
*/
public static String getImportPath() {
return getProfile() + "/import";
}
/**
* 获取头像上传路径
*/
public static String getAvatarPath() {
return getProfile() + "/avatar";
}
/**
* 获取下载路径
*/
public static String getDownloadPath() {
return getProfile() + "/download/";
}
/**
* 获取上传路径
*/
public static String getUploadPath() {
return getProfile() + "/upload";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getCopyrightYear() {
return copyrightYear;
}
public void setCopyrightYear(String copyrightYear) {
this.copyrightYear = copyrightYear;
}
}

View File

@@ -0,0 +1,57 @@
package com.core.common.config.serializer;
import com.core.common.annotation.Sensitive;
import com.core.common.core.domain.model.LoginUser;
import com.core.common.enums.DesensitizedType;
import com.core.common.utils.SecurityUtils;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import java.io.IOException;
import java.util.Objects;
/**
* 数据脱敏序列化过滤
*
* @author system
*/
public class SensitiveJsonSerializer extends JsonSerializer<String> implements ContextualSerializer {
private DesensitizedType desensitizedType;
@Override
public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
if (desensitization()) {
gen.writeString(desensitizedType.desensitizer().apply(value));
} else {
gen.writeString(value);
}
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property)
throws JsonMappingException {
Sensitive annotation = property.getAnnotation(Sensitive.class);
if (Objects.nonNull(annotation) && Objects.equals(String.class, property.getType().getRawClass())) {
this.desensitizedType = annotation.desensitizedType();
return this;
}
return prov.findValueSerializer(property.getType(), property);
}
/**
* 是否需要脱敏处理
*/
private boolean desensitization() {
try {
LoginUser securityUser = SecurityUtils.getLoginUser();
// 管理员不脱敏
return !securityUser.getUser().isAdmin();
} catch (Exception e) {
return true;
}
}
}

View File

@@ -0,0 +1,53 @@
package com.core.common.constant;
/**
* 缓存的key 常量
*
* @author system
*/
public class CacheConstants {
/**
* 登录用户 redis key
*/
public static final String LOGIN_TOKEN_KEY = "login_tokens:";
/**
* 验证码 redis key
*/
public static final String CAPTCHA_CODE_KEY = "captcha_codes:";
/**
* 参数管理 cache key
*/
public static final String SYS_CONFIG_KEY = "sys_config:";
/**
* 字典管理 cache key
*/
public static final String SYS_DICT_KEY = "sys_dict:";
/**
* 防重提交 redis key
*/
public static final String REPEAT_SUBMIT_KEY = "repeat_submit:";
/**
* 限流 redis key
*/
public static final String RATE_LIMIT_KEY = "rate_limit:";
/**
* 登录账户密码错误次数 redis key
*/
public static final String PWD_ERR_CNT_KEY = "pwd_err_cnt:";
/**
* 登录上次勾选的租户
*/
public static final String LOGIN_SELECTED_TENANT = "login_selected_tenant:";
/**
* 超出上限,排番失败(时间:{}KEY{}
*/
public static final String ASSIGN_SEQ_FAILED = "排番失败(时间:{}KEY{},异常信息:{超出上限}";
}

View File

@@ -0,0 +1,174 @@
package com.core.common.constant;
import io.jsonwebtoken.Claims;
import java.util.Locale;
/**
* 通用常量信息
*
* @author system
*/
public class Constants {
/**
* UTF-8 字符集
*/
public static final String UTF8 = "UTF-8";
/**
* GBK 字符集
*/
public static final String GBK = "GBK";
/**
* 系统语言
*/
public static final Locale DEFAULT_LOCALE = Locale.SIMPLIFIED_CHINESE;
/**
* www主域
*/
public static final String WWW = "www.";
/**
* http请求
*/
public static final String HTTP = "http://";
/**
* https请求
*/
public static final String HTTPS = "https://";
/**
* 通用成功标识
*/
public static final String SUCCESS = "0";
/**
* 通用失败标识
*/
public static final String FAIL = "1";
/**
* 登录成功
*/
public static final String LOGIN_SUCCESS = "Success";
/**
* 注销
*/
public static final String LOGOUT = "Logout";
/**
* 注册
*/
public static final String REGISTER = "Register";
/**
* 登录失败
*/
public static final String LOGIN_FAIL = "Error";
/**
* 所有权限标识
*/
public static final String ALL_PERMISSION = "*:*:*";
/**
* 管理员角色权限标识
*/
public static final String SUPER_ADMIN = "admin";
/**
* 角色权限分隔符
*/
public static final String ROLE_DELIMETER = ",";
/**
* 权限标识分隔符
*/
public static final String PERMISSION_DELIMETER = ",";
/**
* 验证码有效期(分钟)
*/
public static final Integer CAPTCHA_EXPIRATION = 2;
/**
* 令牌
*/
public static final String TOKEN = "token";
/**
* 令牌前缀
*/
public static final String TOKEN_PREFIX = "Bearer ";
/**
* 令牌前缀
*/
public static final String LOGIN_USER_KEY = "login_user_key";
/**
* 用户ID
*/
public static final String JWT_USERID = "userid";
/**
* 用户名称
*/
public static final String JWT_USERNAME = Claims.SUBJECT;
/**
* 用户头像
*/
public static final String JWT_AVATAR = "avatar";
/**
* 创建时间
*/
public static final String JWT_CREATED = "created";
/**
* 用户权限
*/
public static final String JWT_AUTHORITIES = "authorities";
/**
* 资源映射路径 前缀
*/
public static final String RESOURCE_PREFIX = "/profile";
/**
* RMI 远程方法调用
*/
public static final String LOOKUP_RMI = "rmi:";
/**
* LDAP 远程方法调用
*/
public static final String LOOKUP_LDAP = "ldap:";
/**
* LDAPS 远程方法调用
*/
public static final String LOOKUP_LDAPS = "ldaps:";
/**
* 自动识别json对象白名单配置仅允许解析的包名范围越小越安全
*/
public static final String[] JSON_WHITELIST_STR = {"org.springframework", "com.core"};
/**
* 定时任务白名单配置(仅允许访问的包名,如其他需要可以自行添加)
*/
public static final String[] JOB_WHITELIST_STR = {"com.openhis.quartz.task"};
/**
* 定时任务违规的字符
*/
public static final String[] JOB_ERROR_STR =
{"java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml", "org.springframework", "org.apache",
"com.core.common.utils.file", "com.core.common.config", "com.core.generator"};
}

View File

@@ -0,0 +1,116 @@
package com.core.common.constant;
/**
* 代码生成通用常量
*
* @author system
*/
public class GenConstants {
/** 单表(增删改查) */
public static final String TPL_CRUD = "crud";
/** 树表(增删改查) */
public static final String TPL_TREE = "tree";
/** 主子表(增删改查) */
public static final String TPL_SUB = "sub";
/** 树编码字段 */
public static final String TREE_CODE = "treeCode";
/** 树父编码字段 */
public static final String TREE_PARENT_CODE = "treeParentCode";
/** 树名称字段 */
public static final String TREE_NAME = "treeName";
/** 上级菜单ID字段 */
public static final String PARENT_MENU_ID = "parentMenuId";
/** 上级菜单名称字段 */
public static final String PARENT_MENU_NAME = "parentMenuName";
/** 数据库字符串类型 */
public static final String[] COLUMNTYPE_STR = {"char", "varchar", "nvarchar", "varchar2"};
/** 数据库文本类型 */
public static final String[] COLUMNTYPE_TEXT = {"tinytext", "text", "mediumtext", "longtext"};
/** 数据库时间类型 */
public static final String[] COLUMNTYPE_TIME = {"datetime", "time", "date", "timestamp"};
/** 数据库数字类型 */
public static final String[] COLUMNTYPE_NUMBER =
{"tinyint", "smallint", "mediumint", "int", "number", "integer", "bit", "bigint", "float", "double", "decimal"};
/** 页面不需要编辑字段 */
public static final String[] COLUMNNAME_NOT_EDIT = {"id", "create_by", "create_time", "del_flag"};
/** 页面不需要显示的列表字段 */
public static final String[] COLUMNNAME_NOT_LIST =
{"id", "create_by", "create_time", "del_flag", "update_by", "update_time"};
/** 页面不需要查询字段 */
public static final String[] COLUMNNAME_NOT_QUERY =
{"id", "create_by", "create_time", "del_flag", "update_by", "update_time", "remark"};
/** Entity基类字段 */
public static final String[] BASE_ENTITY = {"createBy", "createTime", "updateBy", "updateTime", "remark"};
/** Tree基类字段 */
public static final String[] TREE_ENTITY = {"parentName", "parentId", "orderNum", "ancestors", "children"};
/** 文本框 */
public static final String HTML_INPUT = "input";
/** 文本域 */
public static final String HTML_TEXTAREA = "textarea";
/** 下拉框 */
public static final String HTML_SELECT = "select";
/** 单选框 */
public static final String HTML_RADIO = "radio";
/** 复选框 */
public static final String HTML_CHECKBOX = "checkbox";
/** 日期控件 */
public static final String HTML_DATETIME = "datetime";
/** 图片上传控件 */
public static final String HTML_IMAGE_UPLOAD = "imageUpload";
/** 文件上传控件 */
public static final String HTML_FILE_UPLOAD = "fileUpload";
/** 富文本控件 */
public static final String HTML_EDITOR = "editor";
/** 字符串类型 */
public static final String TYPE_STRING = "String";
/** 整型 */
public static final String TYPE_INTEGER = "Integer";
/** 长整型 */
public static final String TYPE_LONG = "Long";
/** 浮点型 */
public static final String TYPE_DOUBLE = "Double";
/** 高精度计算类型 */
public static final String TYPE_BIGDECIMAL = "BigDecimal";
/** 时间类型 */
public static final String TYPE_DATE = "Date";
/** 模糊查询 */
public static final String QUERY_LIKE = "LIKE";
/** 相等查询 */
public static final String QUERY_EQ = "EQ";
/** 需要 */
public static final String REQUIRE = "1";
}

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