xservice/xservice-common-center
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
xiang
2026-03-21 17:56:14 +08:00
commit 81dd7ee546
111 changed files with 11528 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
.gitignore vendored Normal file
View File

@@ -0,0 +1,38 @@
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### IntelliJ IDEA ###
.idea/modules.xml
.idea/jarRepositories.xml
.idea/compiler.xml
.idea/libraries/
*.iws
*.iml
*.ipr
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store

68
pom.xml Normal file
View File

@@ -0,0 +1,68 @@
<?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>
<parent>
<groupId>com.xiang.pom</groupId>
<artifactId>xmc-web-starter</artifactId>
<version>1.0</version>
</parent>
<groupId>com.xiang</groupId>
<artifactId>xservice-common-center</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>xs-api</module>
<module>xs-server</module>
<module>xs-service</module>
</modules>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.boot.version>2.7.18</spring.boot.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!-- 系统二方包 -->
<dependency>
<groupId>com.xiang.starter</groupId>
<artifactId>xmc-mysql-starter</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>com.xiang.starter</groupId>
<artifactId>xmc-cache-starter</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>com.xiang.starter</groupId>
<artifactId>xmc-common</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>com.xiang.starter</groupId>
<artifactId>xmc-message-starter</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>com.xiang.starter</groupId>
<artifactId>xmc-http-starter</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>com.xiang.starter</groupId>
<artifactId>xmc-logger-starter</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
</project>

24
xs-api/pom.xml Normal file
View File

@@ -0,0 +1,24 @@
<?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>
<parent>
<groupId>com.xiang</groupId>
<artifactId>xservice-common-center</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>xs-api</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
</dependencies>
</project>

15
xs-api/src/main/java/com/xiang/xs/api/client/TokenApi.java Normal file
View File

@@ -0,0 +1,15 @@
package com.xiang.xs.api.client;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@FeignClient(name = "xservice-auth-center", fallback = TokenApiFallback.class)
public interface TokenApi {
@GetMapping("/private/user/getUserId/{token}")
Long getUserId(@PathVariable("token") String token);
@GetMapping("/private/user/getTenantId/{token}")
Long getTenantId(@PathVariable("token") String token);
}

20
xs-api/src/main/java/com/xiang/xs/api/client/TokenApiFallback.java Normal file
View File

@@ -0,0 +1,20 @@
package com.xiang.xs.api.client;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class TokenApiFallback implements TokenApi {
@Override
public Long getUserId(String token) {
log.warn("[rpc] 请求auth center 获取userId 异常， time:{}", System.currentTimeMillis());
return null;
}
@Override
public Long getTenantId(String token) {
log.warn("[rpc] 请求auth center tenantId 异常， time:{}", System.currentTimeMillis());
return null;
}
}

31
xs-api/src/main/java/com/xiang/xs/api/pojo/request/LoginRequest.java Normal file
View File

@@ -0,0 +1,31 @@
package com.xiang.xs.api.pojo.request;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginRequest {
/**
* 用户名
*/
private String username;
/**
* 密码
*/
private String password;
/**
* 验证码
*/
private String code;
/**
* UUID
*/
private String uuid;
}

13
xs-api/src/main/java/com/xiang/xs/api/pojo/resp/LoginResp.java Normal file
View File

@@ -0,0 +1,13 @@
package com.xiang.xs.api.pojo.resp;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginResp {
private String token;
}

28
xs-server/pom.xml Normal file
View File

@@ -0,0 +1,28 @@
<?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>
<parent>
<groupId>com.xiang</groupId>
<artifactId>xservice-common-center</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>xs-server</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.xiang</groupId>
<artifactId>xs-service</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>

21
xs-server/src/main/java/com/xiang/xs/server/Application.java Normal file
View File

@@ -0,0 +1,21 @@
package com.xiang.xs.server;
import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
@SpringBootApplication(scanBasePackages = "com.xiang.xs")
@EnableFeignClients
@MapperScan("com.xiang.xs.service.repository.mapper")
public class Application {
private static final Logger log = LoggerFactory.getLogger(Application.class);
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
log.info("common center start success!");
}
}

95
xs-server/src/main/java/com/xiang/xs/server/controller/SysConfigController.java Normal file
View File

@@ -0,0 +1,95 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.service.biz.ISysConfigService;
import com.xiang.xs.service.entity.SysConfig;
import com.xiang.xservice.basic.common.resp.Result;
import lombok.RequiredArgsConstructor;
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 java.util.List;
/**
* 参数配置 信息操作处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/config")
@RequiredArgsConstructor
public class SysConfigController {
private final ISysConfigService configService;
/**
* 获取参数配置列表
*/
@GetMapping("/list")
public Result<List<SysConfig>> list(SysConfig config) {
List<SysConfig> list = configService.selectConfigList(config);
return Result.data(list);
}
/**
* 根据参数编号获取详细信息
*/
@GetMapping(value = "/{configId}")
public Result<SysConfig> getInfo(@PathVariable Long configId) {
return Result.data(configService.selectConfigById(configId));
}
/**
* 根据参数键名查询参数值
*/
@GetMapping(value = "/configKey/{configKey}")
public Result<String> getConfigKey(@PathVariable String configKey) {
return Result.data(configService.selectConfigByKey(configKey));
}
/**
* 新增参数配置
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysConfig config) {
if (!configService.checkConfigKeyUnique(config)) {
return Result.error("新增参数'" + config.getConfigName() + "'失败，参数键名已存在");
}
return Result.data(configService.insertConfig(config) > 0);
}
/**
* 修改参数配置
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysConfig config) {
if (!configService.checkConfigKeyUnique(config)) {
return Result.error("修改参数'" + config.getConfigName() + "'失败，参数键名已存在");
}
return Result.data(configService.updateConfig(config) > 0);
}
/**
* 删除参数配置
*/
@DeleteMapping("/{configIds}")
public Result<Void> remove(@PathVariable Long[] configIds) {
configService.deleteConfigByIds(configIds);
return Result.success();
}
/**
* 刷新参数缓存
*/
@DeleteMapping("/refreshCache")
public Result<Void> refreshCache() {
configService.resetConfigCache();
return Result.success();
}
}

110
xs-server/src/main/java/com/xiang/xs/server/controller/SysDeptController.java Normal file
View File

@@ -0,0 +1,110 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.service.biz.ISysDeptService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysDept;
import com.xiang.xservice.basic.common.resp.Result;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* 部门信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/dept")
public class SysDeptController {
@Autowired
private ISysDeptService deptService;
/**
* 获取部门列表
*/
@GetMapping("/list")
public Result<List<SysDept>> list(SysDept dept) {
List<SysDept> depts = deptService.selectDeptList(dept);
return Result.data(depts);
}
/**
* 查询部门列表（排除节点）
*/
@GetMapping("/list/exclude/{deptId}")
public Result<List<SysDept>> excludeChild(@PathVariable(value = "deptId", required = false) Long deptId) {
List<SysDept> depts = deptService.selectDeptList(new SysDept());
depts.removeIf(d -> d.getDeptId().intValue() == deptId || ArrayUtils.contains(d.getAncestors().split(","), deptId + ""));
return Result.data(depts);
}
/**
* 根据部门编号获取详细信息
*/
@GetMapping(value = "/{deptId}")
public Result<SysDept> getInfo(@PathVariable Long deptId, HttpServletRequest request) {
String token = request.getHeader("Authorization");
deptService.checkDeptDataScope(deptId, token);
return Result.data(deptService.selectDeptById(deptId));
}
/**
* 新增部门
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysDept dept) {
if (!deptService.checkDeptNameUnique(dept)) {
return Result.error("新增部门'" + dept.getDeptName() + "'失败，部门名称已存在");
}
return Result.data(deptService.insertDept(dept) > 0);
}
/**
* 修改部门
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysDept dept, HttpServletRequest request) {
Long deptId = dept.getDeptId();
deptService.checkDeptDataScope(deptId, getToken(request));
if (!deptService.checkDeptNameUnique(dept)) {
return Result.error("修改部门'" + dept.getDeptName() + "'失败，部门名称已存在");
} else if (dept.getParentId().equals(deptId)) {
return Result.error("修改部门'" + dept.getDeptName() + "'失败，上级部门不能是自己");
} else if (StringUtils.equals(UserConstants.DEPT_DISABLE, dept.getStatus()) && deptService.selectNormalChildrenDeptById(deptId) > 0) {
return Result.error("该部门包含未停用的子部门！");
}
return Result.data(deptService.updateDept(dept) > 0);
}
/**
* 删除部门
*/
@DeleteMapping("/{deptId}")
public Result<Boolean> remove(@PathVariable Long deptId, HttpServletRequest request) {
String token = getToken(request);
if (deptService.hasChildByDeptId(deptId)) {
return Result.error("存在下级部门,不允许删除");
}
if (deptService.checkDeptExistUser(deptId)) {
return Result.error("部门存在用户,不允许删除");
}
deptService.checkDeptDataScope(deptId, token);
return Result.data(deptService.deleteDeptById(deptId) > 0);
}
private String getToken(HttpServletRequest request) {
return request.getHeader("Authorization");
}
}

86
xs-server/src/main/java/com/xiang/xs/server/controller/SysDictDataController.java Normal file
View File

@@ -0,0 +1,86 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.service.biz.ISysDictDataService;
import com.xiang.xs.service.biz.ISysDictTypeService;
import com.xiang.xs.service.entity.SysDictData;
import com.xiang.xservice.basic.common.resp.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
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 java.util.ArrayList;
import java.util.List;
/**
* 数据字典信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/dict/data")
public class SysDictDataController {
@Autowired
private ISysDictDataService dictDataService;
@Autowired
private ISysDictTypeService dictTypeService;
@GetMapping("/list")
public Result<List<SysDictData>> list(SysDictData dictData) {
List<SysDictData> list = dictDataService.selectDictDataList(dictData);
return Result.data(list);
}
/**
* 查询字典数据详细
*/
@GetMapping(value = "/{dictCode}")
public Result<SysDictData> getInfo(@PathVariable Long dictCode) {
return Result.data(dictDataService.selectDictDataById(dictCode));
}
/**
* 根据字典类型查询字典数据信息
*/
@GetMapping(value = "/type/{dictType}")
public Result<List<SysDictData>> dictType(@PathVariable String dictType) {
List<SysDictData> data = dictTypeService.selectDictDataByType(dictType);
if (CollectionUtils.isEmpty(data)) {
data = new ArrayList<SysDictData>();
}
return Result.data(data);
}
/**
* 新增字典类型
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysDictData dict) {
return Result.data(dictDataService.insertDictData(dict) > 0);
}
/**
* 修改保存字典类型
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysDictData dict) {
return Result.data(dictDataService.updateDictData(dict) > 0);
}
/**
* 删除字典类型
*/
@DeleteMapping("/{dictCodes}")
public Result<Void> remove(@PathVariable Long[] dictCodes) {
dictDataService.deleteDictDataByIds(dictCodes);
return Result.success();
}
}

104
xs-server/src/main/java/com/xiang/xs/server/controller/SysDictTypeController.java Normal file
View File

@@ -0,0 +1,104 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.service.biz.ISysDictTypeService;
import com.xiang.xs.service.entity.SysDictType;
import com.xiang.xservice.basic.common.resp.Result;
import lombok.extern.java.Log;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 数据字典信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/dict/type")
public class SysDictTypeController
{
@Autowired
private ISysDictTypeService dictTypeService;
@GetMapping("/list")
public Result<List<SysDictType>> list(SysDictType dictType)
{
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
return Result.data(list);
}
/**
* 查询字典类型详细
*/
@GetMapping(value = "/{dictId}")
public Result<SysDictType> getInfo(@PathVariable Long dictId)
{
return Result.data(dictTypeService.selectDictTypeById(dictId));
}
/**
* 新增字典类型
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysDictType dict)
{
if (!dictTypeService.checkDictTypeUnique(dict))
{
return Result.error("新增字典'" + dict.getDictName() + "'失败，字典类型已存在");
}
return Result.data(dictTypeService.insertDictType(dict) > 0);
}
/**
* 修改字典类型
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysDictType dict)
{
if (!dictTypeService.checkDictTypeUnique(dict))
{
return Result.error("修改字典'" + dict.getDictName() + "'失败，字典类型已存在");
}
return Result.data(dictTypeService.updateDictType(dict) > 0);
}
/**
* 删除字典类型
*/
@DeleteMapping("/{dictIds}")
public Result<Void> remove(@PathVariable Long[] dictIds)
{
dictTypeService.deleteDictTypeByIds(dictIds);
return Result.success();
}
/**
* 刷新字典缓存
*/
@DeleteMapping("/refreshCache")
public Result<Void> refreshCache()
{
dictTypeService.resetDictCache();
return Result.success();
}
/**
* 获取字典选择框列表
*/
@GetMapping("/optionselect")
public Result<List<SysDictType>> optionselect()
{
List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll();
return Result.data(dictTypes);
}
}

116
xs-server/src/main/java/com/xiang/xs/server/controller/SysMenuController.java Normal file
View File

@@ -0,0 +1,116 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.api.client.TokenApi;
import com.xiang.xs.service.biz.ISysMenuService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysMenu;
import com.xiang.xs.service.entity.TreeSelect;
import com.xiang.xs.service.entity.vo.RoleTreeVo;
import com.xiang.xservice.basic.common.resp.Result;
import com.xiang.xservice.basic.utils.MyStringUtils;
import lombok.extern.java.Log;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* 菜单信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/menu")
public class SysMenuController {
@Autowired
private ISysMenuService menuService;
@Autowired
private TokenApi tokenApi;
/**
* 获取菜单列表
*/
@GetMapping("/list")
public Result<List<SysMenu>> list(SysMenu menu, HttpServletRequest request) {
Long userId = tokenApi.getUserId(request.getHeader("Authorization"));
List<SysMenu> menus = menuService.selectMenuList(menu, userId);
return Result.data(menus);
}
/**
* 根据菜单编号获取详细信息
*/
@GetMapping(value = "/{menuId}")
public Result<SysMenu> getInfo(@PathVariable Long menuId) {
return Result.data(menuService.selectMenuById(menuId));
}
/**
* 获取菜单下拉树列表
*/
@GetMapping("/treeselect")
public Result<List<TreeSelect>> treeselect(SysMenu menu, HttpServletRequest request) {
List<SysMenu> menus = menuService.selectMenuList(menu, tokenApi.getUserId(request.getHeader("Authorization")));
return Result.data(menuService.buildMenuTreeSelect(menus));
}
/**
* 加载对应角色菜单列表树
*/
@GetMapping(value = "/roleMenuTreeselect/{roleId}")
public Result<RoleTreeVo> roleMenuTreeselect(@PathVariable("roleId") Long roleId, HttpServletRequest request) {
List<SysMenu> menus = menuService.selectMenuList(tokenApi.getUserId(request.getHeader("Authorization")));
return Result.data(new RoleTreeVo(menuService.selectMenuListByRoleId(roleId), menuService.buildMenuTreeSelect(menus)));
}
/**
* 新增菜单
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysMenu menu) {
if (!menuService.checkMenuNameUnique(menu)) {
return Result.error("新增菜单'" + menu.getMenuName() + "'失败，菜单名称已存在");
} else if (UserConstants.YES_FRAME.equals(menu.getIsFrame()) && !MyStringUtils.isHttp(menu.getPath())) {
return Result.error("新增菜单'" + menu.getMenuName() + "'失败，地址必须以http(s)://开头");
}
return Result.data(menuService.insertMenu(menu) > 0);
}
/**
* 修改菜单
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysMenu menu) {
if (!menuService.checkMenuNameUnique(menu)) {
return Result.error("修改菜单'" + menu.getMenuName() + "'失败，菜单名称已存在");
} else if (UserConstants.YES_FRAME.equals(menu.getIsFrame()) && !MyStringUtils.isHttp(menu.getPath())) {
return Result.error("修改菜单'" + menu.getMenuName() + "'失败，地址必须以http(s)://开头");
} else if (menu.getMenuId().equals(menu.getParentId())) {
return Result.error("修改菜单'" + menu.getMenuName() + "'失败，上级菜单不能选择自己");
}
return Result.data(menuService.updateMenu(menu) > 0);
}
/**
* 删除菜单
*/
@DeleteMapping("/{menuId}")
public Result<Boolean> remove(@PathVariable("menuId") Long menuId) {
if (menuService.hasChildByMenuId(menuId)) {
return Result.error("存在子菜单,不允许删除");
}
if (menuService.checkMenuExistRole(menuId)) {
return Result.error("菜单已分配,不允许删除");
}
return Result.data(menuService.deleteMenuById(menuId) > 0);
}
}

71
xs-server/src/main/java/com/xiang/xs/server/controller/SysNoticeController.java Normal file
View File

@@ -0,0 +1,71 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.service.biz.ISysNoticeService;
import com.xiang.xs.service.entity.SysNotice;
import com.xiang.xservice.basic.common.resp.Result;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.List;
/**
* 公告 信息操作处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/notice")
public class SysNoticeController {
@Autowired
private ISysNoticeService noticeService;
/**
* 获取通知公告列表
*/
@GetMapping("/list")
public Result<List<SysNotice>> list(SysNotice notice) {
List<SysNotice> list = noticeService.selectNoticeList(notice);
return Result.data(list);
}
/**
* 根据通知公告编号获取详细信息
*/
@GetMapping(value = "/{noticeId}")
public Result<SysNotice> getInfo(@PathVariable Long noticeId) {
return Result.data(noticeService.selectNoticeById(noticeId));
}
/**
* 新增通知公告
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysNotice notice) {
return Result.data(noticeService.insertNotice(notice) > 0);
}
/**
* 修改通知公告
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysNotice notice) {
return Result.data(noticeService.updateNotice(notice) > 0);
}
/**
* 删除通知公告
*/
@DeleteMapping("/{noticeIds}")
public Result<Boolean> remove(@PathVariable Long[] noticeIds) {
return Result.data(noticeService.deleteNoticeByIds(noticeIds) > 0);
}
}

90
xs-server/src/main/java/com/xiang/xs/server/controller/SysPostController.java Normal file
View File

@@ -0,0 +1,90 @@
package com.xiang.xs.server.controller;
import com.xiang.xs.service.biz.ISysPostService;
import com.xiang.xs.service.entity.SysPost;
import com.xiang.xservice.basic.common.resp.Result;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.List;
/**
* 岗位信息操作处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/post")
public class SysPostController {
@Autowired
private ISysPostService postService;
/**
* 获取岗位列表
*/
@GetMapping("/list")
public Result<List<SysPost>> list(SysPost post) {
List<SysPost> list = postService.selectPostList(post);
return Result.data(list);
}
/**
* 根据岗位编号获取详细信息
*/
@GetMapping(value = "/{postId}")
public Result<SysPost> getInfo(@PathVariable Long postId) {
return Result.data(postService.selectPostById(postId));
}
/**
* 新增岗位
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysPost post) {
if (!postService.checkPostNameUnique(post)) {
return Result.error("新增岗位'" + post.getPostName() + "'失败，岗位名称已存在");
} else if (!postService.checkPostCodeUnique(post)) {
return Result.error("新增岗位'" + post.getPostName() + "'失败，岗位编码已存在");
}
return Result.data(postService.insertPost(post) > 0);
}
/**
* 修改岗位
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysPost post) {
if (!postService.checkPostNameUnique(post)) {
return Result.error("修改岗位'" + post.getPostName() + "'失败，岗位名称已存在");
} else if (!postService.checkPostCodeUnique(post)) {
return Result.error("修改岗位'" + post.getPostName() + "'失败，岗位编码已存在");
}
return Result.data(postService.updatePost(post) > 0);
}
/**
* 删除岗位
*/
@DeleteMapping("/{postIds}")
public Result<Boolean> remove(@PathVariable Long[] postIds) {
return Result.data(postService.deletePostByIds(postIds) > 0);
}
/**
* 获取岗位选择框列表
*/
@GetMapping("/optionselect")
public Result<List<SysPost>> optionselect() {
List<SysPost> posts = postService.selectPostAll();
return Result.data(posts);
}
}

183
xs-server/src/main/java/com/xiang/xs/server/controller/SysRoleController.java Normal file
View File

@@ -0,0 +1,183 @@
package com.xiang.xs.server.controller;
import com.alibaba.fastjson.JSONObject;
import com.xiang.xs.service.biz.ISysDeptService;
import com.xiang.xs.service.biz.ISysRoleService;
import com.xiang.xs.service.biz.ISysUserService;
import com.xiang.xs.service.entity.SysDept;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysUser;
import com.xiang.xs.service.entity.SysUserRole;
import com.xiang.xservice.basic.common.resp.Result;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* 角色信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/role")
public class SysRoleController {
@Autowired
private ISysRoleService roleService;
@Autowired
private ISysUserService userService;
@Autowired
private ISysDeptService deptService;
@GetMapping("/list")
public Result<List<SysRole>> list(SysRole role) {
List<SysRole> list = roleService.selectRoleList(role);
return Result.data(list);
}
/**
* 根据角色编号获取详细信息
*/
@GetMapping(value = "/{roleId}")
public Result<SysRole> getInfo(@PathVariable Long roleId, HttpServletRequest request) {
String token = request.getHeader("Authorization");
roleService.checkRoleDataScope(token, roleId);
return Result.data(roleService.selectRoleById(roleId));
}
/**
* 新增角色
*/
@PostMapping
public Result<Boolean> add(@Validated @RequestBody SysRole role) {
if (!roleService.checkRoleNameUnique(role)) {
return Result.error("新增角色'" + role.getRoleName() + "'失败，角色名称已存在");
} else if (!roleService.checkRoleKeyUnique(role)) {
return Result.error("新增角色'" + role.getRoleName() + "'失败，角色权限已存在");
}
return Result.data(roleService.insertRole(role) > 0);
}
/**
* 修改保存角色
*/
@PutMapping
public Result<Boolean> edit(@Validated @RequestBody SysRole role, HttpServletRequest request) {
String token = request.getHeader("Authorization");
roleService.checkRoleAllowed(role);
roleService.checkRoleDataScope(token, role.getRoleId());
if (!roleService.checkRoleNameUnique(role)) {
return Result.error("修改角色'" + role.getRoleName() + "'失败，角色名称已存在");
} else if (!roleService.checkRoleKeyUnique(role)) {
return Result.error("修改角色'" + role.getRoleName() + "'失败，角色权限已存在");
}
return Result.data(roleService.updateRole(role) > 0);
}
/**
* 修改保存数据权限
*/
@PutMapping("/dataScope")
public Result<Boolean> dataScope(@RequestBody SysRole role, HttpServletRequest request) {
String token = request.getHeader("Authorization");
roleService.checkRoleAllowed(role);
roleService.checkRoleDataScope(token, role.getRoleId());
return Result.data(roleService.authDataScope(role) > 0);
}
/**
* 状态修改
*/
@PutMapping("/changeStatus")
public Result<Boolean> changeStatus(@RequestBody SysRole role, HttpServletRequest request) {
String token = request.getHeader("Authorization");
roleService.checkRoleAllowed(role);
roleService.checkRoleDataScope(token, role.getRoleId());
return Result.data(roleService.updateRoleStatus(role) > 0);
}
/**
* 删除角色
*/
@DeleteMapping("/{roleIds}")
public Result<Boolean> remove(@PathVariable Long[] roleIds, HttpServletRequest request) {
String token = request.getHeader("Authorization");
return Result.data(roleService.deleteRoleByIds(token, roleIds) > 0);
}
/**
* 获取角色选择框列表
*/
@GetMapping("/optionselect")
public Result<List<SysRole>> optionselect() {
return Result.data(roleService.selectRoleAll());
}
/**
* 查询已分配用户角色列表
*/
@GetMapping("/authUser/allocatedList")
public Result<List<SysUser>> allocatedList(SysUser user) {
List<SysUser> list = userService.selectAllocatedList(user);
return Result.data(list);
}
/**
* 查询未分配用户角色列表
*/
@GetMapping("/authUser/unallocatedList")
public Result<List<SysUser>> unallocatedList(SysUser user) {
List<SysUser> list = userService.selectUnallocatedList(user);
return Result.data(list);
}
/**
* 取消授权用户
*/
@PutMapping("/authUser/cancel")
public Result<Boolean> cancelAuthUser(@RequestBody SysUserRole userRole) {
return Result.data(roleService.deleteAuthUser(userRole) > 0);
}
/**
* 批量取消授权用户
*/
@PutMapping("/authUser/cancelAll")
public Result<Boolean> cancelAuthUserAll(Long roleId, Long[] userIds) {
return Result.data(roleService.deleteAuthUsers(roleId, userIds) > 0);
}
/**
* 批量选择用户授权
*/
@PutMapping("/authUser/selectAll")
public Result<Boolean> selectAuthUserAll(Long roleId, Long[] userIds, HttpServletRequest request) {
String token = request.getHeader("Authorization");
roleService.checkRoleDataScope(token, roleId);
return Result.data(roleService.insertAuthUsers(roleId, userIds) > 0);
}
/**
* 获取对应角色部门树列表
*/
@GetMapping(value = "/deptTree/{roleId}")
public Result<JSONObject> deptTree(@PathVariable("roleId") Long roleId) {
JSONObject ajax = new JSONObject();
ajax.put("checkedKeys", deptService.selectDeptListByRoleId(roleId));
ajax.put("depts", deptService.selectDeptTreeList(new SysDept()));
return Result.data(ajax);
}
}

31
xs-server/src/main/resources/application-local.yml Normal file
View File

@@ -0,0 +1,31 @@
spring:
cloud:
nacos:
discovery:
group: DEFAULT_GROUP
namespace: 00131110-3ecb-4a35-8bbb-624edde1d937
server-addr: general.xiangtech.xyz:8848
username: nacos
password: nacos
datasource:
dynamic:
primary: master
datasource:
master:
url: jdbc:mysql://120.27.153.87:3306/xservice-user?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: root
password: sdkljfikdfn@123
driver-class-name: com.mysql.cj.jdbc.Driver
sshConnect: false
redis:
host: r-bp1wt59a6nfyt4e3ltpd.redis.rds.aliyuncs.com
port: 6379
password: Xiang0000 # 如果无密码可以省略
database: 10
timeout: 5000
lettuce:
pool:
max-active: 8
max-idle: 8
min-idle: 0
max-wait: 1000

0
xs-server/src/main/resources/application-prod.yml Normal file
View File

0
xs-server/src/main/resources/application-test.yml Normal file
View File

19
xs-server/src/main/resources/application.yml Normal file
View File

@@ -0,0 +1,19 @@
server:
port: 38012
spring:
profiles:
active: local
application:
name: xservice-common-center
mvc:
pathmatch:
matching-strategy: ant_path_matcher
main:
allow-bean-definition-overriding: true
headless: true
mybatis:
mapper-locations:
- classpath*:mapper/*/*.xml
configuration:
map-underscore-to-camel-case: true

20
xs-server/src/main/resources/mybatis/mybatis-config.xml Normal file
View File

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

29
xs-service/pom.xml Normal file
View File

@@ -0,0 +1,29 @@
<?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>
<parent>
<groupId>com.xiang</groupId>
<artifactId>xservice-common-center</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>xs-service</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.xiang</groupId>
<artifactId>xs-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>

96
xs-service/src/main/java/com/xiang/xs/service/biz/ISysConfigService.java Normal file
View File

@@ -0,0 +1,96 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysConfig;
import java.util.List;
/**
* 参数配置 服务层
*
* @author ruoyi
*/
public interface ISysConfigService {
/**
* 查询参数配置信息
*
* @param configId 参数配置ID
*
* @return 参数配置信息
*/
SysConfig selectConfigById(Long configId);
/**
* 根据键名查询参数配置信息
*
* @param configKey 参数键名
*
* @return 参数键值
*/
String selectConfigByKey(String configKey);
/**
* 获取验证码开关
*
* @return true开启，false关闭
*/
boolean selectCaptchaEnabled();
/**
* 查询参数配置列表
*
* @param config 参数配置信息
*
* @return 参数配置集合
*/
List<SysConfig> selectConfigList(SysConfig config);
/**
* 新增参数配置
*
* @param config 参数配置信息
*
* @return 结果
*/
int insertConfig(SysConfig config);
/**
* 修改参数配置
*
* @param config 参数配置信息
*
* @return 结果
*/
int updateConfig(SysConfig config);
/**
* 批量删除参数信息
*
* @param configIds 需要删除的参数ID
*/
void deleteConfigByIds(Long[] configIds);
/**
* 加载参数缓存数据
*/
void loadingConfigCache();
/**
* 清空参数缓存数据
*/
void clearConfigCache();
/**
* 重置参数缓存数据
*/
void resetConfigCache();
/**
* 校验参数键名是否唯一
*
* @param config 参数信息
*
* @return 结果
*/
boolean checkConfigKeyUnique(SysConfig config);
}

138
xs-service/src/main/java/com/xiang/xs/service/biz/ISysDeptService.java Normal file
View File

@@ -0,0 +1,138 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysDept;
import com.xiang.xs.service.entity.TreeSelect;
import java.util.List;
/**
* 部门管理 服务层
*
* @author ruoyi
*/
public interface ISysDeptService {
/**
* 查询部门管理数据
*
* @param dept 部门信息
*
* @return 部门信息集合
*/
List<SysDept> selectDeptList(SysDept dept);
/**
* 查询部门树结构信息
*
* @param dept 部门信息
*
* @return 部门树信息集合
*/
List<TreeSelect> selectDeptTreeList(SysDept dept);
/**
* 构建前端所需要树结构
*
* @param depts 部门列表
*
* @return 树结构列表
*/
List<SysDept> buildDeptTree(List<SysDept> depts);
/**
* 构建前端所需要下拉树结构
*
* @param depts 部门列表
*
* @return 下拉树结构列表
*/
List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts);
/**
* 根据角色ID查询部门树信息
*
* @param roleId 角色ID
*
* @return 选中部门列表
*/
List<Long> selectDeptListByRoleId(Long roleId);
/**
* 根据部门ID查询信息
*
* @param deptId 部门ID
*
* @return 部门信息
*/
SysDept selectDeptById(Long deptId);
/**
* 根据ID查询所有子部门（正常状态）
*
* @param deptId 部门ID
*
* @return 子部门数
*/
int selectNormalChildrenDeptById(Long deptId);
/**
* 是否存在部门子节点
*
* @param deptId 部门ID
*
* @return 结果
*/
boolean hasChildByDeptId(Long deptId);
/**
* 查询部门是否存在用户
*
* @param deptId 部门ID
*
* @return 结果 true 存在 false 不存在
*/
boolean checkDeptExistUser(Long deptId);
/**
* 校验部门名称是否唯一
*
* @param dept 部门信息
*
* @return 结果
*/
boolean checkDeptNameUnique(SysDept dept);
/**
* 校验部门是否有数据权限
*
* @param deptId 部门id
*/
void checkDeptDataScope(Long deptId, String token);
/**
* 新增保存部门信息
*
* @param dept 部门信息
*
* @return 结果
*/
int insertDept(SysDept dept);
/**
* 修改保存部门信息
*
* @param dept 部门信息
*
* @return 结果
*/
int updateDept(SysDept dept);
/**
* 删除部门管理信息
*
* @param deptId 部门ID
*
* @return 结果
*/
int deleteDeptById(Long deptId);
}

66
xs-service/src/main/java/com/xiang/xs/service/biz/ISysDictDataService.java Normal file
View File

@@ -0,0 +1,66 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysDictData;
import java.util.List;
/**
* 字典 业务层
*
* @author ruoyi
*/
public interface ISysDictDataService {
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
*
* @return 字典数据集合信息
*/
List<SysDictData> selectDictDataList(SysDictData dictData);
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType 字典类型
* @param dictValue 字典键值
*
* @return 字典标签
*/
String selectDictLabel(String dictType, String dictValue);
/**
* 根据字典数据ID查询信息
*
* @param dictCode 字典数据ID
*
* @return 字典数据
*/
SysDictData selectDictDataById(Long dictCode);
/**
* 批量删除字典数据信息
*
* @param dictCodes 需要删除的字典数据ID
*/
void deleteDictDataByIds(Long[] dictCodes);
/**
* 新增保存字典数据信息
*
* @param dictData 字典数据信息
*
* @return 结果
*/
int insertDictData(SysDictData dictData);
/**
* 修改保存字典数据信息
*
* @param dictData 字典数据信息
*
* @return 结果
*/
int updateDictData(SysDictData dictData);
}

106
xs-service/src/main/java/com/xiang/xs/service/biz/ISysDictTypeService.java Normal file
View File

@@ -0,0 +1,106 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysDictData;
import com.xiang.xs.service.entity.SysDictType;
import java.util.List;
/**
* 字典 业务层
*
* @author ruoyi
*/
public interface ISysDictTypeService {
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
*
* @return 字典类型集合信息
*/
List<SysDictType> selectDictTypeList(SysDictType dictType);
/**
* 根据所有字典类型
*
* @return 字典类型集合信息
*/
List<SysDictType> selectDictTypeAll();
/**
* 根据字典类型查询字典数据
*
* @param dictType 字典类型
*
* @return 字典数据集合信息
*/
List<SysDictData> selectDictDataByType(String dictType);
/**
* 根据字典类型ID查询信息
*
* @param dictId 字典类型ID
*
* @return 字典类型
*/
SysDictType selectDictTypeById(Long dictId);
/**
* 根据字典类型查询信息
*
* @param dictType 字典类型
*
* @return 字典类型
*/
SysDictType selectDictTypeByType(String dictType);
/**
* 批量删除字典信息
*
* @param dictIds 需要删除的字典ID
*/
void deleteDictTypeByIds(Long[] dictIds);
/**
* 加载字典缓存数据
*/
void loadingDictCache();
/**
* 清空字典缓存数据
*/
void clearDictCache();
/**
* 重置字典缓存数据
*/
void resetDictCache();
/**
* 新增保存字典类型信息
*
* @param dictType 字典类型信息
*
* @return 结果
*/
int insertDictType(SysDictType dictType);
/**
* 修改保存字典类型信息
*
* @param dictType 字典类型信息
*
* @return 结果
*/
int updateDictType(SysDictType dictType);
/**
* 校验字典类型称是否唯一
*
* @param dictType 字典类型
*
* @return 结果
*/
boolean checkDictTypeUnique(SysDictType dictType);
}

43
xs-service/src/main/java/com/xiang/xs/service/biz/ISysLogininforService.java Normal file
View File

@@ -0,0 +1,43 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysLogininfor;
import java.util.List;
/**
* 系统访问日志情况信息 服务层
*
* @author ruoyi
*/
public interface ISysLogininforService {
/**
* 新增系统登录日志
*
* @param logininfor 访问日志对象
*/
void insertLogininfor(SysLogininfor logininfor);
/**
* 查询系统登录日志集合
*
* @param logininfor 访问日志对象
*
* @return 登录记录集合
*/
List<SysLogininfor> selectLogininforList(SysLogininfor logininfor);
/**
* 批量删除系统登录日志
*
* @param infoIds 需要删除的登录日志ID
*
* @return 结果
*/
int deleteLogininforByIds(Long[] infoIds);
/**
* 清空系统登录日志
*/
void cleanLogininfor();
}

161
xs-service/src/main/java/com/xiang/xs/service/biz/ISysMenuService.java Normal file
View File

@@ -0,0 +1,161 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysMenu;
import com.xiang.xs.service.entity.TreeSelect;
import com.xiang.xs.service.entity.vo.RouterVo;
import java.util.List;
import java.util.Set;
/**
* 菜单 业务层
*
* @author ruoyi
*/
public interface ISysMenuService {
/**
* 根据用户查询系统菜单列表
*
* @param userId 用户ID
*
* @return 菜单列表
*/
List<SysMenu> selectMenuList(Long userId);
/**
* 根据用户查询系统菜单列表
*
* @param menu 菜单信息
* @param userId 用户ID
*
* @return 菜单列表
*/
List<SysMenu> selectMenuList(SysMenu menu, Long userId);
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
*
* @return 权限列表
*/
Set<String> selectMenuPermsByUserId(Long userId);
/**
* 根据角色ID查询权限
*
* @param roleId 角色ID
*
* @return 权限列表
*/
Set<String> selectMenuPermsByRoleId(Long roleId);
/**
* 根据用户ID查询菜单树信息
*
* @param userId 用户ID
*
* @return 菜单列表
*/
List<SysMenu> selectMenuTreeByUserId(Long userId);
/**
* 根据角色ID查询菜单树信息
*
* @param roleId 角色ID
*
* @return 选中菜单列表
*/
List<Long> selectMenuListByRoleId(Long roleId);
/**
* 构建前端路由所需要的菜单
*
* @param menus 菜单列表
*
* @return 路由列表
*/
List<RouterVo> buildMenus(List<SysMenu> menus);
/**
* 构建前端所需要树结构
*
* @param menus 菜单列表
*
* @return 树结构列表
*/
List<SysMenu> buildMenuTree(List<SysMenu> menus);
/**
* 构建前端所需要下拉树结构
*
* @param menus 菜单列表
*
* @return 下拉树结构列表
*/
List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus);
/**
* 根据菜单ID查询信息
*
* @param menuId 菜单ID
*
* @return 菜单信息
*/
SysMenu selectMenuById(Long menuId);
/**
* 是否存在菜单子节点
*
* @param menuId 菜单ID
*
* @return 结果 true 存在 false 不存在
*/
boolean hasChildByMenuId(Long menuId);
/**
* 查询菜单是否存在角色
*
* @param menuId 菜单ID
*
* @return 结果 true 存在 false 不存在
*/
boolean checkMenuExistRole(Long menuId);
/**
* 新增保存菜单信息
*
* @param menu 菜单信息
*
* @return 结果
*/
int insertMenu(SysMenu menu);
/**
* 修改保存菜单信息
*
* @param menu 菜单信息
*
* @return 结果
*/
int updateMenu(SysMenu menu);
/**
* 删除菜单管理信息
*
* @param menuId 菜单ID
*
* @return 结果
*/
int deleteMenuById(Long menuId);
/**
* 校验菜单名称是否唯一
*
* @param menu 菜单信息
*
* @return 结果
*/
boolean checkMenuNameUnique(SysMenu menu);
}

67
xs-service/src/main/java/com/xiang/xs/service/biz/ISysNoticeService.java Normal file
View File

@@ -0,0 +1,67 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysNotice;
import java.util.List;
/**
* 公告 服务层
*
* @author ruoyi
*/
public interface ISysNoticeService {
/**
* 查询公告信息
*
* @param noticeId 公告ID
*
* @return 公告信息
*/
SysNotice selectNoticeById(Long noticeId);
/**
* 查询公告列表
*
* @param notice 公告信息
*
* @return 公告集合
*/
List<SysNotice> selectNoticeList(SysNotice notice);
/**
* 新增公告
*
* @param notice 公告信息
*
* @return 结果
*/
int insertNotice(SysNotice notice);
/**
* 修改公告
*
* @param notice 公告信息
*
* @return 结果
*/
int updateNotice(SysNotice notice);
/**
* 删除公告信息
*
* @param noticeId 公告ID
*
* @return 结果
*/
int deleteNoticeById(Long noticeId);
/**
* 批量删除公告信息
*
* @param noticeIds 需要删除的公告ID
*
* @return 结果
*/
int deleteNoticeByIds(Long[] noticeIds);
}

52
xs-service/src/main/java/com/xiang/xs/service/biz/ISysOperLogService.java Normal file
View File

@@ -0,0 +1,52 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysOperLog;
import java.util.List;
/**
* 操作日志 服务层
*
* @author ruoyi
*/
public interface ISysOperLogService {
/**
* 新增操作日志
*
* @param operLog 操作日志对象
*/
void insertOperlog(SysOperLog operLog);
/**
* 查询系统操作日志集合
*
* @param operLog 操作日志对象
*
* @return 操作日志集合
*/
List<SysOperLog> selectOperLogList(SysOperLog operLog);
/**
* 批量删除系统操作日志
*
* @param operIds 需要删除的操作日志ID
*
* @return 结果
*/
int deleteOperLogByIds(Long[] operIds);
/**
* 查询操作日志详细
*
* @param operId 操作ID
*
* @return 操作日志对象
*/
SysOperLog selectOperLogById(Long operId);
/**
* 清空操作日志
*/
void cleanOperLog();
}

110
xs-service/src/main/java/com/xiang/xs/service/biz/ISysPostService.java Normal file
View File

@@ -0,0 +1,110 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysPost;
import java.util.List;
/**
* 岗位信息 服务层
*
* @author ruoyi
*/
public interface ISysPostService {
/**
* 查询岗位信息集合
*
* @param post 岗位信息
*
* @return 岗位列表
*/
List<SysPost> selectPostList(SysPost post);
/**
* 查询所有岗位
*
* @return 岗位列表
*/
List<SysPost> selectPostAll();
/**
* 通过岗位ID查询岗位信息
*
* @param postId 岗位ID
*
* @return 角色对象信息
*/
SysPost selectPostById(Long postId);
/**
* 根据用户ID获取岗位选择框列表
*
* @param userId 用户ID
*
* @return 选中岗位ID列表
*/
List<Long> selectPostListByUserId(Long userId);
/**
* 校验岗位名称
*
* @param post 岗位信息
*
* @return 结果
*/
boolean checkPostNameUnique(SysPost post);
/**
* 校验岗位编码
*
* @param post 岗位信息
*
* @return 结果
*/
boolean checkPostCodeUnique(SysPost post);
/**
* 通过岗位ID查询岗位使用数量
*
* @param postId 岗位ID
*
* @return 结果
*/
int countUserPostById(Long postId);
/**
* 删除岗位信息
*
* @param postId 岗位ID
*
* @return 结果
*/
int deletePostById(Long postId);
/**
* 批量删除岗位信息
*
* @param postIds 需要删除的岗位ID
*
* @return 结果
*/
int deletePostByIds(Long[] postIds);
/**
* 新增保存岗位信息
*
* @param post 岗位信息
*
* @return 结果
*/
int insertPost(SysPost post);
/**
* 修改保存岗位信息
*
* @param post 岗位信息
*
* @return 结果
*/
int updatePost(SysPost post);
}

191
xs-service/src/main/java/com/xiang/xs/service/biz/ISysRoleService.java Normal file
View File

@@ -0,0 +1,191 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysUserRole;
import java.util.List;
import java.util.Set;
/**
* 角色业务层
*
* @author ruoyi
*/
public interface ISysRoleService {
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
*
* @return 角色数据集合信息
*/
List<SysRole> selectRoleList(SysRole role);
/**
* 根据用户ID查询角色列表
*
* @param userId 用户ID
*
* @return 角色列表
*/
List<SysRole> selectRolesByUserId(Long userId);
/**
* 根据用户ID查询角色权限
*
* @param userId 用户ID
*
* @return 权限列表
*/
Set<String> selectRolePermissionByUserId(Long userId);
/**
* 查询所有角色
*
* @return 角色列表
*/
List<SysRole> selectRoleAll();
/**
* 根据用户ID获取角色选择框列表
*
* @param userId 用户ID
*
* @return 选中角色ID列表
*/
List<Long> selectRoleListByUserId(Long userId);
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
*
* @return 角色对象信息
*/
SysRole selectRoleById(Long roleId);
/**
* 校验角色名称是否唯一
*
* @param role 角色信息
*
* @return 结果
*/
boolean checkRoleNameUnique(SysRole role);
/**
* 校验角色权限是否唯一
*
* @param role 角色信息
*
* @return 结果
*/
boolean checkRoleKeyUnique(SysRole role);
/**
* 校验角色是否允许操作
*
* @param role 角色信息
*/
void checkRoleAllowed(SysRole role);
/**
* 校验角色是否有数据权限
*
* @param roleIds 角色id
*/
void checkRoleDataScope(String token, Long... roleIds);
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
*
* @return 结果
*/
int countUserRoleByRoleId(Long roleId);
/**
* 新增保存角色信息
*
* @param role 角色信息
*
* @return 结果
*/
int insertRole(SysRole role);
/**
* 修改保存角色信息
*
* @param role 角色信息
*
* @return 结果
*/
int updateRole(SysRole role);
/**
* 修改角色状态
*
* @param role 角色信息
*
* @return 结果
*/
int updateRoleStatus(SysRole role);
/**
* 修改数据权限信息
*
* @param role 角色信息
*
* @return 结果
*/
int authDataScope(SysRole role);
/**
* 通过角色ID删除角色
*
* @param roleId 角色ID
*
* @return 结果
*/
int deleteRoleById(Long roleId);
/**
* 批量删除角色信息
*
* @param roleIds 需要删除的角色ID
*
* @return 结果
*/
int deleteRoleByIds(String token, Long[] roleIds);
/**
* 取消授权用户角色
*
* @param userRole 用户和角色关联信息
*
* @return 结果
*/
int deleteAuthUser(SysUserRole userRole);
/**
* 批量取消授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要取消授权的用户数据ID
*
* @return 结果
*/
int deleteAuthUsers(Long roleId, Long[] userIds);
/**
* 批量选择授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要删除的用户数据ID
*
* @return 结果
*/
int insertAuthUsers(Long roleId, Long[] userIds);
}

52
xs-service/src/main/java/com/xiang/xs/service/biz/ISysUserOnlineService.java Normal file
View File

@@ -0,0 +1,52 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.LoginUser;
import com.xiang.xs.service.entity.SysUserOnline;
/**
* 在线用户 服务层
*
* @author ruoyi
*/
public interface ISysUserOnlineService {
/**
* 通过登录地址查询信息
*
* @param ipaddr 登录地址
* @param user 用户信息
*
* @return 在线用户信息
*/
SysUserOnline selectOnlineByIpaddr(String ipaddr, LoginUser user);
/**
* 通过用户名称查询信息
*
* @param userName 用户名称
* @param user 用户信息
*
* @return 在线用户信息
*/
SysUserOnline selectOnlineByUserName(String userName, LoginUser user);
/**
* 通过登录地址/用户名称查询信息
*
* @param ipaddr 登录地址
* @param userName 用户名称
* @param user 用户信息
*
* @return 在线用户信息
*/
SysUserOnline selectOnlineByInfo(String ipaddr, String userName, LoginUser user);
/**
* 设置在线用户信息
*
* @param user 用户信息
*
* @return 在线用户
*/
SysUserOnline loginUserToUserOnline(LoginUser user);
}

217
xs-service/src/main/java/com/xiang/xs/service/biz/ISysUserService.java Normal file
View File

@@ -0,0 +1,217 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.entity.SysUser;
import java.util.List;
/**
* 用户 业务层
*
* @author ruoyi
*/
public interface ISysUserService {
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
List<SysUser> selectUserList(SysUser user);
/**
* 根据条件分页查询已分配用户角色列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
List<SysUser> selectAllocatedList(SysUser user);
/**
* 根据条件分页查询未分配用户角色列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
List<SysUser> selectUnallocatedList(SysUser user);
/**
* 通过用户名查询用户
*
* @param userName 用户名
*
* @return 用户对象信息
*/
SysUser selectUserByUserName(String userName);
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
*
* @return 用户对象信息
*/
SysUser selectUserById(Long userId);
/**
* 根据用户ID查询用户所属角色组
*
* @param userName 用户名
*
* @return 结果
*/
String selectUserRoleGroup(String userName);
/**
* 根据用户ID查询用户所属岗位组
*
* @param userName 用户名
*
* @return 结果
*/
String selectUserPostGroup(String userName);
/**
* 校验用户名称是否唯一
*
* @param user 用户信息
*
* @return 结果
*/
boolean checkUserNameUnique(SysUser user);
/**
* 校验手机号码是否唯一
*
* @param user 用户信息
*
* @return 结果
*/
boolean checkPhoneUnique(SysUser user);
/**
* 校验email是否唯一
*
* @param user 用户信息
*
* @return 结果
*/
boolean checkEmailUnique(SysUser user);
/**
* 校验用户是否允许操作
*
* @param user 用户信息
*/
void checkUserAllowed(SysUser user);
/**
* 校验用户是否有数据权限
*
* @param userId 用户id
*/
void checkUserDataScope(Long userId);
/**
* 新增用户信息
*
* @param user 用户信息
*
* @return 结果
*/
int insertUser(SysUser user);
/**
* 注册用户信息
*
* @param user 用户信息
*
* @return 结果
*/
boolean registerUser(SysUser user);
/**
* 修改用户信息
*
* @param user 用户信息
*
* @return 结果
*/
int updateUser(SysUser user);
/**
* 用户授权角色
*
* @param userId 用户ID
* @param roleIds 角色组
*/
void insertUserAuth(Long userId, Long[] roleIds);
/**
* 修改用户状态
*
* @param user 用户信息
*
* @return 结果
*/
int updateUserStatus(SysUser user);
/**
* 修改用户基本信息
*
* @param user 用户信息
*
* @return 结果
*/
int updateUserProfile(SysUser user);
/**
* 修改用户头像
*
* @param userId 用户ID
* @param avatar 头像地址
*
* @return 结果
*/
boolean updateUserAvatar(Long userId, String avatar);
/**
* 重置用户密码
*
* @param user 用户信息
*
* @return 结果
*/
int resetPwd(SysUser user);
/**
* 重置用户密码
*
* @param userId 用户ID
* @param password 密码
*
* @return 结果
*/
int resetUserPwd(Long userId, String password);
/**
* 通过用户ID删除用户
*
* @param userId 用户ID
*
* @return 结果
*/
int deleteUserById(Long userId);
/**
* 批量删除用户信息
*
* @param userIds 需要删除的用户ID
*
* @return 结果
*/
int deleteUserByIds(Long[] userIds);
}

87
xs-service/src/main/java/com/xiang/xs/service/biz/SysPermissionService.java Normal file
View File

@@ -0,0 +1,87 @@
package com.xiang.xs.service.biz;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysUser;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 用户权限处理
*
* @author ruoyi
*/
@Component
public class SysPermissionService
{
@Autowired
private ISysRoleService roleService;
@Autowired
private ISysMenuService menuService;
/**
* 获取角色数据权限
*
* @param user 用户信息
* @return 角色权限信息
*/
public Set<String> getRolePermission(SysUser user)
{
Set<String> roles = new HashSet<String>();
// 管理员拥有所有权限
if (user.isAdmin())
{
roles.add("admin");
}
else
{
roles.addAll(roleService.selectRolePermissionByUserId(user.getUserId()));
}
return roles;
}
/**
* 获取菜单数据权限
*
* @param user 用户信息
* @return 菜单权限信息
*/
public Set<String> getMenuPermission(SysUser user)
{
Set<String> perms = new HashSet<String>();
// 管理员拥有所有权限
if (user.isAdmin())
{
perms.add("*:*:*");
}
else
{
List<SysRole> roles = user.getRoles();
if (!CollectionUtils.isEmpty(roles))
{
// 多角色设置permissions属性，以便数据权限匹配权限
for (SysRole role : roles)
{
if (StringUtils.equals(role.getStatus(), UserConstants.ROLE_NORMAL) && !role.isAdmin())
{
Set<String> rolePerms = menuService.selectMenuPermsByRoleId(role.getRoleId());
role.setPermissions(rolePerms);
perms.addAll(rolePerms);
}
}
}
else
{
perms.addAll(menuService.selectMenuPermsByUserId(user.getUserId()));
}
}
return perms;
}
}

213
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysConfigServiceImpl.java Normal file
View File

@@ -0,0 +1,213 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xmc.service.cache.service.IRedisService;
import com.xiang.xs.service.biz.ISysConfigService;
import com.xiang.xs.service.contants.CacheConstants;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysConfig;
import com.xiang.xs.service.repository.mapper.SysConfigMapper;
import com.xiang.xservice.basic.exception.BusinessException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
/**
* 参数配置 服务层实现
*
* @author ruoyi
*/
@Service
public class SysConfigServiceImpl implements ISysConfigService {
@Autowired
private SysConfigMapper configMapper;
@Autowired
private IRedisService redisCache;
/**
* 项目启动时，初始化参数到缓存
*/
@PostConstruct
public void init() {
loadingConfigCache();
}
/**
* 查询参数配置信息
*
* @param configId 参数配置ID
*
* @return 参数配置信息
*/
@Override
public SysConfig selectConfigById(Long configId) {
SysConfig config = new SysConfig();
config.setConfigId(configId);
return configMapper.selectConfig(config);
}
/**
* 根据键名查询参数配置信息
*
* @param configKey 参数key
*
* @return 参数键值
*/
@Override
public String selectConfigByKey(String configKey) {
String configValue = (String) redisCache.get(getCacheKey(configKey));
if (StringUtils.isNotBlank(configValue)) {
return configValue;
}
SysConfig config = new SysConfig();
config.setConfigKey(configKey);
SysConfig retConfig = configMapper.selectConfig(config);
if (Objects.nonNull(retConfig)) {
redisCache.set(getCacheKey(configKey), retConfig.getConfigValue());
return retConfig.getConfigValue();
}
return StringUtils.EMPTY;
}
/**
* 获取验证码开关
*
* @return true开启，false关闭
*/
@Override
public boolean selectCaptchaEnabled() {
String captchaEnabled = selectConfigByKey("sys.account.captchaEnabled");
if (StringUtils.isEmpty(captchaEnabled)) {
return true;
}
return StringUtils.equals(captchaEnabled, "true");
}
/**
* 查询参数配置列表
*
* @param config 参数配置信息
*
* @return 参数配置集合
*/
@Override
public List<SysConfig> selectConfigList(SysConfig config) {
return configMapper.selectConfigList(config);
}
/**
* 新增参数配置
*
* @param config 参数配置信息
*
* @return 结果
*/
@Override
public int insertConfig(SysConfig config) {
int row = configMapper.insertConfig(config);
if (row > 0) {
redisCache.set(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
return row;
}
/**
* 修改参数配置
*
* @param config 参数配置信息
*
* @return 结果
*/
@Override
public int updateConfig(SysConfig config) {
SysConfig temp = configMapper.selectConfigById(config.getConfigId());
if (!StringUtils.equals(temp.getConfigKey(), config.getConfigKey())) {
redisCache.delKey(getCacheKey(temp.getConfigKey()));
}
int row = configMapper.updateConfig(config);
if (row > 0) {
redisCache.set(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
return row;
}
/**
* 批量删除参数信息
*
* @param configIds 需要删除的参数ID
*/
@Override
public void deleteConfigByIds(Long[] configIds) {
for (Long configId : configIds) {
SysConfig config = selectConfigById(configId);
if (StringUtils.equals(UserConstants.YES, config.getConfigType())) {
throw new BusinessException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
}
configMapper.deleteConfigById(configId);
redisCache.delKey(getCacheKey(config.getConfigKey()));
}
}
/**
* 加载参数缓存数据
*/
@Override
public void loadingConfigCache() {
List<SysConfig> configsList = configMapper.selectConfigList(new SysConfig());
for (SysConfig config : configsList) {
redisCache.set(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
}
/**
* 清空参数缓存数据
*/
@Override
public void clearConfigCache() {
Collection<String> keys = redisCache.keys(CacheConstants.SYS_CONFIG_KEY + "*");
redisCache.deleteObject(keys);
}
/**
* 重置参数缓存数据
*/
@Override
public void resetConfigCache() {
clearConfigCache();
loadingConfigCache();
}
/**
* 校验参数键名是否唯一
*
* @param config 参数配置信息
*
* @return 结果
*/
@Override
public boolean checkConfigKeyUnique(SysConfig config) {
Long configId = Objects.isNull(config.getConfigId()) ? -1L : config.getConfigId();
SysConfig info = configMapper.checkConfigKeyUnique(config.getConfigKey());
if (Objects.nonNull(info) && info.getConfigId().longValue() != configId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 设置cache key
*
* @param configKey 参数键
*
* @return 缓存键key
*/
private String getCacheKey(String configKey) {
return CacheConstants.SYS_CONFIG_KEY + configKey;
}
}

319
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysDeptServiceImpl.java Normal file
View File

@@ -0,0 +1,319 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.api.client.TokenApi;
import com.xiang.xs.service.biz.ISysDeptService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysDept;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysUser;
import com.xiang.xs.service.entity.TreeSelect;
import com.xiang.xs.service.repository.mapper.SysDeptMapper;
import com.xiang.xs.service.repository.mapper.SysRoleMapper;
import com.xiang.xs.service.utils.Convert;
import com.xiang.xservice.basic.exception.BusinessException;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 部门管理 服务实现
*
* @author ruoyi
*/
@Service
public class SysDeptServiceImpl implements ISysDeptService {
@Autowired
private SysDeptMapper deptMapper;
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private TokenApi tokenApi;
/**
* 查询部门管理数据
*
* @param dept 部门信息
*
* @return 部门信息集合
*/
@Override
public List<SysDept> selectDeptList(SysDept dept) {
return deptMapper.selectDeptList(dept);
}
/**
* 查询部门树结构信息
*
* @param dept 部门信息
*
* @return 部门树信息集合
*/
@Override
public List<TreeSelect> selectDeptTreeList(SysDept dept) {
List<SysDept> depts = selectDeptList(dept);
return buildDeptTreeSelect(depts);
}
/**
* 构建前端所需要树结构
*
* @param depts 部门列表
*
* @return 树结构列表
*/
@Override
public List<SysDept> buildDeptTree(List<SysDept> depts) {
List<SysDept> returnList = new ArrayList<SysDept>();
List<Long> tempList = depts.stream().map(SysDept::getDeptId).collect(Collectors.toList());
for (SysDept dept : depts) {
// 如果是顶级节点, 遍历该父节点的所有子节点
if (!tempList.contains(dept.getParentId())) {
recursionFn(depts, dept);
returnList.add(dept);
}
}
if (returnList.isEmpty()) {
returnList = depts;
}
return returnList;
}
/**
* 构建前端所需要下拉树结构
*
* @param depts 部门列表
*
* @return 下拉树结构列表
*/
@Override
public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts) {
List<SysDept> deptTrees = buildDeptTree(depts);
return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
}
/**
* 根据角色ID查询部门树信息
*
* @param roleId 角色ID
*
* @return 选中部门列表
*/
@Override
public List<Long> selectDeptListByRoleId(Long roleId) {
SysRole role = roleMapper.selectRoleById(roleId);
return deptMapper.selectDeptListByRoleId(roleId, role.isDeptCheckStrictly());
}
/**
* 根据部门ID查询信息
*
* @param deptId 部门ID
*
* @return 部门信息
*/
@Override
public SysDept selectDeptById(Long deptId) {
return deptMapper.selectDeptById(deptId);
}
/**
* 根据ID查询所有子部门（正常状态）
*
* @param deptId 部门ID
*
* @return 子部门数
*/
@Override
public int selectNormalChildrenDeptById(Long deptId) {
return deptMapper.selectNormalChildrenDeptById(deptId);
}
/**
* 是否存在子节点
*
* @param deptId 部门ID
*
* @return 结果
*/
@Override
public boolean hasChildByDeptId(Long deptId) {
int result = deptMapper.hasChildByDeptId(deptId);
return result > 0;
}
/**
* 查询部门是否存在用户
*
* @param deptId 部门ID
*
* @return 结果 true 存在 false 不存在
*/
@Override
public boolean checkDeptExistUser(Long deptId) {
int result = deptMapper.checkDeptExistUser(deptId);
return result > 0;
}
/**
* 校验部门名称是否唯一
*
* @param dept 部门信息
*
* @return 结果
*/
@Override
public boolean checkDeptNameUnique(SysDept dept) {
long deptId = Objects.isNull(dept.getDeptId()) ? -1L : dept.getDeptId();
SysDept info = deptMapper.checkDeptNameUnique(dept.getDeptName(), dept.getParentId());
if (Objects.nonNull(info) && info.getDeptId() != deptId) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验部门是否有数据权限
*
* @param deptId 部门id
*/
@Override
public void checkDeptDataScope(Long deptId, String token) {
if (!SysUser.isAdmin(tokenApi.getUserId(token)) && Objects.nonNull(deptId)) {
SysDept dept = new SysDept();
dept.setDeptId(deptId);
List<SysDept> depts = selectDeptList(dept);
if (CollectionUtils.isEmpty(depts)) {
throw new BusinessException("没有权限访问部门数据！");
}
}
}
/**
* 新增保存部门信息
*
* @param dept 部门信息
*
* @return 结果
*/
@Override
public int insertDept(SysDept dept) {
SysDept info = deptMapper.selectDeptById(dept.getParentId());
// 如果父节点不为正常状态,则不允许新增子节点
if (!UserConstants.DEPT_NORMAL.equals(info.getStatus())) {
throw new BusinessException("部门停用，不允许新增");
}
dept.setAncestors(info.getAncestors() + "," + dept.getParentId());
return deptMapper.insertDept(dept);
}
/**
* 修改保存部门信息
*
* @param dept 部门信息
*
* @return 结果
*/
@Override
public int updateDept(SysDept dept) {
SysDept newParentDept = deptMapper.selectDeptById(dept.getParentId());
SysDept oldDept = deptMapper.selectDeptById(dept.getDeptId());
if (Objects.nonNull(newParentDept) && Objects.nonNull(oldDept)) {
String newAncestors = newParentDept.getAncestors() + "," + newParentDept.getDeptId();
String oldAncestors = oldDept.getAncestors();
dept.setAncestors(newAncestors);
updateDeptChildren(dept.getDeptId(), newAncestors, oldAncestors);
}
int result = deptMapper.updateDept(dept);
if (UserConstants.DEPT_NORMAL.equals(dept.getStatus()) && StringUtils.isNotEmpty(dept.getAncestors())
&& !StringUtils.equals("0", dept.getAncestors())) {
// 如果该部门是启用状态，则启用该部门的所有上级部门
updateParentDeptStatusNormal(dept);
}
return result;
}
/**
* 修改该部门的父级部门状态
*
* @param dept 当前部门
*/
private void updateParentDeptStatusNormal(SysDept dept) {
String ancestors = dept.getAncestors();
Long[] deptIds = Convert.toLongArray(ancestors);
deptMapper.updateDeptStatusNormal(deptIds);
}
/**
* 修改子元素关系
*
* @param deptId 被修改的部门ID
* @param newAncestors 新的父ID集合
* @param oldAncestors 旧的父ID集合
*/
public void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors) {
List<SysDept> children = deptMapper.selectChildrenDeptById(deptId);
for (SysDept child : children) {
child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
}
if (children.size() > 0) {
deptMapper.updateDeptChildren(children);
}
}
/**
* 删除部门管理信息
*
* @param deptId 部门ID
*
* @return 结果
*/
@Override
public int deleteDeptById(Long deptId) {
return deptMapper.deleteDeptById(deptId);
}
/**
* 递归列表
*/
private void recursionFn(List<SysDept> list, SysDept t) {
// 得到子节点列表
List<SysDept> childList = getChildList(list, t);
t.setChildren(childList);
for (SysDept tChild : childList) {
if (hasChild(list, tChild)) {
recursionFn(list, tChild);
}
}
}
/**
* 得到子节点列表
*/
private List<SysDept> getChildList(List<SysDept> list, SysDept t) {
List<SysDept> tlist = new ArrayList<SysDept>();
Iterator<SysDept> it = list.iterator();
while (it.hasNext()) {
SysDept n = (SysDept) it.next();
if (Objects.nonNull(n.getParentId()) && n.getParentId().longValue() == t.getDeptId().longValue()) {
tlist.add(n);
}
}
return tlist;
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<SysDept> list, SysDept t) {
return getChildList(list, t).size() > 0;
}
}

109
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysDictDataServiceImpl.java Normal file
View File

@@ -0,0 +1,109 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysDictDataService;
import com.xiang.xs.service.entity.SysDictData;
import com.xiang.xs.service.repository.mapper.SysDictDataMapper;
import com.xiang.xs.service.utils.DictUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 字典 业务层处理
*
* @author ruoyi
*/
@Service
public class SysDictDataServiceImpl implements ISysDictDataService {
@Autowired
private SysDictDataMapper dictDataMapper;
@Autowired
private DictUtils dictUtils;
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
*
* @return 字典数据集合信息
*/
@Override
public List<SysDictData> selectDictDataList(SysDictData dictData) {
return dictDataMapper.selectDictDataList(dictData);
}
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType 字典类型
* @param dictValue 字典键值
*
* @return 字典标签
*/
@Override
public String selectDictLabel(String dictType, String dictValue) {
return dictDataMapper.selectDictLabel(dictType, dictValue);
}
/**
* 根据字典数据ID查询信息
*
* @param dictCode 字典数据ID
*
* @return 字典数据
*/
@Override
public SysDictData selectDictDataById(Long dictCode) {
return dictDataMapper.selectDictDataById(dictCode);
}
/**
* 批量删除字典数据信息
*
* @param dictCodes 需要删除的字典数据ID
*/
@Override
public void deleteDictDataByIds(Long[] dictCodes) {
for (Long dictCode : dictCodes) {
SysDictData data = selectDictDataById(dictCode);
dictDataMapper.deleteDictDataById(dictCode);
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
dictUtils.setDictCache(data.getDictType(), dictDatas);
}
}
/**
* 新增保存字典数据信息
*
* @param data 字典数据信息
*
* @return 结果
*/
@Override
public int insertDictData(SysDictData data) {
int row = dictDataMapper.insertDictData(data);
if (row > 0) {
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
dictUtils.setDictCache(data.getDictType(), dictDatas);
}
return row;
}
/**
* 修改保存字典数据信息
*
* @param data 字典数据信息
*
* @return 结果
*/
@Override
public int updateDictData(SysDictData data) {
int row = dictDataMapper.updateDictData(data);
if (row > 0) {
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
dictUtils.setDictCache(data.getDictType(), dictDatas);
}
return row;
}
}

211
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysDictTypeServiceImpl.java Normal file
View File

@@ -0,0 +1,211 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysDictTypeService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysDictData;
import com.xiang.xs.service.entity.SysDictType;
import com.xiang.xs.service.repository.mapper.SysDictDataMapper;
import com.xiang.xs.service.repository.mapper.SysDictTypeMapper;
import com.xiang.xs.service.utils.DictUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 字典 业务层处理
*
* @author ruoyi
*/
@Service
public class SysDictTypeServiceImpl implements ISysDictTypeService {
@Autowired
private SysDictTypeMapper dictTypeMapper;
@Autowired
private SysDictDataMapper dictDataMapper;
@Autowired
private DictUtils dictUtils;
/**
* 项目启动时，初始化字典到缓存
*/
@PostConstruct
public void init() {
loadingDictCache();
}
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
*
* @return 字典类型集合信息
*/
@Override
public List<SysDictType> selectDictTypeList(SysDictType dictType) {
return dictTypeMapper.selectDictTypeList(dictType);
}
/**
* 根据所有字典类型
*
* @return 字典类型集合信息
*/
@Override
public List<SysDictType> selectDictTypeAll() {
return dictTypeMapper.selectDictTypeAll();
}
/**
* 根据字典类型查询字典数据
*
* @param dictType 字典类型
*
* @return 字典数据集合信息
*/
@Override
public List<SysDictData> selectDictDataByType(String dictType) {
List<SysDictData> dictDatas = dictUtils.getDictCache(dictType);
if (CollectionUtils.isNotEmpty(dictDatas)) {
return dictDatas;
}
dictDatas = dictDataMapper.selectDictDataByType(dictType);
if (CollectionUtils.isNotEmpty(dictDatas)) {
dictUtils.setDictCache(dictType, dictDatas);
return dictDatas;
}
return null;
}
/**
* 根据字典类型ID查询信息
*
* @param dictId 字典类型ID
*
* @return 字典类型
*/
@Override
public SysDictType selectDictTypeById(Long dictId) {
return dictTypeMapper.selectDictTypeById(dictId);
}
/**
* 根据字典类型查询信息
*
* @param dictType 字典类型
*
* @return 字典类型
*/
@Override
public SysDictType selectDictTypeByType(String dictType) {
return dictTypeMapper.selectDictTypeByType(dictType);
}
/**
* 批量删除字典类型信息
*
* @param dictIds 需要删除的字典ID
*/
@Override
public void deleteDictTypeByIds(Long[] dictIds) {
for (Long dictId : dictIds) {
SysDictType dictType = selectDictTypeById(dictId);
if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0) {
throw new com.xiang.xservice.basic.exception.BusinessException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
}
dictTypeMapper.deleteDictTypeById(dictId);
dictUtils.removeDictCache(dictType.getDictType());
}
}
/**
* 加载字典缓存数据
*/
@Override
public void loadingDictCache() {
SysDictData dictData = new SysDictData();
dictData.setStatus("0");
Map<String, List<SysDictData>> dictDataMap = dictDataMapper.selectDictDataList(dictData).stream().collect(Collectors.groupingBy(SysDictData::getDictType));
for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet()) {
dictUtils.setDictCache(entry.getKey(), entry.getValue().stream().sorted(Comparator.comparing(SysDictData::getDictSort)).collect(Collectors.toList()));
}
}
/**
* 清空字典缓存数据
*/
@Override
public void clearDictCache() {
dictUtils.clearDictCache();
}
/**
* 重置字典缓存数据
*/
@Override
public void resetDictCache() {
clearDictCache();
loadingDictCache();
}
/**
* 新增保存字典类型信息
*
* @param dict 字典类型信息
*
* @return 结果
*/
@Override
public int insertDictType(SysDictType dict) {
int row = dictTypeMapper.insertDictType(dict);
if (row > 0) {
dictUtils.setDictCache(dict.getDictType(), null);
}
return row;
}
/**
* 修改保存字典类型信息
*
* @param dict 字典类型信息
*
* @return 结果
*/
@Override
@Transactional
public int updateDictType(SysDictType dict) {
SysDictType oldDict = dictTypeMapper.selectDictTypeById(dict.getDictId());
dictDataMapper.updateDictDataType(oldDict.getDictType(), dict.getDictType());
int row = dictTypeMapper.updateDictType(dict);
if (row > 0) {
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
dictUtils.setDictCache(dict.getDictType(), dictDatas);
}
return row;
}
/**
* 校验字典类型称是否唯一
*
* @param dict 字典类型
*
* @return 结果
*/
@Override
public boolean checkDictTypeUnique(SysDictType dict) {
long dictId = Objects.isNull(dict.getDictId()) ? -1L : dict.getDictId();
SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType());
if (Objects.nonNull(dictType) && dictType.getDictId() != dictId) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
}

66
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysLogininforServiceImpl.java Normal file
View File

@@ -0,0 +1,66 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysLogininforService;
import com.xiang.xs.service.entity.SysLogininfor;
import com.xiang.xs.service.repository.mapper.SysLogininforMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 系统访问日志情况信息 服务层处理
*
* @author ruoyi
*/
@Service
public class SysLogininforServiceImpl implements ISysLogininforService
{
@Autowired
private SysLogininforMapper logininforMapper;
/**
* 新增系统登录日志
*
* @param logininfor 访问日志对象
*/
@Override
public void insertLogininfor(SysLogininfor logininfor)
{
logininforMapper.insertLogininfor(logininfor);
}
/**
* 查询系统登录日志集合
*
* @param logininfor 访问日志对象
* @return 登录记录集合
*/
@Override
public List<SysLogininfor> selectLogininforList(SysLogininfor logininfor)
{
return logininforMapper.selectLogininforList(logininfor);
}
/**
* 批量删除系统登录日志
*
* @param infoIds 需要删除的登录日志ID
* @return 结果
*/
@Override
public int deleteLogininforByIds(Long[] infoIds)
{
return logininforMapper.deleteLogininforByIds(infoIds);
}
/**
* 清空系统登录日志
*/
@Override
public void cleanLogininfor()
{
logininforMapper.cleanLogininfor();
}
}

506
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysMenuServiceImpl.java Normal file
View File

@@ -0,0 +1,506 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysMenuService;
import com.xiang.xs.service.contants.Constants;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysMenu;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysUser;
import com.xiang.xs.service.entity.TreeSelect;
import com.xiang.xs.service.entity.vo.MetaVo;
import com.xiang.xs.service.entity.vo.RouterVo;
import com.xiang.xs.service.repository.mapper.SysMenuMapper;
import com.xiang.xs.service.repository.mapper.SysRoleMapper;
import com.xiang.xs.service.repository.mapper.SysRoleMenuMapper;
import com.xiang.xservice.basic.utils.MyStringUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
/**
* 菜单 业务层处理
*
* @author ruoyi
*/
@Service
public class SysMenuServiceImpl implements ISysMenuService {
public static final String PREMISSION_STRING = "perms[\"{0}\"]";
@Autowired
private SysMenuMapper menuMapper;
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private SysRoleMenuMapper roleMenuMapper;
/**
* 根据用户查询系统菜单列表
*
* @param userId 用户ID
*
* @return 菜单列表
*/
@Override
public List<SysMenu> selectMenuList(Long userId) {
return selectMenuList(new SysMenu(), userId);
}
/**
* 查询系统菜单列表
*
* @param menu 菜单信息
*
* @return 菜单列表
*/
@Override
public List<SysMenu> selectMenuList(SysMenu menu, Long userId) {
List<SysMenu> menuList = null;
// 管理员显示所有菜单信息
if (SysUser.isAdmin(userId)) {
menuList = menuMapper.selectMenuList(menu);
} else {
menu.getParams().put("userId", userId);
menuList = menuMapper.selectMenuListByUserId(menu);
}
return menuList;
}
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
*
* @return 权限列表
*/
@Override
public Set<String> selectMenuPermsByUserId(Long userId) {
List<String> perms = menuMapper.selectMenuPermsByUserId(userId);
Set<String> permsSet = new HashSet<>();
for (String perm : perms) {
if (StringUtils.isNotEmpty(perm)) {
permsSet.addAll(Arrays.asList(perm.trim().split(",")));
}
}
return permsSet;
}
/**
* 根据角色ID查询权限
*
* @param roleId 角色ID
*
* @return 权限列表
*/
@Override
public Set<String> selectMenuPermsByRoleId(Long roleId) {
List<String> perms = menuMapper.selectMenuPermsByRoleId(roleId);
Set<String> permsSet = new HashSet<>();
for (String perm : perms) {
if (StringUtils.isNotEmpty(perm)) {
permsSet.addAll(Arrays.asList(perm.trim().split(",")));
}
}
return permsSet;
}
/**
* 根据用户ID查询菜单
*
* @param userId 用户名称
*
* @return 菜单列表
*/
@Override
public List<SysMenu> selectMenuTreeByUserId(Long userId) {
List<SysMenu> menus = null;
if (SysUser.isAdmin(userId)) {
menus = menuMapper.selectMenuTreeAll();
} else {
menus = menuMapper.selectMenuTreeByUserId(userId);
}
return getChildPerms(menus, 0);
}
/**
* 根据角色ID查询菜单树信息
*
* @param roleId 角色ID
*
* @return 选中菜单列表
*/
@Override
public List<Long> selectMenuListByRoleId(Long roleId) {
SysRole role = roleMapper.selectRoleById(roleId);
return menuMapper.selectMenuListByRoleId(roleId, role.isMenuCheckStrictly());
}
/**
* 构建前端路由所需要的菜单
*
* @param menus 菜单列表
*
* @return 路由列表
*/
@Override
public List<RouterVo> buildMenus(List<SysMenu> menus) {
List<RouterVo> routers = new LinkedList<RouterVo>();
for (SysMenu menu : menus) {
RouterVo router = new RouterVo();
router.setHidden("1".equals(menu.getVisible()));
router.setName(getRouteName(menu));
router.setPath(getRouterPath(menu));
router.setComponent(getComponent(menu));
router.setQuery(menu.getQuery());
router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
List<SysMenu> cMenus = menu.getChildren();
if (CollectionUtils.isNotEmpty(cMenus) && UserConstants.TYPE_DIR.equals(menu.getMenuType())) {
router.setAlwaysShow(true);
router.setRedirect("noRedirect");
router.setChildren(buildMenus(cMenus));
} else if (isMenuFrame(menu)) {
router.setMeta(null);
List<RouterVo> childrenList = new ArrayList<RouterVo>();
RouterVo children = new RouterVo();
children.setPath(menu.getPath());
children.setComponent(menu.getComponent());
children.setName(getRouteName(menu.getRouteName(), menu.getPath()));
children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
children.setQuery(menu.getQuery());
childrenList.add(children);
router.setChildren(childrenList);
} else if (menu.getParentId().intValue() == 0 && isInnerLink(menu)) {
router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon()));
router.setPath("/");
List<RouterVo> childrenList = new ArrayList<RouterVo>();
RouterVo children = new RouterVo();
String routerPath = innerLinkReplaceEach(menu.getPath());
children.setPath(routerPath);
children.setComponent(UserConstants.INNER_LINK);
children.setName(getRouteName(menu.getRouteName(), routerPath));
children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), menu.getPath()));
childrenList.add(children);
router.setChildren(childrenList);
}
routers.add(router);
}
return routers;
}
/**
* 构建前端所需要树结构
*
* @param menus 菜单列表
*
* @return 树结构列表
*/
@Override
public List<SysMenu> buildMenuTree(List<SysMenu> menus) {
List<SysMenu> returnList = new ArrayList<SysMenu>();
List<Long> tempList = menus.stream().map(SysMenu::getMenuId).collect(Collectors.toList());
for (Iterator<SysMenu> iterator = menus.iterator(); iterator.hasNext(); ) {
SysMenu menu = (SysMenu) iterator.next();
// 如果是顶级节点, 遍历该父节点的所有子节点
if (!tempList.contains(menu.getParentId())) {
recursionFn(menus, menu);
returnList.add(menu);
}
}
if (returnList.isEmpty()) {
returnList = menus;
}
return returnList;
}
/**
* 构建前端所需要下拉树结构
*
* @param menus 菜单列表
*
* @return 下拉树结构列表
*/
@Override
public List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus) {
List<SysMenu> menuTrees = buildMenuTree(menus);
return menuTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
}
/**
* 根据菜单ID查询信息
*
* @param menuId 菜单ID
*
* @return 菜单信息
*/
@Override
public SysMenu selectMenuById(Long menuId) {
return menuMapper.selectMenuById(menuId);
}
/**
* 是否存在菜单子节点
*
* @param menuId 菜单ID
*
* @return 结果
*/
@Override
public boolean hasChildByMenuId(Long menuId) {
int result = menuMapper.hasChildByMenuId(menuId);
return result > 0;
}
/**
* 查询菜单使用数量
*
* @param menuId 菜单ID
*
* @return 结果
*/
@Override
public boolean checkMenuExistRole(Long menuId) {
int result = roleMenuMapper.checkMenuExistRole(menuId);
return result > 0;
}
/**
* 新增保存菜单信息
*
* @param menu 菜单信息
*
* @return 结果
*/
@Override
public int insertMenu(SysMenu menu) {
return menuMapper.insertMenu(menu);
}
/**
* 修改保存菜单信息
*
* @param menu 菜单信息
*
* @return 结果
*/
@Override
public int updateMenu(SysMenu menu) {
return menuMapper.updateMenu(menu);
}
/**
* 删除菜单管理信息
*
* @param menuId 菜单ID
*
* @return 结果
*/
@Override
public int deleteMenuById(Long menuId) {
return menuMapper.deleteMenuById(menuId);
}
/**
* 校验菜单名称是否唯一
*
* @param menu 菜单信息
*
* @return 结果
*/
@Override
public boolean checkMenuNameUnique(SysMenu menu) {
long menuId = Objects.isNull(menu.getMenuId()) ? -1L : menu.getMenuId();
SysMenu info = menuMapper.checkMenuNameUnique(menu.getMenuName(), menu.getParentId());
if (Objects.nonNull(info) && info.getMenuId() != menuId) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 获取路由名称
*
* @param menu 菜单信息
*
* @return 路由名称
*/
public String getRouteName(SysMenu menu) {
// 非外链并且是一级目录（类型为目录）
if (isMenuFrame(menu)) {
return StringUtils.EMPTY;
}
return getRouteName(menu.getRouteName(), menu.getPath());
}
/**
* 获取路由名称，如没有配置路由名称则取路由地址
*
* @param name 路由名称
* @param path 路由地址
*
* @return 路由名称（驼峰格式）
*/
public String getRouteName(String name, String path) {
String routerName = StringUtils.isNotEmpty(name) ? name : path;
return StringUtils.capitalize(routerName);
}
/**
* 获取路由地址
*
* @param menu 菜单信息
*
* @return 路由地址
*/
public String getRouterPath(SysMenu menu) {
String routerPath = menu.getPath();
// 内链打开外网方式
if (menu.getParentId().intValue() != 0 && isInnerLink(menu)) {
routerPath = innerLinkReplaceEach(routerPath);
}
// 非外链并且是一级目录（类型为目录）
if (0 == menu.getParentId().intValue() && UserConstants.TYPE_DIR.equals(menu.getMenuType())
&& UserConstants.NO_FRAME.equals(menu.getIsFrame())) {
routerPath = "/" + menu.getPath();
}
// 非外链并且是一级目录（类型为菜单）
else if (isMenuFrame(menu)) {
routerPath = "/";
}
return routerPath;
}
/**
* 获取组件信息
*
* @param menu 菜单信息
*
* @return 组件信息
*/
public String getComponent(SysMenu menu) {
String component = UserConstants.LAYOUT;
if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu)) {
component = menu.getComponent();
} else if (StringUtils.isEmpty(menu.getComponent()) && menu.getParentId().intValue() != 0 && isInnerLink(menu)) {
component = UserConstants.INNER_LINK;
} else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu)) {
component = UserConstants.PARENT_VIEW;
}
return component;
}
/**
* 是否为菜单内部跳转
*
* @param menu 菜单信息
*
* @return 结果
*/
public boolean isMenuFrame(SysMenu menu) {
return menu.getParentId().intValue() == 0 && UserConstants.TYPE_MENU.equals(menu.getMenuType())
&& menu.getIsFrame().equals(UserConstants.NO_FRAME);
}
/**
* 是否为内链组件
*
* @param menu 菜单信息
*
* @return 结果
*/
public boolean isInnerLink(SysMenu menu) {
return menu.getIsFrame().equals(UserConstants.NO_FRAME) && MyStringUtils.isHttp(menu.getPath());
}
/**
* 是否为parent_view组件
*
* @param menu 菜单信息
*
* @return 结果
*/
public boolean isParentView(SysMenu menu) {
return menu.getParentId().intValue() != 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType());
}
/**
* 根据父节点的ID获取所有子节点
*
* @param list 分类表
* @param parentId 传入的父节点ID
*
* @return String
*/
public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId) {
List<SysMenu> returnList = new ArrayList<SysMenu>();
for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext(); ) {
SysMenu t = (SysMenu) iterator.next();
// 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
if (t.getParentId() == parentId) {
recursionFn(list, t);
returnList.add(t);
}
}
return returnList;
}
/**
* 递归列表
*
* @param list 分类表
* @param t 子节点
*/
private void recursionFn(List<SysMenu> list, SysMenu t) {
// 得到子节点列表
List<SysMenu> childList = getChildList(list, t);
t.setChildren(childList);
for (SysMenu tChild : childList) {
if (hasChild(list, tChild)) {
recursionFn(list, tChild);
}
}
}
/**
* 得到子节点列表
*/
private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t) {
List<SysMenu> tlist = new ArrayList<SysMenu>();
Iterator<SysMenu> it = list.iterator();
while (it.hasNext()) {
SysMenu n = (SysMenu) it.next();
if (n.getParentId().longValue() == t.getMenuId().longValue()) {
tlist.add(n);
}
}
return tlist;
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<SysMenu> list, SysMenu t) {
return getChildList(list, t).size() > 0;
}
/**
* 内链域名特殊字符替换
*
* @return 替换后的内链域名
*/
public String innerLinkReplaceEach(String path) {
return StringUtils.replaceEach(path, new String[]{Constants.HTTP, Constants.HTTPS, Constants.WWW, ".", ":"},
new String[]{"", "", "", "/", "/"});
}
}

92
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysNoticeServiceImpl.java Normal file
View File

@@ -0,0 +1,92 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysNoticeService;
import com.xiang.xs.service.entity.SysNotice;
import com.xiang.xs.service.repository.mapper.SysNoticeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 公告 服务层实现
*
* @author ruoyi
*/
@Service
public class SysNoticeServiceImpl implements ISysNoticeService {
@Autowired
private SysNoticeMapper noticeMapper;
/**
* 查询公告信息
*
* @param noticeId 公告ID
*
* @return 公告信息
*/
@Override
public SysNotice selectNoticeById(Long noticeId) {
return noticeMapper.selectNoticeById(noticeId);
}
/**
* 查询公告列表
*
* @param notice 公告信息
*
* @return 公告集合
*/
@Override
public List<SysNotice> selectNoticeList(SysNotice notice) {
return noticeMapper.selectNoticeList(notice);
}
/**
* 新增公告
*
* @param notice 公告信息
*
* @return 结果
*/
@Override
public int insertNotice(SysNotice notice) {
return noticeMapper.insertNotice(notice);
}
/**
* 修改公告
*
* @param notice 公告信息
*
* @return 结果
*/
@Override
public int updateNotice(SysNotice notice) {
return noticeMapper.updateNotice(notice);
}
/**
* 删除公告对象
*
* @param noticeId 公告ID
*
* @return 结果
*/
@Override
public int deleteNoticeById(Long noticeId) {
return noticeMapper.deleteNoticeById(noticeId);
}
/**
* 批量删除公告信息
*
* @param noticeIds 需要删除的公告ID
*
* @return 结果
*/
@Override
public int deleteNoticeByIds(Long[] noticeIds) {
return noticeMapper.deleteNoticeByIds(noticeIds);
}
}

74
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysOperLogServiceImpl.java Normal file
View File

@@ -0,0 +1,74 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysOperLogService;
import com.xiang.xs.service.entity.SysOperLog;
import com.xiang.xs.service.repository.mapper.SysOperLogMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 操作日志 服务层处理
*
* @author ruoyi
*/
@Service
public class SysOperLogServiceImpl implements ISysOperLogService {
@Autowired
private SysOperLogMapper operLogMapper;
/**
* 新增操作日志
*
* @param operLog 操作日志对象
*/
@Override
public void insertOperlog(SysOperLog operLog) {
operLogMapper.insertOperlog(operLog);
}
/**
* 查询系统操作日志集合
*
* @param operLog 操作日志对象
*
* @return 操作日志集合
*/
@Override
public List<SysOperLog> selectOperLogList(SysOperLog operLog) {
return operLogMapper.selectOperLogList(operLog);
}
/**
* 批量删除系统操作日志
*
* @param operIds 需要删除的操作日志ID
*
* @return 结果
*/
@Override
public int deleteOperLogByIds(Long[] operIds) {
return operLogMapper.deleteOperLogByIds(operIds);
}
/**
* 查询操作日志详细
*
* @param operId 操作ID
*
* @return 操作日志对象
*/
@Override
public SysOperLog selectOperLogById(Long operId) {
return operLogMapper.selectOperLogById(operId);
}
/**
* 清空操作日志
*/
@Override
public void cleanOperLog() {
operLogMapper.cleanOperLog();
}
}

173
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysPostServiceImpl.java Normal file
View File

@@ -0,0 +1,173 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysPostService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysPost;
import com.xiang.xs.service.repository.mapper.SysPostMapper;
import com.xiang.xs.service.repository.mapper.SysUserPostMapper;
import com.xiang.xservice.basic.exception.BusinessException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;
/**
* 岗位信息 服务层处理
*
* @author ruoyi
*/
@Service
public class SysPostServiceImpl implements ISysPostService {
@Autowired
private SysPostMapper postMapper;
@Autowired
private SysUserPostMapper userPostMapper;
/**
* 查询岗位信息集合
*
* @param post 岗位信息
*
* @return 岗位信息集合
*/
@Override
public List<SysPost> selectPostList(SysPost post) {
return postMapper.selectPostList(post);
}
/**
* 查询所有岗位
*
* @return 岗位列表
*/
@Override
public List<SysPost> selectPostAll() {
return postMapper.selectPostAll();
}
/**
* 通过岗位ID查询岗位信息
*
* @param postId 岗位ID
*
* @return 角色对象信息
*/
@Override
public SysPost selectPostById(Long postId) {
return postMapper.selectPostById(postId);
}
/**
* 根据用户ID获取岗位选择框列表
*
* @param userId 用户ID
*
* @return 选中岗位ID列表
*/
@Override
public List<Long> selectPostListByUserId(Long userId) {
return postMapper.selectPostListByUserId(userId);
}
/**
* 校验岗位名称是否唯一
*
* @param post 岗位信息
*
* @return 结果
*/
@Override
public boolean checkPostNameUnique(SysPost post) {
Long postId = Objects.isNull(post.getPostId()) ? -1L : post.getPostId();
SysPost info = postMapper.checkPostNameUnique(post.getPostName());
if (Objects.nonNull(info) && info.getPostId().longValue() != postId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验岗位编码是否唯一
*
* @param post 岗位信息
*
* @return 结果
*/
@Override
public boolean checkPostCodeUnique(SysPost post) {
Long postId = Objects.isNull(post.getPostId()) ? -1L : post.getPostId();
SysPost info = postMapper.checkPostCodeUnique(post.getPostCode());
if (Objects.nonNull(info) && info.getPostId().longValue() != postId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 通过岗位ID查询岗位使用数量
*
* @param postId 岗位ID
*
* @return 结果
*/
@Override
public int countUserPostById(Long postId) {
return userPostMapper.countUserPostById(postId);
}
/**
* 删除岗位信息
*
* @param postId 岗位ID
*
* @return 结果
*/
@Override
public int deletePostById(Long postId) {
return postMapper.deletePostById(postId);
}
/**
* 批量删除岗位信息
*
* @param postIds 需要删除的岗位ID
*
* @return 结果
*/
@Override
public int deletePostByIds(Long[] postIds) {
for (Long postId : postIds) {
SysPost post = selectPostById(postId);
if (countUserPostById(postId) > 0) {
throw new BusinessException(String.format("%1$s已分配,不能删除", post.getPostName()));
}
}
return postMapper.deletePostByIds(postIds);
}
/**
* 新增保存岗位信息
*
* @param post 岗位信息
*
* @return 结果
*/
@Override
public int insertPost(SysPost post) {
return postMapper.insertPost(post);
}
/**
* 修改保存岗位信息
*
* @param post 岗位信息
*
* @return 结果
*/
@Override
public int updatePost(SysPost post) {
return postMapper.updatePost(post);
}
}

406
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysRoleServiceImpl.java Normal file
View File

@@ -0,0 +1,406 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.api.client.TokenApi;
import com.xiang.xs.service.biz.ISysRoleService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysRoleDept;
import com.xiang.xs.service.entity.SysRoleMenu;
import com.xiang.xs.service.entity.SysUser;
import com.xiang.xs.service.entity.SysUserRole;
import com.xiang.xs.service.repository.mapper.SysRoleDeptMapper;
import com.xiang.xs.service.repository.mapper.SysRoleMapper;
import com.xiang.xs.service.repository.mapper.SysRoleMenuMapper;
import com.xiang.xs.service.repository.mapper.SysUserRoleMapper;
import com.xiang.xservice.basic.exception.BusinessException;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
/**
* 角色 业务层处理
*
* @author ruoyi
*/
@Service
public class SysRoleServiceImpl implements ISysRoleService {
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private SysRoleMenuMapper roleMenuMapper;
@Autowired
private SysUserRoleMapper userRoleMapper;
@Autowired
private SysRoleDeptMapper roleDeptMapper;
@Autowired
private TokenApi tokenApi;
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
*
* @return 角色数据集合信息
*/
@Override
public List<SysRole> selectRoleList(SysRole role) {
return roleMapper.selectRoleList(role);
}
/**
* 根据用户ID查询角色
*
* @param userId 用户ID
*
* @return 角色列表
*/
@Override
public List<SysRole> selectRolesByUserId(Long userId) {
List<SysRole> userRoles = roleMapper.selectRolePermissionByUserId(userId);
List<SysRole> roles = selectRoleAll();
for (SysRole role : roles) {
for (SysRole userRole : userRoles) {
if (role.getRoleId().longValue() == userRole.getRoleId().longValue()) {
role.setFlag(true);
break;
}
}
}
return roles;
}
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
*
* @return 权限列表
*/
@Override
public Set<String> selectRolePermissionByUserId(Long userId) {
List<SysRole> perms = roleMapper.selectRolePermissionByUserId(userId);
Set<String> permsSet = new HashSet<>();
for (SysRole perm : perms) {
if (Objects.nonNull(perm)) {
permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(",")));
}
}
return permsSet;
}
/**
* 查询所有角色
*
* @return 角色列表
*/
@Override
public List<SysRole> selectRoleAll() {
return selectRoleList(new SysRole());
}
/**
* 根据用户ID获取角色选择框列表
*
* @param userId 用户ID
*
* @return 选中角色ID列表
*/
@Override
public List<Long> selectRoleListByUserId(Long userId) {
return roleMapper.selectRoleListByUserId(userId);
}
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
*
* @return 角色对象信息
*/
@Override
public SysRole selectRoleById(Long roleId) {
return roleMapper.selectRoleById(roleId);
}
/**
* 校验角色名称是否唯一
*
* @param role 角色信息
*
* @return 结果
*/
@Override
public boolean checkRoleNameUnique(SysRole role) {
Long roleId = Objects.isNull(role.getRoleId()) ? -1L : role.getRoleId();
SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName());
if (Objects.nonNull(info) && info.getRoleId().longValue() != roleId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验角色权限是否唯一
*
* @param role 角色信息
*
* @return 结果
*/
@Override
public boolean checkRoleKeyUnique(SysRole role) {
Long roleId = Objects.isNull(role.getRoleId()) ? -1L : role.getRoleId();
SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
if (Objects.nonNull(info) && info.getRoleId().longValue() != roleId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验角色是否允许操作
*
* @param role 角色信息
*/
@Override
public void checkRoleAllowed(SysRole role) {
if (Objects.nonNull(role.getRoleId()) && role.isAdmin()) {
throw new com.xiang.xservice.basic.exception.BusinessException("不允许操作超级管理员角色");
}
}
/**
* 校验角色是否有数据权限
*
* @param roleIds 角色id
*/
@Override
public void checkRoleDataScope(String token, Long... roleIds) {
if (!SysUser.isAdmin(tokenApi.getUserId(token))) {
for (Long roleId : roleIds) {
SysRole role = new SysRole();
role.setRoleId(roleId);
List<SysRole> roles = selectRoleList(role);
if (CollectionUtils.isEmpty(roles)) {
throw new com.xiang.xservice.basic.exception.BusinessException("没有权限访问角色数据！");
}
}
}
}
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
*
* @return 结果
*/
@Override
public int countUserRoleByRoleId(Long roleId) {
return userRoleMapper.countUserRoleByRoleId(roleId);
}
/**
* 新增保存角色信息
*
* @param role 角色信息
*
* @return 结果
*/
@Override
@Transactional
public int insertRole(SysRole role) {
// 新增角色信息
roleMapper.insertRole(role);
return insertRoleMenu(role);
}
/**
* 修改保存角色信息
*
* @param role 角色信息
*
* @return 结果
*/
@Override
@Transactional
public int updateRole(SysRole role) {
// 修改角色信息
roleMapper.updateRole(role);
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
return insertRoleMenu(role);
}
/**
* 修改角色状态
*
* @param role 角色信息
*
* @return 结果
*/
@Override
public int updateRoleStatus(SysRole role) {
return roleMapper.updateRole(role);
}
/**
* 修改数据权限信息
*
* @param role 角色信息
*
* @return 结果
*/
@Override
@Transactional
public int authDataScope(SysRole role) {
// 修改角色信息
roleMapper.updateRole(role);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
// 新增角色和部门信息（数据权限）
return insertRoleDept(role);
}
/**
* 新增角色菜单信息
*
* @param role 角色对象
*/
public int insertRoleMenu(SysRole role) {
int rows = 1;
// 新增用户与角色管理
List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
for (Long menuId : role.getMenuIds()) {
SysRoleMenu rm = new SysRoleMenu();
rm.setRoleId(role.getRoleId());
rm.setMenuId(menuId);
list.add(rm);
}
if (list.size() > 0) {
rows = roleMenuMapper.batchRoleMenu(list);
}
return rows;
}
/**
* 新增角色部门信息(数据权限)
*
* @param role 角色对象
*/
public int insertRoleDept(SysRole role) {
int rows = 1;
// 新增角色与部门（数据权限）管理
List<SysRoleDept> list = new ArrayList<SysRoleDept>();
for (Long deptId : role.getDeptIds()) {
SysRoleDept rd = new SysRoleDept();
rd.setRoleId(role.getRoleId());
rd.setDeptId(deptId);
list.add(rd);
}
if (list.size() > 0) {
rows = roleDeptMapper.batchRoleDept(list);
}
return rows;
}
/**
* 通过角色ID删除角色
*
* @param roleId 角色ID
*
* @return 结果
*/
@Override
@Transactional
public int deleteRoleById(Long roleId) {
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenuByRoleId(roleId);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDeptByRoleId(roleId);
return roleMapper.deleteRoleById(roleId);
}
/**
* 批量删除角色信息
*
* @param roleIds 需要删除的角色ID
*
* @return 结果
*/
@Override
@Transactional
public int deleteRoleByIds(String token, Long[] roleIds) {
for (Long roleId : roleIds) {
checkRoleAllowed(new SysRole(roleId));
checkRoleDataScope(token, roleId);
SysRole role = selectRoleById(roleId);
if (countUserRoleByRoleId(roleId) > 0) {
throw new com.xiang.xservice.basic.exception.BusinessException(String.format("%1$s已分配,不能删除", role.getRoleName()));
}
}
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenu(roleIds);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDept(roleIds);
return roleMapper.deleteRoleByIds(roleIds);
}
/**
* 取消授权用户角色
*
* @param userRole 用户和角色关联信息
*
* @return 结果
*/
@Override
public int deleteAuthUser(SysUserRole userRole) {
return userRoleMapper.deleteUserRoleInfo(userRole);
}
/**
* 批量取消授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要取消授权的用户数据ID
*
* @return 结果
*/
@Override
public int deleteAuthUsers(Long roleId, Long[] userIds) {
return userRoleMapper.deleteUserRoleInfos(roleId, userIds);
}
/**
* 批量选择授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要授权的用户数据ID
*
* @return 结果
*/
@Override
public int insertAuthUsers(Long roleId, Long[] userIds) {
// 新增用户与角色管理
List<SysUserRole> list = new ArrayList<SysUserRole>();
for (Long userId : userIds) {
SysUserRole ur = new SysUserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
return userRoleMapper.batchUserRole(list);
}
}

92
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysUserOnlineServiceImpl.java Normal file
View File

@@ -0,0 +1,92 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysUserOnlineService;
import com.xiang.xs.service.entity.LoginUser;
import com.xiang.xs.service.entity.SysUserOnline;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.Objects;
/**
* 在线用户 服务层处理
*
* @author ruoyi
*/
@Service
public class SysUserOnlineServiceImpl implements ISysUserOnlineService {
/**
* 通过登录地址查询信息
*
* @param ipaddr 登录地址
* @param user 用户信息
*
* @return 在线用户信息
*/
@Override
public SysUserOnline selectOnlineByIpaddr(String ipaddr, LoginUser user) {
if (StringUtils.equals(ipaddr, user.getIpaddr())) {
return loginUserToUserOnline(user);
}
return null;
}
/**
* 通过用户名称查询信息
*
* @param userName 用户名称
* @param user 用户信息
*
* @return 在线用户信息
*/
@Override
public SysUserOnline selectOnlineByUserName(String userName, LoginUser user) {
if (StringUtils.equals(userName, user.getUsername())) {
return loginUserToUserOnline(user);
}
return null;
}
/**
* 通过登录地址/用户名称查询信息
*
* @param ipaddr 登录地址
* @param userName 用户名称
* @param user 用户信息
*
* @return 在线用户信息
*/
@Override
public SysUserOnline selectOnlineByInfo(String ipaddr, String userName, LoginUser user) {
if (StringUtils.equals(ipaddr, user.getIpaddr()) && StringUtils.equals(userName, user.getUsername())) {
return loginUserToUserOnline(user);
}
return null;
}
/**
* 设置在线用户信息
*
* @param user 用户信息
*
* @return 在线用户
*/
@Override
public SysUserOnline loginUserToUserOnline(LoginUser user) {
if (Objects.isNull(user) || Objects.isNull(user.getUser())) {
return null;
}
SysUserOnline sysUserOnline = new SysUserOnline();
sysUserOnline.setTokenId(user.getToken());
sysUserOnline.setUserName(user.getUsername());
sysUserOnline.setIpaddr(user.getIpaddr());
sysUserOnline.setLoginLocation(user.getLoginLocation());
sysUserOnline.setBrowser(user.getBrowser());
sysUserOnline.setOs(user.getOs());
sysUserOnline.setLoginTime(user.getLoginTime());
if (Objects.nonNull(user.getUser().getDept())) {
sysUserOnline.setDeptName(user.getUser().getDept().getDeptName());
}
return sysUserOnline;
}
}

452
xs-service/src/main/java/com/xiang/xs/service/biz/impl/SysUserServiceImpl.java Normal file
View File

@@ -0,0 +1,452 @@
package com.xiang.xs.service.biz.impl;
import com.xiang.xs.service.biz.ISysConfigService;
import com.xiang.xs.service.biz.ISysDeptService;
import com.xiang.xs.service.biz.ISysUserService;
import com.xiang.xs.service.contants.UserConstants;
import com.xiang.xs.service.entity.SysPost;
import com.xiang.xs.service.entity.SysRole;
import com.xiang.xs.service.entity.SysUser;
import com.xiang.xs.service.entity.SysUserPost;
import com.xiang.xs.service.entity.SysUserRole;
import com.xiang.xs.service.repository.mapper.SysPostMapper;
import com.xiang.xs.service.repository.mapper.SysRoleMapper;
import com.xiang.xs.service.repository.mapper.SysUserMapper;
import com.xiang.xs.service.repository.mapper.SysUserPostMapper;
import com.xiang.xs.service.repository.mapper.SysUserRoleMapper;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.logging.log4j.util.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import javax.validation.Validator;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 用户 业务层处理
*
* @author ruoyi
*/
@Service
public class SysUserServiceImpl implements ISysUserService {
private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
@Autowired
private SysUserMapper userMapper;
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private SysPostMapper postMapper;
@Autowired
private SysUserRoleMapper userRoleMapper;
@Autowired
private SysUserPostMapper userPostMapper;
@Autowired
private ISysConfigService configService;
@Autowired
private ISysDeptService deptService;
@Autowired
protected Validator validator;
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
@Override
public List<SysUser> selectUserList(SysUser user) {
return userMapper.selectUserList(user);
}
/**
* 根据条件分页查询已分配用户角色列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
@Override
public List<SysUser> selectAllocatedList(SysUser user) {
return userMapper.selectAllocatedList(user);
}
/**
* 根据条件分页查询未分配用户角色列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
@Override
public List<SysUser> selectUnallocatedList(SysUser user) {
return userMapper.selectUnallocatedList(user);
}
/**
* 通过用户名查询用户
*
* @param userName 用户名
*
* @return 用户对象信息
*/
@Override
public SysUser selectUserByUserName(String userName) {
return userMapper.selectUserByUserName(userName);
}
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
*
* @return 用户对象信息
*/
@Override
public SysUser selectUserById(Long userId) {
return userMapper.selectUserById(userId);
}
/**
* 查询用户所属角色组
*
* @param userName 用户名
*
* @return 结果
*/
@Override
public String selectUserRoleGroup(String userName) {
List<SysRole> list = roleMapper.selectRolesByUserName(userName);
if (CollectionUtils.isEmpty(list)) {
return Strings.EMPTY;
}
return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(","));
}
/**
* 查询用户所属岗位组
*
* @param userName 用户名
*
* @return 结果
*/
@Override
public String selectUserPostGroup(String userName) {
List<SysPost> list = postMapper.selectPostsByUserName(userName);
if (CollectionUtils.isEmpty(list)) {
return Strings.EMPTY;
}
return list.stream().map(SysPost::getPostName).collect(Collectors.joining(","));
}
/**
* 校验用户名称是否唯一
*
* @param user 用户信息
*
* @return 结果
*/
@Override
public boolean checkUserNameUnique(SysUser user) {
Long userId = Objects.isNull(user) ? -1L : user.getUserId();
SysUser info = userMapper.checkUserNameUnique(user.getUserName());
if (Objects.nonNull(info) && info.getUserId().longValue() != userId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验手机号码是否唯一
*
* @param user 用户信息
*
* @return
*/
@Override
public boolean checkPhoneUnique(SysUser user) {
Long userId = Objects.isNull(user.getUserId()) ? -1L : user.getUserId();
SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
if (Objects.nonNull(info) && info.getUserId().longValue() != userId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验email是否唯一
*
* @param user 用户信息
*
* @return
*/
@Override
public boolean checkEmailUnique(SysUser user) {
Long userId = Objects.isNull(user.getUserId()) ? -1L : user.getUserId();
SysUser info = userMapper.checkEmailUnique(user.getEmail());
if (Objects.nonNull(info) && info.getUserId().longValue() != userId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验用户是否允许操作
*
* @param user 用户信息
*/
@Override
public void checkUserAllowed(SysUser user) {
if (Objects.nonNull(user.getUserId()) && user.isAdmin()) {
throw new com.xiang.xservice.basic.exception.BusinessException("不允许操作超级管理员用户");
}
}
/**
* 校验用户是否有数据权限
*
* @param userId 用户id
*/
@Override
public void checkUserDataScope(Long userId) {
if (!SysUser.isAdmin(userId)) {
SysUser user = new SysUser();
user.setUserId(userId);
List<SysUser> users = selectUserList(user);
if (CollectionUtils.isEmpty(users)) {
throw new com.xiang.xservice.basic.exception.BusinessException("没有权限访问用户数据！");
}
}
}
/**
* 新增保存用户信息
*
* @param user 用户信息
*
* @return 结果
*/
@Override
@Transactional
public int insertUser(SysUser user) {
// 新增用户信息
int rows = userMapper.insertUser(user);
// 新增用户岗位关联
insertUserPost(user);
// 新增用户与角色管理
insertUserRole(user);
return rows;
}
/**
* 注册用户信息
*
* @param user 用户信息
*
* @return 结果
*/
@Override
public boolean registerUser(SysUser user) {
return userMapper.insertUser(user) > 0;
}
/**
* 修改保存用户信息
*
* @param user 用户信息
*
* @return 结果
*/
@Override
@Transactional
public int updateUser(SysUser user) {
Long userId = user.getUserId();
// 删除用户与角色关联
userRoleMapper.deleteUserRoleByUserId(userId);
// 新增用户与角色管理
insertUserRole(user);
// 删除用户与岗位关联
userPostMapper.deleteUserPostByUserId(userId);
// 新增用户与岗位管理
insertUserPost(user);
return userMapper.updateUser(user);
}
/**
* 用户授权角色
*
* @param userId 用户ID
* @param roleIds 角色组
*/
@Override
@Transactional
public void insertUserAuth(Long userId, Long[] roleIds) {
userRoleMapper.deleteUserRoleByUserId(userId);
insertUserRole(userId, roleIds);
}
/**
* 修改用户状态
*
* @param user 用户信息
*
* @return 结果
*/
@Override
public int updateUserStatus(SysUser user) {
return userMapper.updateUser(user);
}
/**
* 修改用户基本信息
*
* @param user 用户信息
*
* @return 结果
*/
@Override
public int updateUserProfile(SysUser user) {
return userMapper.updateUser(user);
}
/**
* 修改用户头像
*
* @param userId 用户ID
* @param avatar 头像地址
*
* @return 结果
*/
@Override
public boolean updateUserAvatar(Long userId, String avatar) {
return userMapper.updateUserAvatar(userId, avatar) > 0;
}
/**
* 重置用户密码
*
* @param user 用户信息
*
* @return 结果
*/
@Override
public int resetPwd(SysUser user) {
return userMapper.updateUser(user);
}
/**
* 重置用户密码
*
* @param userId 用户ID
* @param password 密码
*
* @return 结果
*/
@Override
public int resetUserPwd(Long userId, String password) {
return userMapper.resetUserPwd(userId, password);
}
/**
* 新增用户角色信息
*
* @param user 用户对象
*/
public void insertUserRole(SysUser user) {
this.insertUserRole(user.getUserId(), user.getRoleIds());
}
/**
* 新增用户岗位信息
*
* @param user 用户对象
*/
public void insertUserPost(SysUser user) {
Long[] posts = user.getPostIds();
if (ArrayUtils.isNotEmpty(posts)) {
// 新增用户与岗位管理
List<SysUserPost> list = new ArrayList<SysUserPost>(posts.length);
for (Long postId : posts) {
SysUserPost up = new SysUserPost();
up.setUserId(user.getUserId());
up.setPostId(postId);
list.add(up);
}
userPostMapper.batchUserPost(list);
}
}
/**
* 新增用户角色信息
*
* @param userId 用户ID
* @param roleIds 角色组
*/
public void insertUserRole(Long userId, Long[] roleIds) {
if (ArrayUtils.isNotEmpty(roleIds)) {
// 新增用户与角色管理
List<SysUserRole> list = new ArrayList<SysUserRole>(roleIds.length);
for (Long roleId : roleIds) {
SysUserRole ur = new SysUserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
userRoleMapper.batchUserRole(list);
}
}
/**
* 通过用户ID删除用户
*
* @param userId 用户ID
*
* @return 结果
*/
@Override
@Transactional
public int deleteUserById(Long userId) {
// 删除用户与角色关联
userRoleMapper.deleteUserRoleByUserId(userId);
// 删除用户与岗位表
userPostMapper.deleteUserPostByUserId(userId);
return userMapper.deleteUserById(userId);
}
/**
* 批量删除用户信息
*
* @param userIds 需要删除的用户ID
*
* @return 结果
*/
@Override
@Transactional
public int deleteUserByIds(Long[] userIds) {
for (Long userId : userIds) {
checkUserAllowed(new SysUser(userId));
checkUserDataScope(userId);
}
// 删除用户与角色关联
userRoleMapper.deleteUserRole(userIds);
// 删除用户与岗位关联
userPostMapper.deleteUserPost(userIds);
return userMapper.deleteUserByIds(userIds);
}
}

38
xs-service/src/main/java/com/xiang/xs/service/contants/CacheConstants.java Normal file
View File

@@ -0,0 +1,38 @@
package com.xiang.xs.service.contants;
public class CacheConstants {
/**
* 登录用户 redis key
*/
public static final String LOGIN_TOKEN_KEY = "login_tokens:";
/**
* 验证码 redis key
*/
public static final String CAPTCHA_CODE_KEY = "captcha_codes:";
/**
* 参数管理 cache key
*/
public static final String SYS_CONFIG_KEY = "sys_config:";
/**
* 字典管理 cache key
*/
public static final String SYS_DICT_KEY = "sys_dict:";
/**
* 防重提交 redis key
*/
public static final String REPEAT_SUBMIT_KEY = "repeat_submit:";
/**
* 限流 redis key
*/
public static final String RATE_LIMIT_KEY = "rate_limit:";
/**
* 登录账户密码错误次数 redis key
*/
public static final String PWD_ERR_CNT_KEY = "pwd_err_cnt:";
}

168
xs-service/src/main/java/com/xiang/xs/service/contants/Constants.java Normal file
View File

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

117
xs-service/src/main/java/com/xiang/xs/service/contants/GenConstants.java Normal file
View File

@@ -0,0 +1,117 @@
package com.xiang.xs.service.contants;
/**
* 代码生成通用常量
*
* @author ruoyi
*/
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";
}

94
xs-service/src/main/java/com/xiang/xs/service/contants/HttpStatus.java Normal file
View File

@@ -0,0 +1,94 @@
package com.xiang.xs.service.contants;
/**
* 返回状态码
*
* @author ruoyi
*/
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;
/**
* 系统警告消息
*/
public static final int WARN = 601;
}

50
xs-service/src/main/java/com/xiang/xs/service/contants/ScheduleConstants.java Normal file
View File

@@ -0,0 +1,50 @@
package com.xiang.xs.service.contants;
/**
* 任务调度通用常量
*
* @author ruoyi
*/
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;
}
}
}

81
xs-service/src/main/java/com/xiang/xs/service/contants/UserConstants.java Normal file
View File

@@ -0,0 +1,81 @@
package com.xiang.xs.service.contants;
/**
* 用户常量信息
*
* @author ruoyi
*/
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_NORMAL = "0";
/** 角色封禁状态 */
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 boolean UNIQUE = true;
public final static boolean NOT_UNIQUE = false;
/**
* 用户名长度限制
*/
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;
}

117
xs-service/src/main/java/com/xiang/xs/service/entity/BaseEntity.java Normal file
View File

@@ -0,0 +1,117 @@
package com.xiang.xs.service.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
* Entity基类
*
* @author ruoyi
*/
public class BaseEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 搜索值
*/
@JsonIgnore
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;
/**
* 请求参数
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
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;
}
}

178
xs-service/src/main/java/com/xiang/xs/service/entity/LoginUser.java Normal file
View File

@@ -0,0 +1,178 @@
package com.xiang.xs.service.entity;
import com.alibaba.fastjson2.annotation.JSONField;
import java.util.Collection;
import java.util.Set;
/**
* 登录用户身份权限
*
* @author ruoyi
*/
public class LoginUser {
private static final long serialVersionUID = 1L;
/**
* 用户ID
*/
private Long userId;
/**
* 部门ID
*/
private Long deptId;
/**
* 用户唯一标识
*/
private String token;
/**
* 登录时间
*/
private Long loginTime;
/**
* 过期时间
*/
private Long expireTime;
/**
* 登录IP地址
*/
private String ipaddr;
/**
* 登录地点
*/
private String loginLocation;
/**
* 浏览器类型
*/
private String browser;
/**
* 操作系统
*/
private String os;
/**
* 权限列表
*/
private Set<String> permissions;
/**
* 用户信息
*/
private SysUser user;
public LoginUser() {
}
public LoginUser(SysUser user, Set<String> permissions) {
this.user = user;
this.permissions = permissions;
}
public LoginUser(Long userId, Long deptId, SysUser user, Set<String> permissions) {
this.userId = userId;
this.deptId = deptId;
this.user = user;
this.permissions = permissions;
}
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public Long getDeptId() {
return deptId;
}
public void setDeptId(Long deptId) {
this.deptId = deptId;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public Long getLoginTime() {
return loginTime;
}
public void setLoginTime(Long loginTime) {
this.loginTime = loginTime;
}
public String getIpaddr() {
return ipaddr;
}
public void setIpaddr(String ipaddr) {
this.ipaddr = ipaddr;
}
public String getLoginLocation() {
return loginLocation;
}
public void setLoginLocation(String loginLocation) {
this.loginLocation = loginLocation;
}
public String getBrowser() {
return browser;
}
public void setBrowser(String browser) {
this.browser = browser;
}
public String getOs() {
return os;
}
public void setOs(String os) {
this.os = os;
}
public Long getExpireTime() {
return expireTime;
}
public void setExpireTime(Long expireTime) {
this.expireTime = expireTime;
}
public Set<String> getPermissions() {
return permissions;
}
public void setPermissions(Set<String> permissions) {
this.permissions = permissions;
}
public SysUser getUser() {
return user;
}
public void setUser(SysUser user) {
this.user = user;
}
public String getUsername()
{
return user.getUserName();
}
}

36
xs-service/src/main/java/com/xiang/xs/service/entity/SysCache.java Normal file
View File

@@ -0,0 +1,36 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 缓存信息
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysCache extends BaseEntity {
/**
* 缓存名称
*/
private String cacheName = "";
/**
* 缓存键名
*/
private String cacheKey = "";
/**
* 缓存内容
*/
private String cacheValue = "";
/**
* 备注
*/
private String remark = "";
}

43
xs-service/src/main/java/com/xiang/xs/service/entity/SysConfig.java Normal file
View File

@@ -0,0 +1,43 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 参数配置表 sys_config
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysConfig extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 参数主键
*/
private Long configId;
/**
* 参数名称
*/
private String configName;
/**
* 参数键名
*/
private String configKey;
/**
* 参数键值
*/
private String configValue;
/**
* 系统内置（Y是 N否）
*/
private String configType;
}

80
xs-service/src/main/java/com/xiang/xs/service/entity/SysDept.java Normal file
View File

@@ -0,0 +1,80 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.List;
/**
* 部门表 sys_dept
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysDept extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 部门ID
*/
private Long deptId;
/**
* 父部门ID
*/
private Long parentId;
/**
* 祖级列表
*/
private String ancestors;
/**
* 部门名称
*/
private String deptName;
/**
* 显示顺序
*/
private Integer orderNum;
/**
* 负责人
*/
private String leader;
/**
* 联系电话
*/
private String phone;
/**
* 邮箱
*/
private String email;
/**
* 部门状态:0正常,1停用
*/
private String status;
/**
* 删除标志（0代表存在 2代表删除）
*/
private String delFlag;
/**
* 父部门名称
*/
private String parentName;
/**
* 子部门
*/
private List<SysDept> children = new ArrayList<SysDept>();
}

63
xs-service/src/main/java/com/xiang/xs/service/entity/SysDictData.java Normal file
View File

@@ -0,0 +1,63 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 字典数据表 sys_dict_data
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysDictData extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 字典编码
*/
private Long dictCode;
/**
* 字典排序
*/
private Long dictSort;
/**
* 字典标签
*/
private String dictLabel;
/**
* 字典键值
*/
private String dictValue;
/**
* 字典类型
*/
private String dictType;
/**
* 样式属性（其他样式扩展）
*/
private String cssClass;
/**
* 表格字典样式
*/
private String listClass;
/**
* 是否默认（Y是 N否）
*/
private String isDefault;
/**
* 状态（0正常 1停用）
*/
private String status;
}

37
xs-service/src/main/java/com/xiang/xs/service/entity/SysDictType.java Normal file
View File

@@ -0,0 +1,37 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 字典类型表 sys_dict_type
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysDictType extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 字典主键
*/
private Long dictId;
/**
* 字典名称
*/
private String dictName;
/**
* 字典类型
*/
private String dictType;
/**
* 状态（0正常 1停用）
*/
private String status;
}

65
xs-service/src/main/java/com/xiang/xs/service/entity/SysLogininfor.java Normal file
View File

@@ -0,0 +1,65 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 系统访问记录表 sys_logininfor
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysLogininfor extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* ID
*/
private Long infoId;
/**
* 用户账号
*/
private String userName;
/**
* 登录状态 0成功 1失败
*/
private String status;
/**
* 登录IP地址
*/
private String ipaddr;
/**
* 登录地点
*/
private String loginLocation;
/**
* 浏览器类型
*/
private String browser;
/**
* 操作系统
*/
private String os;
/**
* 提示消息
*/
private String msg;
/**
* 访问时间
*/
private Date loginTime;
}

105
xs-service/src/main/java/com/xiang/xs/service/entity/SysMenu.java Normal file
View File

@@ -0,0 +1,105 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.List;
/**
* 菜单权限表 sys_menu
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysMenu extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 菜单ID
*/
private Long menuId;
/**
* 菜单名称
*/
private String menuName;
/**
* 父菜单名称
*/
private String parentName;
/**
* 父菜单ID
*/
private Long parentId;
/**
* 显示顺序
*/
private Integer orderNum;
/**
* 路由地址
*/
private String path;
/**
* 组件路径
*/
private String component;
/**
* 路由参数
*/
private String query;
/**
* 路由名称，默认和路由地址相同的驼峰格式（注意：因为vue3版本的router会删除名称相同路由，为避免名字的冲突，特殊情况可以自定义）
*/
private String routeName;
/**
* 是否为外链（0是 1否）
*/
private String isFrame;
/**
* 是否缓存（0缓存 1不缓存）
*/
private String isCache;
/**
* 类型（M目录 C菜单 F按钮）
*/
private String menuType;
/**
* 显示状态（0显示 1隐藏）
*/
private String visible;
/**
* 菜单状态（0正常 1停用）
*/
private String status;
/**
* 权限字符串
*/
private String perms;
/**
* 菜单图标
*/
private String icon;
/**
* 子菜单
*/
private List<SysMenu> children = new ArrayList<SysMenu>();
}

44
xs-service/src/main/java/com/xiang/xs/service/entity/SysNotice.java Normal file
View File

@@ -0,0 +1,44 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 通知公告表 sys_notice
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysNotice extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 公告ID
*/
private Long noticeId;
/**
* 公告标题
*/
private String noticeTitle;
/**
* 公告类型（1通知 2公告）
*/
private String noticeType;
/**
* 公告内容
*/
private String noticeContent;
/**
* 公告状态（0正常 1关闭）
*/
private String status;
}

110
xs-service/src/main/java/com/xiang/xs/service/entity/SysOperLog.java Normal file
View File

@@ -0,0 +1,110 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 操作日志记录表 oper_log
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysOperLog extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 日志主键
*/
private Long operId;
/**
* 操作模块
*/
private String title;
/**
* 业务类型（0其它 1新增 2修改 3删除）
*/
private Integer businessType;
/**
* 业务类型数组
*/
private Integer[] businessTypes;
/**
* 请求方法
*/
private String method;
/**
* 请求方式
*/
private String requestMethod;
/**
* 操作类别（0其它 1后台用户 2手机端用户）
*/
private Integer operatorType;
/**
* 操作人员
*/
private String operName;
/**
* 部门名称
*/
private String deptName;
/**
* 请求url
*/
private String operUrl;
/**
* 操作地址
*/
private String operIp;
/**
* 操作地点
*/
private String operLocation;
/**
* 请求参数
*/
private String operParam;
/**
* 返回参数
*/
private String jsonResult;
/**
* 操作状态（0正常 1异常）
*/
private Integer status;
/**
* 错误消息
*/
private String errorMsg;
/**
* 操作时间
*/
private Date operTime;
/**
* 消耗时间
*/
private Long costTime;
}

47
xs-service/src/main/java/com/xiang/xs/service/entity/SysPost.java Normal file
View File

@@ -0,0 +1,47 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 岗位表 sys_post
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysPost extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 岗位序号
*/
private Long postId;
/**
* 岗位编码
*/
private String postCode;
/**
* 岗位名称
*/
private String postName;
/**
* 岗位排序
*/
private Integer postSort;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 用户是否存在此岗位标识 默认不存在
*/
private boolean flag = false;
}

97
xs-service/src/main/java/com/xiang/xs/service/entity/SysRole.java Normal file
View File

@@ -0,0 +1,97 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Set;
/**
* 角色表 sys_role
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysRole extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 角色ID
*/
private Long roleId;
/**
* 角色名称
*/
private String roleName;
/**
* 角色权限
*/
private String roleKey;
/**
* 角色排序
*/
private Integer roleSort;
/**
* 数据范围（1：所有数据权限；2：自定义数据权限；3：本部门数据权限；4：本部门及以下数据权限；5：仅本人数据权限）
*/
private String dataScope;
/**
* 菜单树选择项是否关联显示（ 0：父子不互相关联显示 1：父子互相关联显示）
*/
private boolean menuCheckStrictly;
/**
* 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示 ）
*/
private boolean deptCheckStrictly;
/**
* 角色状态（0正常 1停用）
*/
private String status;
/**
* 删除标志（0代表存在 2代表删除）
*/
private String delFlag;
/**
* 用户是否存在此角色标识 默认不存在
*/
private boolean flag = false;
/**
* 菜单组
*/
private Long[] menuIds;
/**
* 部门组（数据权限）
*/
private Long[] deptIds;
/**
* 角色菜单权限
*/
private Set<String> permissions;
public boolean isAdmin() {
return isAdmin(this.roleId);
}
public static boolean isAdmin(Long roleId) {
return roleId != null && 1L == roleId;
}
public SysRole(Long roleId) {
this.roleId = roleId;
}
}

25
xs-service/src/main/java/com/xiang/xs/service/entity/SysRoleDept.java Normal file
View File

@@ -0,0 +1,25 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 角色和部门关联 sys_role_dept
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysRoleDept extends BaseEntity {
/**
* 角色ID
*/
private Long roleId;
/**
* 部门ID
*/
private Long deptId;
}

25
xs-service/src/main/java/com/xiang/xs/service/entity/SysRoleMenu.java Normal file
View File

@@ -0,0 +1,25 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 角色和菜单关联 sys_role_menu
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysRoleMenu extends BaseEntity{
/**
* 角色ID
*/
private Long roleId;
/**
* 菜单ID
*/
private Long menuId;
}

128
xs-service/src/main/java/com/xiang/xs/service/entity/SysUser.java Normal file
View File

@@ -0,0 +1,128 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
import java.util.List;
/**
* 用户对象 sys_user
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysUser extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 用户ID
*/
private Long userId;
/**
* 部门ID
*/
private Long deptId;
/**
* 用户账号
*/
private String userName;
/**
* 用户昵称
*/
private String nickName;
/**
* 用户邮箱
*/
private String email;
/**
* 手机号码
*/
private String phonenumber;
/**
* 用户性别
*/
private String sex;
/**
* 用户头像
*/
private String avatar;
/**
* 密码
*/
private String password;
/**
* 账号状态（0正常 1停用）
*/
private String status;
/**
* 删除标志（0代表存在 2代表删除）
*/
private String delFlag;
/**
* 最后登录IP
*/
private String loginIp;
/**
* 最后登录时间
*/
private Date loginDate;
/**
* 密码最后更新时间
*/
private Date pwdUpdateDate;
/**
* 部门对象
*/
private SysDept dept;
/**
* 角色对象
*/
private List<SysRole> roles;
/**
* 角色组
*/
private Long[] roleIds;
/**
* 岗位组
*/
private Long[] postIds;
/**
* 角色ID
*/
private Long roleId;
public boolean isAdmin() {
return isAdmin(this.userId);
}
public static boolean isAdmin(Long userId) {
return userId != null && 1L == userId;
}
public SysUser(Long userId) {
this.userId = userId;
}
}

55
xs-service/src/main/java/com/xiang/xs/service/entity/SysUserOnline.java Normal file
View File

@@ -0,0 +1,55 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 当前在线会话
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysUserOnline extends BaseEntity {
/**
* 会话编号
*/
private String tokenId;
/**
* 部门名称
*/
private String deptName;
/**
* 用户名称
*/
private String userName;
/**
* 登录IP地址
*/
private String ipaddr;
/**
* 登录地址
*/
private String loginLocation;
/**
* 浏览器类型
*/
private String browser;
/**
* 操作系统
*/
private String os;
/**
* 登录时间
*/
private Long loginTime;
}

25
xs-service/src/main/java/com/xiang/xs/service/entity/SysUserPost.java Normal file
View File

@@ -0,0 +1,25 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 用户和岗位关联 sys_user_post
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysUserPost extends BaseEntity {
/**
* 用户ID
*/
private Long userId;
/**
* 岗位ID
*/
private Long postId;
}

25
xs-service/src/main/java/com/xiang/xs/service/entity/SysUserRole.java Normal file
View File

@@ -0,0 +1,25 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 用户和角色关联 sys_user_role
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysUserRole extends BaseEntity {
/**
* 用户ID
*/
private Long userId;
/**
* 角色ID
*/
private Long roleId;
}

46
xs-service/src/main/java/com/xiang/xs/service/entity/TreeEntity.java Normal file
View File

@@ -0,0 +1,46 @@
package com.xiang.xs.service.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.List;
/**
* Tree基类
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TreeEntity extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 父菜单名称
*/
private String parentName;
/**
* 父菜单ID
*/
private Long parentId;
/**
* 显示顺序
*/
private Integer orderNum;
/**
* 祖级列表
*/
private String ancestors;
/**
* 子部门
*/
private List<?> children = new ArrayList<>();
}

62
xs-service/src/main/java/com/xiang/xs/service/entity/TreeSelect.java Normal file
View File

@@ -0,0 +1,62 @@
package com.xiang.xs.service.entity;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.xiang.xs.service.contants.UserConstants;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.io.Serializable;
import java.util.List;
import java.util.stream.Collectors;
/**
* Treeselect树结构实体类
*
* @author xiang
*/
@Data
@AllArgsConstructor
public class TreeSelect extends BaseEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 节点ID
*/
private Long id;
/**
* 节点名称
*/
private String label;
/**
* 节点禁用
*/
private boolean disabled = false;
/**
* 子节点
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private List<TreeSelect> children;
public TreeSelect() {
}
public TreeSelect(SysDept dept) {
this.id = dept.getDeptId();
this.label = dept.getDeptName();
this.disabled = StringUtils.equals(UserConstants.DEPT_DISABLE, dept.getStatus());
this.children = dept.getChildren().stream().map(TreeSelect::new).collect(Collectors.toList());
}
public TreeSelect(SysMenu menu) {
this.id = menu.getMenuId();
this.label = menu.getMenuName();
this.children = menu.getChildren().stream().map(TreeSelect::new).collect(Collectors.toList());
}
}

60
xs-service/src/main/java/com/xiang/xs/service/entity/vo/MetaVo.java Normal file
View File

@@ -0,0 +1,60 @@
package com.xiang.xs.service.entity.vo;
import com.xiang.xservice.basic.utils.MyStringUtils;
import lombok.Data;
/**
* 路由显示信息
*
* @author xiang
*/
@Data
public class MetaVo {
/**
* 设置该路由在侧边栏和面包屑中展示的名字
*/
private String title;
/**
* 设置该路由的图标，对应路径src/assets/icons/svg
*/
private String icon;
/**
* 设置为true，则不会被 <keep-alive>缓存
*/
private boolean noCache;
/**
* 内链地址（http(s)://开头）
*/
private String link;
public MetaVo(String title, String icon) {
this.title = title;
this.icon = icon;
}
public MetaVo(String title, String icon, boolean noCache) {
this.title = title;
this.icon = icon;
this.noCache = noCache;
}
public MetaVo(String title, String icon, String link) {
this.title = title;
this.icon = icon;
this.link = link;
}
public MetaVo(String title, String icon, boolean noCache, String link) {
this.title = title;
this.icon = icon;
this.noCache = noCache;
if (MyStringUtils.isHttp(link)) {
this.link = link;
}
}
}

16
xs-service/src/main/java/com/xiang/xs/service/entity/vo/RoleTreeVo.java Normal file
View File

@@ -0,0 +1,16 @@
package com.xiang.xs.service.entity.vo;
import com.xiang.xs.service.entity.TreeSelect;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RoleTreeVo {
private List<Long> checkedKeys;
private List<TreeSelect> menus;
}

62
xs-service/src/main/java/com/xiang/xs/service/entity/vo/RouterVo.java Normal file
View File

@@ -0,0 +1,62 @@
package com.xiang.xs.service.entity.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* 路由配置信息
*
* @author xiang
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RouterVo {
/**
* 路由名字
*/
private String name;
/**
* 路由地址
*/
private String path;
/**
* 是否隐藏路由，当设置 true 的时候该路由不会再侧边栏出现
*/
private boolean hidden;
/**
* 重定向地址，当设置 noRedirect 的时候该路由在面包屑导航中不可被点击
*/
private String redirect;
/**
* 组件地址
*/
private String component;
/**
* 路由参数：如 {"id": 1, "name": "ry"}
*/
private String query;
/**
* 当你一个路由下面的 children 声明的路由大于1个时，自动会变成嵌套的模式--如组件页面
*/
private Boolean alwaysShow;
/**
* 子路由
*/
private List<RouterVo> children;
/**
* 其他元素
*/
private MetaVo meta;
}

88
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysConfigMapper.java Normal file
View File

@@ -0,0 +1,88 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysConfig;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 参数配置 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysConfigMapper {
/**
* 查询参数配置信息
*
* @param config 参数配置信息
*
* @return 参数配置信息
*/
SysConfig selectConfig(SysConfig config);
/**
* 通过ID查询配置
*
* @param configId 参数ID
*
* @return 参数配置信息
*/
SysConfig selectConfigById(Long configId);
/**
* 查询参数配置列表
*
* @param config 参数配置信息
*
* @return 参数配置集合
*/
List<SysConfig> selectConfigList(SysConfig config);
/**
* 根据键名查询参数配置信息
*
* @param configKey 参数键名
*
* @return 参数配置信息
*/
SysConfig checkConfigKeyUnique(String configKey);
/**
* 新增参数配置
*
* @param config 参数配置信息
*
* @return 结果
*/
int insertConfig(SysConfig config);
/**
* 修改参数配置
*
* @param config 参数配置信息
*
* @return 结果
*/
int updateConfig(SysConfig config);
/**
* 删除参数配置
*
* @param configId 参数ID
*
* @return 结果
*/
int deleteConfigById(Long configId);
/**
* 批量删除参数信息
*
* @param configIds 需要删除的参数ID
*
* @return 结果
*/
int deleteConfigByIds(Long[] configIds);
}

134
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysDeptMapper.java Normal file
View File

@@ -0,0 +1,134 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysDept;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 部门管理 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysDeptMapper {
/**
* 查询部门管理数据
*
* @param dept 部门信息
*
* @return 部门信息集合
*/
List<SysDept> selectDeptList(SysDept dept);
/**
* 根据角色ID查询部门树信息
*
* @param roleId 角色ID
* @param deptCheckStrictly 部门树选择项是否关联显示
*
* @return 选中部门列表
*/
List<Long> selectDeptListByRoleId(@Param("roleId") Long roleId, @Param("deptCheckStrictly") boolean deptCheckStrictly);
/**
* 根据部门ID查询信息
*
* @param deptId 部门ID
*
* @return 部门信息
*/
SysDept selectDeptById(Long deptId);
/**
* 根据ID查询所有子部门
*
* @param deptId 部门ID
*
* @return 部门列表
*/
List<SysDept> selectChildrenDeptById(Long deptId);
/**
* 根据ID查询所有子部门（正常状态）
*
* @param deptId 部门ID
*
* @return 子部门数
*/
int selectNormalChildrenDeptById(Long deptId);
/**
* 是否存在子节点
*
* @param deptId 部门ID
*
* @return 结果
*/
int hasChildByDeptId(Long deptId);
/**
* 查询部门是否存在用户
*
* @param deptId 部门ID
*
* @return 结果
*/
int checkDeptExistUser(Long deptId);
/**
* 校验部门名称是否唯一
*
* @param deptName 部门名称
* @param parentId 父部门ID
*
* @return 结果
*/
SysDept checkDeptNameUnique(@Param("deptName") String deptName, @Param("parentId") Long parentId);
/**
* 新增部门信息
*
* @param dept 部门信息
*
* @return 结果
*/
int insertDept(SysDept dept);
/**
* 修改部门信息
*
* @param dept 部门信息
*
* @return 结果
*/
int updateDept(SysDept dept);
/**
* 修改所在部门正常状态
*
* @param deptIds 部门ID组
*/
void updateDeptStatusNormal(Long[] deptIds);
/**
* 修改子元素关系
*
* @param depts 子元素
*
* @return 结果
*/
int updateDeptChildren(@Param("depts") List<SysDept> depts);
/**
* 删除部门管理信息
*
* @param deptId 部门ID
*
* @return 结果
*/
int deleteDeptById(Long deptId);
}

109
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysDictDataMapper.java Normal file
View File

@@ -0,0 +1,109 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysDictData;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 字典表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysDictDataMapper {
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
*
* @return 字典数据集合信息
*/
List<SysDictData> selectDictDataList(SysDictData dictData);
/**
* 根据字典类型查询字典数据
*
* @param dictType 字典类型
*
* @return 字典数据集合信息
*/
List<SysDictData> selectDictDataByType(String dictType);
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType 字典类型
* @param dictValue 字典键值
*
* @return 字典标签
*/
String selectDictLabel(@Param("dictType") String dictType, @Param("dictValue") String dictValue);
/**
* 根据字典数据ID查询信息
*
* @param dictCode 字典数据ID
*
* @return 字典数据
*/
SysDictData selectDictDataById(Long dictCode);
/**
* 查询字典数据
*
* @param dictType 字典类型
*
* @return 字典数据
*/
int countDictDataByType(String dictType);
/**
* 通过字典ID删除字典数据信息
*
* @param dictCode 字典数据ID
*
* @return 结果
*/
int deleteDictDataById(Long dictCode);
/**
* 批量删除字典数据信息
*
* @param dictCodes 需要删除的字典数据ID
*
* @return 结果
*/
int deleteDictDataByIds(Long[] dictCodes);
/**
* 新增字典数据信息
*
* @param dictData 字典数据信息
*
* @return 结果
*/
int insertDictData(SysDictData dictData);
/**
* 修改字典数据信息
*
* @param dictData 字典数据信息
*
* @return 结果
*/
int updateDictData(SysDictData dictData);
/**
* 同步修改字典类型
*
* @param oldDictType 旧字典类型
* @param newDictType 新旧字典类型
*
* @return 结果
*/
int updateDictDataType(@Param("oldDictType") String oldDictType, @Param("newDictType") String newDictType);
}

95
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysDictTypeMapper.java Normal file
View File

@@ -0,0 +1,95 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysDictType;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 字典表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysDictTypeMapper {
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
*
* @return 字典类型集合信息
*/
List<SysDictType> selectDictTypeList(SysDictType dictType);
/**
* 根据所有字典类型
*
* @return 字典类型集合信息
*/
List<SysDictType> selectDictTypeAll();
/**
* 根据字典类型ID查询信息
*
* @param dictId 字典类型ID
*
* @return 字典类型
*/
SysDictType selectDictTypeById(Long dictId);
/**
* 根据字典类型查询信息
*
* @param dictType 字典类型
*
* @return 字典类型
*/
SysDictType selectDictTypeByType(String dictType);
/**
* 通过字典ID删除字典信息
*
* @param dictId 字典ID
*
* @return 结果
*/
int deleteDictTypeById(Long dictId);
/**
* 批量删除字典类型信息
*
* @param dictIds 需要删除的字典ID
*
* @return 结果
*/
int deleteDictTypeByIds(Long[] dictIds);
/**
* 新增字典类型信息
*
* @param dictType 字典类型信息
*
* @return 结果
*/
int insertDictType(SysDictType dictType);
/**
* 修改字典类型信息
*
* @param dictType 字典类型信息
*
* @return 结果
*/
int updateDictType(SysDictType dictType);
/**
* 校验字典类型称是否唯一
*
* @param dictType 字典类型
*
* @return 结果
*/
SysDictType checkDictTypeUnique(String dictType);
}

48
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysLogininforMapper.java Normal file
View File

@@ -0,0 +1,48 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysLogininfor;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 系统访问日志情况信息 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysLogininforMapper {
/**
* 新增系统登录日志
*
* @param logininfor 访问日志对象
*/
void insertLogininfor(SysLogininfor logininfor);
/**
* 查询系统登录日志集合
*
* @param logininfor 访问日志对象
*
* @return 登录记录集合
*/
List<SysLogininfor> selectLogininforList(SysLogininfor logininfor);
/**
* 批量删除系统登录日志
*
* @param infoIds 需要删除的登录日志ID
*
* @return 结果
*/
int deleteLogininforByIds(Long[] infoIds);
/**
* 清空系统登录日志
*
* @return 结果
*/
int cleanLogininfor();
}

141
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysMenuMapper.java Normal file
View File

@@ -0,0 +1,141 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysMenu;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 菜单表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysMenuMapper {
/**
* 查询系统菜单列表
*
* @param menu 菜单信息
*
* @return 菜单列表
*/
List<SysMenu> selectMenuList(SysMenu menu);
/**
* 根据用户所有权限
*
* @return 权限列表
*/
List<String> selectMenuPerms();
/**
* 根据用户查询系统菜单列表
*
* @param menu 菜单信息
*
* @return 菜单列表
*/
List<SysMenu> selectMenuListByUserId(SysMenu menu);
/**
* 根据角色ID查询权限
*
* @param roleId 角色ID
*
* @return 权限列表
*/
List<String> selectMenuPermsByRoleId(Long roleId);
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
*
* @return 权限列表
*/
List<String> selectMenuPermsByUserId(Long userId);
/**
* 根据用户ID查询菜单
*
* @return 菜单列表
*/
List<SysMenu> selectMenuTreeAll();
/**
* 根据用户ID查询菜单
*
* @param userId 用户ID
*
* @return 菜单列表
*/
List<SysMenu> selectMenuTreeByUserId(Long userId);
/**
* 根据角色ID查询菜单树信息
*
* @param roleId 角色ID
* @param menuCheckStrictly 菜单树选择项是否关联显示
*
* @return 选中菜单列表
*/
List<Long> selectMenuListByRoleId(@Param("roleId") Long roleId, @Param("menuCheckStrictly") boolean menuCheckStrictly);
/**
* 根据菜单ID查询信息
*
* @param menuId 菜单ID
*
* @return 菜单信息
*/
SysMenu selectMenuById(Long menuId);
/**
* 是否存在菜单子节点
*
* @param menuId 菜单ID
*
* @return 结果
*/
int hasChildByMenuId(Long menuId);
/**
* 新增菜单信息
*
* @param menu 菜单信息
*
* @return 结果
*/
int insertMenu(SysMenu menu);
/**
* 修改菜单信息
*
* @param menu 菜单信息
*
* @return 结果
*/
int updateMenu(SysMenu menu);
/**
* 删除菜单管理信息
*
* @param menuId 菜单ID
*
* @return 结果
*/
int deleteMenuById(Long menuId);
/**
* 校验菜单名称是否唯一
*
* @param menuName 菜单名称
* @param parentId 父菜单ID
*
* @return 结果
*/
SysMenu checkMenuNameUnique(@Param("menuName") String menuName, @Param("parentId") Long parentId);
}

70
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysNoticeMapper.java Normal file
View File

@@ -0,0 +1,70 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysNotice;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 通知公告表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysNoticeMapper {
/**
* 查询公告信息
*
* @param noticeId 公告ID
*
* @return 公告信息
*/
SysNotice selectNoticeById(Long noticeId);
/**
* 查询公告列表
*
* @param notice 公告信息
*
* @return 公告集合
*/
List<SysNotice> selectNoticeList(SysNotice notice);
/**
* 新增公告
*
* @param notice 公告信息
*
* @return 结果
*/
int insertNotice(SysNotice notice);
/**
* 修改公告
*
* @param notice 公告信息
*
* @return 结果
*/
int updateNotice(SysNotice notice);
/**
* 批量删除公告
*
* @param noticeId 公告ID
*
* @return 结果
*/
int deleteNoticeById(Long noticeId);
/**
* 批量删除公告信息
*
* @param noticeIds 需要删除的公告ID
*
* @return 结果
*/
int deleteNoticeByIds(Long[] noticeIds);
}

55
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysOperLogMapper.java Normal file
View File

@@ -0,0 +1,55 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysOperLog;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 操作日志 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysOperLogMapper {
/**
* 新增操作日志
*
* @param operLog 操作日志对象
*/
void insertOperlog(SysOperLog operLog);
/**
* 查询系统操作日志集合
*
* @param operLog 操作日志对象
*
* @return 操作日志集合
*/
List<SysOperLog> selectOperLogList(SysOperLog operLog);
/**
* 批量删除系统操作日志
*
* @param operIds 需要删除的操作日志ID
*
* @return 结果
*/
int deleteOperLogByIds(Long[] operIds);
/**
* 查询操作日志详细
*
* @param operId 操作ID
*
* @return 操作日志对象
*/
SysOperLog selectOperLogById(Long operId);
/**
* 清空操作日志
*/
void cleanOperLog();
}

113
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysPostMapper.java Normal file
View File

@@ -0,0 +1,113 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysPost;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 岗位信息 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysPostMapper {
/**
* 查询岗位数据集合
*
* @param post 岗位信息
*
* @return 岗位数据集合
*/
List<SysPost> selectPostList(SysPost post);
/**
* 查询所有岗位
*
* @return 岗位列表
*/
List<SysPost> selectPostAll();
/**
* 通过岗位ID查询岗位信息
*
* @param postId 岗位ID
*
* @return 角色对象信息
*/
SysPost selectPostById(Long postId);
/**
* 根据用户ID获取岗位选择框列表
*
* @param userId 用户ID
*
* @return 选中岗位ID列表
*/
List<Long> selectPostListByUserId(Long userId);
/**
* 查询用户所属岗位组
*
* @param userName 用户名
*
* @return 结果
*/
List<SysPost> selectPostsByUserName(String userName);
/**
* 删除岗位信息
*
* @param postId 岗位ID
*
* @return 结果
*/
int deletePostById(Long postId);
/**
* 批量删除岗位信息
*
* @param postIds 需要删除的岗位ID
*
* @return 结果
*/
int deletePostByIds(Long[] postIds);
/**
* 修改岗位信息
*
* @param post 岗位信息
*
* @return 结果
*/
int updatePost(SysPost post);
/**
* 新增岗位信息
*
* @param post 岗位信息
*
* @return 结果
*/
int insertPost(SysPost post);
/**
* 校验岗位名称
*
* @param postName 岗位名称
*
* @return 结果
*/
SysPost checkPostNameUnique(String postName);
/**
* 校验岗位编码
*
* @param postCode 岗位编码
*
* @return 结果
*/
SysPost checkPostCodeUnique(String postCode);
}

52
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysRoleDeptMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysRoleDept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 角色与部门关联表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysRoleDeptMapper {
/**
* 通过角色ID删除角色和部门关联
*
* @param roleId 角色ID
*
* @return 结果
*/
int deleteRoleDeptByRoleId(Long roleId);
/**
* 批量删除角色部门关联信息
*
* @param ids 需要删除的数据ID
*
* @return 结果
*/
int deleteRoleDept(Long[] ids);
/**
* 查询部门使用数量
*
* @param deptId 部门ID
*
* @return 结果
*/
int selectCountRoleDeptByDeptId(Long deptId);
/**
* 批量新增角色部门信息
*
* @param roleDeptList 角色部门列表
*
* @return 结果
*/
int batchRoleDept(List<SysRoleDept> roleDeptList);
}

122
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysRoleMapper.java Normal file
View File

@@ -0,0 +1,122 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysRole;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 角色表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysRoleMapper {
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
*
* @return 角色数据集合信息
*/
List<SysRole> selectRoleList(SysRole role);
/**
* 根据用户ID查询角色
*
* @param userId 用户ID
*
* @return 角色列表
*/
List<SysRole> selectRolePermissionByUserId(Long userId);
/**
* 查询所有角色
*
* @return 角色列表
*/
List<SysRole> selectRoleAll();
/**
* 根据用户ID获取角色选择框列表
*
* @param userId 用户ID
*
* @return 选中角色ID列表
*/
List<Long> selectRoleListByUserId(Long userId);
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
*
* @return 角色对象信息
*/
SysRole selectRoleById(Long roleId);
/**
* 根据用户ID查询角色
*
* @param userName 用户名
*
* @return 角色列表
*/
List<SysRole> selectRolesByUserName(String userName);
/**
* 校验角色名称是否唯一
*
* @param roleName 角色名称
*
* @return 角色信息
*/
SysRole checkRoleNameUnique(String roleName);
/**
* 校验角色权限是否唯一
*
* @param roleKey 角色权限
*
* @return 角色信息
*/
SysRole checkRoleKeyUnique(String roleKey);
/**
* 修改角色信息
*
* @param role 角色信息
*
* @return 结果
*/
int updateRole(SysRole role);
/**
* 新增角色信息
*
* @param role 角色信息
*
* @return 结果
*/
int insertRole(SysRole role);
/**
* 通过角色ID删除角色
*
* @param roleId 角色ID
*
* @return 结果
*/
int deleteRoleById(Long roleId);
/**
* 批量删除角色信息
*
* @param roleIds 需要删除的角色ID
*
* @return 结果
*/
int deleteRoleByIds(Long[] roleIds);
}

52
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysRoleMenuMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysRoleMenu;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 角色与菜单关联表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysRoleMenuMapper {
/**
* 查询菜单使用数量
*
* @param menuId 菜单ID
*
* @return 结果
*/
int checkMenuExistRole(Long menuId);
/**
* 通过角色ID删除角色和菜单关联
*
* @param roleId 角色ID
*
* @return 结果
*/
int deleteRoleMenuByRoleId(Long roleId);
/**
* 批量删除角色菜单关联信息
*
* @param ids 需要删除的数据ID
*
* @return 结果
*/
int deleteRoleMenu(Long[] ids);
/**
* 批量新增角色菜单信息
*
* @param roleMenuList 角色菜单列表
*
* @return 结果
*/
int batchRoleMenu(List<SysRoleMenu> roleMenuList);
}

145
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysUserMapper.java Normal file
View File

@@ -0,0 +1,145 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 用户表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysUserMapper {
/**
* 根据条件分页查询用户列表
*
* @param sysUser 用户信息
*
* @return 用户信息集合信息
*/
List<SysUser> selectUserList(SysUser sysUser);
/**
* 根据条件分页查询已配用户角色列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
List<SysUser> selectAllocatedList(SysUser user);
/**
* 根据条件分页查询未分配用户角色列表
*
* @param user 用户信息
*
* @return 用户信息集合信息
*/
List<SysUser> selectUnallocatedList(SysUser user);
/**
* 通过用户名查询用户
*
* @param userName 用户名
*
* @return 用户对象信息
*/
SysUser selectUserByUserName(String userName);
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
*
* @return 用户对象信息
*/
SysUser selectUserById(Long userId);
/**
* 新增用户信息
*
* @param user 用户信息
*
* @return 结果
*/
int insertUser(SysUser user);
/**
* 修改用户信息
*
* @param user 用户信息
*
* @return 结果
*/
int updateUser(SysUser user);
/**
* 修改用户头像
*
* @param userId 用户ID
* @param avatar 头像地址
*
* @return 结果
*/
int updateUserAvatar(@Param("userId") Long userId, @Param("avatar") String avatar);
/**
* 重置用户密码
*
* @param userId 用户ID
* @param password 密码
*
* @return 结果
*/
int resetUserPwd(@Param("userId") Long userId, @Param("password") String password);
/**
* 通过用户ID删除用户
*
* @param userId 用户ID
*
* @return 结果
*/
int deleteUserById(Long userId);
/**
* 批量删除用户信息
*
* @param userIds 需要删除的用户ID
*
* @return 结果
*/
int deleteUserByIds(Long[] userIds);
/**
* 校验用户名称是否唯一
*
* @param userName 用户名称
*
* @return 结果
*/
SysUser checkUserNameUnique(String userName);
/**
* 校验手机号码是否唯一
*
* @param phonenumber 手机号码
*
* @return 结果
*/
SysUser checkPhoneUnique(String phonenumber);
/**
* 校验email是否唯一
*
* @param email 用户邮箱
*
* @return 结果
*/
SysUser checkEmailUnique(String email);
}

52
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysUserPostMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysUserPost;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 用户与岗位关联表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysUserPostMapper {
/**
* 通过用户ID删除用户和岗位关联
*
* @param userId 用户ID
*
* @return 结果
*/
int deleteUserPostByUserId(Long userId);
/**
* 通过岗位ID查询岗位使用数量
*
* @param postId 岗位ID
*
* @return 结果
*/
int countUserPostById(Long postId);
/**
* 批量删除用户和岗位关联
*
* @param ids 需要删除的数据ID
*
* @return 结果
*/
int deleteUserPost(Long[] ids);
/**
* 批量新增用户岗位信息
*
* @param userPostList 用户岗位列表
*
* @return 结果
*/
int batchUserPost(List<SysUserPost> userPostList);
}

72
xs-service/src/main/java/com/xiang/xs/service/repository/mapper/SysUserRoleMapper.java Normal file
View File

@@ -0,0 +1,72 @@
package com.xiang.xs.service.repository.mapper;
import com.xiang.xs.service.entity.SysUserRole;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 用户与角色关联表 数据层
*
* @author xiang
*/
@Mapper
@Repository
public interface SysUserRoleMapper {
/**
* 通过用户ID删除用户和角色关联
*
* @param userId 用户ID
*
* @return 结果
*/
int deleteUserRoleByUserId(Long userId);
/**
* 批量删除用户和角色关联
*
* @param ids 需要删除的数据ID
*
* @return 结果
*/
int deleteUserRole(Long[] ids);
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
*
* @return 结果
*/
int countUserRoleByRoleId(Long roleId);
/**
* 批量新增用户角色信息
*
* @param userRoleList 用户角色列表
*
* @return 结果
*/
int batchUserRole(List<SysUserRole> userRoleList);
/**
* 删除用户和角色关联信息
*
* @param userRole 用户和角色关联信息
*
* @return 结果
*/
int deleteUserRoleInfo(SysUserRole userRole);
/**
* 批量取消授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要删除的用户数据ID
*
* @return 结果
*/
int deleteUserRoleInfos(@Param("roleId") Long roleId, @Param("userIds") Long[] userIds);
}

95
xs-service/src/main/java/com/xiang/xs/service/utils/CharsetKit.java Normal file
View File

@@ -0,0 +1,95 @@
package com.xiang.xs.service.utils;
import org.apache.commons.lang3.StringUtils;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* 字符集工具类
*
* @author ruoyi
*/
public class CharsetKit {
/**
* ISO-8859-1
*/
public static final String ISO_8859_1 = "ISO-8859-1";
/**
* UTF-8
*/
public static final String UTF_8 = "UTF-8";
/**
* GBK
*/
public static final String GBK = "GBK";
/**
* ISO-8859-1
*/
public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
/**
* UTF-8
*/
public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
/**
* GBK
*/
public static final Charset CHARSET_GBK = Charset.forName(GBK);
/**
* 转换为Charset对象
*
* @param charset 字符集，为空则返回默认字符集
*
* @return Charset
*/
public static Charset charset(String charset) {
return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
}
/**
* 转换字符串的字符集编码
*
* @param source 字符串
* @param srcCharset 源字符集，默认ISO-8859-1
* @param destCharset 目标字符集，默认UTF-8
*
* @return 转换后的字符集
*/
public static String convert(String source, String srcCharset, String destCharset) {
return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
}
/**
* 转换字符串的字符集编码
*
* @param source 字符串
* @param srcCharset 源字符集，默认ISO-8859-1
* @param destCharset 目标字符集，默认UTF-8
*
* @return 转换后的字符集
*/
public static String convert(String source, Charset srcCharset, Charset destCharset) {
if (null == srcCharset) {
srcCharset = StandardCharsets.ISO_8859_1;
}
if (null == destCharset) {
destCharset = StandardCharsets.UTF_8;
}
if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) {
return source;
}
return new String(source.getBytes(srcCharset), destCharset);
}
/**
* @return 系统字符集编码
*/
public static String systemCharset() {
return Charset.defaultCharset().name();
}
}

909
xs-service/src/main/java/com/xiang/xs/service/utils/Convert.java Normal file
View File

@@ -0,0 +1,909 @@
package com.xiang.xs.service.utils;
import org.apache.commons.lang3.StringUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.NumberFormat;
import java.util.Set;
/**
* 类型转换器
*
* @author ruoyi
*/
public class Convert {
/**
* 转换为字符串<br>
* 如果给定的值为null，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static String toStr(Object value, String defaultValue) {
if (null == value) {
return defaultValue;
}
if (value instanceof String) {
return (String) value;
}
return value.toString();
}
/**
* 转换为字符串<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static String toStr(Object value) {
return toStr(value, null);
}
/**
* 转换为字符<br>
* 如果给定的值为null，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Character toChar(Object value, Character defaultValue) {
if (null == value) {
return defaultValue;
}
if (value instanceof Character) {
return (Character) value;
}
final String valueStr = toStr(value, null);
return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
}
/**
* 转换为字符<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Character toChar(Object value) {
return toChar(value, null);
}
/**
* 转换为byte<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Byte toByte(Object value, Byte defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Byte) {
return (Byte) value;
}
if (value instanceof Number) {
return ((Number) value).byteValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return Byte.parseByte(valueStr);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为byte<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Byte toByte(Object value) {
return toByte(value, null);
}
/**
* 转换为Short<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Short toShort(Object value, Short defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Short) {
return (Short) value;
}
if (value instanceof Number) {
return ((Number) value).shortValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return Short.parseShort(valueStr.trim());
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为Short<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Short toShort(Object value) {
return toShort(value, null);
}
/**
* 转换为Number<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Number toNumber(Object value, Number defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Number) {
return (Number) value;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return NumberFormat.getInstance().parse(valueStr);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为Number<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Number toNumber(Object value) {
return toNumber(value, null);
}
/**
* 转换为int<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Integer toInt(Object value, Integer defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Integer) {
return (Integer) value;
}
if (value instanceof Number) {
return ((Number) value).intValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return Integer.parseInt(valueStr.trim());
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为int<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Integer toInt(Object value) {
return toInt(value, null);
}
/**
* 转换为Integer数组<br>
*
* @param str 被转换的值
*
* @return 结果
*/
public static Integer[] toIntArray(String str) {
return toIntArray(",", str);
}
/**
* 转换为Long数组<br>
*
* @param str 被转换的值
*
* @return 结果
*/
public static Long[] toLongArray(String str) {
return toLongArray(",", str);
}
/**
* 转换为Integer数组<br>
*
* @param split 分隔符
* @param split 被转换的值
*
* @return 结果
*/
public static Integer[] toIntArray(String split, String str) {
if (StringUtils.isEmpty(str)) {
return new Integer[]{};
}
String[] arr = str.split(split);
final Integer[] ints = new Integer[arr.length];
for (int i = 0; i < arr.length; i++) {
final Integer v = toInt(arr[i], 0);
ints[i] = v;
}
return ints;
}
/**
* 转换为Long数组<br>
*
* @param split 分隔符
* @param str 被转换的值
*
* @return 结果
*/
public static Long[] toLongArray(String split, String str) {
if (StringUtils.isEmpty(str)) {
return new Long[]{};
}
String[] arr = str.split(split);
final Long[] longs = new Long[arr.length];
for (int i = 0; i < arr.length; i++) {
final Long v = toLong(arr[i], null);
longs[i] = v;
}
return longs;
}
/**
* 转换为String数组<br>
*
* @param str 被转换的值
*
* @return 结果
*/
public static String[] toStrArray(String str) {
if (StringUtils.isEmpty(str)) {
return new String[]{};
}
return toStrArray(",", str);
}
/**
* 转换为String数组<br>
*
* @param split 分隔符
* @param split 被转换的值
*
* @return 结果
*/
public static String[] toStrArray(String split, String str) {
return str.split(split);
}
/**
* 转换为long<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Long toLong(Object value, Long defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Long) {
return (Long) value;
}
if (value instanceof Number) {
return ((Number) value).longValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
// 支持科学计数法
return new BigDecimal(valueStr.trim()).longValue();
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为long<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Long toLong(Object value) {
return toLong(value, null);
}
/**
* 转换为double<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Double toDouble(Object value, Double defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Double) {
return (Double) value;
}
if (value instanceof Number) {
return ((Number) value).doubleValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
// 支持科学计数法
return new BigDecimal(valueStr.trim()).doubleValue();
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为double<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Double toDouble(Object value) {
return toDouble(value, null);
}
/**
* 转换为Float<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Float toFloat(Object value, Float defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Float) {
return (Float) value;
}
if (value instanceof Number) {
return ((Number) value).floatValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return Float.parseFloat(valueStr.trim());
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为Float<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Float toFloat(Object value) {
return toFloat(value, null);
}
/**
* 转换为boolean<br>
* String支持的值为：true、false、yes、ok、no、1、0、是、否, 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static Boolean toBool(Object value, Boolean defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof Boolean) {
return (Boolean) value;
}
String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
valueStr = valueStr.trim().toLowerCase();
switch (valueStr) {
case "true":
case "yes":
case "ok":
case "1":
case "是":
return true;
case "false":
case "no":
case "0":
case "否":
return false;
default:
return defaultValue;
}
}
/**
* 转换为boolean<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static Boolean toBool(Object value) {
return toBool(value, null);
}
/**
* 转换为Enum对象<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
*
* @param clazz Enum的Class
* @param value 值
* @param defaultValue 默认值
*
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) {
if (value == null) {
return defaultValue;
}
if (clazz.isAssignableFrom(value.getClass())) {
@SuppressWarnings("unchecked")
E myE = (E) value;
return myE;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return Enum.valueOf(clazz, valueStr);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为Enum对象<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
*
* @param clazz Enum的Class
* @param value 值
*
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) {
return toEnum(clazz, value, null);
}
/**
* 转换为BigInteger<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof BigInteger) {
return (BigInteger) value;
}
if (value instanceof Long) {
return BigInteger.valueOf((Long) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return new BigInteger(valueStr);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为BigInteger<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static BigInteger toBigInteger(Object value) {
return toBigInteger(value, null);
}
/**
* 转换为BigDecimal<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
*
* @return 结果
*/
public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {
if (value == null) {
return defaultValue;
}
if (value instanceof BigDecimal) {
return (BigDecimal) value;
}
if (value instanceof Long) {
return new BigDecimal((Long) value);
}
if (value instanceof Double) {
return BigDecimal.valueOf((Double) value);
}
if (value instanceof Integer) {
return new BigDecimal((Integer) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr)) {
return defaultValue;
}
try {
return new BigDecimal(valueStr);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为BigDecimal<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
*
* @return 结果
*/
public static BigDecimal toBigDecimal(Object value) {
return toBigDecimal(value, null);
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
*
* @return 字符串
*/
public static String utf8Str(Object obj) {
return str(obj, CharsetKit.CHARSET_UTF_8);
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @param charsetName 字符集
*
* @return 字符串
*/
public static String str(Object obj, String charsetName) {
return str(obj, Charset.forName(charsetName));
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @param charset 字符集
*
* @return 字符串
*/
public static String str(Object obj, Charset charset) {
if (null == obj) {
return null;
}
if (obj instanceof String) {
return (String) obj;
} else if (obj instanceof byte[] || obj instanceof Byte[]) {
if (obj instanceof byte[]) {
return str((byte[]) obj, charset);
} else {
Byte[] bytes = (Byte[]) obj;
int length = bytes.length;
byte[] dest = new byte[length];
for (int i = 0; i < length; i++) {
dest[i] = bytes[i];
}
return str(dest, charset);
}
} else if (obj instanceof ByteBuffer) {
return str((ByteBuffer) obj, charset);
}
return obj.toString();
}
/**
* 将byte数组转为字符串
*
* @param bytes byte数组
* @param charset 字符集
*
* @return 字符串
*/
public static String str(byte[] bytes, String charset) {
return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
}
/**
* 解码字节码
*
* @param data 字符串
* @param charset 字符集，如果此字段为空，则解码的结果取决于平台
*
* @return 解码后的字符串
*/
public static String str(byte[] data, Charset charset) {
if (data == null) {
return null;
}
if (null == charset) {
return new String(data);
}
return new String(data, charset);
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集，如果为空使用当前系统字符集
*
* @return 字符串
*/
public static String str(ByteBuffer data, String charset) {
if (data == null) {
return null;
}
return str(data, Charset.forName(charset));
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集，如果为空使用当前系统字符集
*
* @return 字符串
*/
public static String str(ByteBuffer data, Charset charset) {
if (null == charset) {
charset = Charset.defaultCharset();
}
return charset.decode(data).toString();
}
// ----------------------------------------------------------------------- 全角半角转换
/**
* 半角转全角
*
* @param input String.
*
* @return 全角字符串.
*/
public static String toSBC(String input) {
return toSBC(input, null);
}
/**
* 半角转全角
*
* @param input String
* @param notConvertSet 不替换的字符集合
*
* @return 全角字符串.
*/
public static String toSBC(String input, Set<Character> notConvertSet) {
char[] c = input.toCharArray();
for (int i = 0; i < c.length; i++) {
if (null != notConvertSet && notConvertSet.contains(c[i])) {
// 跳过不替换的字符
continue;
}
if (c[i] == ' ') {
c[i] = '\u3000';
} else if (c[i] < '\177') {
c[i] = (char) (c[i] + 65248);
}
}
return new String(c);
}
/**
* 全角转半角
*
* @param input String.
*
* @return 半角字符串
*/
public static String toDBC(String input) {
return toDBC(input, null);
}
/**
* 替换全角为半角
*
* @param text 文本
* @param notConvertSet 不替换的字符集合
*
* @return 替换后的字符
*/
public static String toDBC(String text, Set<Character> notConvertSet) {
char[] c = text.toCharArray();
for (int i = 0; i < c.length; i++) {
if (null != notConvertSet && notConvertSet.contains(c[i])) {
// 跳过不替换的字符
continue;
}
if (c[i] == '\u3000') {
c[i] = ' ';
} else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
c[i] = (char) (c[i] - 65248);
}
}
return new String(c);
}
/**
* 数字金额大写转换 先写个完整的然后将如零拾替换成零
*
* @param n 数字
*
* @return 中文大写数字
*/
public static String digitUppercase(double n) {
String[] fraction = {"角", "分"};
String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
String[][] unit = {{"元", "万", "亿"}, {"", "拾", "佰", "仟"}};
String head = n < 0 ? "负" : "";
n = Math.abs(n);
String s = "";
for (int i = 0; i < fraction.length; i++) {
// 优化double计算精度丢失问题
BigDecimal nNum = new BigDecimal(n);
BigDecimal decimal = new BigDecimal(10);
BigDecimal scale = nNum.multiply(decimal).setScale(2, RoundingMode.HALF_EVEN);
double d = scale.doubleValue();
s += (digit[(int) (Math.floor(d * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
}
if (s.length() < 1) {
s = "整";
}
int integerPart = (int) Math.floor(n);
for (int i = 0; i < unit[0].length && integerPart > 0; i++) {
String p = "";
for (int j = 0; j < unit[1].length && n > 0; j++) {
p = digit[integerPart % 10] + unit[1][j] + p;
integerPart = integerPart / 10;
}
s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
}
return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
}
}

215
xs-service/src/main/java/com/xiang/xs/service/utils/DictUtils.java Normal file
View File

@@ -0,0 +1,215 @@
package com.xiang.xs.service.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.xiang.xmc.service.cache.service.IRedisService;
import com.xiang.xs.service.contants.CacheConstants;
import com.xiang.xs.service.entity.SysDictData;
import lombok.RequiredArgsConstructor;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.List;
/**
* 字典工具类
*
* @author ruoyi
*/
@Component
@RequiredArgsConstructor
public class DictUtils {
private final IRedisService redisCache;
/**
* 分隔符
*/
public static final String SEPARATOR = ",";
/**
* 设置字典缓存
*
* @param key 参数键
* @param dictDatas 字典数据列表
*/
public void setDictCache(String key, List<SysDictData> dictDatas) {
redisCache.set(getCacheKey(key), JSON.toJSONString(dictDatas));
}
/**
* 获取字典缓存
*
* @param key 参数键
*
* @return dictDatas 字典数据列表
*/
public List<SysDictData> getDictCache(String key) {
String value = (String) redisCache.get(getCacheKey(key));
return JSON.parseArray(value, SysDictData.class);
}
/**
* 根据字典类型和字典值获取字典标签
*
* @param dictType 字典类型
* @param dictValue 字典值
*
* @return 字典标签
*/
public String getDictLabel(String dictType, String dictValue) {
if (StringUtils.isEmpty(dictValue)) {
return StringUtils.EMPTY;
}
return getDictLabel(dictType, dictValue, SEPARATOR);
}
/**
* 根据字典类型和字典标签获取字典值
*
* @param dictType 字典类型
* @param dictLabel 字典标签
*
* @return 字典值
*/
public String getDictValue(String dictType, String dictLabel) {
if (StringUtils.isEmpty(dictLabel)) {
return StringUtils.EMPTY;
}
return getDictValue(dictType, dictLabel, SEPARATOR);
}
/**
* 根据字典类型和字典值获取字典标签
*
* @param dictType 字典类型
* @param dictValue 字典值
* @param separator 分隔符
*
* @return 字典标签
*/
public String getDictLabel(String dictType, String dictValue, String separator) {
StringBuilder propertyString = new StringBuilder();
List<SysDictData> datas = getDictCache(dictType);
if (CollectionUtils.isEmpty(datas)) {
return StringUtils.EMPTY;
}
if (StringUtils.containsAny(separator, dictValue)) {
for (SysDictData dict : datas) {
for (String value : dictValue.split(separator)) {
if (value.equals(dict.getDictValue())) {
propertyString.append(dict.getDictLabel()).append(separator);
break;
}
}
}
} else {
for (SysDictData dict : datas) {
if (dictValue.equals(dict.getDictValue())) {
return dict.getDictLabel();
}
}
}
return StringUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 根据字典类型和字典标签获取字典值
*
* @param dictType 字典类型
* @param dictLabel 字典标签
* @param separator 分隔符
*
* @return 字典值
*/
public String getDictValue(String dictType, String dictLabel, String separator) {
StringBuilder propertyString = new StringBuilder();
List<SysDictData> datas = getDictCache(dictType);
if (CollectionUtils.isEmpty(datas)) {
return StringUtils.EMPTY;
}
if (StringUtils.containsAny(separator, dictLabel)) {
for (SysDictData dict : datas) {
for (String label : dictLabel.split(separator)) {
if (label.equals(dict.getDictLabel())) {
propertyString.append(dict.getDictValue()).append(separator);
break;
}
}
}
} else {
for (SysDictData dict : datas) {
if (dictLabel.equals(dict.getDictLabel())) {
return dict.getDictValue();
}
}
}
return StringUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 根据字典类型获取字典所有值
*
* @param dictType 字典类型
*
* @return 字典值
*/
public String getDictValues(String dictType) {
StringBuilder propertyString = new StringBuilder();
List<SysDictData> datas = getDictCache(dictType);
if (CollectionUtils.isEmpty(datas)) {
return StringUtils.EMPTY;
}
for (SysDictData dict : datas) {
propertyString.append(dict.getDictValue()).append(SEPARATOR);
}
return StringUtils.stripEnd(propertyString.toString(), SEPARATOR);
}
/**
* 根据字典类型获取字典所有标签
*
* @param dictType 字典类型
*
* @return 字典值
*/
public String getDictLabels(String dictType) {
StringBuilder propertyString = new StringBuilder();
List<SysDictData> datas = getDictCache(dictType);
if (CollectionUtils.isEmpty(datas)) {
return StringUtils.EMPTY;
}
for (SysDictData dict : datas) {
propertyString.append(dict.getDictLabel()).append(SEPARATOR);
}
return StringUtils.stripEnd(propertyString.toString(), SEPARATOR);
}
/**
* 删除指定字典缓存
*
* @param key 字典键
*/
public void removeDictCache(String key) {
redisCache.delKey(getCacheKey(key));
}
/**
* 清空字典缓存
*/
public void clearDictCache() {
Collection<String> keys = redisCache.keys(CacheConstants.SYS_DICT_KEY + "*");
redisCache.deleteObject(keys);
}
/**
* 设置cache key
*
* @param configKey 参数键
*
* @return 缓存键key
*/
public static String getCacheKey(String configKey) {
return CacheConstants.SYS_DICT_KEY + configKey;
}
}

113
xs-service/src/main/resources/mapper/SysConfigMapper.xml Normal file
View File

@@ -0,0 +1,113 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiang.xs.service.repository.mapper.SysConfigMapper">
<resultMap type="com.xiang.xs.service.entity.SysConfig" id="SysConfigResult">
<id property="configId" column="config_id" />
<result property="configName" column="config_name" />
<result property="configKey" column="config_key" />
<result property="configValue" column="config_value" />
<result property="configType" column="config_type" />
</resultMap>
<sql id="selectConfigVo">
select config_id, config_name, config_key, config_value, config_type, create_by, create_time, update_by, update_time, remark
from sys_config
</sql>
<!-- 查询条件 -->
<sql id="sqlwhereSearch">
<where>
<if test="configId !=null">
and config_id = #{configId}
</if>
<if test="configKey !=null and configKey != ''">
and config_key = #{configKey}
</if>
</where>
</sql>
<select id="selectConfig" parameterType="com.xiang.xs.service.entity.SysConfig" resultMap="SysConfigResult">
<include refid="selectConfigVo"/>
<include refid="sqlwhereSearch"/>
</select>
<select id="selectConfigList" parameterType="com.xiang.xs.service.entity.SysConfig" resultMap="SysConfigResult">
<include refid="selectConfigVo"/>
<where>
<if test="configName != null and configName != ''">
AND config_name like concat('%', #{configName}, '%')
</if>
<if test="configType != null and configType != ''">
AND config_type = #{configType}
</if>
<if test="configKey != null and configKey != ''">
AND config_key like concat('%', #{configKey}, '%')
</if>
<if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
and date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d')
</if>
<if test="params.endTime != null and params.endTime != ''"><!-- 结束时间检索 -->
and date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d')
</if>
</where>
</select>
<select id="selectConfigById" parameterType="Long" resultMap="SysConfigResult">
<include refid="selectConfigVo"/>
where config_id = #{configId}
</select>
<select id="checkConfigKeyUnique" parameterType="String" resultMap="SysConfigResult">
<include refid="selectConfigVo"/>
where config_key = #{configKey} limit 1
</select>
<insert id="insertConfig" parameterType="com.xiang.xs.service.entity.SysConfig">
insert into sys_config (
<if test="configName != null and configName != '' ">config_name,</if>
<if test="configKey != null and configKey != '' ">config_key,</if>
<if test="configValue != null and configValue != '' ">config_value,</if>
<if test="configType != null and configType != '' ">config_type,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
<if test="remark != null and remark != ''">remark,</if>
create_time
)values(
<if test="configName != null and configName != ''">#{configName},</if>
<if test="configKey != null and configKey != ''">#{configKey},</if>
<if test="configValue != null and configValue != ''">#{configValue},</if>
<if test="configType != null and configType != ''">#{configType},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
<if test="remark != null and remark != ''">#{remark},</if>
sysdate()
)
</insert>
<update id="updateConfig" parameterType="com.xiang.xs.service.entity.SysConfig">
update sys_config
<set>
<if test="configName != null and configName != ''">config_name = #{configName},</if>
<if test="configKey != null and configKey != ''">config_key = #{configKey},</if>
<if test="configValue != null and configValue != ''">config_value = #{configValue},</if>
<if test="configType != null and configType != ''">config_type = #{configType},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
<if test="remark != null">remark = #{remark},</if>
update_time = sysdate()
</set>
where config_id = #{configId}
</update>
<delete id="deleteConfigById" parameterType="Long">
delete from sys_config where config_id = #{configId}
</delete>
<delete id="deleteConfigByIds" parameterType="Long">
delete from sys_config where config_id in
<foreach item="configId" collection="array" open="(" separator="," close=")">
#{configId}
</foreach>
</delete>
</mapper>

155
xs-service/src/main/resources/mapper/SysDeptMapper.xml Normal file
View File

@@ -0,0 +1,155 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiang.xs.service.repository.mapper.SysDeptMapper">
<resultMap type="com.xiang.xs.service.entity.SysDept" id="SysDeptResult">
<id property="deptId" column="dept_id" />
<result property="parentId" column="parent_id" />
<result property="ancestors" column="ancestors" />
<result property="deptName" column="dept_name" />
<result property="orderNum" column="order_num" />
<result property="leader" column="leader" />
<result property="phone" column="phone" />
<result property="email" column="email" />
<result property="status" column="status" />
<result property="delFlag" column="del_flag" />
<result property="parentName" column="parent_name" />
</resultMap>
<sql id="selectDeptVo">
select d.dept_id, d.parent_id, d.ancestors, d.dept_name, d.order_num, d.leader, d.phone, d.email, d.status, d.del_flag, d.create_by, d.create_time
from sys_dept d
</sql>
<select id="selectDeptList" parameterType="com.xiang.xs.service.entity.SysDept" resultMap="SysDeptResult">
<include refid="selectDeptVo"/>
where d.del_flag = '0'
<if test="deptId != null and deptId != 0">
AND dept_id = #{deptId}
</if>
<if test="parentId != null and parentId != 0">
AND parent_id = #{parentId}
</if>
<if test="deptName != null and deptName != ''">
AND dept_name like concat('%', #{deptName}, '%')
</if>
<if test="status != null and status != ''">
AND status = #{status}
</if>
<!-- 数据范围过滤 -->
${params.dataScope}
order by d.parent_id, d.order_num
</select>
<select id="selectDeptListByRoleId" resultType="Long">
select d.dept_id
from sys_dept d
left join sys_role_dept rd on d.dept_id = rd.dept_id
where rd.role_id = #{roleId}
<if test="deptCheckStrictly">
and d.dept_id not in (select d.parent_id from sys_dept d inner join sys_role_dept rd on d.dept_id = rd.dept_id and rd.role_id = #{roleId})
</if>
order by d.parent_id, d.order_num
</select>
<select id="selectDeptById" parameterType="Long" resultMap="SysDeptResult">
select d.dept_id, d.parent_id, d.ancestors, d.dept_name, d.order_num, d.leader, d.phone, d.email, d.status,
(select dept_name from sys_dept where dept_id = d.parent_id) parent_name
from sys_dept d
where d.dept_id = #{deptId}
</select>
<select id="checkDeptExistUser" parameterType="Long" resultType="int">
select count(1) from sys_user where dept_id = #{deptId} and del_flag = '0'
</select>
<select id="hasChildByDeptId" parameterType="Long" resultType="int">
select count(1) from sys_dept
where del_flag = '0' and parent_id = #{deptId} limit 1
</select>
<select id="selectChildrenDeptById" parameterType="Long" resultMap="SysDeptResult">
select * from sys_dept where find_in_set(#{deptId}, ancestors)
</select>
<select id="selectNormalChildrenDeptById" parameterType="Long" resultType="int">
select count(*) from sys_dept where status = 0 and del_flag = '0' and find_in_set(#{deptId}, ancestors)
</select>
<select id="checkDeptNameUnique" resultMap="SysDeptResult">
<include refid="selectDeptVo"/>
where dept_name=#{deptName} and parent_id = #{parentId} and del_flag = '0' limit 1
</select>
<insert id="insertDept" parameterType="com.xiang.xs.service.entity.SysDept">
insert into sys_dept(
<if test="deptId != null and deptId != 0">dept_id,</if>
<if test="parentId != null and parentId != 0">parent_id,</if>
<if test="deptName != null and deptName != ''">dept_name,</if>
<if test="ancestors != null and ancestors != ''">ancestors,</if>
<if test="orderNum != null">order_num,</if>
<if test="leader != null and leader != ''">leader,</if>
<if test="phone != null and phone != ''">phone,</if>
<if test="email != null and email != ''">email,</if>
<if test="status != null">status,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
create_time
)values(
<if test="deptId != null and deptId != 0">#{deptId},</if>
<if test="parentId != null and parentId != 0">#{parentId},</if>
<if test="deptName != null and deptName != ''">#{deptName},</if>
<if test="ancestors != null and ancestors != ''">#{ancestors},</if>
<if test="orderNum != null">#{orderNum},</if>
<if test="leader != null and leader != ''">#{leader},</if>
<if test="phone != null and phone != ''">#{phone},</if>
<if test="email != null and email != ''">#{email},</if>
<if test="status != null">#{status},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
sysdate()
)
</insert>
<update id="updateDept" parameterType="com.xiang.xs.service.entity.SysDept">
update sys_dept
<set>
<if test="parentId != null and parentId != 0">parent_id = #{parentId},</if>
<if test="deptName != null and deptName != ''">dept_name = #{deptName},</if>
<if test="ancestors != null and ancestors != ''">ancestors = #{ancestors},</if>
<if test="orderNum != null">order_num = #{orderNum},</if>
<if test="leader != null">leader = #{leader},</if>
<if test="phone != null">phone = #{phone},</if>
<if test="email != null">email = #{email},</if>
<if test="status != null and status != ''">status = #{status},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
update_time = sysdate()
</set>
where dept_id = #{deptId}
</update>
<update id="updateDeptChildren" parameterType="java.util.List">
update sys_dept set ancestors =
<foreach collection="depts" item="item" index="index"
separator=" " open="case dept_id" close="end">
when #{item.deptId} then #{item.ancestors}
</foreach>
where dept_id in
<foreach collection="depts" item="item" index="index"
separator="," open="(" close=")">
#{item.deptId}
</foreach>
</update>
<update id="updateDeptStatusNormal" parameterType="Long">
update sys_dept set status = '0' where dept_id in
<foreach collection="array" item="deptId" open="(" separator="," close=")">
#{deptId}
</foreach>
</update>
<delete id="deleteDeptById" parameterType="Long">
update sys_dept set del_flag = '2' where dept_id = #{deptId}
</delete>
</mapper>

120
xs-service/src/main/resources/mapper/SysDictDataMapper.xml Normal file
View File

@@ -0,0 +1,120 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiang.xs.service.repository.mapper.SysDictDataMapper">
<resultMap type="com.xiang.xs.service.entity.SysDictData" id="SysDictDataResult">
<id property="dictCode" column="dict_code" />
<result property="dictSort" column="dict_sort" />
<result property="dictLabel" column="dict_label" />
<result property="dictValue" column="dict_value" />
<result property="dictType" column="dict_type" />
<result property="cssClass" column="css_class" />
<result property="listClass" column="list_class" />
<result property="isDefault" column="is_default" />
<result property="status" column="status" />
</resultMap>
<sql id="selectDictDataVo">
select dict_code, dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, create_time, remark
from sys_dict_data
</sql>
<select id="selectDictDataList" parameterType="com.xiang.xs.service.entity.SysDictData" resultMap="SysDictDataResult">
<include refid="selectDictDataVo"/>
<where>
<if test="dictType != null and dictType != ''">
AND dict_type = #{dictType}
</if>
<if test="dictLabel != null and dictLabel != ''">
AND dict_label like concat('%', #{dictLabel}, '%')
</if>
<if test="status != null and status != ''">
AND status = #{status}
</if>
</where>
order by dict_sort asc
</select>
<select id="selectDictDataByType" parameterType="String" resultMap="SysDictDataResult">
<include refid="selectDictDataVo"/>
where status = '0' and dict_type = #{dictType} order by dict_sort asc
</select>
<select id="selectDictLabel" resultType="String">
select dict_label from sys_dict_data
where dict_type = #{dictType} and dict_value = #{dictValue}
</select>
<select id="selectDictDataById" parameterType="Long" resultMap="SysDictDataResult">
<include refid="selectDictDataVo"/>
where dict_code = #{dictCode}
</select>
<select id="countDictDataByType" resultType="Integer">
select count(1) from sys_dict_data where dict_type=#{dictType}
</select>
<delete id="deleteDictDataById" parameterType="Long">
delete from sys_dict_data where dict_code = #{dictCode}
</delete>
<delete id="deleteDictDataByIds" parameterType="Long">
delete from sys_dict_data where dict_code in
<foreach collection="array" item="dictCode" open="(" separator="," close=")">
#{dictCode}
</foreach>
</delete>
<update id="updateDictData" parameterType="com.xiang.xs.service.entity.SysDictData">
update sys_dict_data
<set>
<if test="dictSort != null">dict_sort = #{dictSort},</if>
<if test="dictLabel != null and dictLabel != ''">dict_label = #{dictLabel},</if>
<if test="dictValue != null and dictValue != ''">dict_value = #{dictValue},</if>
<if test="dictType != null and dictType != ''">dict_type = #{dictType},</if>
<if test="cssClass != null">css_class = #{cssClass},</if>
<if test="listClass != null">list_class = #{listClass},</if>
<if test="isDefault != null and isDefault != ''">is_default = #{isDefault},</if>
<if test="status != null">status = #{status},</if>
<if test="remark != null">remark = #{remark},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
update_time = sysdate()
</set>
where dict_code = #{dictCode}
</update>
<update id="updateDictDataType" parameterType="String">
update sys_dict_data set dict_type = #{newDictType} where dict_type = #{oldDictType}
</update>
<insert id="insertDictData" parameterType="com.xiang.xs.service.entity.SysDictData">
insert into sys_dict_data(
<if test="dictSort != null">dict_sort,</if>
<if test="dictLabel != null and dictLabel != ''">dict_label,</if>
<if test="dictValue != null and dictValue != ''">dict_value,</if>
<if test="dictType != null and dictType != ''">dict_type,</if>
<if test="cssClass != null and cssClass != ''">css_class,</if>
<if test="listClass != null and listClass != ''">list_class,</if>
<if test="isDefault != null and isDefault != ''">is_default,</if>
<if test="status != null">status,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
create_time
)values(
<if test="dictSort != null">#{dictSort},</if>
<if test="dictLabel != null and dictLabel != ''">#{dictLabel},</if>
<if test="dictValue != null and dictValue != ''">#{dictValue},</if>
<if test="dictType != null and dictType != ''">#{dictType},</if>
<if test="cssClass != null and cssClass != ''">#{cssClass},</if>
<if test="listClass != null and listClass != ''">#{listClass},</if>
<if test="isDefault != null and isDefault != ''">#{isDefault},</if>
<if test="status != null">#{status},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
sysdate()
)
</insert>
</mapper>

101
xs-service/src/main/resources/mapper/SysDictTypeMapper.xml Normal file
View File

@@ -0,0 +1,101 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiang.xs.service.repository.mapper.SysDictTypeMapper">
<resultMap type="com.xiang.xs.service.entity.SysDictType" id="SysDictTypeResult">
<id property="dictId" column="dict_id" />
<result property="dictName" column="dict_name" />
<result property="dictType" column="dict_type" />
<result property="status" column="status" />
</resultMap>
<sql id="selectDictTypeVo">
select dict_id, dict_name, dict_type, status, create_by, create_time, remark
from sys_dict_type
</sql>
<select id="selectDictTypeList" parameterType="com.xiang.xs.service.entity.SysDictType" resultMap="SysDictTypeResult">
<include refid="selectDictTypeVo"/>
<where>
<if test="dictName != null and dictName != ''">
AND dict_name like concat('%', #{dictName}, '%')
</if>
<if test="status != null and status != ''">
AND status = #{status}
</if>
<if test="dictType != null and dictType != ''">
AND dict_type like concat('%', #{dictType}, '%')
</if>
<if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
and date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d')
</if>
<if test="params.endTime != null and params.endTime != ''"><!-- 结束时间检索 -->
and date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d')
</if>
</where>
</select>
<select id="selectDictTypeAll" resultMap="SysDictTypeResult">
<include refid="selectDictTypeVo"/>
</select>
<select id="selectDictTypeById" parameterType="Long" resultMap="SysDictTypeResult">
<include refid="selectDictTypeVo"/>
where dict_id = #{dictId}
</select>
<select id="selectDictTypeByType" parameterType="String" resultMap="SysDictTypeResult">
<include refid="selectDictTypeVo"/>
where dict_type = #{dictType}
</select>
<select id="checkDictTypeUnique" parameterType="String" resultMap="SysDictTypeResult">
<include refid="selectDictTypeVo"/>
where dict_type = #{dictType} limit 1
</select>
<delete id="deleteDictTypeById" parameterType="Long">
delete from sys_dict_type where dict_id = #{dictId}
</delete>
<delete id="deleteDictTypeByIds" parameterType="Long">
delete from sys_dict_type where dict_id in
<foreach collection="array" item="dictId" open="(" separator="," close=")">
#{dictId}
</foreach>
</delete>
<update id="updateDictType" parameterType="com.xiang.xs.service.entity.SysDictType">
update sys_dict_type
<set>
<if test="dictName != null and dictName != ''">dict_name = #{dictName},</if>
<if test="dictType != null and dictType != ''">dict_type = #{dictType},</if>
<if test="status != null">status = #{status},</if>
<if test="remark != null">remark = #{remark},</if>
<if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
update_time = sysdate()
</set>
where dict_id = #{dictId}
</update>
<insert id="insertDictType" parameterType="com.xiang.xs.service.entity.SysDictType">
insert into sys_dict_type(
<if test="dictName != null and dictName != ''">dict_name,</if>
<if test="dictType != null and dictType != ''">dict_type,</if>
<if test="status != null">status,</if>
<if test="remark != null and remark != ''">remark,</if>
<if test="createBy != null and createBy != ''">create_by,</if>
create_time
)values(
<if test="dictName != null and dictName != ''">#{dictName},</if>
<if test="dictType != null and dictType != ''">#{dictType},</if>
<if test="status != null">#{status},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<if test="createBy != null and createBy != ''">#{createBy},</if>
sysdate()
)
</insert>
</mapper>

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