hanjian/salpa-admin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Jane 2023-12-26 11:02:39 +08:00
commit 03cc177018
519 changed files with 54893 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
LICENSE Normal file
View File

@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

99
README.md Normal file
View File

@ -0,0 +1,99 @@
## Salpa：数据模型统一管理平台
Salpa是一个非常易用数据模型设计、模型监控、模型管理的集成平台，Salpa可以对市面上已知的大部分数据库，如mysql、oracle、sqlserver、mariadb、postgresql等进行数据模型设计与管理。
![输入图片说明](diagrams/salpa/%E4%BB%8B%E7%BB%8D%E5%9B%BE%E7%A4%BA.png)
### 我们为什么需要 Salpa
Salpa尽所能为您解决数据模型管理可能遇到的问题：
​ ● 数据业务飞速发展，成百上千规模时候，模型如何管理
​ ● 如何从全局角度来审视整个数据体系全貌
​ ● 数据模型分散在不同引擎中
​ ● 每个引擎数据模型长什么样，业务人员无法实时感知
​ ● 数据项目没有办法有效落标引起数据质量问题
​ ● 数据时效性问题
### Salpa 使用场景
​ ● 数据模型设计
​ ● 可视化模型管理
​ ● 实时数据模型监控
​ ● 整合不同引擎数据模型
​ ● 编写SQL在线查询各类库
​ ● 数据模型变化告警
### Salpa 的特性
​ ● 前后端分离技术
​ ● 简单易用，灵活配置，无需开发
​ ● 支持加载动态权限菜单
​ ● 多方式轻松权限控制
​ ● 支持多种数据库扩展
​ ● 模块化，易于扩展
### Salpa 的架构图示
简单来说，前端UI采用react,typescript,以及antd对页面进行渲染展示，通过Ajax的get和post请求进入后端控制层，调用api接口获取相关数据。请求进入后端后根据不同模块进行业务处理，并通过持久层对数据库进行调用及进行相关数据处理，salpa的架构如下图所示。
<img src="diagrams/salpa/%E6%9E%B6%E6%9E%84%E5%9B%BE.png" width="70%" height="70%" />
### Salpa 的功能说明
系统主要模块包含模型管理、模型监控、在线查询以及系统管理：
1. 模型管理主要应用于项目初期，数据模型设计阶段。支持对项目人员管理，数据模型设计以及设计完成后导入数据库。
2. 模型监控，包含主题管理、数据库扩展和告警管理三部分，支持对数据模型进行监控，及时发现模型问题及变化。
3. 在线查询，数据在线查询功能，支持各种数据源。
4. 系统管理，包含用户管理、角色管理、菜单管理、部门管理、岗位管理、字典管理六个模块。
![输入图片说明](diagrams/salpa/%E5%8A%9F%E8%83%BD%E5%9B%BE%E7%A4%BA.png)
### salpa 效果图
<img src="diagrams/salpa/%E6%95%88%E6%9E%9C%E5%9B%BE/%E6%95%88%E6%9E%9C%E5%9B%BE1.png" width="30%" height="30%" /> <img src="diagrams/salpa/%E6%95%88%E6%9E%9C%E5%9B%BE/%E6%95%88%E6%9E%9C%E5%9B%BE2.png" width="30%" height="30%" /> <img src="diagrams/salpa/%E6%95%88%E6%9E%9C%E5%9B%BE/%E6%95%88%E6%9E%9C%E5%9B%BE3.png" width="30%" height="30%" /> <img src="diagrams/salpa/%E6%95%88%E6%9E%9C%E5%9B%BE/%E6%95%88%E6%9E%9C%E5%9B%BE4.png" width="30%" height="30%" /> <img src="diagrams/salpa/%E6%95%88%E6%9E%9C%E5%9B%BE/%E6%95%88%E6%9E%9C%E5%9B%BE5.png" width="30%" height="30%" />
### 环境依赖
1.JDK >= 11 (推荐11.0.14版本)
2.Mysql >= 5.7.0 (推荐5.7.22版本)
3.Redis >= 3.0 (推荐4.0.8版本)
4.nginx (推荐nginx/1.99版本)
### 快速入门
关于Salpa[需求文档](/docs/01-Salpa需求规格说明书.doc)
关于Salpa[设计文档](/docs/02-详细设计说明书.doc)
关于Salpa[使用手册](/docs/salpa使用手册.docx)
### 欢迎联系
微信：
<img src="diagrams/salpa/%E4%BA%8C%E7%BB%B4%E7%A0%81.jpg" width="10%" height="10%" />

12
bin/clean.bat Normal file
View File

@ -0,0 +1,12 @@
@echo off
echo.
echo [信息] 清理工程target生成路径。
echo.
%~d0
cd %~dp0
cd ..
call mvn clean
pause

12
bin/package.bat Normal file
View File

@ -0,0 +1,12 @@
@echo off
echo.
echo [信息] 打包Web工程，生成war/jar包文件。
echo.
%~d0
cd %~dp0
cd ..
call mvn clean package -Dmaven.test.skip=true
pause

14
bin/run.bat Normal file
View File

@ -0,0 +1,14 @@
@echo off
echo.
echo [信息] 使用Jar命令运行Web工程。
echo.
cd %~dp0
cd ../ruoyi-admin/target
set JAVA_OPTS=-Xms256m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m
java -jar %JAVA_OPTS% ruoyi-admin.jar
cd bin
pause

0
diagrams/salpa/.keep Normal file
View File

BIN
diagrams/salpa/二维码.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 98 KiB

BIN
diagrams/salpa/介绍图示.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.4 MiB

BIN
diagrams/salpa/功能图示.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.5 MiB

0
diagrams/salpa/效果图/.keep Normal file
View File

BIN
diagrams/salpa/效果图/效果图1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 332 KiB

BIN
diagrams/salpa/效果图/效果图2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 299 KiB

BIN
diagrams/salpa/效果图/效果图3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 287 KiB

BIN
diagrams/salpa/效果图/效果图4.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 324 KiB

BIN
diagrams/salpa/效果图/效果图5.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 185 KiB

BIN
diagrams/salpa/架构图.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 308 KiB

0
docs/.keep Normal file
View File

0
docs/01-Salpa需求规格说明书.doc Normal file
View File

0
docs/02-详细设计说明书.doc Normal file
View File

526
docs/salpa使用手册.docx Normal file
View File

@ -0,0 +1,526 @@
Salpa：数据模型统一管理平台使用说明
1.1 模型管理
模型管理用来做数据模型的设计，包括图表、数据修改、数据库连接，分配给不同用户操作不同模型的权限。
点击菜单栏"模型管理"-->"模型设计"，进入模型设计页面，具体如图1.1-1。
图1.1-1模型设计
1.1.1新建
在模型设计的头部导航栏中点击【+】按钮，页面会弹出新建项目，输入必填的信息，点击【保存】，就可以把数据保存到数据内容资产列表，具体如图1.1-2。
图1.1-2新建
1.1.2删除
鼠标移动到想要删除的项目卡片上，会出现删除图标，点击图标，会弹出提示信息，点击【确定】按钮，具体如图1.1-3、1.1-1。
-->
图1.1-3删除按钮 图1.1-1删除提示框
1.1.3查询
在头部导航栏的搜索框中填入搜索内容，点击【搜索】按钮，就会实现数据查询，具体如图1.1-5。
图1.1-5查询
1.1.4编辑
鼠标移动到想要编辑的项目卡片上，会出现编辑图标，点击图标，会弹出编辑框，输入想要修改的内容，点击【保存】按钮，具体如图1.1-6、1.1-7。
-->
图1.1-6编辑按钮 图1.1-7编辑提示框
1.1.5权限管理
在新建和编辑中的人员管理，是给用户分配权限的。切换用户，所看到的的项目也会有所不同，具体如图1.1-8。
图1.1-8权限管理
1.1.6数据表
点击数据表【学生管理系统】或者新建成功，会直接跳转到数据表设计界面。页面头部是返回按钮【<】和数据表的名字，具体如图1.1-9。
图1.1-9数据表
1.1.6.1新建/删除
点击左侧菜单栏中的图标，会显示【新增/删除】操作，点击【新增】,出现新增弹窗，填好数据点击【确定】，具体如图1.1-10。
图1.1-10新建
点击【删除】，出现删除提示框，点击【确定】，具体如图1.1-11。
图1.1-11删除
1.1.6.1.1逻辑模型新建/删除/编辑
点击图标会出现【新增/删除/编辑】选项，具体如图1.1-12。
图1.1-12选项框
点击【新增】，出现新增弹窗，输入内容后，点击【确定】，具体如图1.1-13。
图1.1-13新增
点击【删除】，出现删除提示框，点击【确定】，具体如图1.1-11。
图1.1-11删除
点击【信息编辑】，出现编辑弹窗，修改内容后，点击【确定】，具体如图1.1-15。
图1.1-15编辑
1.1.6.1.2 UML表
点击建立好的逻辑模型，点击图标拖拽到页面，创建UML表，可以实现矩形、菱形的表结构，可以改变字体颜色、背景颜色、图形的放大缩小，快捷键【Ctrl+C/Ctrl+V/Delete】可以实现图表的复制粘贴和删除等。具体如图1.1-16。
图1.1-16 icon图标
点击创建好的表，可以进行连接，具体如图1.1-17。
图1.1-17 UML图
1.1.6.1.3 数据表
左侧菜单对应的数据表创建好后，打开数据表，右侧会展示数据表中的数据，具体如图1.1-18、1.1-19、1.1-20。
图1.1-18 数据表
图1.1-19 索引
图1.1-20 数据库代码
1.1.6.1.1 数据表新建
数据表页面的【字段明细】中有【新增】按钮，点击右侧的图标，会显示新增条数选项，选中之后，列表会自动增加对应的空表格，具体如图1.1-21。
图1.1-20 数据表新建
1.1.6.1.5 数据表删除
在数据表页面的【字段明细】中，选中要删除的列表，【置顶】、【上移】、【删除】等功能可以使用，点击【删除】选中的列表就会被删掉，具体如图1.1-21。
图1.1-21 数据表删除
1.1.6.1.6 数据表连接UML
数据表的列表最左侧的图标，点击开启，在UML图中拖拽的当前数据表，会显示出当条数据；如果被隐藏，在UML图中不会有这条数据。具体如图1.1-22。
图1.1-22 UML引入学生表
当数据列表中被隐藏数据，具体如图1.1-23。
图1.1-23 数据表
UML图中被隐藏数据已经消失，具体如图1.1-21。
图1.1-21 UML图
1.1.6.1.7 索引新建
索引页面有【新增】按钮，点击右侧的图标，会显示新增条数选项，选中之后，列表会自动增加对应的空表格，具体如图1.1-25。
图1.1-25 新建
1.1.6.1.8 索引删除
在索引页面选中要删除的列表，【置顶】、【上移】、【删除】等功能可以使用，点击【删除】选中的列表就会被删掉，具体如图1.1-26。
图1.1-26 删除
1.1.6.1.9 数据库代码
数据库代码页面是通过点击上方不同的数据库，会生成不同的代码。还可以查看整个模型数据，具体如图1.1-27、1.1-28。
图1.1-27 MySQL代码
图1.1-28 模型数据
1.1.6.1.10 数据字典
打开左侧菜单中【数据字典】，每一个页面中点击文本框进行编辑，点击【保存】，保存数据,具体如图1.1-29。
图1.1-29 数据字典编辑
1.1.6.2 保存
所有的数据设计完成之后，点击左上方【保存】图标，将整个页面数据保存下来，具体如图6-30。
图1.1-30 保存
1.1.6.3 数据库连接
点击头部图标中的【数据库】，会出现弹窗，设置数据库配置，点击【测试】，成功会提示【连接成功】，具体如图1.1-31。
图1.1-31 数据库连接测试
1.1.6.1 数据库提交
连接成功之后，点击【执行】按钮，将建好的数据库数据传给后台，成功之后返回提示弹窗，具体如图1.1-32。
图1.1-32 数据库连接测试
1.2模型监控
1.2.1主题管理
主题管理管理多个主题，能够实现主题的增加，删除，修改，每个主题有一个数据库，数据库管理多个模型，能够实现模型的增加，删除，修改，能够以表格的形式及uml的形式展示数据库中所有表的具体情况。
点击上方菜单栏"模型监控 -- -- 主题管理"进入主题管理页面，如图1.2.1-1。
图1.2.1-1主题管理
1.2.1.1新建
点击左上方的"+"按钮，页面弹出新建框，在框内输入主题名称和主题描述,名称必须填写，描述非必填，点击保存按钮即可新建主题成功，如下图1.2.1-2。
图1.2.1-2创建新主题
1.2.1.2 查询
点击搜索栏，输入相应的主题名称，点击搜索按钮进行查询，如下图1.2.1-3.
图1.2.1-3查询主题
1.2.1.3编辑
当鼠标悬浮在主题卡片上，会出现该主题卡片的删除按钮和编辑按钮，如下图1.2.1-1，点击编辑按钮，出现编辑框，修改主题名称和主题内容，主题名称不能修改为空，点击保存按钮即可保存成功，点击取消按钮则恢复原数据，如下图1.2.1-5。
图1.2.1-1编辑按钮和删除按钮
图1.2.1-5编辑主题
1.2.1.1主题数据库
点击主题卡片的主题名称，即可进入该主题数据库，如图1.2.1-6，点击数据库中左上侧的面包屑导航即可返回主题管理页面，如图1.2.1-7。
图1.2.1-6点击进入主题数据库
图1.2.1-7主题数据库
1.2.1.5新建
点击左上的"+新建"按钮，弹出新建框，输入基础配置和高级配置，带"*"表示必填，保存按钮，确定按钮在高级配置Tab页，点击确定即可创建成功，如图1.2.1-8
图1.2.1-8创建
1.2.1.6查询
根据需求点击上方的输入栏，输入栏的搜索种类有模型名称搜索、数据库名称搜索、Schema名称搜索、数据库类型搜索，输入条件后点击最右侧的搜索按钮即可完成条件查询，如下图1.2.1-9。
图1.2.1-9 查询
1.2.1.7编辑
点击表格中的操作列，鼠标悬浮在"v"按钮时，出现该模型的操作下拉框，如图1.2.1-10，点击"编辑模型"按钮，出现该模型的编辑框，修改后点击保存即可修改成功，如图1.2.1-11。
图1.2.1-10 操作
图1.2.1-11编辑
1.2.1.8查看日志
点击表格中操作的"查看日志"按钮，弹出日志框，如图1.2.1-12.
图1.2.1-12查看日志
1.2.1.9删除
点击表格中操作的"删除模型"按钮，点击确定即可删除该模型，如图1.2.1-13。
图1.2.1-13删除模型
1.2.1.10主题详情
点击表格中操作的"详情"按钮，即可进入到主题详情页面，如图1.2.1-11,点击主题详情页面左上面包屑的主题管理页面返回到主题管理页面，点击数据库返回到数据库页面，如图1.2.1-15。
图1.2.1-11 点击进入主题详情
图1.2.1-15主题详情
1.2.1.11菜单的缩放与条件查询
点击左上角缩放按钮即可完成左侧菜单的缩放效果，点击搜索栏输入条件后取消焦点后自动查询，如图1.2.1-16。
图1.2.1-16菜单
1.2.1.12菜单切换
点击概览菜单选项时页面显示的是全部表的情况，文档Tab以表的形式展示如图1.2.1-17，UMLTab以uml图展示，如图1.2.1-18。
图1.2.1-17概览菜单文档Tab
图1.2.1-18概览菜单UMl Tab
1.2.1.13单表菜单
除概览以外的均为单表菜单，点击单表菜单显示该表的具体情况，文档Tab以表格形式展示如图1.2.1-19，UML Tab以该表的uml图展示如图1.2.1-20。
图1.2.1-19单表菜单文档Tab
图1.2.1-20单表菜单UML Tab
1.2.1.11讨论
当菜单处于概览选项时，点击页面中Tables表中的讨论列的按钮时如图1.2.1-21，会弹出表格中该条数据的讨论弹窗，点击输入框输入文字后点击提交即可提交讨论，鼠标悬浮在讨论上时如果为本人提交的讨论会出现删除按钮， 点击即可删除，非本人提交的不出现删除按钮，无法删除，如图1.2.1-22。
图1.2.1-21概览菜单讨论
图1.2.1-22讨论
1.2.1.15同步
点击上方的同步按钮，即可进行同步操作，同步时弹出当前任务进度条，如图1.2.1-23,当任务完成后，该任务进度条显示已完成，如图1.2.1-21。
图1.2.1-23同步任务进度提示框
图1.2.1-21同步结束提示框
1.2.1.16取消同步任务
任务同步时，鼠标悬浮在该任务的"同步中"进度提示时，出现"点击即可取消"按钮，点击该按钮即可取消同步任务，如图1.2.1-25。
图1.2.1-25取消同步任务
1.2.1.17查看任务同步情况
点击"同步"按钮左侧按钮，当未同步时该按钮隐藏，点击该按钮出现同步任务进度情况，如图1.2.1-26。
图1.2.1-26同步任务日志
1.2.1.18导出
点击上方的"导出"按钮，点击所需导出的格式即可完成导出，支持的格式有Markdown、UML SVG、UML PNG、Word如图1.2.1-27。
图1.2.1-27 导出
1.2.1.19切换版本
点击上方切换菜单下拉框，选择需要切换的版本，即可切换成功如图1.2.1-28。
图1.2.1-28 切换版本
1.2.1.20显示版本差异
点击上方的"显示版本差异按钮",出现对比版本下拉框，如图1.2.1-29。
图1.2.1-29显示版本差异
1.2.1.21对比版本
默认当前版本和对比版本都为最新版本，切换当前版本和对比版本时，概览会显示数据库中所有表的变化情况，绿色代表新增表，红色代表删除表，橙色代表修改表，如图1.2.1-30，图1.2.1-31，单表会显示其数据变化情况，绿色代表该表新增数据，红色代表该表删除数据，橙色代表该表修改数据。如图1.2.1-32。
图1.2.1-30概览菜单对比版本效果图
图1.2.1-31概览菜单对比版本效果图
图1.2.1-32单表对比版本效果图
1.2.2数据库拓展
数据库拓展用来管理数据库的类型，同时也可以完成数据库的新增，修改和删除。
点击上方菜单栏"模型监控 -- -- 数据库拓展"进入数据库拓展页面，如图1.2.2-1。
图1.2.2-1数据库拓展
1.2.2.1新建
点击页面上方的"+"按钮进行新建数据库，弹出新建框如图1.2.2-2，点击"驱动获取方式"下拉框，默认驱动方式为链接下载，在"JDBC驱动下载地址"输入框输入地址后点击"驱动类名"按钮获取驱动类名，如图1.2.2-3，当驱动方式切换成本地导入后，点击"点击上传文件"按钮上传文件后，点击"驱动类名"按钮获取驱动类名，如图1.2.2-1 全部信息输入后点击"确定"按钮创建新的数据库。
图1.2.2-2新建数据库
图1.2.2-3链接下载
图1.2.2-1本地导入
1.2.2.2查询
点击查询输入框输入需要查询的数据库类型名称后点击搜索按钮,如图1.2.2-5。
图1.2.2-5查询
1.2.2.3删除
当鼠标悬浮在数据库卡片上，会出现该数据库的删除按钮和编辑按钮，如图1.2.2-6，点击删除后，出现删除框，点击确定即可删除，如图1.2.2-7。
图1.2.2-6 删除按钮和编辑按钮
图1.2.2-7删除
1.2.2.1编辑
鼠标悬浮在数据库卡片上，点击编辑按钮，出现该数据库的编辑框，根据需求修改信息，点击"确定"按钮即可，如图1.2.2-8。
图1.2.2-8编辑
1.2.3告警管理
告警管理页面是当数据库发生改变生成新的版本时，将会自动生成一条告警信息，通过点击处理来确认是否已经查看过此条告警信息，同时显示已读者即处理人的名称。
点击上方菜单栏"模型监控 -- -- 告警管理"进入告警管理页面，如图1.2.3-1。
图1.2.3-1告警管理
1.2.3.1处理
点击页面中表格的操作列，点击"待处理"按钮进行处理，处理完成后，"待处理"按钮变为"已处理"按钮，显示为"已处理"的数据不能再次操作，处理人列显示该条数据的处理人的名称，告警状态由未读改为已读 如图1.2.3-2。
图1.2.3-2处理
1.3 在线查询
在线查询用来做数据转换、集成和可视化，支持各种数据源。
点击菜单栏"在线查询"-->"数据库查询"，进入数据库查询页面，具体如图1.3-1。
图1.3-1 数据库查询
1.3.1查询
在顶部【选择数据源】中选择数据源，左侧会展示出相对应的数据库，具体如图1.3-2。
图1.3-2 查询
1.3.2 Sql输入
右侧输入sql语句，用来查询数据库中的数据，具体如图7-3。
图1.3-3 sql语句
1.3.3 数据库
点击顶部【执行】按钮，会在sql语句底部展示出列表数据，具体如图1.3-1。
图1.3-4 数据库列表
列表具有排序、滚动条、分页功能，具体如图1.3-5。
图1.3-5 数据库列表
1.4 系统管理
1.4.1 用户管理
⽤户管理可以管理系统的所有账户，控制账户的各种权限。⽤户管理模块只有系统管理员有权限执⾏操作。
点击菜单栏"系统管理"-->"⽤户管理"，进⼊⽤户管理⻚⾯，具体如图1.4.1-1。
图1.4.1-1 用户管理页面
1.4.1.1 新增用户
在⽤户管理，点击左上⻆的 "新建"按钮即可创建⼀个新⽤户，具体如图1.4.1-2。
图1.4.1-2 新增用户
进⼊表单⻚后，需要填写⽤户的基础信息，并为该⽤户设置⼀个密码，平台⽬前不会校验邮箱的真实性，请确保邮箱填写正确，具体如图1.4.1-3。
图1.4.1-3 新增用户弹框
点击保存以后就可以在列表⻚看⻅刚刚新增的⽤户了
1.4.1.2 修改用户
在⽤户管理，点击⽤户列表的 "编辑"按钮即可修改⽤户，具体如图1.4.1-4和1.4.1-5。
图1.4.1-4 修改用户
图1.4.1-5 修改用户弹框
1.4.1.3 删除用户
在⽤户管理，点击⽤户列表的 "删除"按钮即可删除⽤户，删除需⼆次确认，确认后将删除⽤户选中多个⽤户后，⽀持批量删除⽤户，具体如图1.4.1-6。
图1.4.1-6 删除用户
1.4.1.4 密码重置
在⽤户管理，点击⽤户列表的 "密码"按钮即可修改⽤户密码，修改⽤户密码需要输⼊原密码，具体如图1.4.1-7。
图1.4.1-7 密码重置
1.4.1.5 导出用户
在⽤户列表中选中要导出的⽤户，⽀持多选，点击右上⽅"导出"按钮，导出⽤户信息。如果不选中⽤户信息，直接点击"导出"，将导出全部⽤户信息，具体如图1.4.1-8。
图1.4.1-8 导出用户
1.4.1.6 查询用户
在⽤户列表中上⽅⽀持进⾏查询搜索、重置等功能，查询选项默认三项：部⻔ID、⽤户账号、⽤户邮箱，点击"展开"按钮后，查询选项为五项，分别为：部⻔ID、⽤户账号、⽤户邮箱、⼿机号码、账号状态，具体如图1.4.1-9。
图1.4.1-9查询用户
1.4.1.7 设置
在⽤户列表中上⽅⽀持刷新列表、配置列表密度和列配置，具体如图1.4.1-10。
图1.4.1-10设置
1.4.2角色管理
⻆⾊管理对系统所有⻆⾊进⾏管理，为不同⻆⾊设置不同的菜单权限。⻆⾊管理模块只有系统管理员有权限执⾏操作。
点击菜单栏"系统管理"-->"⻆⾊管理"，进⼊⻆⾊管理⻚⾯，具体如图1.4.2-1。
图1.4.2-1角色管理
1.4.2.1 新建角色
在⻆⾊管理，点击左上⻆的 "新建"按钮即可创建⼀个新⻆⾊，具体如图1.4.2-2。
图1.4.2.2新建角色
进⼊表单⻚后，需要填写⻆⾊的基础信息，点击确定，完成⻆⾊新建，具体如图1.4.2.3
图1.4.2.3新建角色弹框
1.4.2.2 修改角色
在⻆⾊管理，点击⻆⾊列表的 "编辑"按钮即可修改⻆⾊，具体如图1.4.2-4、1.4.2-5。
图1.4.2-4修改角色
图1.4.2-5修改弹框
1.4.2.3 删除角色
在⻆⾊管理，点击⻆⾊列表的 "删除"按钮即可删除⻆⾊，删除需⼆次确认，确认后将删除⻆⾊；选中多个⻆⾊后，⽀持批量删除。具体如图1.4.2-6。
图1.4.2-6删除角色
1.4.2.4 导出角色
在⻆⾊列表中选中要导出的⻆⾊，⽀持多选，点击右上⽅"导出"按钮，导出⻆⾊信息。如果不选中⻆⾊信息，直接点击"导出"，将导出全部⻆⾊信息，具体如图1.4.2-7。
图1.4.2-7导出角色
1.4.2.5 查询角色
在⻆⾊列表中上⽅⽀持进⾏查询搜索、重置等功能，查询选项默认包括三项：⻆⾊名称、⻆⾊权限字符串、显示顺序，点击"展开"按钮，查询选项为四项，分别为：⻆⾊名称、⻆⾊权限字符串、显示顺序、⻆⾊状态。具体如图1.4.2-8。
图1.4.2-8查询角色
1.4.2.6 设置
在⻆⾊列表中上⽅⽀持刷新列表、配置列表密度和列配置，具体如图1.4.2-9。
图1.4.2-9设置
1.4.3菜单管理
菜单管理⽀持控制平台所有菜单名称、图标、可⻅状态等。菜单管理模块只有系统管理员有权限执⾏操作。
点击菜单栏"系统管理"-->"菜单管理"，进⼊菜单管理⻚⾯，具体如图
1.4.3-1。
图1.4.3-1菜单管理
1.4.3.1 新建菜单
在菜单管理，点击左上⻆的 "新建"按钮即可创建⼀个新菜单，菜单存在层级关系，因此新建时，需要选择⽗级菜单。具体如图1.4.3-2。
图1.4.3-2新建菜单
进⼊表单⻚后，需要填写菜单信息，点击确定，完成菜单新建，具体如图1.4.3-3。
图1.4.3-3新建菜单弹框
1.4.3.2 修改菜单
在部⻔管理，点击部⻔列表的 "编辑"按钮即可修改⻆⾊，具体如图1.4.3-4、1.4.3-5。
图1.4.3-4修改菜单
图1.4.3-5修改菜单弹框
1.4.3.3 删除菜单
在菜单管理，点击菜单列表的 "删除"按钮即可删除菜单，删除需⼆次确认，确认后将删除菜单；选中多个菜单后，⽀持批量删除。具体如图1.4.3-6。
图1.4.3-6删除菜单
1.4.3.4 查询菜单
在菜单列表中上⽅⽀持进⾏查询搜索、重置等功能，查询选项默认包括三项：菜单名称、权限标识、菜单类型，点击"展开"，查询选项包括：菜单名称、权限标识、菜单类型、菜单状态，具体如图1.4.3-7。
图1.4.3-7查询菜单
1.4.3.5 设置
在菜单列表中上⽅⽀持刷新列表、配置列表密度和列配置，具体如图1.4.3-8。
图1.4.3-8设置
1.4.4部门管理
部⻔管理模块只有系统管理员有权限执⾏操作。点击菜单栏"系统管理"-->"部⻔管理"，进⼊部⻔管理⻚⾯，具体如图1.4.4-1。
图1.4.4-1部门管理
1.4.4.1新建部门
在菜单列表中上⽅⽀持刷新列表、配置列表密度和列配置，具体如图1.4.4-2。
图1.4.4-2新建部门
进⼊表单⻚后，需要填写部⻔的信息，点击确定，完成部⻔新建，具体如图1.4.4-3。
图1.4.4-3新建部门弹框
1.4.4.2修改部门
在部⻔管理，点击部⻔列表的 "编辑"按钮即可修改⻆⾊，具体如图1.4.4-4、1.4-4-5。
图1.4.4-4修改部门
图1.4.4-5修改部门弹框
1.4.4.3删除部门
在部⻔管理，点击部⻔列表的 "编辑"按钮即可修改⻆⾊，具体如图1.4.4-6。
图1.4.4-6删除部门
1.4.4.4查询部门
在部⻔列表中上⽅⽀持进⾏查询搜索、重置等功能，查询选项默认包括三项：部⻔名称、显示顺序、负责⼈，点击"展开"，查询选项包括：部⻔名称、显示顺序、负责⼈、联系电话、邮箱、部⻔状态，具体如图1.4.4-7。
图1.4.4-7查询部门
1.4.4.5设置
在⻆⾊列表中上⽅⽀持刷新列表、配置列表密度和列配置，具体如图1.4.4-8。
图1.4.4-8设置
1.4.5岗位管理
岗位管理将岗位信息展示在列表中，实现岗位的增删改查操作。点击菜单栏"系统管理"-->"岗位管理"，进⼊岗位管理⻚⾯，具体如图1.4.5-1。
图1.4.5-1岗位管理
1.4.5.1新建岗位
点击右侧的【新建】按钮，出现新建弹窗，填写完成，点击【确定】新建成功，具体如图1.4.5-2。
图1.4.5-2新建岗位
1.4.5.2删除岗位
点击想要删除⾏的【删除】按钮，弹出提示框，点击【确定】，删除成功；选中多个岗位后，⽀持批量删除。具体如图1.4.5-3。
图1.4.5-3删除岗位
1.4.5.3编辑岗位
点击想要编辑⾏的【编辑】按钮，弹出修改窗⼝，点击【确定】，修改成功，具体如图1.4.5-4。
图1.4.5-4编辑岗位
1.4.5.4查询岗位
顶部栏中输⼊想要查询的条件，点击右侧的【查询】，实现搜索，默认搜索包括三项：岗位编码、岗位名称、显示顺序，展开后新增状态筛选，具体如图1.4.5-5。
图1.4.5-5查询岗位
1.4.5.5导出岗位
点击右侧的【导出】按钮，会⽣成Excel⽂件，选择位置，点击【保存】，具体如图1.4.5-6。
图1.4.5-6导出岗位
1.4.6字典管理
字典管理是为数据库提供的⼀系列数据，可以进⾏增删改查操作。点击菜单栏"系统管理"-->"字典管理"，进⼊系统管理⻚⾯，具体如图1.4.6-1。
图1.4.6-1字典管理
1.4.6.1新建字典
点击右侧的【新建】按钮，出现新建弹窗，填写完成，点击【确定】新建成功，具体如图1.4.6-2。
图1.4.6-2新建字典
1.4.6.2删除字典
点击想要删除⾏的【删除】按钮，弹出提示框， 点击【确定】，删除成功；选中多个字典后，⽀持批量删除。1.4.6-3。
图1.4.6-3删除字典
1.4.6.3编辑字典
点击想要编辑⾏的【编辑】按钮，弹出修改窗⼝，点击【确定】，修改成功，具体如图1.4.6-4。
图1.4.6-4编辑字典
1.4.6.4查询字典
顶部栏中输⼊想要查询的条件，点击右侧的【查询】，实现搜索，具体如图1.4.6-5。
图1.4.6-5查询字典
1.4.6.5导出字典
点击右侧的【导出】按钮，会⽣成Excel⽂件，选择位置，点击【保存】，具体如图1.4.6-6。
图1.4.6-6导出字典
1.4.6.6字典数据
点击【字典类型】，会跳转到该列管理的数据中，具体如图1.4.6-7、1.4.6-8。
图1.4.6-7字典类型
图1.4.6-8字典数据
1.4.6.6.1字典数据新建
点击右侧的【新建】按钮，出现新建弹窗，填写完成，点击【确定】新建成功，具体如图1.4.6.6-1。
图1.4.6.6-1新建
1.4.6.6.2字典数据删除
点击想要删除⾏的【删除】按钮，弹出提示框，点击【确定】，删除成功，具体如图1.4.6.6-2。
图1.4.6.6-2删除
1.4.6.6.3字典数据编辑
点击想要编辑⾏的【编辑】按钮，弹出修改窗⼝，点击【确定】，修改成功，具体如图1.4.6.6-3。
图1.4.6.6-3编辑
1.4.6.6.4字典数据查询
顶部栏中输⼊想要查询的条件，点击右侧的【查询】，实现搜索，具体如图1.4.6.6-4。
图1.4.6.6-4查询
1.4.6.6.5字典数据导出
点击右侧的【导出】按钮，会⽣成Excel⽂件，选择位置，点击【保存】，具体如图1.4.6.6-5。
图1.4.6.6-5导出

3
docs/salpa安装手册.docx Normal file
View File

@ -0,0 +1,3 @@
1）准备工作检查服务器是否安装以下软件或程序JDK >= 11 (推荐11版本)Mysql >= 5.7.0 (推荐5.7版本)Redis >= 3.0Maven >= 3.0Node >= 122）创建数据库1.创建新数据库3）必要配置 (1)修改数据库连接 (2)修改服务器配置(3)修改redis配置false(4)修改文件路径，根据实际情况调整。4）后端部署oo 打包工程文件
在项目的bin目录下执行package.bat打包Web工程，生成war/jar包文件。生成在metaops/salpa-admin模块下target文件夹oo 部署工程文件
1、 jar部署方式（1）将打包好的jar文件上传至服务器(2)进入jar包所在目录使用命令启动jar包2、 war部署方式(1)metaops/pom.xml中的packaging修改为war(2)放入tomcat服务器webapps5)前端部署1.安装npm依赖进入前端项目cd metaops-front安装依赖npm install --registry=https://registry.npm.taobao.org2.打包构建生产环境npm run build:prod构建打包成功之后，会在根目录生成 dist 文件夹，里面就是构建打包好的文件，通常是 ***.js 、***.css、index.html 等静态文件。3.然后将dist文件夹的静态文件上传到服务器4.进入nginx安装目录，修改nginx.conf文件cd /usr/local/nginx/confvim nginx.confhttp下新增下列内容，并修改相关配置server { listen 89; //端口 server_name 192.168.XX.XX; //ip charset utf-8; location / { root /home/dataplatform/dist; //dist文件存放目录 index index.html index.htm; try_files $uri $uri/ /index.html; } location /api/{ proxy_pass http://192.168.XX.XX:8080/; //后端服务器访问地址 } error_page 500 502 503 504 /50x.html; location = /50x.html { root html; }}5.重新启动nginxcd /usr/local/nginx/sbin./nginx /usr/local/nginx/conf/nginx.conf6)登录7)效果图

15
metaops.iml Normal file
View File

@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_11">
<output url="file://$MODULE_DIR$/target/classes" />
<output-test url="file://$MODULE_DIR$/target/test-classes" />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
<sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
<sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
<excludeFolder url="file://$MODULE_DIR$/target" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

259
pom.xml Normal file
View File

@ -0,0 +1,259 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.salpa</groupId>
<artifactId>salpa</artifactId>
<version>3.8.3</version>
<name>metaops</name>
<description>敏捷元数据模型设计系统</description>
<properties>
<metaops.version>3.8.3</metaops.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>11</java.version>
<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
<druid.version>1.2.11</druid.version>
<bitwalker.version>1.21</bitwalker.version>
<swagger.version>3.0.0</swagger.version>
<kaptcha.version>2.3.2</kaptcha.version>
<mybatis-spring-boot.version>2.2.2</mybatis-spring-boot.version>
<pagehelper.boot.version>1.4.1</pagehelper.boot.version>
<fastjson.version>2.0.8</fastjson.version>
<oshi.version>6.1.6</oshi.version>
<commons.io.version>2.11.0</commons.io.version>
<commons.fileupload.version>1.4</commons.fileupload.version>
<commons.collections.version>3.2.2</commons.collections.version>
<poi.version>4.1.2</poi.version>
<velocity.version>2.3</velocity.version>
<jwt.version>0.9.1</jwt.version>
</properties>
<!-- 依赖声明 -->
<dependencyManagement>
<dependencies>
<!-- SpringBoot的依赖配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.14</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- 阿里数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- 解析客户端操作系统、浏览器等 -->
<dependency>
<groupId>eu.bitwalker</groupId>
<artifactId>UserAgentUtils</artifactId>
<version>${bitwalker.version}</version>
</dependency>
<!-- SpringBoot集成mybatis框架 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot.version}</version>
</dependency>
<!-- pagehelper 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>${pagehelper.boot.version}</version>
</dependency>
<!-- 获取系统信息 -->
<dependency>
<groupId>com.github.oshi</groupId>
<artifactId>oshi-core</artifactId>
<version>${oshi.version}</version>
</dependency>
<!-- Swagger3依赖 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>${swagger.version}</version>
<exclusions>
<exclusion>
<groupId>io.swagger</groupId>
<artifactId>swagger-models</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- io常用工具类 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>${commons.io.version}</version>
</dependency>
<!-- 文件上传工具类 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>${commons.fileupload.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
<version>1.21</version>
</dependency>
<!-- excel工具 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>${poi.version}</version>
</dependency>
<!-- poi-tl基于poi的word模板引擎 -->
<dependency>
<groupId>com.deepoove</groupId>
<artifactId>poi-tl</artifactId>
<version>1.10.0</version>
</dependency>
<!-- velocity代码生成使用模板 -->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity-engine-core</artifactId>
<version>${velocity.version}</version>
</dependency>
<!-- collections工具类 -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>${commons.collections.version}</version>
</dependency>
<!-- 阿里JSON解析器 -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!-- Token生成与解析-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>${jwt.version}</version>
</dependency>
<!-- 验证码 -->
<dependency>
<groupId>com.github.penggle</groupId>
<artifactId>kaptcha</artifactId>
<version>${kaptcha.version}</version>
</dependency>
<!-- 定时任务-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-quartz</artifactId>
<version>${metaops.version}</version>
</dependency>
<!-- 代码生成-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-generator</artifactId>
<version>${metaops.version}</version>
</dependency>
<!-- 核心模块-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-framework</artifactId>
<version>${metaops.version}</version>
</dependency>
<!-- 系统模块-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-system</artifactId>
<version>${metaops.version}</version>
</dependency>
<!-- 通用工具-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-common</artifactId>
<version>${metaops.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<modules>
<module>salpa-admin</module>
<module>salpa-framework</module>
<module>salpa-system</module>
<module>salpa-quartz</module>
<module>salpa-generator</module>
<module>salpa-common</module>
</modules>
<packaging>pom</packaging>
<dependencies>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<encoding>${project.build.sourceEncoding}</encoding>
</configuration>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>public</id>
<name>aliyun nexus</name>
<url>https://maven.aliyun.com/repository/public</url>
<releases>
<enabled>true</enabled>
</releases>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>public</id>
<name>aliyun nexus</name>
<url>https://maven.aliyun.com/repository/public</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</project>

277
salpa-admin/pom.xml Normal file
View File

@ -0,0 +1,277 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>salpa</artifactId>
<groupId>com.salpa</groupId>
<version>3.8.3</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<packaging>jar</packaging>
<artifactId>salpa-admin</artifactId>
<description>
web服务入口
</description>
<dependencies>
<!-- spring-boot-devtools -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional> <!-- 表示依赖不会传递 -->
</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>
<version>1.6.2</version>
</dependency>
<!-- Mysql驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- orcale驱动 -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.3</version>
</dependency>
<!-- postgresql驱动 -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.3.1</version>
</dependency>
<!-- mariadb驱动 -->
<dependency>
<groupId>org.mariadb.jdbc</groupId>
<artifactId>mariadb-java-client</artifactId>
<version>2.7.3</version>
</dependency>
<!-- db2驱动 -->
<!-- 阿里云仓库下载不到，需另行下载添加到maven仓库，如不需该数据库依赖可删除或注释掉 -->
<!-- https://mvnrepository.com/artifact/com.ibm.db2/db2jcc -->
<!--<dependency>
<groupId>com.ibm.db2</groupId>
<artifactId>db2jcc</artifactId>
<version>8.1</version>
</dependency>-->
<!-- https://mvnrepository.com/artifact/com.ibm.db2.jcc/db2jcc4 -->
<!--<dependency>
<groupId>com.ibm.db2.jcc</groupId>
<artifactId>db2jcc4</artifactId>
<version>10.1</version>
</dependency>-->
<!-- https://mvnrepository.com/artifact/com.ibm.db2/db2jcc_license_cu -->
<!--<dependency>
<groupId>com.ibm.db2</groupId>
<artifactId>db2jcc_license_cu</artifactId>
<version>9.7</version>
</dependency>-->
<!-- sqlserver驱动 -->
<!-- https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc -->
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>10.2.1.jre11</version>
</dependency>
<!-- clickhouse驱动 -->
<dependency>
<groupId>com.clickhouse</groupId>
<artifactId>clickhouse-jdbc</artifactId>
<version>0.3.2-patch9</version>
</dependency>
<!-- es驱动 -->
<dependency>
<groupId>org.elasticsearch.plugin</groupId>
<artifactId>x-pack-sql-jdbc</artifactId>
<version>7.10.0</version>
</dependency>
<!-- ignite驱动 -->
<!--<dependency>
<groupId>org.apache.ignite</groupId>
<artifactId>ignite-core</artifactId>
<version>2.8.1</version>
</dependency>-->
<!-- kylin驱动 -->
<dependency>
<groupId>org.apache.kylin</groupId>
<artifactId>kylin-jdbc</artifactId>
<version>2.6.3</version>
</dependency>
<!-- kyuubi驱动 -->
<dependency>
<groupId>org.apache.kyuubi</groupId>
<artifactId>kyuubi-hive-jdbc-shaded</artifactId>
<version>1.6.0-incubating</version>
</dependency>
<!-- prestosql驱动 -->
<dependency>
<groupId>io.prestosql</groupId>
<artifactId>presto-jdbc</artifactId>
<version>350</version>
</dependency>
<!-- trino驱动 -->
<dependency>
<groupId>io.trino</groupId>
<artifactId>trino-jdbc</artifactId>
<version>397</version>
</dependency>
<!-- hive驱动 -->
<dependency>
<groupId>org.apache.hive</groupId>
<artifactId>hive-jdbc</artifactId>
<version>1.2.1</version>
<exclusions>
<exclusion>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
</exclusion>
<exclusion>
<groupId>jdk.tools</groupId>
<artifactId>jdk.tools</artifactId>
</exclusion>
<exclusion>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
</exclusion>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</exclusion>
<exclusion>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
</exclusion>
<exclusion>
<groupId>org.eclipse.jetty.orbit</groupId>
<artifactId>*</artifactId>
</exclusion>
<exclusion>
<groupId>org.eclipse.jetty.aggregate</groupId>
<artifactId>*</artifactId>
</exclusion>
<exclusion>
<groupId>tomcat</groupId>
<artifactId>*</artifactId>
</exclusion>
<exclusion>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
</exclusion>
<exclusion>
<groupId>org.mortbay.jetty</groupId>
<artifactId>*</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<!-- 达梦数据库 -->
<!-- https://mvnrepository.com/artifact/com.dameng/DmJdbcDriver18 -->
<dependency>
<groupId>com.dameng</groupId>
<artifactId>DmJdbcDriver18</artifactId>
<version>8.1.2.79</version>
</dependency>
<!-- 人大金仓 -->
<!-- 阿里云仓库下载不到，需另行下载添加到maven仓库，如不需该数据库依赖可删除或注释掉 -->
<!--<dependency>
<groupId>com.kingbase8.jdbc</groupId>
<artifactId>kingbase8</artifactId>
<version>8.6.0</version>
</dependency>-->
<!-- MaxCompute -->
<!-- https://mvnrepository.com/artifact/com.aliyun.odps/odps-jdbc -->
<dependency>
<groupId>com.aliyun.odps</groupId>
<artifactId>odps-jdbc</artifactId>
<version>1.6</version>
</dependency>
<!-- sqlite -->
<!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.36.0.3</version>
</dependency>
<!-- 核心模块-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-framework</artifactId>
</dependency>
<!-- 定时任务-->
<dependency>
<groupId>com.salpa</groupId>
<artifactId>salpa-quartz</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.1.1.RELEASE</version>
<configuration>
<fork>true</fork> <!-- 如果没有该配置，devtools不会生效 -->
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.1.0</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
<warName>${project.artifactId}</warName>
</configuration>
</plugin>
</plugins>
<finalName>${project.artifactId}</finalName>
</build>
</project>

289
salpa-admin/salpa-admin.iml Normal file
View File

@ -0,0 +1,289 @@
<?xml version="1.0" encoding="UTF-8"?>
<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
<component name="FacetManager">
<facet type="Spring" name="Spring">
<configuration />
</facet>
<facet type="web" name="Web">
<configuration>
<webroots />
</configuration>
</facet>
</component>
<component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_11">
<output url="file://$MODULE_DIR$/target/classes" />
<output-test url="file://$MODULE_DIR$/target/test-classes" />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
<sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
<excludeFolder url="file://$MODULE_DIR$/target" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-devtools:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-core:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-jcl:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-context:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-expression:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-autoconfigure:2.5.14" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-boot-starter:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-oas:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.swagger.core.v3:swagger-annotations:2.1.2" level="project" />
<orderEntry type="library" name="Maven: io.swagger.core.v3:swagger-models:2.1.2" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-spi:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-schema:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-core:3.0.0" level="project" />
<orderEntry type="library" name="Maven: net.bytebuddy:byte-buddy:1.10.22" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-spring-web:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.github.classgraph:classgraph:4.8.83" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-spring-webmvc:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-spring-webflux:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-swagger-common:3.0.0" level="project" />
<orderEntry type="library" name="Maven: org.mapstruct:mapstruct:1.3.1.Final" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-data-rest:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-bean-validators:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-swagger2:3.0.0" level="project" />
<orderEntry type="library" name="Maven: io.springfox:springfox-swagger-ui:3.0.0" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml:classmate:1.5.1" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:slf4j-api:1.7.36" level="project" />
<orderEntry type="library" name="Maven: org.springframework.plugin:spring-plugin-core:2.0.0.RELEASE" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-beans:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-aop:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework.plugin:spring-plugin-metadata:2.0.0.RELEASE" level="project" />
<orderEntry type="library" name="Maven: io.swagger:swagger-models:1.6.2" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-annotations:2.12.6" level="project" />
<orderEntry type="library" name="Maven: io.swagger:swagger-annotations:1.6.2" level="project" />
<orderEntry type="library" name="Maven: mysql:mysql-connector-java:8.0.29" level="project" />
<orderEntry type="library" name="Maven: com.oracle:ojdbc6:11.2.0.3" level="project" />
<orderEntry type="library" name="Maven: org.postgresql:postgresql:42.3.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.checkerframework:checker-qual:3.5.0" level="project" />
<orderEntry type="library" name="Maven: org.mariadb.jdbc:mariadb-java-client:2.7.3" level="project" />
<orderEntry type="library" name="Maven: com.microsoft.sqlserver:mssql-jdbc:10.2.1.jre11" level="project" />
<orderEntry type="library" name="Maven: com.clickhouse:clickhouse-jdbc:0.3.2-patch9" level="project" />
<orderEntry type="library" name="Maven: com.clickhouse:clickhouse-grpc-client:netty:0.3.2-patch9" level="project" />
<orderEntry type="library" name="Maven: com.clickhouse:clickhouse-http-client:shaded:0.3.2-patch9" level="project" />
<orderEntry type="library" name="Maven: com.google.code.gson:gson:2.8.9" level="project" />
<orderEntry type="library" name="Maven: org.apache.httpcomponents:httpclient:4.5.13" level="project" />
<orderEntry type="library" name="Maven: commons-codec:commons-codec:1.15" level="project" />
<orderEntry type="library" name="Maven: org.apache.httpcomponents:httpmime:4.5.13" level="project" />
<orderEntry type="library" name="Maven: org.lz4:lz4-java:1.8.0" level="project" />
<orderEntry type="library" name="Maven: org.elasticsearch.plugin:x-pack-sql-jdbc:7.10.0" level="project" />
<orderEntry type="library" name="Maven: org.apache.kylin:kylin-jdbc:2.6.3" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:jcl-over-slf4j:1.7.36" level="project" />
<orderEntry type="library" name="Maven: org.apache.kyuubi:kyuubi-hive-jdbc-shaded:1.6.0-incubating" level="project" />
<orderEntry type="library" name="Maven: io.prestosql:presto-jdbc:350" level="project" />
<orderEntry type="library" name="Maven: io.trino:trino-jdbc:397" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive:hive-jdbc:1.2.1" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive:hive-common:1.2.1" level="project" />
<orderEntry type="library" name="Maven: commons-cli:commons-cli:1.2" level="project" />
<orderEntry type="library" name="Maven: commons-lang:commons-lang:2.6" level="project" />
<orderEntry type="library" name="Maven: joda-time:joda-time:2.5" level="project" />
<orderEntry type="library" name="Maven: log4j:log4j:1.2.16" level="project" />
<orderEntry type="library" name="Maven: log4j:apache-log4j-extras:1.2.17" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-compress:1.21" level="project" />
<orderEntry type="library" name="Maven: org.apache.ant:ant:1.9.1" level="project" />
<orderEntry type="library" name="Maven: org.apache.ant:ant-launcher:1.9.1" level="project" />
<orderEntry type="library" name="Maven: org.json:json:20090211" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive:hive-service:1.2.1" level="project" />
<orderEntry type="library" name="Maven: net.sf.jpam:jpam:1.1" level="project" />
<orderEntry type="library" name="Maven: org.apache.thrift:libfb303:0.9.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.curator:curator-recipes:2.6.0" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive:hive-serde:1.2.1" level="project" />
<orderEntry type="library" name="Maven: com.google.code.findbugs:jsr305:3.0.0" level="project" />
<orderEntry type="library" name="Maven: org.apache.avro:avro:1.7.5" level="project" />
<orderEntry type="library" name="Maven: org.codehaus.jackson:jackson-core-asl:1.9.13" level="project" />
<orderEntry type="library" name="Maven: com.thoughtworks.paranamer:paranamer:2.3" level="project" />
<orderEntry type="library" name="Maven: net.sf.opencsv:opencsv:2.3" level="project" />
<orderEntry type="library" name="Maven: com.twitter:parquet-hadoop-bundle:1.6.0" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive:hive-metastore:1.2.1" level="project" />
<orderEntry type="library" name="Maven: com.google.guava:guava:14.0.1" level="project" />
<orderEntry type="library" name="Maven: com.jolbox:bonecp:0.8.0.RELEASE" level="project" />
<orderEntry type="library" name="Maven: org.apache.derby:derby:10.14.2.0" level="project" />
<orderEntry type="library" name="Maven: org.datanucleus:datanucleus-api-jdo:3.2.6" level="project" />
<orderEntry type="library" name="Maven: org.datanucleus:datanucleus-core:3.2.10" level="project" />
<orderEntry type="library" name="Maven: org.datanucleus:datanucleus-rdbms:3.2.9" level="project" />
<orderEntry type="library" name="Maven: commons-pool:commons-pool:1.6" level="project" />
<orderEntry type="library" name="Maven: commons-dbcp:commons-dbcp:1.4" level="project" />
<orderEntry type="library" name="Maven: javax.jdo:jdo-api:3.0.1" level="project" />
<orderEntry type="library" name="Maven: javax.transaction:jta:1.1" level="project" />
<orderEntry type="library" name="Maven: org.antlr:antlr-runtime:3.4" level="project" />
<orderEntry type="library" name="Maven: org.antlr:stringtemplate:3.2.1" level="project" />
<orderEntry type="library" name="Maven: antlr:antlr:2.7.7" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive:hive-shims:1.2.1" level="project" />
<orderEntry type="library" name="Maven: org.apache.hive.shims:hive-shims-common:1.2.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hive.shims:hive-shims-0.20S:1.2.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hive.shims:hive-shims-0.23:1.2.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-yarn-server-resourcemanager:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-annotations:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.google.inject.extensions:guice-servlet:3.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.google.inject:guice:3.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: javax.inject:javax.inject:1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: aopalliance:aopalliance:1.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.sun.jersey:jersey-json:1.9" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.sun.xml.bind:jaxb-impl:2.2.3-1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.codehaus.jackson:jackson-jaxrs:1.8.3" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.codehaus.jackson:jackson-xc:1.8.3" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.sun.jersey.contribs:jersey-guice:1.9" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.sun.jersey:jersey-server:1.9" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: asm:asm:3.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-yarn-common:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-yarn-api:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.codehaus.jettison:jettison:1.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.sun.jersey:jersey-core:1.9" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.sun.jersey:jersey-client:1.9" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-yarn-server-common:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.fusesource.leveldbjni:leveldbjni-all:1.8" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-yarn-server-applicationhistoryservice:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: commons-collections:commons-collections:3.2.2" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hadoop:hadoop-yarn-server-web-proxy:2.6.0" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: commons-httpclient:commons-httpclient:3.1" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.apache.hive.shims:hive-shims-scheduler:1.2.1" level="project" />
<orderEntry type="library" name="Maven: commons-logging:commons-logging:1.1.3" level="project" />
<orderEntry type="library" name="Maven: org.apache.httpcomponents:httpcore:4.4.15" level="project" />
<orderEntry type="library" name="Maven: org.apache.thrift:libthrift:0.9.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.zookeeper:zookeeper:3.4.6" level="project" />
<orderEntry type="library" name="Maven: jline:jline:0.9.94" level="project" />
<orderEntry type="library" name="Maven: junit:junit:4.13.2" level="project" />
<orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:2.2" level="project" />
<orderEntry type="library" name="Maven: org.hamcrest:hamcrest:2.2" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty:3.7.0.Final" level="project" />
<orderEntry type="library" name="Maven: org.apache.curator:curator-framework:2.6.0" level="project" />
<orderEntry type="library" name="Maven: org.apache.curator:curator-client:2.6.0" level="project" />
<orderEntry type="library" name="Maven: com.alibaba:druid:1.2.8" level="project" />
<orderEntry type="library" name="Maven: javax.annotation:javax.annotation-api:1.3.2" level="project" />
<orderEntry type="library" name="Maven: com.dameng:DmJdbcDriver18:8.1.2.79" level="project" />
<orderEntry type="library" name="Maven: com.aliyun.odps:odps-jdbc:1.6" level="project" />
<orderEntry type="library" name="Maven: com.aliyun.odps:odps-sdk-core:0.18.3-public" level="project" />
<orderEntry type="library" name="Maven: com.aliyun.odps:odps-sdk-commons:0.18.3-public" level="project" />
<orderEntry type="library" name="Maven: com.jcabi:jcabi-aspects:0.20.1" level="project" />
<orderEntry type="library" name="Maven: com.jcabi:jcabi-log:0.15" level="project" />
<orderEntry type="library" name="Maven: org.aspectj:aspectjrt:1.9.7" level="project" />
<orderEntry type="library" name="Maven: javax.validation:validation-api:2.0.1.Final" level="project" />
<orderEntry type="library" name="Maven: org.codehaus.jackson:jackson-mapper-asl:1.9.13" level="project" />
<orderEntry type="library" name="Maven: net.sourceforge.javacsv:javacsv:2.0" level="project" />
<orderEntry type="library" name="Maven: org.bouncycastle:bcprov-jdk15on:1.52" level="project" />
<orderEntry type="library" name="Maven: org.xerial.snappy:snappy-java:1.1.1.6" level="project" />
<orderEntry type="library" name="Maven: com.google.protobuf:protobuf-java:2.4.1" level="project" />
<orderEntry type="library" name="Maven: commons-io:commons-io:2.11.0" level="project" />
<orderEntry type="library" name="Maven: com.alibaba:fastjson:1.2.6" level="project" />
<orderEntry type="library" name="Maven: org.xerial:sqlite-jdbc:3.36.0.3" level="project" />
<orderEntry type="module" module-name="salpa-framework" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-web:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-logging:2.5.14" level="project" />
<orderEntry type="library" name="Maven: ch.qos.logback:logback-classic:1.2.11" level="project" />
<orderEntry type="library" name="Maven: ch.qos.logback:logback-core:1.2.11" level="project" />
<orderEntry type="library" name="Maven: org.apache.logging.log4j:log4j-to-slf4j:2.17.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.logging.log4j:log4j-api:2.17.2" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:jul-to-slf4j:1.7.36" level="project" />
<orderEntry type="library" name="Maven: jakarta.annotation:jakarta.annotation-api:1.3.5" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-json:2.5.14" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.12.6" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.12.6" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.module:jackson-module-parameter-names:2.12.6" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-tomcat:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.tomcat.embed:tomcat-embed-core:9.0.63" level="project" />
<orderEntry type="library" name="Maven: org.apache.tomcat.embed:tomcat-embed-el:9.0.63" level="project" />
<orderEntry type="library" name="Maven: org.apache.tomcat.embed:tomcat-embed-websocket:9.0.63" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-web:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-webmvc:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-aop:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.aspectj:aspectjweaver:1.9.7" level="project" />
<orderEntry type="library" name="Maven: com.alibaba:druid-spring-boot-starter:1.2.11" level="project" />
<orderEntry type="library" name="Maven: com.github.penggle:kaptcha:2.3.2" level="project" />
<orderEntry type="library" name="Maven: com.jhlabs:filters:2.0.235-1" level="project" />
<orderEntry type="library" name="Maven: com.github.oshi:oshi-core:6.1.6" level="project" />
<orderEntry type="library" name="Maven: net.java.dev.jna:jna:5.11.0" level="project" />
<orderEntry type="library" name="Maven: net.java.dev.jna:jna-platform:5.11.0" level="project" />
<orderEntry type="module" module-name="salpa-system" />
<orderEntry type="module" module-name="salpa-quartz" />
<orderEntry type="library" name="Maven: org.quartz-scheduler:quartz:2.3.2" level="project" />
<orderEntry type="library" name="Maven: com.mchange:mchange-commons-java:0.2.15" level="project" />
<orderEntry type="module" module-name="salpa-common" />
<orderEntry type="library" name="Maven: org.springframework:spring-context-support:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-security:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-config:5.5.8" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-core:5.5.8" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-crypto:5.5.8" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-web:5.5.8" level="project" />
<orderEntry type="library" name="Maven: com.github.pagehelper:pagehelper-spring-boot-starter:1.4.1" level="project" />
<orderEntry type="library" name="Maven: org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.2" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-jdbc:2.5.14" level="project" />
<orderEntry type="library" name="Maven: com.zaxxer:HikariCP:4.0.3" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-jdbc:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.mybatis.spring.boot:mybatis-spring-boot-autoconfigure:2.2.2" level="project" />
<orderEntry type="library" name="Maven: org.mybatis:mybatis:3.5.9" level="project" />
<orderEntry type="library" name="Maven: org.mybatis:mybatis-spring:2.0.7" level="project" />
<orderEntry type="library" name="Maven: com.github.pagehelper:pagehelper-spring-boot-autoconfigure:1.4.1" level="project" />
<orderEntry type="library" name="Maven: com.github.pagehelper:pagehelper:5.3.0" level="project" />
<orderEntry type="library" name="Maven: com.github.jsqlparser:jsqlparser:4.2" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-validation:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.hibernate.validator:hibernate-validator:6.2.3.Final" level="project" />
<orderEntry type="library" name="Maven: jakarta.validation:jakarta.validation-api:2.0.2" level="project" />
<orderEntry type="library" name="Maven: org.jboss.logging:jboss-logging:3.4.3.Final" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-lang3:3.12.0" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-databind:2.12.6.1" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-core:2.12.6" level="project" />
<orderEntry type="library" name="Maven: com.alibaba.fastjson2:fastjson2:2.0.8" level="project" />
<orderEntry type="library" name="Maven: commons-fileupload:commons-fileupload:1.4" level="project" />
<orderEntry type="library" name="Maven: org.apache.poi:poi-ooxml:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.poi:poi:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-collections4:4.4" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-math3:3.6.1" level="project" />
<orderEntry type="library" name="Maven: com.zaxxer:SparseBitSet:1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.poi:poi-ooxml-schemas:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlbeans:xmlbeans:3.1.0" level="project" />
<orderEntry type="library" name="Maven: com.github.virtuald:curvesapi:1.06" level="project" />
<orderEntry type="library" name="Maven: com.deepoove:poi-tl:1.10.0" level="project" />
<orderEntry type="library" name="Maven: com.deepoove:poi-ooxml-schemas-extra:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-transcoder:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-anim:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-css:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-ext:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-parser:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-svg-dom:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-awt-util:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:xmlgraphics-commons:2.6" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-bridge:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-script:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-dom:1.14" level="project" />
<orderEntry type="library" name="Maven: xalan:xalan:2.7.2" level="project" />
<orderEntry type="library" name="Maven: xalan:serializer:2.7.2" level="project" />
<orderEntry type="library" name="Maven: xml-apis:xml-apis:1.4.01" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-gvt:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-shared-resources:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-svggen:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-util:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-constants:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-i18n:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-xml:1.14" level="project" />
<orderEntry type="library" name="Maven: xml-apis:xml-apis-ext:1.3.04" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-codec:1.14" level="project" />
<orderEntry type="library" name="Maven: org.yaml:snakeyaml:1.28" level="project" />
<orderEntry type="library" name="Maven: io.jsonwebtoken:jjwt:0.9.1" level="project" />
<orderEntry type="library" name="Maven: javax.xml.bind:jaxb-api:2.3.1" level="project" />
<orderEntry type="library" name="Maven: javax.activation:javax.activation-api:1.2.0" level="project" />
<orderEntry type="library" name="Maven: org.projectlombok:lombok:1.18.24" level="project" />
<orderEntry type="library" name="Maven: net.sourceforge.plantuml:plantuml:1.2022.6" level="project" />
<orderEntry type="library" name="Maven: org.freemarker:freemarker:2.3.31" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-data-redis:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.data:spring-data-redis:2.5.11" level="project" />
<orderEntry type="library" name="Maven: org.springframework.data:spring-data-keyvalue:2.5.11" level="project" />
<orderEntry type="library" name="Maven: org.springframework.data:spring-data-commons:2.5.11" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-tx:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-oxm:5.3.20" level="project" />
<orderEntry type="library" name="Maven: io.lettuce:lettuce-core:6.1.8.RELEASE" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-common:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-handler:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-resolver:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-buffer:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-codec:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-transport:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.projectreactor:reactor-core:3.4.18" level="project" />
<orderEntry type="library" name="Maven: org.reactivestreams:reactive-streams:1.0.3" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-pool2:2.9.0" level="project" />
<orderEntry type="library" name="Maven: eu.bitwalker:UserAgentUtils:1.21" level="project" />
<orderEntry type="library" name="Maven: javax.servlet:javax.servlet-api:4.0.1" level="project" />
</component>
</module>

23
salpa-admin/src/main/java/com/salpa/SalpaApplication.java Normal file
View File

@ -0,0 +1,23 @@
package com.salpa;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.scheduling.annotation.EnableScheduling;
/**
* 启动程序
*
* @author salpa
*/
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
@EnableScheduling
public class SalpaApplication
{
public static void main(String[] args)
{
// System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(SalpaApplication.class, args);
System.out.println("(♥◠‿◠)ﾉﾞ 敏捷元数据模型设计后台启动成功 ლ(´ڡ`ლ)ﾞ ");
}
}

18
salpa-admin/src/main/java/com/salpa/SalpaServletInitializer.java Normal file
View File

@ -0,0 +1,18 @@
package com.salpa;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
/**
* web容器中进行部署
*
* @author salpa
*/
public class SalpaServletInitializer extends SpringBootServletInitializer
{
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application)
{
return application.sources(SalpaApplication.class);
}
}

94
salpa-admin/src/main/java/com/salpa/web/controller/common/CaptchaController.java Normal file
View File

@ -0,0 +1,94 @@
package com.salpa.web.controller.common;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
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 com.google.code.kaptcha.Producer;
import com.salpa.common.config.SalpaConfig;
import com.salpa.common.constant.CacheConstants;
import com.salpa.common.constant.Constants;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.redis.RedisCache;
import com.salpa.common.utils.sign.Base64;
import com.salpa.common.utils.uuid.IdUtils;
import com.salpa.system.service.ISysConfigService;
/**
* 验证码操作处理
*
* @author salpa
*/
@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 captchaOnOff = configService.selectCaptchaOnOff();
ajax.put("captchaOnOff", captchaOnOff);
if (!captchaOnOff)
{
return ajax;
}
// 保存验证码信息
String uuid = IdUtils.simpleUUID();
String verifyKey = CacheConstants.CAPTCHA_CODE_KEY + uuid;
String capStr = null, code = null;
BufferedImage image = null;
// 生成验证码
String captchaType = SalpaConfig.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;
}
}

163
salpa-admin/src/main/java/com/salpa/web/controller/common/CommonController.java Normal file
View File

@ -0,0 +1,163 @@
package com.salpa.web.controller.common;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
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 com.salpa.common.config.SalpaConfig;
import com.salpa.common.constant.Constants;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.utils.StringUtils;
import com.salpa.common.utils.file.FileUploadUtils;
import com.salpa.common.utils.file.FileUtils;
import com.salpa.framework.config.ServerConfig;
/**
* 通用请求处理
*
* @author salpa
*/
@RestController
@RequestMapping("/common")
public class CommonController
{
private static final Logger log = LoggerFactory.getLogger(CommonController.class);
@Autowired
private ServerConfig serverConfig;
private static final String FILE_DELIMETER = ",";
/**
* 通用下载请求
*
* @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 = SalpaConfig.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 = SalpaConfig.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 = SalpaConfig.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 = SalpaConfig.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);
}
}
}

542
salpa-admin/src/main/java/com/salpa/web/controller/common/MockApiContoller.java Normal file
View File

@ -0,0 +1,542 @@
package com.salpa.web.controller.common;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.utils.DateUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MockApiContoller {
String[] titles = new String[] {
"Alipay",
"Angular",
"Ant Design",
"Ant Design Pro",
"Bootstrap",
"React",
"Vue",
"Webpack",
};
String[] avatars = new String[] {
"https://gw.alipayobjects.com/zos/rmsportal/WdGqmHpayyMjiEhcKoVE.png", // Alipay
"https://gw.alipayobjects.com/zos/rmsportal/zOsKZmFRdUtvpqCImOVY.png", // Angular
"https://gw.alipayobjects.com/zos/rmsportal/dURIMkkrRFpPgTuzkwnB.png", // Ant Design
"https://gw.alipayobjects.com/zos/rmsportal/sfjbOqnsXXJgNCjCzDBL.png", // Ant Design Pro
"https://gw.alipayobjects.com/zos/rmsportal/siCrBXXhmvTQGWPNLBow.png", // Bootstrap
"https://gw.alipayobjects.com/zos/rmsportal/kZzEzemZyKLKFsojXItE.png", // React
"https://gw.alipayobjects.com/zos/rmsportal/ComBAopevLwENQdKWiIn.png", // Vue
"https://gw.alipayobjects.com/zos/rmsportal/nxkuOJlFJuAUhzlMTCEe.png", // Webpack
};
String[] covers = new String[] {
"https://gw.alipayobjects.com/zos/rmsportal/uMfMFlvUuceEyPpotzlq.png",
"https://gw.alipayobjects.com/zos/rmsportal/iZBVOIhGJiAnhplqjvZW.png",
"https://gw.alipayobjects.com/zos/rmsportal/iXjVmWVHbCJAyqvDxdtx.png",
"https://gw.alipayobjects.com/zos/rmsportal/gLaIAoVWTtLbBWZNYEMg.png",
};
String[] desc = new String[] {
"那是一种内在的东西， 他们到达不了，也无法触及的",
"希望是一个好东西，也许是最好的，好东西是不会消亡的",
"生命就像一盒巧克力，结果往往出人意料",
"城镇中有那么多的酒馆，她却偏偏走进了我的酒馆",
"那时候我只会想自己想要什么，从不想自己拥有什么",
};
String[] user = new String[] {
"付小小",
"曲丽丽",
"林东东",
"周星星",
"吴加好",
"朱偏右",
"鱼酱",
"乐哥",
"谭小仪",
"仲尼",
};
@GetMapping("/fake_list_Detail")
public AjaxResult getFakeListDetail() {
JSONArray info = new JSONArray();
for(int i = 0 ; i < 20 ; i ++) {
JSONObject item = new JSONObject();
item.put("id", "fake-list-" + i);
item.put("owner", user[i % 10]);
item.put("title", titles[i % 8]);
item.put("avatar", avatars[i % 8]);
item.put("cover", covers[i % 4]);
item.put("status", "active");
item.put("percent", Math.ceil(Math.random() * 50) + 50);
item.put("logo", avatars[i % 8]);
item.put("href", "https://ant.design");
item.put("description", "在中台产品的研发过程中，会出现不同的设计规范和实现方式，但其中往往存在很多类似的页面和组件，这些类似的组件会被抽离成一套标准规范。");
item.put("content", "段落示意：蚂蚁金服设计平台 ant.design，用最小的工作量，无缝接入蚂蚁金服生态，提供跨越设计与开发的体验解决方案。蚂蚁金服设计平台 ant.design，用最小的工作量，无缝接入蚂蚁金服生态，提供跨越设计与开发的体验解决方案。");
item.put("activeUser", Math.ceil(Math.random() * 100000) + 100000);
item.put("newUser", Math.ceil(Math.random() * 1000) + 1000);
item.put("star", Math.ceil(Math.random() * 100) + 100);
item.put("like", Math.ceil(Math.random() * 100) + 100);
item.put("message", Math.ceil(Math.random() * 10) + 10);
JSONArray members = new JSONArray();
item.put("members", members);
info.add(item);
}
JSONObject list = new JSONObject();
list.put("list", info);
AjaxResult ajax = AjaxResult.success();
ajax.put("data", list);
return ajax;
}
@GetMapping("/notices")
public AjaxResult getNoticeData() {
JSONArray info = new JSONArray();
JSONObject item = new JSONObject();
item.put("id", "000000012");
item.put("avatar", avatars[0]);
item.put("title", "ABCD 版本发布");
item.put("description", "提交于 2017-01-06，需在 2017-01-07 前完成代码变更任务");
item.put("extra", "进行中");
item.put("status", "processing");
item.put("type", "event");
info.add(item);
item = new JSONObject();
item.put("id", "000000006");
item.put("avatar", avatars[1]);
item.put("title", "左侧图标用于区分不同的类型");
item.put("datetime", "2022-01-07");
item.put("type", "notification");
info.add(item);
item = new JSONObject();
item.put("id", "000000006");
item.put("avatar", avatars[2]);
item.put("title", "曲丽丽 评论了你");
item.put("description", "描述信息描述信息描述信息");
item.put("datetime", "2022-01-01");
item.put("type", "message");
item.put("clickClose", true);
info.add(item);
AjaxResult ajax = AjaxResult.success();
ajax.put("data", info);
return ajax;
}
@GetMapping("/tags")
public AjaxResult getTags() {
JSONArray taglist = new JSONArray();
JSONObject item = new JSONObject();
item.put("name", "离岛");
item.put("type", "1");
item.put("value", "19");
taglist.add(item);
item = new JSONObject();
item.put("name", "大同市");
item.put("type", "1");
item.put("value", "68");
taglist.add(item);
item = new JSONObject();
item.put("name", "三亚市");
item.put("type", "0");
item.put("value", "42");
taglist.add(item);
JSONObject list = new JSONObject();
list.put("list", taglist);
AjaxResult ajax = AjaxResult.success();
ajax.put("data", list);
return ajax;
}
@GetMapping("/project/notice")
public AjaxResult getProjectNotice() {
JSONArray info = new JSONArray();
JSONObject item = new JSONObject();
item.put("id", "xxx1");
item.put("logo", avatars[0]);
item.put("title", "Alipay");
item.put("description", "那是一种内在的东西，他们到达不了，也无法触及的");
item.put("updatedAt", DateUtils.getTime());
item.put("member", "科学搬砖组");
item.put("href", "");
item.put("memberLink", "");
info.add(item);
item = new JSONObject();
item.put("id", "xxx2");
item.put("logo", avatars[1]);
item.put("title", "Angular");
item.put("description", "希望是一个好东西，也许是最好的，好东西是不会消亡的");
item.put("updatedAt", DateUtils.getTime());
item.put("member", "全组都是吴彦祖");
item.put("href", "");
item.put("memberLink", "");
info.add(item);
item = new JSONObject();
item.put("id", "xxx3");
item.put("logo", avatars[2]);
item.put("title", "Ant Design");
item.put("description", "城镇中有那么多的酒馆，她却偏偏走进了我的酒馆");
item.put("updatedAt", DateUtils.getTime());
item.put("member", "中二少女团");
item.put("href", "");
item.put("memberLink", "");
info.add(item);
item = new JSONObject();
item.put("id", "xxx4");
item.put("logo", avatars[3]);
item.put("title", "Bootstrap");
item.put("description", "那时候我只会想自己想要什么，从不想自己拥有什么");
item.put("updatedAt", DateUtils.getTime());
item.put("member", "程序员日常");
item.put("href", "");
item.put("memberLink", "");
info.add(item);
item = new JSONObject();
item.put("id", "xxx5");
item.put("logo", avatars[4]);
item.put("title", "React");
item.put("description", "凛冬将至");
item.put("updatedAt", DateUtils.getTime());
item.put("member", "高逼格设计天团");
item.put("href", "");
item.put("memberLink", "");
info.add(item);
item = new JSONObject();
item.put("id", "xxx6");
item.put("logo", avatars[5]);
item.put("title", "Webpack");
item.put("description", "生命就像一盒巧克力，结果往往出人意料");
item.put("updatedAt", DateUtils.getTime());
item.put("member", "程序员日常");
item.put("href", "");
item.put("memberLink", "");
info.add(item);
AjaxResult ajax = AjaxResult.success();
ajax.put("data", info);
return ajax;
}
@GetMapping("/activities")
public AjaxResult getActivities() {
JSONArray list = new JSONArray();
JSONObject item = new JSONObject();
item.put("id", "trend-1");
item.put("updatedAt", DateUtils.getTime());
JSONObject user = new JSONObject();
user.put("name", "曲丽丽");
user.put("avatar", avatars[2]);
item.put("user", user);
JSONObject group = new JSONObject();
user.put("name", "高逼格设计天团");
user.put("link", "http://github.com/");
item.put("group", group);
JSONObject project = new JSONObject();
user.put("name", "六月迭代");
user.put("link", "http://github.com/");
item.put("project", project);
item.put("template", "在 @{group} 新建项目 @{project}");
list.add(item);
item = new JSONObject();
item.put("id", "trend-2");
item.put("updatedAt", DateUtils.getTime());
user = new JSONObject();
user.put("name", "付小小");
user.put("avatar", avatars[1]);
item.put("user", user);
group = new JSONObject();
user.put("name", "高逼格设计天团");
user.put("link", "http://github.com/");
item.put("group", group);
project = new JSONObject();
user.put("name", "六月迭代");
user.put("link", "http://github.com/");
item.put("project", project);
item.put("template", "在 @{group} 新建项目 @{project}");
list.add(item);
item = new JSONObject();
item.put("id", "trend-3");
item.put("updatedAt", DateUtils.getTime());
user = new JSONObject();
user.put("name", "林东东");
user.put("avatar", avatars[3]);
item.put("user", user);
group = new JSONObject();
user.put("name", "中二少女团");
user.put("link", "http://github.com/");
item.put("group", group);
project = new JSONObject();
user.put("name", "六月迭代");
user.put("link", "http://github.com/");
item.put("project", project);
item.put("template", "在 @{group} 新建项目 @{project}");
list.add(item);
AjaxResult ajax = AjaxResult.success();
ajax.put("data", list);
return ajax;
}
@GetMapping("/fake_workplace_chart_data")
public AjaxResult getWorkplaceChartData() {
return getChartData("work");
}
@GetMapping("/fake_analysis_chart_data")
public AjaxResult getAnalysisChartData() {
return getChartData("analysis");
}
public AjaxResult getChartData(String type) {
JSONArray visitData = new JSONArray();
int[] fakeY = { 7, 5, 4, 2, 4, 7, 5, 6, 5, 9, 6, 3, 1, 5, 3, 6, 5 };
for (int i = 0; i < fakeY.length; i += 1) {
JSONObject item = new JSONObject();
Date d = new Date(new Date().getTime() + 1000 * 60 * 60 * 24 * i);
item.put("x", DateUtils.dateTime(d));
item.put("y", fakeY[i]);
visitData.add(item);
}
JSONArray visitData2 = new JSONArray();
int[] fakeY2 = { 1, 6, 4, 8, 3, 7, 2 };
for (int i = 0; i < fakeY2.length; i += 1) {
JSONObject item = new JSONObject();
Date d = new Date(new Date().getTime() + 1000 * 60 * 60 * 24 * i);
item.put("x", DateUtils.dateTime(d));
item.put("y", fakeY2[i]);
visitData2.add(item);
}
JSONArray salesData = new JSONArray();
for (Integer i = 1; i < 13; i += 1) {
JSONObject item = new JSONObject();
item.put("x", i.toString() + "月");
item.put("y", Math.floor(Math.random() * 1000 + 200));
salesData.add(item);
}
JSONArray searchData = new JSONArray();
for (Integer i = 0; i < 50; i += 1) {
JSONObject item = new JSONObject();
item.put("index", i + 1);
item.put("keyword", "搜索关键词-" + i.toString());
item.put("count", Math.floor(Math.random() * 1000));
item.put("range", Math.floor(Math.random() * 1000));
item.put("status", Math.floor(Math.random() * 1000));
searchData.add(item);
}
JSONArray offlineData = new JSONArray();
for (Integer i = 1; i <= 50; i += 1) {
JSONObject item = new JSONObject();
item.put("name", "Stores " + i.toString());
item.put("cvr", Math.ceil(Math.random() * 9 / 10));
offlineData.add(item);
}
JSONArray offlineChartData = new JSONArray();
if (type.equals("work")) {
for (Integer i = 1; i <= 50; i += 1) {
JSONObject item = new JSONObject();
item.put("x", new Date().getTime() + 1000 * 60 * 60 * i);
item.put("y1", Math.floor(Math.random() * 1000) + 10);
item.put("y2", Math.floor(Math.random() * 1000) + 10);
offlineChartData.add(item);
}
} else {
for (Integer i = 1; i <= 20; i += 1) {
JSONObject item = new JSONObject();
String date = DateUtils.parseDateToStr("HH:mm", new Date(new Date().getTime() + 1000 * 60 * 60 * i));
item.put("date", date);
item.put("type", "客流量");
item.put("value", Math.floor(Math.random() * 100) + 10);
item = new JSONObject();
item.put("date", date);
item.put("type", "支付笔数");
item.put("value", Math.floor(Math.random() * 100) + 10);
offlineChartData.add(item);
}
}
JSONArray salesTypeData = new JSONArray();
JSONObject item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 4544);
salesTypeData.add(item);
item = new JSONObject();
item.put("x", "食用酒水");
item.put("y", 3321);
salesTypeData.add(item);
item = new JSONObject();
item.put("x", "个护健康");
item.put("y", 3113);
salesTypeData.add(item);
item = new JSONObject();
item.put("x", "服饰箱包");
item.put("y", 2341);
salesTypeData.add(item);
item = new JSONObject();
item.put("x", "母婴产品");
item.put("y", 1231);
salesTypeData.add(item);
item = new JSONObject();
item.put("x", "其他");
item.put("y", 1231);
salesTypeData.add(item);
JSONArray salesTypeDataOnline = new JSONArray();
item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 244);
salesTypeDataOnline.add(item);
item = new JSONObject();
item.put("x", "食用酒水");
item.put("y", 321);
salesTypeDataOnline.add(item);
item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 244);
salesTypeDataOnline.add(item);
item = new JSONObject();
item.put("x", "个护健康");
item.put("y", 311);
salesTypeDataOnline.add(item);
item = new JSONObject();
item.put("x", "服饰箱包");
item.put("y", 41);
salesTypeDataOnline.add(item);
item = new JSONObject();
item.put("x", "母婴产品");
item.put("y", 121);
salesTypeDataOnline.add(item);
item = new JSONObject();
item.put("x", "其他");
item.put("y", 111);
salesTypeDataOnline.add(item);
JSONArray salesTypeDataOffline = new JSONArray();
item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 99);
salesTypeDataOffline.add(item);
item = new JSONObject();
item.put("x", "食用酒水");
item.put("y", 188);
salesTypeDataOffline.add(item);
item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 244);
salesTypeDataOffline.add(item);
item = new JSONObject();
item.put("x", "个护健康");
item.put("y", 311);
salesTypeDataOffline.add(item);
item = new JSONObject();
item.put("x", "服饰箱包");
item.put("y", 66);
salesTypeDataOffline.add(item);
item = new JSONObject();
item.put("x", "母婴产品");
item.put("y", 46);
salesTypeDataOffline.add(item);
item = new JSONObject();
item.put("x", "其他");
item.put("y", 65);
salesTypeDataOffline.add(item);
JSONArray radarOriginData = new JSONArray();
if (type.equals("work")) {
ArrayList<String> radarTypes = new ArrayList<>();
radarTypes.add("个人");
radarTypes.add("团队");
radarTypes.add("部门");
Map<String, String> radarTitleMap = new HashMap<>();
radarTitleMap.put("ref", "引用");
radarTitleMap.put("koubei", "口碑");
radarTitleMap.put("output", "产量");
radarTitleMap.put("contribute", "贡献");
radarTitleMap.put("hot", "热度");
for (String radarType : radarTypes) {
for (Entry<String, String> key : radarTitleMap.entrySet()) {
item = new JSONObject();
item.put("name", radarType);
item.put("label", key.getValue());
item.put("value", Math.floor(Math.random() * 10));
radarOriginData.add(item);
}
}
radarOriginData.add(item);
} else {
item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 99);
radarOriginData.add(item);
item = new JSONObject();
item.put("x", "食用酒水");
item.put("y", 188);
radarOriginData.add(item);
item = new JSONObject();
item.put("x", "家用电器");
item.put("y", 244);
radarOriginData.add(item);
}
JSONObject res = new JSONObject();
res.put("visitData", visitData);
res.put("visitData2", visitData2);
res.put("salesData", salesData);
res.put("searchData", searchData);
res.put("offlineData", offlineData);
res.put("offlineChartData", offlineChartData);
res.put("salesTypeData", salesTypeData);
res.put("salesTypeDataOnline", salesTypeDataOnline);
res.put("salesTypeDataOffline", salesTypeDataOffline);
res.put("radarData", radarOriginData);
AjaxResult ajax = AjaxResult.success();
ajax.put("data", res);
return ajax;
}
}

134
salpa-admin/src/main/java/com/salpa/web/controller/model/ModelController.java Normal file
View File

@ -0,0 +1,134 @@
package com.salpa.web.controller.model;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.model.domain.ProjectModelInfo;
import com.salpa.model.service.ModelService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
* 模型管理
*
* @author zhuff
*/
@RestController
@RequestMapping("/model/management")
public class ModelController extends BaseController {
@Autowired
private ModelService modelService;
/**
* 获取当前用户项目模型列表
* @author zhuff
* @return
*/
@GetMapping("list")
public TableDataInfo getList(@RequestParam Integer pageNum,@RequestParam Integer pageSize,@RequestParam String projectName) {
List<ProjectModelInfo> list = modelService.getList(pageNum,pageSize,projectName);
return getDataTable(list);
}
/**
* 根据项目id获取项目模型
* @author zhuff
* @param projectId
* @return
*/
@GetMapping("getById")
public AjaxResult getById(Integer projectId) {
return AjaxResult.success(modelService.getById(projectId));
}
/**
* 新增项目模型
* @author zhuff
* @param projectModelInfo
* @return
*/
@PostMapping("add")
public AjaxResult addProject(@RequestBody ProjectModelInfo projectModelInfo) throws IOException {
if (UserConstants.NOT_UNIQUE.equals(modelService.checkProjectNameUnique(projectModelInfo.getProjectName())))
{
return AjaxResult.error("新增项目模型'" + projectModelInfo.getProjectName() + "'失败，该项目模型已存在");
}
return toAjax(modelService.addProject(projectModelInfo));
}
/**
* 修改项目模型
* @author zhuff
* @param projectModelInfo
* @return
*/
@PostMapping("update")
public AjaxResult updateProject(@RequestBody ProjectModelInfo projectModelInfo) {
ProjectModelInfo project = modelService.getById(projectModelInfo.getProjectId());
if (!project.getProjectName().equals(projectModelInfo.getProjectName())){
if (UserConstants.NOT_UNIQUE.equals(modelService.checkProjectNameUnique(projectModelInfo.getProjectName())))
{
return AjaxResult.error("修改项目模型'" + projectModelInfo.getProjectName() + "'失败，该项目模型已存在");
}
}
return toAjax(modelService.updateProject(projectModelInfo));
}
/**
* 删除项目模型
* @author zhuff
* @param projectId
* @return
*/
@DeleteMapping("delete")
public AjaxResult deleteProject(Integer projectId) {
return toAjax(modelService.deleteProject(projectId));
}
/**
* 获取除管理员外所有用户
* @author zhuff
* @return
*/
@GetMapping("userList")
public AjaxResult getUserList() {
List<Map<String ,Object>> list = modelService.getUserList();
return AjaxResult.success(list);
}
/**
* 更新jsonFile
* @param projectModelInfo
* @return
*/
@PostMapping("updateJsonFile")
public AjaxResult updateJsonFile(@RequestBody ProjectModelInfo projectModelInfo){
return toAjax(modelService.updateJsonFile(projectModelInfo));
}
/**
* 测试连接数据库
* @param map
* @return
*/
@PostMapping("connectDataSource")
public AjaxResult connectDataSource(@RequestBody Map map) {
return modelService.connectDataSource(map);
}
/**
* 执行ddl语句
* @param map
* @return
*/
@PostMapping("executeSql")
public AjaxResult executeSql(@RequestBody Map map) {
return modelService.executeSql(map);
}
}

119
salpa-admin/src/main/java/com/salpa/web/controller/monitor/CacheController.java Normal file
View File

@ -0,0 +1,119 @@
package com.salpa.web.controller.monitor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.constant.CacheConstants;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.utils.StringUtils;
import com.salpa.system.domain.SysCache;
/**
* 缓存监控
*
* @author salpa
*/
@RestController
@RequestMapping("/monitor/cache")
public class CacheController
{
@Autowired
private RedisTemplate<String, String> redisTemplate;
private final static List<SysCache> caches = new ArrayList<SysCache>();
{
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, "限流处理"));
}
@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> cacheKyes = redisTemplate.keys(cacheName + "*");
return AjaxResult.success(cacheKyes);
}
@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();
}
}

27
salpa-admin/src/main/java/com/salpa/web/controller/monitor/ServerController.java Normal file
View File

@ -0,0 +1,27 @@
package com.salpa.web.controller.monitor;
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;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.framework.web.domain.Server;
/**
* 服务器监控
*
* @author salpa
*/
@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);
}
}

69
salpa-admin/src/main/java/com/salpa/web/controller/monitor/SysLogininforController.java Normal file
View File

@ -0,0 +1,69 @@
package com.salpa.web.controller.monitor;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.domain.SysLogininfor;
import com.salpa.system.service.ISysLogininforService;
/**
* 系统访问记录
*
* @author salpa
*/
@RestController
@RequestMapping("/monitor/logininfor")
public class SysLogininforController extends BaseController
{
@Autowired
private ISysLogininforService logininforService;
@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 AjaxResult.success();
}
}

69
salpa-admin/src/main/java/com/salpa/web/controller/monitor/SysOperlogController.java Normal file
View File

@ -0,0 +1,69 @@
package com.salpa.web.controller.monitor;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.domain.SysOperLog;
import com.salpa.system.service.ISysOperLogService;
/**
* 操作日志记录
*
* @author salpa
*/
@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 AjaxResult.success();
}
}

92
salpa-admin/src/main/java/com/salpa/web/controller/monitor/SysUserOnlineController.java Normal file
View File

@ -0,0 +1,92 @@
package com.salpa.web.controller.monitor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.CacheConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.model.LoginUser;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.core.redis.RedisCache;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.StringUtils;
import com.salpa.system.domain.SysUserOnline;
import com.salpa.system.service.ISysUserOnlineService;
/**
* 在线用户监控
*
* @author salpa
*/
@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))
{
if (StringUtils.equals(ipaddr, user.getIpaddr()) && StringUtils.equals(userName, user.getUsername()))
{
userOnlineList.add(userOnlineService.selectOnlineByInfo(ipaddr, userName, user));
}
}
else if (StringUtils.isNotEmpty(ipaddr))
{
if (StringUtils.equals(ipaddr, user.getIpaddr()))
{
userOnlineList.add(userOnlineService.selectOnlineByIpaddr(ipaddr, user));
}
}
else if (StringUtils.isNotEmpty(userName) && StringUtils.isNotNull(user.getUser()))
{
if (StringUtils.equals(userName, user.getUsername()))
{
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 AjaxResult.success();
}
}

58
salpa-admin/src/main/java/com/salpa/web/controller/online/OnlineController.java Normal file
View File

@ -0,0 +1,58 @@
package com.salpa.web.controller.online;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.utils.StringUtils;
import com.salpa.online.service.OnlineService;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author zhuff
*
* 数据库在线查询
*/
@RestController
@RequestMapping("/online/demand")
public class OnlineController {
@Autowired
private OnlineService onlineService;
/**
* 获取数据源
* @return
*/
@PostMapping("getDataSource")
public AjaxResult getDataSource() {
return AjaxResult.success(onlineService.getDataSource());
}
/**
* 连接数据库
* @param databaseName
* @return
*/
@GetMapping("connectDataSource")
public AjaxResult connectDataSource(String databaseName) {
return onlineService.connectDataSource(databaseName);
}
/**
* 执行
* @param databaseName
* @param script
* @return
*/
@GetMapping("testExecute")
public AjaxResult testExecute(String databaseName,String script) {
if (StringUtils.isEmpty(databaseName)) {
return AjaxResult.error("请连接数据源");
} else {
return onlineService.testExecute(databaseName,script);
}
}
}

171
salpa-admin/src/main/java/com/salpa/web/controller/subject/DatabaseTypeController.java Normal file
View File

@ -0,0 +1,171 @@
package com.salpa.web.controller.subject;
import com.salpa.common.config.SalpaConfig;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.utils.file.FileUploadUtils;
import com.salpa.subject.domain.MonitorDatabaseType;
import com.salpa.subject.service.DatabaseTypeService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.IOException;
import java.util.List;
/**
* 数据库类型
*
* @author zhuff
*/
@RestController
@RequestMapping("/subject/databaseType")
public class DatabaseTypeController extends BaseController {
@Autowired
private DatabaseTypeService databaseTypeService;
/**
* 获取数据库类型列表
* @author zhuff
* @return
*/
@GetMapping("getDatabaseType")
public AjaxResult getDatabaseTypeAll() {
List<MonitorDatabaseType> list = databaseTypeService.getDatabaseTypeAll();
return AjaxResult.success(list);
}
/**
* 数据库类型列表查询
* @author zhuff
* @return
*/
@GetMapping("list")
public AjaxResult getList(String databaseType) {
List<MonitorDatabaseType> list = databaseTypeService.getList(databaseType);
return AjaxResult.success(list);
}
/**
* 创建数据库类型
* @param monitorDatabaseType
* @return
*/
@PostMapping("add")
public AjaxResult addDatabaseType(@RequestBody MonitorDatabaseType monitorDatabaseType) {
if (monitorDatabaseType.getUrlPattern() == null) {
return AjaxResult.error("url pattern 不能为空");
}
if (!monitorDatabaseType.getUrlPattern().contains("{{jdbc.protocol}}")) {
return AjaxResult.error("必须包含变量{{jdbc.protocol}}");
}
if (!monitorDatabaseType.getUrlPattern().contains("{{db.url}}")) {
return AjaxResult.error("必须包含变量{{db.url}}不能为空");
}
if (!monitorDatabaseType.getUrlPattern().contains("{{db.schema}}") && !monitorDatabaseType.getUrlPattern().contains("{{db.name}}")) {
return AjaxResult.error("{{db.schema}} 和 {{db.name}} 至少设置一个");
}
if (UserConstants.NOT_UNIQUE.equals(databaseTypeService.checkDatabaseTypeUnique(monitorDatabaseType.getDatabaseType()))) {
return AjaxResult.error("该数据库类型已存在");
}
return toAjax(databaseTypeService.addDatabaseType(monitorDatabaseType));
}
/**
* 修改数据库类型
* @param monitorDatabaseType
* @return
*/
@PostMapping("update")
public AjaxResult updateDatabaseType(@RequestBody MonitorDatabaseType monitorDatabaseType) {
if (monitorDatabaseType.getUrlPattern() == null) {
return AjaxResult.error("url pattern 不能为空");
}
if (!monitorDatabaseType.getUrlPattern().contains("{{jdbc.protocol}}")) {
return AjaxResult.error("必须包含变量{{jdbc.protocol}}");
}
if (!monitorDatabaseType.getUrlPattern().contains("{{db.url}}")) {
return AjaxResult.error("必须包含变量{{db.url}}不能为空");
}
/*if (!monitorDatabaseType.getUrlPattern().contains("{{db.schema}}") && !monitorDatabaseType.getUrlPattern().contains("{{db.name}}")) {
return AjaxResult.error("{{db.schema}} 和 {{db.name}} 至少设置一个");
}*/
if (!databaseTypeService.getById(monitorDatabaseType.getId()).getDatabaseType().equals(monitorDatabaseType.getDatabaseType())) {
if (UserConstants.NOT_UNIQUE.equals(databaseTypeService.checkDatabaseTypeUnique(monitorDatabaseType.getDatabaseType()))) {
return AjaxResult.error("该数据库类型已存在");
}
}
return toAjax(databaseTypeService.updateDatabaseType(monitorDatabaseType));
}
/**
* 删除数据库类型
* @param id
* @return
*/
@DeleteMapping("delete")
public AjaxResult deleteDatabaseType(Integer id) {
return toAjax(databaseTypeService.deleteDatabaseType(id));
}
/**
* 解析数据库驱动类名
* @param jdbcDriverFileUrl
* @return
*/
@GetMapping("resolveDriverClassName")
public AjaxResult resolveDriverClassName(String jdbcDriverFileUrl,String jdbcDriverFilePath) {
if (StringUtils.isAllBlank(jdbcDriverFilePath, jdbcDriverFileUrl)) {
return AjaxResult.error("请填写下载驱动的地址或手动上传驱动文件");
} else if (StringUtils.isNotBlank(jdbcDriverFilePath)) {
File saveDir = new File(SalpaConfig.getProfile()+jdbcDriverFilePath);
if (!saveDir.exists()) {
return AjaxResult.error("驱动文件不存在，请重新上传");
} else {
String className = databaseTypeService.resolveDriverClassNameFromLocal(jdbcDriverFilePath);
if (className == "") {
return AjaxResult.error("解析失败，请检查地址");
} else {
return AjaxResult.success(className);
}
}
} else if (StringUtils.isNotBlank(jdbcDriverFileUrl)) {
String className = databaseTypeService.resolveDriverClassName(jdbcDriverFileUrl);
if (className == "") {
return AjaxResult.error("解析失败，请检查地址");
} else {
return AjaxResult.success(className);
}
} else {
return AjaxResult.error("解析失败，请检查地址");
}
}
/**
* 上传数据库驱动
* @param file
* @return
*/
@PostMapping("uploadDriver")
public AjaxResult uploadDriver(MultipartFile file) {
String fileName = "";
try {
// 上传驱动文件路径
String filePath = SalpaConfig.getDriverPath();
File file1 = new File(filePath);
if (file1.exists()) {
file1.delete();
}
// 上传并返回新文件名称
fileName = FileUploadUtils.upload(filePath, file);
} catch (IOException e) {
return AjaxResult.error("上传失败，请检查后重新上传");
}
return AjaxResult.success(fileName);
}
}

156
salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentController.java Normal file
View File

@ -0,0 +1,156 @@
package com.salpa.web.controller.subject;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.model.LoginUser;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.subject.service.DocumentService;
import com.salpa.subject.service.ProjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
/**
* 数据库文档
*
* @author zhuff
*/
@RestController
@RequestMapping("/subject/document")
public class DocumentController extends BaseController {
@Autowired
private DocumentService documentService;
@Autowired
private ProjectService projectService;
/**
* 创建同步任务
* @param projectId
* @return
*/
@GetMapping("createSyncTask")
public AjaxResult createSyncTask(Integer projectId) {
LoginUser loginUser = SecurityUtils.getLoginUser();
int syncTask = documentService.createSyncTask(projectId, loginUser.getUserId(), false);
if (syncTask > 0) {
return AjaxResult.success(syncTask);
} else {
return AjaxResult.error("创建同步任务失败");
}
}
/**
* 获取版本号
* @param projectId
* @return
*/
@GetMapping("getVersionsByProjectId")
public AjaxResult getVersionsByProjectId(Integer projectId) {
return AjaxResult.success(documentService.getVersionsByProjectId(projectId));
}
/**
* 获取文档信息
* @param projectId
* @param version
* @param search
* @param originalVersion
* @return
*/
@GetMapping("getSimpleByProjectId")
public AjaxResult getSimpleByProjectId(Integer projectId,Long version,String search,Long originalVersion) {
return AjaxResult.success(documentService.getSimpleByProjectId(projectId,version,search,originalVersion));
}
/**
* 获取表名列表
* @param projectId
* @param version
* @param search
* @return
*/
@GetMapping("getTableDocumentByProjectId")
public AjaxResult getTableDocumentByProjectId(Integer projectId,Long version,String search){
return AjaxResult.success(documentService.getTableDocumentByProjectId(projectId,version,search));
}
/**
* 获取每张表详细信息
* @param id
* @param projectId
* @param version
* @param originalVersion
* @return
*/
@GetMapping("getTableDetail")
public AjaxResult getTableDetail(Integer id,Integer projectId,Long version,Long originalVersion) {
return AjaxResult.success(documentService.getTableDetail(id,projectId,version,originalVersion));
}
/**
* 获取同步任务列表
* @param taskIds
* @return
*/
@GetMapping("getSyncTaskList")
public AjaxResult getSyncTaskList(@RequestParam Integer[] taskIds) {
return AjaxResult.success(documentService.getSyncTaskList(taskIds));
}
/**
* 取消同步任务
* @param taskId
* @return
*/
@GetMapping("cancelTask")
public AjaxResult cancelTask(Integer taskId) {
return toAjax(documentService.cancelTask(taskId));
}
/**
* 获取同步任务状态
* @param taskId
* @return
*/
@GetMapping("getSyncTaskStatus")
public AjaxResult getSyncTaskStatus(Integer taskId) {
return AjaxResult.success(documentService.getSyncTaskStatus(taskId));
}
/**
* 导出文档
* @param projectId
* @param version
* @param fileType
* @return
*/
@GetMapping("getDocumentFiles")
public ResponseEntity<StreamingResponseBody> getDocumentFiles(Integer projectId, Long version, String fileType) {
HttpHeaders headers = new HttpHeaders();
String projectName = projectService.getProjectById(projectId).getProjectName();
String fileName = projectName;
if ("Markdown".equals(fileType)) {
fileName += ".md";
} else if ("UML SVG".equals(fileType)) {
fileName += ".svg";
} else if ("UML PNG".equals(fileType)) {
fileName += ".png";
} else if ("Word".equals(fileType)) {
fileName += ".docx";
}
headers.setContentDisposition(ContentDisposition.attachment()
.filename(fileName)
.build());
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
return ResponseEntity.ok()
.headers(headers)
.body(out -> documentService.export(projectId, version, fileType, out));
}
}

35
salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentDescriptionController.java Normal file
View File

@ -0,0 +1,35 @@
package com.salpa.web.controller.subject;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.subject.domain.MonitorDocumentDescription;
import com.salpa.subject.service.DocumentDescriptionService;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/subject/documentDescription")
public class DocumentDescriptionController extends BaseController {
@Autowired
private DocumentDescriptionService documentDescriptionService;
/**
* 修改描述
* @author rhl
* @param monitorDocumentDescription
* @return
*/
@PostMapping("update")
public AjaxResult updateDescription(@RequestBody MonitorDocumentDescription monitorDocumentDescription){
SysUser user = SecurityUtils.getLoginUser().getUser();
monitorDocumentDescription.setUpdateBy(user.getUserId());
System.out.println(monitorDocumentDescription);
return AjaxResult.success(documentDescriptionService.updateDescription(monitorDocumentDescription));
}
}

55
salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentDiscussionController.java Normal file
View File

@ -0,0 +1,55 @@
package com.salpa.web.controller.subject;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.subject.domain.MonitorDocumentDiscussion;
import com.salpa.subject.service.DocumentDiscussionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 评论
* @author
*/
@RestController
@RequestMapping("/subject/documentDiscussion")
public class DocumentDiscussionController extends BaseController {
@Autowired
private DocumentDiscussionService documentDiscussionService;
/**
* 添加评论
* @author rhl
* @param monitorDocumentDiscussion
* @return
*/
@PostMapping("add")
public AjaxResult addDiscussion(@RequestBody MonitorDocumentDiscussion monitorDocumentDiscussion) {
SysUser user = SecurityUtils.getLoginUser().getUser();
monitorDocumentDiscussion.setUserId(user.getUserId());
return AjaxResult.success(documentDiscussionService.add(monitorDocumentDiscussion));
}
/**
* 获取评论列表
* @author hzl
* @return
*/
@PostMapping ("list")
public TableDataInfo getList(@RequestBody MonitorDocumentDiscussion monitorDocumentDiscussion) {
List<MonitorDocumentDiscussion> list = documentDiscussionService.getList(monitorDocumentDiscussion);
return getDataTable(list);
}
/**
* 删除评论
* @author hzl
* @param id
* @return
*/
@DeleteMapping("delete")
public AjaxResult deleteComment(Integer id){
return toAjax(documentDiscussionService.deleteComment(id));
}
}

30
salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentTemplateController.java Normal file
View File

@ -0,0 +1,30 @@
package com.salpa.web.controller.subject;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.subject.service.DocumentTemplateService;
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;
/**
* 文档模板
*
* @author zhuff
*/
@RestController
@RequestMapping("/subject/documentTemplate")
public class DocumentTemplateController {
@Autowired
private DocumentTemplateService documentTemplateService;
/**
* 获取模板属性
* @return
*/
@PostMapping("getAllProperties")
public AjaxResult getAllProperties() {
return AjaxResult.success(documentTemplateService.getAllProperties());
}
}

154
salpa-admin/src/main/java/com/salpa/web/controller/subject/ProjectController.java Normal file
View File

@ -0,0 +1,154 @@
package com.salpa.web.controller.subject;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.subject.domain.MonitorOperationLog;
import com.salpa.subject.domain.MonitorProject;
import com.salpa.subject.domain.vo.MonitorDataSourceVo;
import com.salpa.subject.domain.vo.OperationLogVo;
import com.salpa.subject.service.ProjectService;
import org.quartz.CronExpression;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.text.ParseException;
import java.util.List;
import java.util.Map;
/**
* 项目管理
*
* @author zhuff
*/
@RestController
@RequestMapping("/subject/project")
public class ProjectController extends BaseController {
@Autowired
private ProjectService projectService;
/**
* 获取项目列表
* @author zhuff
* @param monitorDataSourceVo
* @return
*/
@PostMapping("list")
public TableDataInfo getList(@RequestBody MonitorDataSourceVo monitorDataSourceVo) {
List<Map<String , Object>> list = projectService.getList(monitorDataSourceVo);
return getDataTable(list);
}
/**
* 创建项目
* @author zhuff
* @param monitorProject
* @return
*/
@PostMapping("createProject")
public AjaxResult createProject(@RequestBody MonitorProject monitorProject) {
if (monitorProject.getProjectSyncRule().isAutoSync()){
try {
new CronExpression(monitorProject.getProjectSyncRule().getAutoSyncCron());
} catch (ParseException e) {
e.printStackTrace();
return AjaxResult.error("新增项目模型'" + monitorProject.getProjectName() + "'失败，错误的Cron表达式");
}
}
if (UserConstants.NOT_UNIQUE.equals(projectService.checkProjectNameUnique(monitorProject.getProjectName())))
{
return AjaxResult.error("新增项目模型'" + monitorProject.getProjectName() + "'失败，该项目模型已存在");
}
if (UserConstants.NOT_UNIQUE.equals(projectService.checkDatabaseNameUnique(monitorProject.getMonitorDataSource().getDatabaseName())))
{
return AjaxResult.error("新增数据库'" + monitorProject.getMonitorDataSource().getDatabaseName() + "'失败，该数据库已存在");
}
return toAjax(projectService.addProject(monitorProject));
}
/**
* 修改项目
* @author zhuff
* @param monitorProject
* @return
*/
@PostMapping("updateProject")
public AjaxResult updateProject(@RequestBody MonitorProject monitorProject) {
if (monitorProject.getProjectSyncRule().isAutoSync()){
try {
new CronExpression(monitorProject.getProjectSyncRule().getAutoSyncCron());
} catch (ParseException e) {
e.printStackTrace();
return AjaxResult.error("修改项目模型'" + monitorProject.getProjectName() + "'失败，错误的Cron表达式");
}
}
if (!projectService.getById(monitorProject.getId()).getProjectName().equals(monitorProject.getProjectName())) {
if (UserConstants.NOT_UNIQUE.equals(projectService.checkProjectNameUnique(monitorProject.getProjectName())))
{
return AjaxResult.error("修改项目模型'" + monitorProject.getProjectName() + "'失败，该项目模型已存在");
}
}
if (!projectService.getDataSource(monitorProject.getId()).getDatabaseName().equals(monitorProject.getMonitorDataSource().getDatabaseName())) {
if (UserConstants.NOT_UNIQUE.equals(projectService.checkDatabaseNameUnique(monitorProject.getMonitorDataSource().getDatabaseName())))
{
return AjaxResult.error("修改数据库'" + monitorProject.getMonitorDataSource().getDatabaseName() + "'失败，该数据库已存在");
}
}
return toAjax(projectService.updateProject(monitorProject));
}
/**
* 根据id获取项目
* @author zhuff
* @param id
* @return
*/
@GetMapping("getProjectById")
public AjaxResult getProjectById(@RequestParam Integer id) {
return AjaxResult.success(projectService.getProjectById(id));
}
/**
* 删除项目
* @param id
* @return
*/
@DeleteMapping("deleteProject")
public AjaxResult deleteProject(Integer id){
return toAjax(projectService.deleteProject(id));
}
/**
* 测试连接
* @param monitorProject
* @return
*/
@PostMapping("testConnection")
public AjaxResult testConnection(@RequestBody MonitorProject monitorProject){
int i = projectService.testConnection(monitorProject.getMonitorDataSource());
if (i == 1) {
return AjaxResult.error("加载驱动失败,请检查后重试");
} else if (i == 2) {
return AjaxResult.error("数据库连接失败,请检查后重试");
} else if (i == 3) {
return AjaxResult.success("连接数据库成功");
} else {
return AjaxResult.error("连接失败，请检查后重试");
}
}
/**
* 获取日志列表
* @param operationLogVo
* @return
*/
@PostMapping("getLogList")
public TableDataInfo getLogList(@RequestBody OperationLogVo operationLogVo) {
List<MonitorOperationLog> list = projectService.getLogList(operationLogVo);
return getDataTable(list);
}
}

94
salpa-admin/src/main/java/com/salpa/web/controller/subject/SubjectController.java Normal file
View File

@ -0,0 +1,94 @@
package com.salpa.web.controller.subject;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.subject.domain.MonitorSubject;
import com.salpa.subject.service.SubjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 主题管理
*
* @author zhuff
*/
@RestController
@RequestMapping("/subject/manage")
public class SubjectController extends BaseController {
@Autowired
private SubjectService subjectService;
/**
* 获取主题管理列表
* @author zhuff
* @param pageNum
* @param pageSize
* @param subjectName
* @return
*/
@GetMapping("list")
public TableDataInfo getList(@RequestParam Integer pageNum,@RequestParam Integer pageSize,@RequestParam String subjectName) {
List<MonitorSubject> list = subjectService.getList(pageNum,pageSize,subjectName);
return getDataTable(list);
}
/**
* 根据项目id获取主题管理
* @author zhuff
* @param id
* @return
*/
@GetMapping("getById")
public AjaxResult getById(Integer id) {
return AjaxResult.success(subjectService.getById(id));
}
/**
* 新增主题管理
* @author zhuff
* @param monitorSubject
* @return
*/
@PostMapping("add")
public AjaxResult addSubject(@RequestBody MonitorSubject monitorSubject) {
if (UserConstants.NOT_UNIQUE.equals(subjectService.checkSubjectNameUnique(monitorSubject.getSubjectName())))
{
return AjaxResult.error("新增主题'" + monitorSubject.getSubjectName() + "'失败，该主题已存在");
}
return toAjax(subjectService.addSubject(monitorSubject));
}
/**
* 修改主题管理
* @author zhuff
* @param monitorSubject
* @return
*/
@PostMapping("update")
public AjaxResult updateSubject(@RequestBody MonitorSubject monitorSubject) {
MonitorSubject subject = subjectService.getById(monitorSubject.getId());
if (!subject.getSubjectName().equals(monitorSubject.getSubjectName())){
if (UserConstants.NOT_UNIQUE.equals(subjectService.checkSubjectNameUnique(monitorSubject.getSubjectName())))
{
return AjaxResult.error("修改主题'" + monitorSubject.getSubjectName() + "'失败，该主题已存在");
}
}
return toAjax(subjectService.updateSubject(monitorSubject));
}
/**
* 删除主题管理
* @author zhuff
* @param id
* @return
*/
@DeleteMapping("delete")
public AjaxResult deleteSubject(Integer id) {
return toAjax(subjectService.deleteSubject(id));
}
}

47
salpa-admin/src/main/java/com/salpa/web/controller/subject/WarningController.java Normal file
View File

@ -0,0 +1,47 @@
package com.salpa.web.controller.subject;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.subject.domain.MonitorWarning;
import com.salpa.subject.service.WarningService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* 告警管理
* @author zff
*/
@RestController
@RequestMapping("/subject/warning")
public class WarningController extends BaseController {
@Autowired
private WarningService warningService;
/**
* 获取告警列表
* @param pageNum 页数
* @param pageSize 条数
* @return list
*/
@GetMapping("list")
public TableDataInfo warningList(Integer pageNum,Integer pageSize) {
List<MonitorWarning> list = warningService.warningList(pageNum,pageSize);
return getDataTable(list);
}
/**
* 修改告警状态
* @param id 告警id
* @return 结果
*/
@GetMapping("updateStatus")
public AjaxResult updateStatus(Long id) {
return toAjax(warningService.updateStatus(id));
}
}

134
salpa-admin/src/main/java/com/salpa/web/controller/system/SysConfigController.java Normal file
View File

@ -0,0 +1,134 @@
package com.salpa.web.controller.system;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.domain.SysConfig;
import com.salpa.system.service.ISysConfigService;
/**
* 参数配置 信息操作处理
*
* @author salpa
*/
@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 AjaxResult.success(configService.selectConfigById(configId));
}
/**
* 根据参数键名查询参数值
*/
@GetMapping(value = "/configKey/{configKey}")
public AjaxResult getConfigKey(@PathVariable String configKey)
{
return AjaxResult.success(configService.selectConfigByKey(configKey));
}
/**
* 新增参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:add')")
@Log(title = "参数管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysConfig config)
{
if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config)))
{
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config)))
{
return AjaxResult.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 AjaxResult.success();
}
}

165
salpa-admin/src/main/java/com/salpa/web/controller/system/SysDeptController.java Normal file
View File

@ -0,0 +1,165 @@
package com.salpa.web.controller.system;
import java.util.Iterator;
import java.util.List;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysDept;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.StringUtils;
import com.salpa.system.service.ISysDeptService;
/**
* 部门信息
*
* @author salpa
*/
@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 AjaxResult.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());
Iterator<SysDept> it = depts.iterator();
while (it.hasNext())
{
SysDept d = (SysDept) it.next();
if (d.getDeptId().intValue() == deptId
|| ArrayUtils.contains(StringUtils.split(d.getAncestors(), ","), deptId + ""))
{
it.remove();
}
}
return AjaxResult.success(depts);
}
/**
* 根据部门编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:dept:query')")
@GetMapping(value = "/{deptId}")
public AjaxResult getInfo(@PathVariable Long deptId)
{
deptService.checkDeptDataScope(deptId);
return AjaxResult.success(deptService.selectDeptById(deptId));
}
/**
* 获取部门下拉树列表
*/
@GetMapping("/treeselect")
public AjaxResult treeselect(SysDept dept)
{
List<SysDept> depts = deptService.selectDeptList(dept);
return AjaxResult.success(deptService.buildDeptTreeSelect(depts));
}
/**
* 加载对应角色部门列表树
*/
@GetMapping(value = "/roleDeptTreeselect/{roleId}")
public AjaxResult roleDeptTreeselect(@PathVariable("roleId") Long roleId)
{
List<SysDept> depts = deptService.selectDeptList(new SysDept());
AjaxResult ajax = AjaxResult.success();
ajax.put("checkedKeys", deptService.selectDeptListByRoleId(roleId));
ajax.put("depts", deptService.buildDeptTreeSelect(depts));
return ajax;
}
/**
* 新增部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:add')")
@Log(title = "部门管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDept dept)
{
if (UserConstants.NOT_UNIQUE.equals(deptService.checkDeptNameUnique(dept)))
{
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(deptService.checkDeptNameUnique(dept)))
{
return AjaxResult.error("修改部门'" + dept.getDeptName() + "'失败，部门名称已存在");
}
else if (dept.getParentId().equals(deptId))
{
return AjaxResult.error("修改部门'" + dept.getDeptName() + "'失败，上级部门不能是自己");
}
else if (StringUtils.equals(UserConstants.DEPT_DISABLE, dept.getStatus()) && deptService.selectNormalChildrenDeptById(deptId) > 0)
{
return AjaxResult.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 AjaxResult.error("存在下级部门,不允许删除");
}
if (deptService.checkDeptExistUser(deptId))
{
return AjaxResult.error("部门存在用户,不允许删除");
}
deptService.checkDeptDataScope(deptId);
return toAjax(deptService.deleteDeptById(deptId));
}
}

121
salpa-admin/src/main/java/com/salpa/web/controller/system/SysDictDataController.java Normal file
View File

@ -0,0 +1,121 @@
package com.salpa.web.controller.system;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysDictData;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.StringUtils;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.service.ISysDictDataService;
import com.salpa.system.service.ISysDictTypeService;
/**
* 数据字典信息
*
* @author salpa
*/
@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 AjaxResult.success(dictDataService.selectDictDataById(dictCode));
}
/**
* 根据字典类型查询字典数据信息
*/
@GetMapping(value = "/type/{dictType}")
public AjaxResult dictType(@PathVariable String dictType)
{
List<SysDictData> data = dictTypeService.selectDictDataByType(dictType);
if (StringUtils.isNull(data))
{
data = new ArrayList<SysDictData>();
}
return AjaxResult.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();
}
}

132
salpa-admin/src/main/java/com/salpa/web/controller/system/SysDictTypeController.java Normal file
View File

@ -0,0 +1,132 @@
package com.salpa.web.controller.system;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysDictType;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.service.ISysDictTypeService;
/**
* 数据字典信息
*
* @author salpa
*/
@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 AjaxResult.success(dictTypeService.selectDictTypeById(dictId));
}
/**
* 新增字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:add')")
@Log(title = "字典类型", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDictType dict)
{
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict)))
{
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict)))
{
return AjaxResult.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 AjaxResult.success();
}
/**
* 获取字典选择框列表
*/
@GetMapping("/optionselect")
public AjaxResult optionselect()
{
List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll();
return AjaxResult.success(dictTypes);
}
}

29
salpa-admin/src/main/java/com/salpa/web/controller/system/SysIndexController.java Normal file
View File

@ -0,0 +1,29 @@
package com.salpa.web.controller.system;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.config.SalpaConfig;
import com.salpa.common.utils.StringUtils;
/**
* 首页
*
* @author salpa
*/
@RestController
public class SysIndexController
{
/** 系统基础配置 */
@Autowired
private SalpaConfig salpaConfig;
/**
* 访问首页，提示语
*/
@RequestMapping("/")
public String index()
{
return StringUtils.format("欢迎使用{}敏捷元数据模型后台，当前版本：v{}，请通过前端地址访问。", salpaConfig.getName(), salpaConfig.getVersion());
}
}

86
salpa-admin/src/main/java/com/salpa/web/controller/system/SysLoginController.java Normal file
View File

@ -0,0 +1,86 @@
package com.salpa.web.controller.system;
import java.util.List;
import java.util.Set;
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 com.salpa.common.constant.Constants;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysMenu;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.common.core.domain.model.LoginBody;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.framework.web.service.SysLoginService;
import com.salpa.framework.web.service.SysPermissionService;
import com.salpa.system.service.ISysMenuService;
/**
* 登录验证
*
* @author salpa
*/
@RestController
public class SysLoginController
{
@Autowired
private SysLoginService loginService;
@Autowired
private ISysMenuService menuService;
@Autowired
private SysPermissionService permissionService;
/**
* 登录方法
*
* @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());
ajax.put(Constants.TOKEN, token);
return ajax;
}
/**
* 获取用户信息
*
* @return 用户信息
*/
@GetMapping("getInfo")
public AjaxResult getInfo()
{
SysUser user = SecurityUtils.getLoginUser().getUser();
// 角色集合
Set<String> roles = permissionService.getRolePermission(user);
// 权限集合
Set<String> permissions = permissionService.getMenuPermission(user);
AjaxResult ajax = AjaxResult.success();
ajax.put("user", user);
ajax.put("roles", roles);
ajax.put("permissions", permissions);
return ajax;
}
/**
* 获取路由信息
*
* @return 路由信息
*/
@GetMapping("getRouters")
public AjaxResult getRouters()
{
Long userId = SecurityUtils.getUserId();
List<SysMenu> menus = menuService.selectMenuTreeByUserId(userId);
return AjaxResult.success(menuService.buildMenus(menus));
}
}

142
salpa-admin/src/main/java/com/salpa/web/controller/system/SysMenuController.java Normal file
View File

@ -0,0 +1,142 @@
package com.salpa.web.controller.system;
import java.util.List;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysMenu;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.StringUtils;
import com.salpa.system.service.ISysMenuService;
/**
* 菜单信息
*
* @author salpa
*/
@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 AjaxResult.success(menus);
}
/**
* 根据菜单编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:menu:query')")
@GetMapping(value = "/{menuId}")
public AjaxResult getInfo(@PathVariable Long menuId)
{
return AjaxResult.success(menuService.selectMenuById(menuId));
}
/**
* 获取菜单下拉树列表
*/
@GetMapping("/treeselect")
public AjaxResult treeselect(SysMenu menu)
{
List<SysMenu> menus = menuService.selectMenuList(menu, getUserId());
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(menuService.checkMenuNameUnique(menu)))
{
return AjaxResult.error("新增菜单'" + menu.getMenuName() + "'失败，菜单名称已存在");
}
else if (UserConstants.YES_FRAME.equals(menu.getIsFrame()) && !StringUtils.ishttp(menu.getPath()))
{
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(menuService.checkMenuNameUnique(menu)))
{
return AjaxResult.error("修改菜单'" + menu.getMenuName() + "'失败，菜单名称已存在");
}
else if (UserConstants.YES_FRAME.equals(menu.getIsFrame()) && !StringUtils.ishttp(menu.getPath()))
{
return AjaxResult.error("修改菜单'" + menu.getMenuName() + "'失败，地址必须以http(s)://开头");
}
else if (menu.getMenuId().equals(menu.getParentId()))
{
return AjaxResult.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 AjaxResult.error("存在子菜单,不允许删除");
}
if (menuService.checkMenuExistRole(menuId))
{
return AjaxResult.error("菜单已分配,不允许删除");
}
return toAjax(menuService.deleteMenuById(menuId));
}
}

91
salpa-admin/src/main/java/com/salpa/web/controller/system/SysNoticeController.java Normal file
View File

@ -0,0 +1,91 @@
package com.salpa.web.controller.system;
import java.util.List;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.system.domain.SysNotice;
import com.salpa.system.service.ISysNoticeService;
/**
* 公告 信息操作处理
*
* @author salpa
*/
@RestController
@RequestMapping("/system/notice")
public class SysNoticeController extends BaseController
{
@Autowired
private ISysNoticeService noticeService;
/**
* 获取通知公告列表
*/
@PreAuthorize("@ss.hasPermi('system:notice:list')")
@GetMapping("/list")
public TableDataInfo list(SysNotice notice)
{
startPage();
List<SysNotice> list = noticeService.selectNoticeList(notice);
return getDataTable(list);
}
/**
* 根据通知公告编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:notice:query')")
@GetMapping(value = "/{noticeId}")
public AjaxResult getInfo(@PathVariable Long noticeId)
{
return AjaxResult.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());
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));
}
}

130
salpa-admin/src/main/java/com/salpa/web/controller/system/SysPostController.java Normal file
View File

@ -0,0 +1,130 @@
package com.salpa.web.controller.system;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.domain.SysPost;
import com.salpa.system.service.ISysPostService;
/**
* 岗位信息操作处理
*
* @author salpa
*/
@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 AjaxResult.success(postService.selectPostById(postId));
}
/**
* 新增岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:add')")
@Log(title = "岗位管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysPost post)
{
if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post)))
{
return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败，岗位名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post)))
{
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post)))
{
return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败，岗位名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post)))
{
return AjaxResult.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 AjaxResult.success(posts);
}
}

142
salpa-admin/src/main/java/com/salpa/web/controller/system/SysProfileController.java Normal file
View File

@ -0,0 +1,142 @@
package com.salpa.web.controller.system;
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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.salpa.common.annotation.Log;
import com.salpa.common.config.SalpaConfig;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.common.core.domain.model.LoginUser;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.common.utils.StringUtils;
import com.salpa.common.utils.file.FileUploadUtils;
import com.salpa.common.utils.file.MimeTypeUtils;
import com.salpa.framework.web.service.TokenService;
import com.salpa.system.service.ISysUserService;
/**
* 个人信息 业务处理
*
* @author salpa
*/
@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 sysUser = loginUser.getUser();
user.setUserName(sysUser.getUserName());
if (StringUtils.isNotEmpty(user.getPhonenumber())
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，手机号码已存在");
}
if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，邮箱账号已存在");
}
user.setUserId(sysUser.getUserId());
user.setPassword(null);
if (userService.updateUserProfile(user) > 0)
{
// 更新缓存用户信息
sysUser.setNickName(user.getNickName());
sysUser.setPhonenumber(user.getPhonenumber());
sysUser.setEmail(user.getEmail());
sysUser.setSex(user.getSex());
tokenService.setLoginUser(loginUser);
return AjaxResult.success();
}
return AjaxResult.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 AjaxResult.error("修改密码失败，旧密码错误");
}
if (SecurityUtils.matchesPassword(newPassword, password))
{
return AjaxResult.error("新密码不能与旧密码相同");
}
if (userService.resetUserPwd(userName, SecurityUtils.encryptPassword(newPassword)) > 0)
{
// 更新缓存用户密码
loginUser.getUser().setPassword(SecurityUtils.encryptPassword(newPassword));
tokenService.setLoginUser(loginUser);
return AjaxResult.success();
}
return AjaxResult.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 = "/profile"+ FileUploadUtils.upload(SalpaConfig.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 AjaxResult.error("上传图片异常，请联系管理员");
}
}

38
salpa-admin/src/main/java/com/salpa/web/controller/system/SysRegisterController.java Normal file
View File

@ -0,0 +1,38 @@
package com.salpa.web.controller.system;
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;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.model.RegisterBody;
import com.salpa.common.utils.StringUtils;
import com.salpa.framework.web.service.SysRegisterService;
import com.salpa.system.service.ISysConfigService;
/**
* 注册验证
*
* @author salpa
*/
@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);
}
}

245
salpa-admin/src/main/java/com/salpa/web/controller/system/SysRoleController.java Normal file
View File

@ -0,0 +1,245 @@
package com.salpa.web.controller.system;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysRole;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.common.core.domain.model.LoginUser;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.StringUtils;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.framework.web.service.SysPermissionService;
import com.salpa.framework.web.service.TokenService;
import com.salpa.system.domain.SysUserRole;
import com.salpa.system.service.ISysRoleService;
import com.salpa.system.service.ISysUserService;
/**
* 角色信息
*
* @author salpa
*/
@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;
@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 AjaxResult.success(roleService.selectRoleById(roleId));
}
/**
* 新增角色
*/
@PreAuthorize("@ss.hasPermi('system:role:add')")
@Log(title = "角色管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysRole role)
{
if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role)))
{
return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败，角色名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role)))
{
return AjaxResult.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 (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role)))
{
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败，角色名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role)))
{
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败，角色权限已存在");
}
role.setUpdateBy(getUsername());
if (roleService.updateRole(role) > 0)
{
// 更新缓存用户权限
LoginUser loginUser = getLoginUser();
if (StringUtils.isNotNull(loginUser.getUser()) && !loginUser.getUser().isAdmin())
{
loginUser.setPermissions(permissionService.getMenuPermission(loginUser.getUser()));
loginUser.setUser(userService.selectUserByUserName(loginUser.getUser().getUserName()));
tokenService.setLoginUser(loginUser);
}
return AjaxResult.success();
}
return AjaxResult.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 AjaxResult.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));
}
}

237
salpa-admin/src/main/java/com/salpa/web/controller/system/SysUserController.java Normal file
View File

@ -0,0 +1,237 @@
package com.salpa.web.controller.system;
import java.util.List;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.salpa.common.annotation.Log;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysRole;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.common.utils.StringUtils;
import com.salpa.common.utils.poi.ExcelUtil;
import com.salpa.system.service.ISysPostService;
import com.salpa.system.service.ISysRoleService;
import com.salpa.system.service.ISysUserService;
/**
* 用户信息
*
* @author salpa
*/
@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController
{
@Autowired
private ISysUserService userService;
@Autowired
private ISysRoleService roleService;
@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 AjaxResult.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)
{
userService.checkUserDataScope(userId);
AjaxResult ajax = AjaxResult.success();
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());
if (StringUtils.isNotNull(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()));
}
return ajax;
}
/**
* 新增用户
*/
@PreAuthorize("@ss.hasPermi('system:user:add')")
@Log(title = "用户管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysUser user)
{
if (UserConstants.NOT_UNIQUE.equals(userService.checkUserNameUnique(user.getUserName())))
{
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，登录账号已存在");
}
else if (StringUtils.isNotEmpty(user.getPhonenumber())
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
{
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，手机号码已存在");
}
else if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.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());
if (StringUtils.isNotEmpty(user.getPhonenumber())
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，手机号码已存在");
}
else if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.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);
userService.insertUserAuth(userId, roleIds);
return success();
}
}

24
salpa-admin/src/main/java/com/salpa/web/controller/tool/SwaggerController.java Normal file
View File

@ -0,0 +1,24 @@
package com.salpa.web.controller.tool;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.salpa.common.core.controller.BaseController;
/**
* swagger 接口
*
* @author salpa
*/
@Controller
@RequestMapping("/tool/swagger")
public class SwaggerController extends BaseController
{
@PreAuthorize("@ss.hasPermi('tool:swagger:view')")
@GetMapping()
public String index()
{
return redirect("/swagger-ui.html");
}
}

183
salpa-admin/src/main/java/com/salpa/web/controller/tool/TestController.java Normal file
View File

@ -0,0 +1,183 @@
package com.salpa.web.controller.tool;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.R;
import com.salpa.common.utils.StringUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
/**
* swagger 用户测试方法
*
* @author salpa
*/
@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;
}
}

125
salpa-admin/src/main/java/com/salpa/web/core/config/SwaggerConfig.java Normal file
View File

@ -0,0 +1,125 @@
package com.salpa.web.core.config;
import java.util.ArrayList;
import java.util.List;
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 com.salpa.common.config.SalpaConfig;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.ApiKey;
import springfox.documentation.service.AuthorizationScope;
import springfox.documentation.service.Contact;
import springfox.documentation.service.SecurityReference;
import springfox.documentation.service.SecurityScheme;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;
/**
* Swagger2的接口配置
*
* @author salpa
*/
@Configuration
public class SwaggerConfig
{
/** 系统基础配置 */
@Autowired
private SalpaConfig salpaConfig;
/** 是否开启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.ruoyi.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(salpaConfig.getName(), null, null))
// 版本
.version("版本号:" + salpaConfig.getVersion())
.build();
}
}

26
salpa-admin/src/main/java/com/salpa/web/job/ProjectSyncJob.java Normal file
View File

@ -0,0 +1,26 @@
package com.salpa.web.job;
import com.salpa.subject.service.DocumentService;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
public class ProjectSyncJob implements Job {
@Autowired
private DocumentService documentService;
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
JobDataMap dataMap = context.getMergedJobDataMap();
Integer projectId = dataMap.getInt("projectId");
try {
documentService.createSyncTask(projectId, (long)-1, true);
} catch (Exception e) {
e.printStackTrace();
}
}
}

180
salpa-admin/src/main/java/com/salpa/web/job/ProjectSyncJobScheduler.java Normal file
View File

@ -0,0 +1,180 @@
package com.salpa.web.job;
import com.salpa.subject.domain.MonitorProjectSyncRule;
import com.salpa.subject.mapper.ProjectSyncRuleMapper;
import com.salpa.subject.service.DocumentService;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.util.Pair;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* 用于启用 / 停用项目同步任务的调度器
*/
@Component
public class ProjectSyncJobScheduler {
private static final String JOB_IDENTITY_PATTERN = "JOB_PROJECT[%s]";
private static final String TRIGGER_IDENTITY_PATTERN = "TRIGGER_PROJECT[%s]";
@Autowired
private Scheduler scheduler;
@Autowired
private ProjectSyncRuleMapper projectSyncRuleMapper;
@Autowired
private DocumentService documentService;
/**
* 启动 isAutoSync=true 的任务
*/
@Scheduled(fixedRate = 1000)
public void scheduleProjectSync() {
List<JobDetail> list = getProjectJobDetails();
for (JobDetail jobDetail : list) {
System.out.println(jobDetail.getJobDataMap().getInt("projectId"));
System.out.println(jobDetail.getJobDataMap().get("projectId"));
}
List<Integer> currentlyTriggerProjectIds = getProjectJobDetails()
.stream()
.map(job -> job.getJobDataMap().getInt("projectId"))
.collect(Collectors.toList());
// 查询已开启自动同步但还未运行的任务
projectSyncRuleMapper.selectByIsAutoSyncAndNotInProjectIds(true, currentlyTriggerProjectIds)
.stream()
.map(this::jobAndTriggers)
.forEach(jobAndTriggers -> {
try {
if (!scheduler.checkExists(jobAndTriggers.getSecond().getKey())) {
scheduler.scheduleJob(jobAndTriggers.getFirst(), jobAndTriggers.getSecond());
}
} catch (SchedulerException e) {
e.printStackTrace();
}
});
}
/**
* 停止 Rule.cron 更新过的任务
*/
@Scheduled(fixedRate = 1000)
public void reScheduleProjectSync() {
List<JobDetail> list = getProjectJobDetails();
for (JobDetail jobDetail : list) {
System.out.println(jobDetail.getJobDataMap().getInt("projectId"));
System.out.println(jobDetail.getJobDataMap().get("projectId"));
}
List<TriggerKey> triggerKeys = getProjectJobDetails()
.stream()
.filter(jobDetail -> {
JobDataMap dataMap = jobDetail.getJobDataMap();
System.out.println(dataMap.getInt("projectId"));
int projectId = dataMap.getInt("projectId");
String cron = dataMap.getString("cron");
return !projectSyncRuleMapper.existsByProjectIdAndCron(projectId, cron);
})
.map(jobDetail -> jobDetail.getJobDataMap().getInt("projectId"))
.map(this::triggerKey)
.collect(Collectors.toList());
try {
if (!triggerKeys.isEmpty()) {
scheduler.unscheduleJobs(triggerKeys);
}
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 停止 isAutoSync=false 的项目
*/
@Scheduled(fixedRate = 1000)
public void unScheduleProjectSync() {
List<JobDetail> list = getProjectJobDetails();
for (JobDetail jobDetail : list) {
System.out.println(jobDetail.getJobDataMap().getInt("projectId"));
System.out.println(jobDetail.getJobDataMap().get("projectId"));
}
List<Integer> projectIds = getProjectJobDetails()
.stream()
.map(job -> job.getJobDataMap().getInt("projectId"))
.collect(Collectors.toList());
// 查询已关闭自动同步但还在运行的任务
List<TriggerKey> triggerKeys = projectSyncRuleMapper.selectByIsAutoSyncAndProjectIds(false, projectIds)
.stream()
.map(p -> triggerKey(p.getProjectId()))
.collect(Collectors.toList());
try {
if (!triggerKeys.isEmpty()) {
scheduler.unscheduleJobs(triggerKeys);
}
} catch (SchedulerException e) {
e.printStackTrace();
}
}
private List<JobDetail> getProjectJobDetails() {
try {
return scheduler.getJobKeys(GroupMatcher.anyGroup())
.stream()
.map(jobKey -> {
try {
JobDetail job = scheduler.getJobDetail(jobKey);
if (job.getJobDataMap().containsKey("projectId")) {
return Optional.of(job);
} else {
return Optional.<JobDetail>empty();
}
} catch (SchedulerException e) {
return Optional.<JobDetail>empty();
}
})
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.toList());
} catch (SchedulerException e) {
return Collections.emptyList();
}
}
private Pair<JobDetail, Trigger> jobAndTriggers(MonitorProjectSyncRule rule) {
JobDataMap dataMap = new JobDataMap();
Integer projectId = rule.getProjectId();
Integer ruleId = rule.getId();
dataMap.put("projectId", projectId);
dataMap.put("ruleId", ruleId);
dataMap.put("cron", rule.getAutoSyncCron());
dataMap.put("documentService", documentService);
JobDetail job = JobBuilder.newJob()
.ofType(com.salpa.web.job.ProjectSyncJob.class)
.withIdentity(jobKey(projectId))
.withDescription("auto sync project document")
.usingJobData(dataMap)
.build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(rule.getAutoSyncCron());
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey(projectId))
.forJob(job)
.withSchedule(scheduleBuilder)
.startNow()
.build();
return Pair.of(job, trigger);
}
private TriggerKey triggerKey(Integer projectId) {
return TriggerKey.triggerKey(String.format(TRIGGER_IDENTITY_PATTERN, projectId));
}
private JobKey jobKey(Integer projectId) {
return JobKey.jobKey(String.format(JOB_IDENTITY_PATTERN, projectId));
}
}

118
salpa-admin/src/main/java/com/salpa/web/job/ProjectSyncTaskScheduler.java Normal file
View File

@ -0,0 +1,118 @@
package com.salpa.web.job;
import com.alibaba.fastjson2.JSON;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.entity.SysUser;
import com.salpa.subject.domain.MonitorOperationLog;
import com.salpa.subject.domain.MonitorProjectSyncTask;
import com.salpa.subject.domain.data.ProjectSyncTaskStatus;
import com.salpa.subject.mapper.OperationLogMapper;
import com.salpa.subject.mapper.ProjectSyncTaskMapper;
import com.salpa.subject.service.DocumentSyncService;
import com.salpa.system.mapper.SysUserMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Objects;
@Component
@RequiredArgsConstructor
@Slf4j
public class ProjectSyncTaskScheduler {
@Autowired
private DocumentSyncService documentSyncService;
@Autowired
private OperationLogMapper operationLogMapper;
@Autowired
private ProjectSyncTaskMapper projectSyncTaskMapper;
@Autowired
private SysUserMapper sysUserMapper;
private final ThreadPoolTaskExecutor projectSyncTaskThreadPoolTaskExecutor;
/*每隔 5s 执行一次*/
@Scheduled(fixedRate = 5000L)
public void startSyncTask() {
final int size = 10;
List<MonitorProjectSyncTask> tasks = projectSyncTaskMapper.listNewTasks(size);
tasks.forEach(task -> {
projectSyncTaskThreadPoolTaskExecutor.execute(() -> {
Integer taskId = task.getId();
Integer projectId = task.getProjectId();
Long userId = task.getUserId();
sync(taskId, projectId, userId);
});
});
}
private void sync(Integer taskId, Integer projectId, Long userId) {
try {
updateSyncTaskStatus(taskId, ProjectSyncTaskStatus.RUNNING.toString(), "running");
Integer docId = documentSyncService.syncByProjectId(projectId, taskId);
String status = documentSyncService.selectStatusById(taskId);
if (!"CANCELED".equals(status)) {
updateSyncTaskStatus(taskId, ProjectSyncTaskStatus.FINISHED.toString(), "ok");
saveOperationLog(projectId, userId, null);
} else {
if (docId != null) {
Long version = documentSyncService.getDocumentVersionById(docId);
documentSyncService.deleteDocumentById(docId);
documentSyncService.updateDocument(projectId,version-1);
}
}
} catch (Exception e) {
String result = Objects.requireNonNullElse(e.getMessage(), "unknown");
updateSyncTaskStatus(taskId, ProjectSyncTaskStatus.FAILED.toString(), result);
saveOperationLog(projectId, userId, e);
throw e;
}
}
private void updateSyncTaskStatus(Integer taskId, String status, String result) {
projectSyncTaskMapper.updateStatusAndResultById(taskId, status, result);
}
private void saveOperationLog(Integer projectId, Long userId, Exception ex) {
String operatorNickName;
String operatorUsername;
String operationName;
if (Objects.equals(-1, userId)) {
operatorNickName = "system";
operatorUsername = "system";
operationName = "定时同步";
} else {
SysUser user = sysUserMapper.selectUserById(userId);
operatorNickName = user.getNickName();
operatorUsername = user.getUserName();
operationName = "手动同步";
}
AjaxResult response;
if (ex == null) {
response = AjaxResult.success();
} else {
response = AjaxResult.error(-1,ex.getMessage());
}
MonitorOperationLog operationLog = MonitorOperationLog.builder()
.operatorNickname(operatorNickName)
.operatorUsername(operatorUsername)
.operatorUserId(userId)
.operationName(operationName)
.operationCode("autoSyncDocumentation")
.operationModule("project")
.operationResponse(JSON.toJSONString(response))
.success(ex == null)
.involvedProjectId(projectId)
.build();
operationLogMapper.addOperationLog(operationLog);
}
}

27
salpa-admin/src/main/java/com/salpa/web/job/config/ProjectSyncTaskThreadPoolConfig.java Normal file
View File

@ -0,0 +1,27 @@
package com.salpa.web.job.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;
@Configuration
public class ProjectSyncTaskThreadPoolConfig {
@Bean
public ThreadPoolTaskExecutor projectSyncTaskThreadPoolTaskExecutor() {
final int maxCorePoolSize = 12;
final int maxPoolSize = 32;
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
int availableProcessorCount = Runtime.getRuntime().availableProcessors() + 2;
int corePoolSize = Math.min(maxCorePoolSize, availableProcessorCount);
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setAllowCoreThreadTimeOut(true);
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
return executor;
}
}

36
salpa-admin/src/main/resources/.idea/inspectionProfiles/Project_Default.xml generated Normal file
View File

@ -0,0 +1,36 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="JavaDoc" enabled="true" level="WARNING" enabled_by_default="true">
<option name="TOP_LEVEL_CLASS_OPTIONS">
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<option name="REQUIRED_TAGS" value="" />
</value>
</option>
<option name="INNER_CLASS_OPTIONS">
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<option name="REQUIRED_TAGS" value="" />
</value>
</option>
<option name="METHOD_OPTIONS">
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<option name="REQUIRED_TAGS" value="@return@param@throws or @exception" />
</value>
</option>
<option name="FIELD_OPTIONS">
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<option name="REQUIRED_TAGS" value="" />
</value>
</option>
<option name="IGNORE_DEPRECATED" value="false" />
<option name="IGNORE_JAVADOC_PERIOD" value="true" />
<option name="IGNORE_DUPLICATED_THROWS" value="false" />
<option name="IGNORE_POINT_TO_ITSELF" value="false" />
<option name="myAdditionalJavadocTags" value="date" />
</inspection_tool>
</profile>
</component>

9
salpa-admin/src/main/resources/.idea/misc.xml generated Normal file
View File

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="JavaScriptSettings">
<option name="languageLevel" value="ES6" />
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

8
salpa-admin/src/main/resources/.idea/modules.xml generated Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/resources.iml" filepath="$PROJECT_DIR$/.idea/resources.iml" />
</modules>
</component>
</project>

9
salpa-admin/src/main/resources/.idea/resources.iml generated Normal file
View File

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

6
salpa-admin/src/main/resources/.idea/vcs.xml generated Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$/../../../.." vcs="Git" />
</component>
</project>

43
salpa-admin/src/main/resources/.idea/workspace.xml generated Normal file
View File

@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ChangeListManager">
<list default="true" id="3b94f0ce-cfab-4c8d-92c0-b1f2bb5f50bf" name="Default Changelist" comment="" />
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
<option name="LAST_RESOLUTION" value="IGNORE" />
</component>
<component name="Git.Settings">
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/../../../.." />
</component>
<component name="ProjectId" id="2D44FCzATVZxntMBrzQmJH9DrzN" />
<component name="ProjectLevelVcsManager" settingsEditedManually="true" />
<component name="ProjectViewState">
<option name="hideEmptyMiddlePackages" value="true" />
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent">
<property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
<property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
<property name="WebServerToolWindowFactoryState" value="false" />
<property name="aspect.path.notification.shown" value="true" />
<property name="last_opened_file_path" value="$PROJECT_DIR$" />
</component>
<component name="SvnConfiguration">
<configuration />
</component>
<component name="TaskManager">
<task active="true" id="Default" summary="Default task">
<changelist id="3b94f0ce-cfab-4c8d-92c0-b1f2bb5f50bf" name="Default Changelist" comment="" />
<created>1659944916476</created>
<option name="number" value="Default" />
<option name="presentableId" value="Default" />
<updated>1659944916476</updated>
<workItem from="1659944917575" duration="5000" />
</task>
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="2" />
</component>
</project>

1
salpa-admin/src/main/resources/META-INF/spring-devtools.properties Normal file
View File

@ -0,0 +1 @@
restart.include.json=/com.alibaba.fastjson.*.jar

57
salpa-admin/src/main/resources/application-druid.yml Normal file
View File

@ -0,0 +1,57 @@
# 数据源配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
druid:
# 主库数据源
master:
url: jdbc:mysql://192.168.1.168:3307/metaops?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8
username: metaops
password: Metaops@123
# 从库数据源
slave:
# 从数据源开关/默认关闭
enabled: false
url:
username:
password:
# 初始连接数
initialSize: 5
# 最小连接池数量
minIdle: 10
# 最大连接池数量
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
minEvictableIdleTimeMillis: 300000
# 配置一个连接在池中最大生存的时间，单位是毫秒
maxEvictableIdleTimeMillis: 900000
# 配置检测连接是否有效
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
webStatFilter:
enabled: true
statViewServlet:
enabled: true
# 设置白名单，不填则允许所有访问
allow:
url-pattern: /druid/*
# 控制台管理用户名和密码
login-username: ruoyi
login-password: 123456
filter:
stat:
enabled: true
# 慢SQL记录
log-slow-sql: true
slow-sql-millis: 1000
merge-sql: true
wall:
config:
multi-statement-allow: true

123
salpa-admin/src/main/resources/application.yml Normal file
View File

@ -0,0 +1,123 @@
# 项目相关配置
metaops:
# 名称
name: Salpa
# 版本
version: 3.8.3
# 版权年份
copyrightYear: 2022
# 实例演示开关
demoEnabled: true
# 文件路径 示例（ Windows配置D:/metaops/uploadPath，Linux配置 /home/metaops/uploadPath）
profile: /home/metaops/uploadPath
# 获取ip地址开关
addressEnabled: false
# 验证码类型 math 数组计算 char 字符验证
captchaType: math
# 开发环境配置
server:
# 服务器的HTTP端口，默认为8080
port: 9080
servlet:
# 应用的访问路径
context-path: /
tomcat:
# tomcat的URI编码
uri-encoding: UTF-8
# 连接数满后的排队数，默认为100
accept-count: 1000
threads:
# tomcat最大线程数，默认为200
max: 800
# Tomcat启动初始化的线程数，默认值10
min-spare: 100
# 日志配置
logging:
level:
com.metaops: debug
org.springframework: warn
# Spring配置
spring:
# 资源信息
messages:
# 国际化资源文件路径
basename: i18n/messages
profiles:
active: druid
# 文件上传
servlet:
multipart:
# 单个文件大小
max-file-size: 1024MB
# 设置总上传的文件大小
max-request-size: 1024MB
# 服务模块
devtools:
restart:
# 热部署开关
enabled: true
# redis 配置
redis:
# 地址
host: 192.168.1.168
# 端口，默认为6379
port: 6379
# 数据库索引
database: 10
# 密码
password:
# 连接超时时间
timeout: 10s
lettuce:
pool:
# 连接池中的最小空闲连接
min-idle: 0
# 连接池中的最大空闲连接
max-idle: 8
# 连接池的最大数据库连接数
max-active: 8
# #连接池最大阻塞等待时间（使用负值表示没有限制）
max-wait: -1ms
# token配置
token:
# 令牌自定义标识
header: Authorization
# 令牌密钥
secret: abcdefghijklmnopqrstuvwxyz
# 令牌有效期（默认30分钟）
expireTime: 30
# MyBatis配置
mybatis:
# 搜索指定包别名
typeAliasesPackage: com.salpa.**.domain
# 配置mapper的扫描，找到所有的mapper.xml映射文件
mapperLocations: classpath*:mapper/**/*Mapper.xml
# 加载全局的配置文件
configLocation: classpath:mybatis/mybatis-config.xml
# PageHelper分页插件
pagehelper:
helperDialect: mysql
supportMethodsArguments: true
params: count=countSql
# Swagger配置
swagger:
# 是否开启swagger
enabled: true
# 请求前缀
pathMapping: /dev-api
# 防止XSS攻击
xss:
# 过滤开关
enabled: true
# 排除链接（多个用逗号分隔）
excludes: /system/notice
# 匹配链接
urlPatterns: /system/*,/monitor/*,/tool/*

24
salpa-admin/src/main/resources/banner.txt Normal file
View File

@ -0,0 +1,24 @@
Application Version: ${ruoyi.version}
Spring Boot Version: ${spring-boot.version}
////////////////////////////////////////////////////////////////////
// _ooOoo_ //
// o8888888o //
// 88" . "88 //
// (| ^_^ |) //
// O\ = /O //
// ____/`---'\____ //
// .' \\| |// `. //
// / \\||| : |||// \ //
// / _||||| -:- |||||- \ //
// | | \\\ - /// | | //
// | \_| ''\---/'' | | //
// \ .-\__ `-` ___/-. / //
// ___`. .' /--.--\ `. . ___ //
// ."" '< `.___\_<|>_/___.' >'"". //
// | | : `- \`.;`\ _ /`;.`/ - ` : | | //
// \ \ `-. \_ __\ /__ _/ .-` / / //
// ========`-.____`-.___\_____/___.-`____.-'======== //
// `=---=' //
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ //
// 佛祖保佑 永不宕机 永无BUG //
////////////////////////////////////////////////////////////////////

1292
salpa-admin/src/main/resources/empty.json Normal file
View File

File diff suppressed because one or more lines are too long

37
salpa-admin/src/main/resources/i18n/messages.properties Normal file
View File

@ -0,0 +1,37 @@
#错误消息
not.null=* 必须填写
user.jcaptcha.error=验证码错误
user.jcaptcha.expire=验证码已失效
user.not.exists=用户不存在/密码错误
user.password.not.match=用户不存在/密码错误
user.password.retry.limit.count=密码输入错误{0}次
user.password.retry.limit.exceed=密码输入错误{0}次，帐户锁定10分钟
user.password.delete=对不起，您的账号已被删除
user.blocked=用户已封禁，请联系管理员
role.blocked=角色已封禁，请联系管理员
user.logout.success=退出成功
length.not.valid=长度必须在{min}到{max}个字符之间
user.username.not.valid=* 2到20个汉字、字母、数字或下划线组成，且必须以非数字开头
user.password.not.valid=* 5-50个字符
user.email.not.valid=邮箱格式错误
user.mobile.phone.number.not.valid=手机号格式错误
user.login.success=登录成功
user.register.success=注册成功
user.notfound=请重新登录
user.forcelogout=管理员强制退出，请重新登录
user.unknown.error=未知错误，请重新登录
##文件上传消息
upload.exceed.maxSize=上传的文件大小超出限制的文件大小！<br/>允许的文件最大大小是：{0}MB！
upload.filename.exceed.length=上传的文件名最长{0}个字符
##权限
no.permission=您没有数据的权限，请联系管理员添加权限 [{0}]
no.create.permission=您没有创建数据的权限，请联系管理员添加权限 [{0}]
no.update.permission=您没有修改数据的权限，请联系管理员添加权限 [{0}]
no.delete.permission=您没有删除数据的权限，请联系管理员添加权限 [{0}]
no.export.permission=您没有导出数据的权限，请联系管理员添加权限 [{0}]
no.view.permission=您没有查看数据的权限，请联系管理员添加权限 [{0}]

93
salpa-admin/src/main/resources/logback.xml Normal file
View File

@ -0,0 +1,93 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 日志存放路径 -->
<property name="log.path" value="/home/metaops/logs" />
<!-- 日志输出格式 -->
<property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />
<!-- 控制台输出 -->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
</appender>
<!-- 系统日志输出 -->
<appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${log.path}/sys-info.log</file>
<!-- 循环政策：基于时间创建日志文件 -->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 日志文件名格式 -->
<fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>
<!-- 日志最大的历史 60天 -->
<maxHistory>60</maxHistory>
</rollingPolicy>
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<!-- 过滤的级别 -->
<level>INFO</level>
<!-- 匹配时的操作：接收（记录） -->
<onMatch>ACCEPT</onMatch>
<!-- 不匹配时的操作：拒绝（不记录） -->
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${log.path}/sys-error.log</file>
<!-- 循环政策：基于时间创建日志文件 -->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 日志文件名格式 -->
<fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log</fileNamePattern>
<!-- 日志最大的历史 60天 -->
<maxHistory>60</maxHistory>
</rollingPolicy>
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<!-- 过滤的级别 -->
<level>ERROR</level>
<!-- 匹配时的操作：接收（记录） -->
<onMatch>ACCEPT</onMatch>
<!-- 不匹配时的操作：拒绝（不记录） -->
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<!-- 用户访问日志输出 -->
<appender name="sys-user" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${log.path}/sys-user.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 按天回滚 daily -->
<fileNamePattern>${log.path}/sys-user.%d{yyyy-MM-dd}.log</fileNamePattern>
<!-- 日志最大的历史 60天 -->
<maxHistory>60</maxHistory>
</rollingPolicy>
<encoder>
<pattern>${log.pattern}</pattern>
</encoder>
</appender>
<!-- 系统模块日志级别控制 -->
<logger name="com.salpa" level="info" />
<!-- Spring日志级别控制 -->
<logger name="org.springframework" level="warn" />
<root level="info">
<appender-ref ref="console" />
</root>
<!--系统操作日志-->
<root level="info">
<appender-ref ref="file_info" />
<appender-ref ref="file_error" />
</root>
<!--系统用户操作日志-->
<logger name="sys-user" level="info">
<appender-ref ref="sys-user"/>
</logger>
</configuration>

20
salpa-admin/src/main/resources/mybatis/mybatis-config.xml Normal file
View File

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 全局参数 -->
<settings>
<!-- 使全局的映射器启用或禁用缓存 -->
<setting name="cacheEnabled" value="true" />
<!-- 允许JDBC 支持自动生成主键 -->
<setting name="useGeneratedKeys" value="true" />
<!-- 配置默认的执行器.SIMPLE就是普通执行器;REUSE执行器会重用预处理语句(prepared statements);BATCH执行器将重用语句并执行批量更新 -->
<setting name="defaultExecutorType" value="SIMPLE" />
<!-- 指定 MyBatis 所用日志的具体实现 -->
<setting name="logImpl" value="SLF4J" />
<!-- 使用驼峰命名法转换字段 -->
<!-- <setting name="mapUnderscoreToCamelCase" value="true"/> -->
</settings>
</configuration>

29
salpa-admin/src/main/resources/word.docx Normal file
View File

@ -0,0 +1,29 @@
{{databaseName}}
overview
{{tables}}表名
类型
备注
[tableName]
[tableType]
[tableComment]
{{?tableColumns}}
{{tableName}}
{{columns}}名称
类型
主键
可空
自增
默认值
注释
[name]
[type]
[primaryKey]
[nullable]
[autoincrement]
[defaultValue]
[comment]
{{/tableColumns}}

166
salpa-common/pom.xml Normal file
View File

@ -0,0 +1,166 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>salpa</artifactId>
<groupId>com.salpa</groupId>
<version>3.8.3</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>salpa-common</artifactId>
<description>
common通用工具
</description>
<dependencies>
<!-- 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>
<!-- 自定义验证注解 -->
<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>
<!-- 文件上传工具类 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
</dependency>
<!-- excel工具 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
</dependency>
<!-- poi-tl基于poi的word模板引擎 -->
<dependency>
<groupId>com.deepoove</groupId>
<artifactId>poi-tl</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>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct</artifactId>
<version>1.4.2.Final</version>
</dependency>
<!-- uml-->
<dependency>
<groupId>net.sourceforge.plantuml</groupId>
<artifactId>plantuml</artifactId>
<version>1.2022.6</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.31</version>
</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>
</dependencies>
</project>

128
salpa-common/salpa-common.iml Normal file
View File

@ -0,0 +1,128 @@
<?xml version="1.0" encoding="UTF-8"?>
<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
<component name="FacetManager">
<facet type="Spring" name="Spring">
<configuration />
</facet>
</component>
<component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_11">
<output url="file://$MODULE_DIR$/target/classes" />
<output-test url="file://$MODULE_DIR$/target/test-classes" />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
<excludeFolder url="file://$MODULE_DIR$/target" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="Maven: org.springframework:spring-context-support:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-beans:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-context:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-expression:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-core:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-jcl:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-web:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-security:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-autoconfigure:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-logging:2.5.14" level="project" />
<orderEntry type="library" name="Maven: ch.qos.logback:logback-classic:1.2.11" level="project" />
<orderEntry type="library" name="Maven: ch.qos.logback:logback-core:1.2.11" level="project" />
<orderEntry type="library" name="Maven: org.apache.logging.log4j:log4j-to-slf4j:2.17.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.logging.log4j:log4j-api:2.17.2" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:jul-to-slf4j:1.7.36" level="project" />
<orderEntry type="library" name="Maven: jakarta.annotation:jakarta.annotation-api:1.3.5" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-aop:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-config:5.5.8" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-core:5.5.8" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-crypto:5.5.8" level="project" />
<orderEntry type="library" name="Maven: org.springframework.security:spring-security-web:5.5.8" level="project" />
<orderEntry type="library" name="Maven: com.github.pagehelper:pagehelper-spring-boot-starter:1.4.1" level="project" />
<orderEntry type="library" name="Maven: org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.2" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-jdbc:2.5.14" level="project" />
<orderEntry type="library" name="Maven: com.zaxxer:HikariCP:4.0.3" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-jdbc:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.mybatis.spring.boot:mybatis-spring-boot-autoconfigure:2.2.2" level="project" />
<orderEntry type="library" name="Maven: org.mybatis:mybatis:3.5.9" level="project" />
<orderEntry type="library" name="Maven: org.mybatis:mybatis-spring:2.0.7" level="project" />
<orderEntry type="library" name="Maven: com.github.pagehelper:pagehelper-spring-boot-autoconfigure:1.4.1" level="project" />
<orderEntry type="library" name="Maven: com.github.pagehelper:pagehelper:5.3.0" level="project" />
<orderEntry type="library" name="Maven: com.github.jsqlparser:jsqlparser:4.2" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-validation:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.tomcat.embed:tomcat-embed-el:9.0.63" level="project" />
<orderEntry type="library" name="Maven: org.hibernate.validator:hibernate-validator:6.2.3.Final" level="project" />
<orderEntry type="library" name="Maven: jakarta.validation:jakarta.validation-api:2.0.2" level="project" />
<orderEntry type="library" name="Maven: org.jboss.logging:jboss-logging:3.4.3.Final" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml:classmate:1.5.1" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-lang3:3.12.0" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-databind:2.12.6.1" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-annotations:2.12.6" level="project" />
<orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-core:2.12.6" level="project" />
<orderEntry type="library" name="Maven: com.alibaba.fastjson2:fastjson2:2.0.8" level="project" />
<orderEntry type="library" name="Maven: commons-io:commons-io:2.11.0" level="project" />
<orderEntry type="library" name="Maven: commons-fileupload:commons-fileupload:1.4" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-compress:1.21" level="project" />
<orderEntry type="library" name="Maven: org.apache.poi:poi-ooxml:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.poi:poi:4.1.2" level="project" />
<orderEntry type="library" name="Maven: commons-codec:commons-codec:1.15" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-collections4:4.4" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-math3:3.6.1" level="project" />
<orderEntry type="library" name="Maven: com.zaxxer:SparseBitSet:1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.poi:poi-ooxml-schemas:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlbeans:xmlbeans:3.1.0" level="project" />
<orderEntry type="library" name="Maven: com.github.virtuald:curvesapi:1.06" level="project" />
<orderEntry type="library" name="Maven: com.deepoove:poi-tl:1.10.0" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:slf4j-api:1.7.36" level="project" />
<orderEntry type="library" name="Maven: com.deepoove:poi-ooxml-schemas-extra:4.1.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-transcoder:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-anim:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-css:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-ext:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-parser:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-svg-dom:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-awt-util:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:xmlgraphics-commons:2.6" level="project" />
<orderEntry type="library" name="Maven: commons-logging:commons-logging:1.0.4" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-bridge:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-script:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-dom:1.14" level="project" />
<orderEntry type="library" name="Maven: xalan:xalan:2.7.2" level="project" />
<orderEntry type="library" name="Maven: xalan:serializer:2.7.2" level="project" />
<orderEntry type="library" name="Maven: xml-apis:xml-apis:1.4.01" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-gvt:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-shared-resources:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-svggen:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-util:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-constants:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-i18n:1.14" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-xml:1.14" level="project" />
<orderEntry type="library" name="Maven: xml-apis:xml-apis-ext:1.3.04" level="project" />
<orderEntry type="library" name="Maven: org.apache.xmlgraphics:batik-codec:1.14" level="project" />
<orderEntry type="library" name="Maven: org.yaml:snakeyaml:1.28" level="project" />
<orderEntry type="library" name="Maven: io.jsonwebtoken:jjwt:0.9.1" level="project" />
<orderEntry type="library" name="Maven: javax.xml.bind:jaxb-api:2.3.1" level="project" />
<orderEntry type="library" name="Maven: javax.activation:javax.activation-api:1.2.0" level="project" />
<orderEntry type="library" name="Maven: org.projectlombok:lombok:1.18.24" level="project" />
<orderEntry type="library" name="Maven: org.mapstruct:mapstruct:1.4.2.Final" level="project" />
<orderEntry type="library" name="Maven: net.sourceforge.plantuml:plantuml:1.2022.6" level="project" />
<orderEntry type="library" name="Maven: org.freemarker:freemarker:2.3.31" level="project" />
<orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-data-redis:2.5.14" level="project" />
<orderEntry type="library" name="Maven: org.springframework.data:spring-data-redis:2.5.11" level="project" />
<orderEntry type="library" name="Maven: org.springframework.data:spring-data-keyvalue:2.5.11" level="project" />
<orderEntry type="library" name="Maven: org.springframework.data:spring-data-commons:2.5.11" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-tx:5.3.20" level="project" />
<orderEntry type="library" name="Maven: org.springframework:spring-oxm:5.3.20" level="project" />
<orderEntry type="library" name="Maven: io.lettuce:lettuce-core:6.1.8.RELEASE" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-common:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-handler:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-resolver:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-buffer:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-codec:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.netty:netty-transport:4.1.77.Final" level="project" />
<orderEntry type="library" name="Maven: io.projectreactor:reactor-core:3.4.18" level="project" />
<orderEntry type="library" name="Maven: org.reactivestreams:reactive-streams:1.0.3" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-pool2:2.9.0" level="project" />
<orderEntry type="library" name="Maven: eu.bitwalker:UserAgentUtils:1.21" level="project" />
<orderEntry type="library" name="Maven: javax.servlet:javax.servlet-api:4.0.1" level="project" />
</component>
</module>

19
salpa-common/src/main/java/com/salpa/common/annotation/Anonymous.java Normal file
View File

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

28
salpa-common/src/main/java/com/salpa/common/annotation/DataScope.java Normal file
View File

@ -0,0 +1,28 @@
package com.salpa.common.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 数据权限过滤注解
*
* @author salpa
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope
{
/**
* 部门表的别名
*/
public String deptAlias() default "";
/**
* 用户表的别名
*/
public String userAlias() default "";
}

28
salpa-common/src/main/java/com/salpa/common/annotation/DataSource.java Normal file
View File

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

183
salpa-common/src/main/java/com/salpa/common/annotation/Excel.java Normal file
View File

@ -0,0 +1,183 @@
package com.salpa.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.math.BigDecimal;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.IndexedColors;
import com.salpa.common.utils.poi.ExcelHandlerAdapter;
/**
* 自定义导出Excel数据注解
*
* @author salpa
*/
@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 {};
/**
* 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
*/
public boolean isExport() default true;
/**
* 另一个类中的属性名称,支持多级获取,以小数点隔开
*/
public String targetAttr() default "";
/**
* 是否自动统计数据,在最后追加一行统计数据总和
*/
public boolean isStatistics() default false;
/**
* 导出类型（0数字 1字符串）
*/
public ColumnType cellType() default ColumnType.STRING;
/**
* 导出字体颜色
*/
public IndexedColors color() default IndexedColors.BLACK;
/**
* 导出字段对齐方式
*/
public HorizontalAlignment align() default HorizontalAlignment.CENTER;
/**
* 自定义数据处理器
*/
public Class<?> handler() default ExcelHandlerAdapter.class;
/**
* 自定义数据处理器参数
*/
public String[] args() default {};
public enum Align
{
AUTO(0), LEFT(1), CENTER(2), RIGHT(3);
private final int value;
Align(int value)
{
this.value = value;
}
public int value()
{
return this.value;
}
}
/**
* 字段类型（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);
private final int value;
ColumnType(int value)
{
this.value = value;
}
public int value()
{
return this.value;
}
}
}

18
salpa-common/src/main/java/com/salpa/common/annotation/Excels.java Normal file
View File

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

46
salpa-common/src/main/java/com/salpa/common/annotation/Log.java Normal file
View File

@ -0,0 +1,46 @@
package com.salpa.common.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.salpa.common.enums.BusinessType;
import com.salpa.common.enums.OperatorType;
/**
* 自定义操作日志记录注解
*
* @author salpa
*
*/
@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;
}

40
salpa-common/src/main/java/com/salpa/common/annotation/RateLimiter.java Normal file
View File

@ -0,0 +1,40 @@
package com.salpa.common.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.salpa.common.constant.CacheConstants;
import com.salpa.common.enums.LimitType;
/**
* 限流注解
*
* @author salpa
*/
@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;
}

31
salpa-common/src/main/java/com/salpa/common/annotation/RepeatSubmit.java Normal file
View File

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

143
salpa-common/src/main/java/com/salpa/common/config/SalpaConfig.java Normal file
View File

@ -0,0 +1,143 @@
package com.salpa.common.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 读取项目相关配置
*
* @author salpa
*/
@Component
@ConfigurationProperties(prefix = "metaops")
public class SalpaConfig
{
/** 项目名称 */
private String name;
/** 版本 */
private String version;
/** 版权年份 */
private String copyrightYear;
/** 实例演示开关 */
private boolean demoEnabled;
/** 上传路径 */
private static String profile;
/** 获取地址开关 */
private static boolean addressEnabled;
/** 验证码类型 */
private static String captchaType;
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;
}
public boolean isDemoEnabled()
{
return demoEnabled;
}
public void setDemoEnabled(boolean demoEnabled)
{
this.demoEnabled = demoEnabled;
}
public static String getProfile()
{
return profile;
}
public void setProfile(String profile)
{
SalpaConfig.profile = profile;
}
public static boolean isAddressEnabled()
{
return addressEnabled;
}
public void setAddressEnabled(boolean addressEnabled)
{
SalpaConfig.addressEnabled = addressEnabled;
}
public static String getCaptchaType() {
return captchaType;
}
public void setCaptchaType(String captchaType) {
SalpaConfig.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";
}
/**
* 获取drivers路径
*/
public static String getDriverPath()
{
return getProfile() + "/driver";
}
}

39
salpa-common/src/main/java/com/salpa/common/constant/CacheConstants.java Normal file
View File

@ -0,0 +1,39 @@
package com.salpa.common.constant;
/**
* 缓存的key 常量
*
* @author salpa
*/
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:";
}

137
salpa-common/src/main/java/com/salpa/common/constant/Constants.java Normal file
View File

@ -0,0 +1,137 @@
package com.salpa.common.constant;
import io.jsonwebtoken.Claims;
/**
* 通用常量信息
*
* @author salpa
*/
public class Constants
{
/**
* UTF-8 字符集
*/
public static final String UTF8 = "UTF-8";
/**
* GBK 字符集
*/
public static final String GBK = "GBK";
/**
* 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 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:";
/**
* 定时任务白名单配置（仅允许访问的包名，如其他需要可以自行添加）
*/
public static final String[] JOB_WHITELIST_STR = { "com.salpa" };
/**
* 定时任务违规的字符
*/
public static final String[] JOB_ERROR_STR = { "java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml",
"org.springframework", "org.apache", "com.salpa.common.utils.file" };
}

117
salpa-common/src/main/java/com/salpa/common/constant/GenConstants.java Normal file
View File

@ -0,0 +1,117 @@
package com.salpa.common.constant;
/**
* 代码生成通用常量
*
* @author salpa
*/
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";
}

89
salpa-common/src/main/java/com/salpa/common/constant/HttpStatus.java Normal file
View File

@ -0,0 +1,89 @@
package com.salpa.common.constant;
/**
* 返回状态码
*
* @author salpa
*/
public class HttpStatus
{
/**
* 操作成功
*/
public static final int SUCCESS = 200;
/**
* 对象创建成功
*/
public static final int CREATED = 201;
/**
* 请求已经被接受
*/
public static final int ACCEPTED = 202;
/**
* 操作已经执行成功，但是没有返回数据
*/
public static final int NO_CONTENT = 204;
/**
* 资源已被移除
*/
public static final int MOVED_PERM = 301;
/**
* 重定向
*/
public static final int SEE_OTHER = 303;
/**
* 资源没有被修改
*/
public static final int NOT_MODIFIED = 304;
/**
* 参数列表错误（缺少，格式不匹配）
*/
public static final int BAD_REQUEST = 400;
/**
* 未授权
*/
public static final int UNAUTHORIZED = 401;
/**
* 访问受限，授权过期
*/
public static final int FORBIDDEN = 403;
/**
* 资源，服务未找到
*/
public static final int NOT_FOUND = 404;
/**
* 不允许的http方法
*/
public static final int BAD_METHOD = 405;
/**
* 资源冲突，或者资源被锁
*/
public static final int CONFLICT = 409;
/**
* 不支持的数据，媒体类型
*/
public static final int UNSUPPORTED_TYPE = 415;
/**
* 系统内部错误
*/
public static final int ERROR = 500;
/**
* 接口未实现
*/
public static final int NOT_IMPLEMENTED = 501;
}

50
salpa-common/src/main/java/com/salpa/common/constant/ScheduleConstants.java Normal file
View File

@ -0,0 +1,50 @@
package com.salpa.common.constant;
/**
* 任务调度通用常量
*
* @author salpa
*/
public class ScheduleConstants
{
public static final String TASK_CLASS_NAME = "TASK_CLASS_NAME";
/** 执行目标key */
public static final String TASK_PROPERTIES = "TASK_PROPERTIES";
/** 默认 */
public static final String MISFIRE_DEFAULT = "0";
/** 立即触发执行 */
public static final String MISFIRE_IGNORE_MISFIRES = "1";
/** 触发一次执行 */
public static final String MISFIRE_FIRE_AND_PROCEED = "2";
/** 不触发立即执行 */
public static final String MISFIRE_DO_NOTHING = "3";
public enum Status
{
/**
* 正常
*/
NORMAL("0"),
/**
* 暂停
*/
PAUSE("1");
private String value;
private Status(String value)
{
this.value = value;
}
public String getValue()
{
return value;
}
}
}

78
salpa-common/src/main/java/com/salpa/common/constant/UserConstants.java Normal file
View File

@ -0,0 +1,78 @@
package com.salpa.common.constant;
/**
* 用户常量信息
*
* @author salpa
*/
public class UserConstants
{
/**
* 平台内系统用户的唯一标志
*/
public static final String SYS_USER = "SYS_USER";
/** 正常状态 */
public static final String NORMAL = "0";
/** 异常状态 */
public static final String EXCEPTION = "1";
/** 用户封禁状态 */
public static final String USER_DISABLE = "1";
/** 角色封禁状态 */
public static final String ROLE_DISABLE = "1";
/** 部门正常状态 */
public static final String DEPT_NORMAL = "0";
/** 部门停用状态 */
public static final String DEPT_DISABLE = "1";
/** 字典正常状态 */
public static final String DICT_NORMAL = "0";
/** 是否为系统默认（是） */
public static final String YES = "Y";
/** 是否菜单外链（是） */
public static final String YES_FRAME = "0";
/** 是否菜单外链（否） */
public static final String NO_FRAME = "1";
/** 菜单类型（目录） */
public static final String TYPE_DIR = "M";
/** 菜单类型（菜单） */
public static final String TYPE_MENU = "C";
/** 菜单类型（按钮） */
public static final String TYPE_BUTTON = "F";
/** Layout组件标识 */
public final static String LAYOUT = "Layout";
/** ParentView组件标识 */
public final static String PARENT_VIEW = "ParentView";
/** InnerLink组件标识 */
public final static String INNER_LINK = "InnerLink";
/** 校验返回结果码 */
public final static String UNIQUE = "0";
public final static String NOT_UNIQUE = "1";
/**
* 用户名长度限制
*/
public static final int USERNAME_MIN_LENGTH = 2;
public static final int USERNAME_MAX_LENGTH = 20;
/**
* 密码长度限制
*/
public static final int PASSWORD_MIN_LENGTH = 5;
public static final int PASSWORD_MAX_LENGTH = 20;
}

186
salpa-common/src/main/java/com/salpa/common/core/controller/BaseController.java Normal file
View File

@ -0,0 +1,186 @@
package com.salpa.common.core.controller;
import java.beans.PropertyEditorSupport;
import java.util.Date;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.salpa.common.constant.HttpStatus;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.core.domain.model.LoginUser;
import com.salpa.common.core.page.PageDomain;
import com.salpa.common.core.page.TableDataInfo;
import com.salpa.common.core.page.TableSupport;
import com.salpa.common.utils.DateUtils;
import com.salpa.common.utils.PageUtils;
import com.salpa.common.utils.SecurityUtils;
import com.salpa.common.utils.StringUtils;
import com.salpa.common.utils.sql.SqlUtil;
/**
* web层通用数据处理
*
* @author salpa
*/
public class BaseController
{
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 将前台传递过来的日期格式的字符串，自动转化为Date类型
*/
@InitBinder
public void initBinder(WebDataBinder binder)
{
// Date 类型转换
binder.registerCustomEditor(Date.class, new PropertyEditorSupport()
{
@Override
public void setAsText(String text)
{
setValue(DateUtils.parseDate(text));
}
});
}
/**
* 设置请求分页数据
*/
protected void startPage()
{
PageUtils.startPage();
}
/**
* 设置请求排序数据
*/
protected void startOrderBy()
{
PageDomain pageDomain = TableSupport.buildPageRequest();
if (StringUtils.isNotEmpty(pageDomain.getOrderBy()))
{
String orderBy = SqlUtil.escapeOrderBySql(pageDomain.getOrderBy());
PageHelper.orderBy(orderBy);
}
}
/**
* 清理分页的线程变量
*/
protected void clearPage()
{
PageUtils.clearPage();
}
/**
* 响应请求分页数据
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
protected TableDataInfo getDataTable(List<?> list)
{
TableDataInfo rspData = new TableDataInfo();
rspData.setCode(HttpStatus.SUCCESS);
rspData.setMsg("查询成功");
rspData.setRows(list);
rspData.setTotal(new PageInfo(list).getTotal());
return rspData;
}
/**
* 返回成功
*/
public AjaxResult success()
{
return AjaxResult.success();
}
/**
* 返回失败消息
*/
public AjaxResult error()
{
return AjaxResult.error();
}
/**
* 返回成功消息
*/
public AjaxResult success(String message)
{
return AjaxResult.success(message);
}
/**
* 返回失败消息
*/
public AjaxResult error(String message)
{
return AjaxResult.error(message);
}
/**
* 响应返回结果
*
* @param rows 影响行数
* @return 操作结果
*/
protected AjaxResult toAjax(int rows)
{
return rows > 0 ? AjaxResult.success() : AjaxResult.error();
}
/**
* 响应返回结果
*
* @param result 结果
* @return 操作结果
*/
protected AjaxResult toAjax(boolean result)
{
return result ? success() : error();
}
/**
* 页面跳转
*/
public String redirect(String url)
{
return StringUtils.format("redirect:{}", url);
}
/**
* 获取用户缓存信息
*/
public LoginUser getLoginUser()
{
return SecurityUtils.getLoginUser();
}
/**
* 获取登录用户id
*/
public Long getUserId()
{
return getLoginUser().getUserId();
}
/**
* 获取登录部门id
*/
public Long getDeptId()
{
return getLoginUser().getDeptId();
}
/**
* 获取登录用户名
*/
public String getUsername()
{
return getLoginUser().getUsername();
}
}

162
salpa-common/src/main/java/com/salpa/common/core/domain/AjaxResult.java Normal file
View File

@ -0,0 +1,162 @@
package com.salpa.common.core.domain;
import java.util.HashMap;
import com.salpa.common.constant.HttpStatus;
import com.salpa.common.utils.StringUtils;
/**
* 操作消息提醒
*
* @author salpa
*/
public class AjaxResult extends HashMap<String, Object>
{
private static final long serialVersionUID = 1L;
/** 状态码 */
public static final String CODE_TAG = "code";
/** 返回内容 */
public static final String MSG_TAG = "msg";
/** 数据对象 */
public static final String DATA_TAG = "data";
/**
* 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
*/
public AjaxResult()
{
}
/**
* 初始化一个新创建的 AjaxResult 对象
*
* @param code 状态码
* @param msg 返回内容
*/
public AjaxResult(int code, String msg)
{
super.put(CODE_TAG, code);
super.put(MSG_TAG, msg);
}
/**
* 初始化一个新创建的 AjaxResult 对象
*
* @param code 状态码
* @param msg 返回内容
* @param data 数据对象
*/
public AjaxResult(int code, String msg, Object data)
{
super.put(CODE_TAG, code);
super.put(MSG_TAG, msg);
if (StringUtils.isNotNull(data))
{
super.put(DATA_TAG, data);
}
}
/**
* 返回成功消息
*
* @return 成功消息
*/
public static AjaxResult success()
{
return AjaxResult.success("操作成功");
}
/**
* 返回成功数据
*
* @return 成功消息
*/
public static AjaxResult success(Object data)
{
return AjaxResult.success("操作成功", data);
}
/**
* 返回成功消息
*
* @param msg 返回内容
* @return 成功消息
*/
public static AjaxResult success(String msg)
{
return AjaxResult.success(msg, null);
}
/**
* 返回成功消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 成功消息
*/
public static AjaxResult success(String msg, Object data)
{
return new AjaxResult(HttpStatus.SUCCESS, msg, data);
}
/**
* 返回错误消息
*
* @return
*/
public static AjaxResult error()
{
return AjaxResult.error("操作失败");
}
/**
* 返回错误消息
*
* @param msg 返回内容
* @return 警告消息
*/
public static AjaxResult error(String msg)
{
return AjaxResult.error(msg, null);
}
/**
* 返回错误消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 警告消息
*/
public static AjaxResult error(String msg, Object data)
{
return new AjaxResult(HttpStatus.ERROR, msg, data);
}
/**
* 返回错误消息
*
* @param code 状态码
* @param msg 返回内容
* @return 警告消息
*/
public static AjaxResult error(int code, String msg)
{
return new AjaxResult(code, msg, null);
}
/**
* 方便链式调用
*
* @param key 键
* @param value 值
* @return 数据对象
*/
@Override
public AjaxResult put(String key, Object value)
{
super.put(key, value);
return this;
}
}

114
salpa-common/src/main/java/com/salpa/common/core/domain/BaseEntity.java Normal file
View File

@ -0,0 +1,114 @@
package com.salpa.common.core.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* Entity基类
*
* @author salpa
*/
public class BaseEntity implements Serializable
{
private static final long serialVersionUID = 1L;
/** 搜索值 */
private String searchValue;
/** 创建者 */
private String createBy;
/** 创建时间 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/** 更新者 */
private String updateBy;
/** 更新时间 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/** 备注 */
private String remark;
/** 请求参数 */
private Map<String, Object> params;
public String getSearchValue()
{
return searchValue;
}
public void setSearchValue(String searchValue)
{
this.searchValue = searchValue;
}
public String getCreateBy()
{
return createBy;
}
public void setCreateBy(String createBy)
{
this.createBy = createBy;
}
public Date getCreateTime()
{
return createTime;
}
public void setCreateTime(Date createTime)
{
this.createTime = createTime;
}
public String getUpdateBy()
{
return updateBy;
}
public void setUpdateBy(String updateBy)
{
this.updateBy = updateBy;
}
public Date getUpdateTime()
{
return updateTime;
}
public void setUpdateTime(Date updateTime)
{
this.updateTime = updateTime;
}
public String getRemark()
{
return remark;
}
public void setRemark(String remark)
{
this.remark = remark;
}
public Map<String, Object> getParams()
{
if (params == null)
{
params = new HashMap<>();
}
return params;
}
public void setParams(Map<String, Object> params)
{
this.params = params;
}
}

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