init

LICENSE

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

README.md

@@ -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%" />
+
+
+

bin/clean.bat

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

bin/package.bat

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

bin/run.bat

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

docs/salpa使用手册.docx

@@ -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导出
+

docs/salpa安装手册.docx

@@ -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)效果图

metaops.iml

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

pom.xml

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

salpa-admin/pom.xml

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

salpa-admin/salpa-admin.iml

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

salpa-admin/src/main/java/com/salpa/SalpaApplication.java

@@ -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("(♥◠‿◠)ﾉﾞ  敏捷元数据模型设计后台启动成功   ლ(´ڡ`ლ)ﾞ ");
+    }
+}

salpa-admin/src/main/java/com/salpa/SalpaServletInitializer.java

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

salpa-admin/src/main/java/com/salpa/web/controller/common/CaptchaController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/common/CommonController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/common/MockApiContoller.java

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

salpa-admin/src/main/java/com/salpa/web/controller/model/ModelController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/monitor/CacheController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/monitor/ServerController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/monitor/SysLogininforController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/monitor/SysOperlogController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/monitor/SysUserOnlineController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/online/OnlineController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/DatabaseTypeController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentDescriptionController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentDiscussionController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/DocumentTemplateController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/ProjectController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/SubjectController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/subject/WarningController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysConfigController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysDeptController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysDictDataController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysDictTypeController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysIndexController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysLoginController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysMenuController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysNoticeController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysPostController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysProfileController.java

@@ -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("上传图片异常，请联系管理员");
+    }
+}

salpa-admin/src/main/java/com/salpa/web/controller/system/SysRegisterController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysRoleController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/system/SysUserController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/tool/SwaggerController.java

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

salpa-admin/src/main/java/com/salpa/web/controller/tool/TestController.java

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

salpa-admin/src/main/java/com/salpa/web/core/config/SwaggerConfig.java

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

salpa-admin/src/main/java/com/salpa/web/job/ProjectSyncJob.java

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

salpa-admin/src/main/java/com/salpa/web/job/ProjectSyncJobScheduler.java

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

salpa-admin/src/main/java/com/salpa/web/job/ProjectSyncTaskScheduler.java

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

salpa-admin/src/main/java/com/salpa/web/job/config/ProjectSyncTaskThreadPoolConfig.java

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

salpa-admin/src/main/resources/.idea/inspectionProfiles/Project_Default.xml

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

salpa-admin/src/main/resources/.idea/misc.xml

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

salpa-admin/src/main/resources/.idea/modules.xml

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

salpa-admin/src/main/resources/.idea/resources.iml

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

salpa-admin/src/main/resources/.idea/vcs.xml

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

salpa-admin/src/main/resources/.idea/workspace.xml

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

salpa-admin/src/main/resources/META-INF/spring-devtools.properties

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

salpa-admin/src/main/resources/application-druid.yml

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

salpa-admin/src/main/resources/application.yml

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

salpa-admin/src/main/resources/banner.txt

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

salpa-admin/src/main/resources/i18n/messages.properties

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

salpa-admin/src/main/resources/logback.xml

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

salpa-admin/src/main/resources/mybatis/mybatis-config.xml

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

salpa-admin/src/main/resources/word.docx

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

salpa-common/pom.xml

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

salpa-common/salpa-common.iml

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

salpa-common/src/main/java/com/salpa/common/annotation/Anonymous.java

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

salpa-common/src/main/java/com/salpa/common/annotation/DataScope.java

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

salpa-common/src/main/java/com/salpa/common/annotation/DataSource.java

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

salpa-common/src/main/java/com/salpa/common/annotation/Excel.java

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

salpa-common/src/main/java/com/salpa/common/annotation/Excels.java

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

salpa-common/src/main/java/com/salpa/common/annotation/Log.java

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

salpa-common/src/main/java/com/salpa/common/annotation/RateLimiter.java

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

salpa-common/src/main/java/com/salpa/common/annotation/RepeatSubmit.java

@@ -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 "不允许重复提交，请稍候再试";
+}

salpa-common/src/main/java/com/salpa/common/config/SalpaConfig.java

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

salpa-common/src/main/java/com/salpa/common/constant/CacheConstants.java

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

salpa-common/src/main/java/com/salpa/common/constant/Constants.java

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

salpa-common/src/main/java/com/salpa/common/constant/GenConstants.java

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

salpa-common/src/main/java/com/salpa/common/constant/HttpStatus.java

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

salpa-common/src/main/java/com/salpa/common/constant/ScheduleConstants.java

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

salpa-common/src/main/java/com/salpa/common/constant/UserConstants.java

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

salpa-common/src/main/java/com/salpa/common/core/controller/BaseController.java

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

salpa-common/src/main/java/com/salpa/common/core/domain/AjaxResult.java

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

salpa-common/src/main/java/com/salpa/common/core/domain/BaseEntity.java

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