【修改】将jeecg字样修改为jero(修改完毕)

This commit is contained in:
zer0Black
2021-03-11 09:03:44 +08:00
parent ba4ef45423
commit 684543524b
688 changed files with 394236 additions and 13426 deletions
@@ -0,0 +1,387 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.api.ISysBaseAPI;
import com.jero.common.util.CommonUtils;
import com.jero.common.util.RestUtil;
import com.jero.common.util.TokenUtils;
import com.jero.common.util.oConvertUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLDecoder;
/**
* <p>
* 用户表 前端控制器
* </p>
*
* @Author scott
* @since 2018-12-20
*/
@Slf4j
@RestController
@RequestMapping("/sys/common")
public class CommonController {
@Autowired
private ISysBaseAPI sysBaseAPI;
@Value(value = "${jero.path.upload}")
private String uploadpath;
/**
* 本地:local miniominio 阿里:alioss
*/
@Value(value="${jero.uploadType}")
private String uploadType;
/**
* @Author 政辉
* @return
*/
@GetMapping("/403")
public Result<?> noauth() {
return Result.error("没有权限,请联系管理员授权");
}
/**
* 文件上传统一方法
* @param request
* @param response
* @return
*/
@PostMapping(value = "/upload")
public Result<?> upload(HttpServletRequest request, HttpServletResponse response) {
Result<?> result = new Result<>();
String savePath = "";
String bizPath = request.getParameter("biz");
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("file");// 获取上传文件对象
if(oConvertUtils.isEmpty(bizPath)){
if(CommonConstant.UPLOAD_TYPE_OSS.equals(uploadType)){
//未指定目录,则用阿里云默认目录 upload
bizPath = "upload";
//result.setMessage("使用阿里云文件上传时,必须添加目录!");
//result.setSuccess(false);
//return result;
}else{
bizPath = "";
}
}
if(CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)){
//update-begin-author:lvdandan date:20200928 for:修改JEditor编辑器本地上传
savePath = this.uploadLocal(file,bizPath);
//update-begin-author:lvdandan date:20200928 for:修改JEditor编辑器本地上传
/** 富文本编辑器及markdown本地上传时,采用返回链接方式
//针对jeditor编辑器如何使 lcaol模式,采用 base64格式存储
String jeditor = request.getParameter("jeditor");
if(oConvertUtils.isNotEmpty(jeditor)){
result.setMessage(CommonConstant.UPLOAD_TYPE_LOCAL);
result.setSuccess(true);
return result;
}else{
savePath = this.uploadLocal(file,bizPath);
}
*/
}else{
//update-begin-author:taoyan date:20200814 for:文件上传改造
savePath = CommonUtils.upload(file, bizPath, uploadType);
//update-end-author:taoyan date:20200814 for:文件上传改造
}
if(oConvertUtils.isNotEmpty(savePath)){
result.setMessage(savePath);
result.setSuccess(true);
}else {
result.setMessage("上传失败!");
result.setSuccess(false);
}
return result;
}
/**
* 本地文件上传
* @param mf 文件
* @param bizPath 自定义路径
* @return
*/
private String uploadLocal(MultipartFile mf,String bizPath){
try {
String ctxPath = uploadpath;
String fileName = null;
File file = new File(ctxPath + File.separator + bizPath + File.separator );
if (!file.exists()) {
file.mkdirs();// 创建文件根目录
}
String orgName = mf.getOriginalFilename();// 获取文件名
orgName = CommonUtils.getFileName(orgName);
if(orgName.indexOf(".")!=-1){
fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.indexOf("."));
}else{
fileName = orgName+ "_" + System.currentTimeMillis();
}
String savePath = file.getPath() + File.separator + fileName;
File savefile = new File(savePath);
FileCopyUtils.copy(mf.getBytes(), savefile);
String dbpath = null;
if(oConvertUtils.isNotEmpty(bizPath)){
dbpath = bizPath + File.separator + fileName;
}else{
dbpath = fileName;
}
if (dbpath.contains("\\")) {
dbpath = dbpath.replace("\\", "/");
}
return dbpath;
} catch (IOException e) {
log.error(e.getMessage(), e);
}
return "";
}
// @PostMapping(value = "/upload2")
// public Result<?> upload2(HttpServletRequest request, HttpServletResponse response) {
// Result<?> result = new Result<>();
// try {
// String ctxPath = uploadpath;
// String fileName = null;
// String bizPath = "files";
// String tempBizPath = request.getParameter("biz");
// if(oConvertUtils.isNotEmpty(tempBizPath)){
// bizPath = tempBizPath;
// }
// String nowday = new SimpleDateFormat("yyyyMMdd").format(new Date());
// File file = new File(ctxPath + File.separator + bizPath + File.separator + nowday);
// if (!file.exists()) {
// file.mkdirs();// 创建文件根目录
// }
// MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
// MultipartFile mf = multipartRequest.getFile("file");// 获取上传文件对象
// String orgName = mf.getOriginalFilename();// 获取文件名
// fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.indexOf("."));
// String savePath = file.getPath() + File.separator + fileName;
// File savefile = new File(savePath);
// FileCopyUtils.copy(mf.getBytes(), savefile);
// String dbpath = bizPath + File.separator + nowday + File.separator + fileName;
// if (dbpath.contains("\\")) {
// dbpath = dbpath.replace("\\", "/");
// }
// result.setMessage(dbpath);
// result.setSuccess(true);
// } catch (IOException e) {
// result.setSuccess(false);
// result.setMessage(e.getMessage());
// log.error(e.getMessage(), e);
// }
// return result;
// }
/**
* 预览图片&下载文件
* 请求地址:http://localhost:8080/common/static/{user/20190119/e1fe9925bc315c60addea1b98eb1cb1349547719_1547866868179.jpg}
*
* @param request
* @param response
*/
@GetMapping(value = "/static/**")
public void view(HttpServletRequest request, HttpServletResponse response) {
// ISO-8859-1 ==> UTF-8 进行编码转换
String imgPath = extractPathFromPattern(request);
if(oConvertUtils.isEmpty(imgPath) || imgPath=="null"){
return;
}
// 其余处理略
InputStream inputStream = null;
OutputStream outputStream = null;
try {
imgPath = imgPath.replace("..", "");
if (imgPath.endsWith(",")) {
imgPath = imgPath.substring(0, imgPath.length() - 1);
}
String filePath = uploadpath + File.separator + imgPath;
File file = new File(filePath);
if(!file.exists()){
response.setStatus(404);
throw new RuntimeException("文件不存在..");
}
response.setContentType("application/force-download");// 设置强制下载不打开
response.addHeader("Content-Disposition", "attachment;fileName=" + new String(file.getName().getBytes("UTF-8"),"iso-8859-1"));
inputStream = new BufferedInputStream(new FileInputStream(filePath));
outputStream = response.getOutputStream();
byte[] buf = new byte[1024];
int len;
while ((len = inputStream.read(buf)) > 0) {
outputStream.write(buf, 0, len);
}
response.flushBuffer();
} catch (IOException e) {
log.error("预览文件失败" + e.getMessage());
response.setStatus(404);
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
}
}
// /**
// * 下载文件
// * 请求地址:http://localhost:8080/common/download/{user/20190119/e1fe9925bc315c60addea1b98eb1cb1349547719_1547866868179.jpg}
// *
// * @param request
// * @param response
// * @throws Exception
// */
// @GetMapping(value = "/download/**")
// public void download(HttpServletRequest request, HttpServletResponse response) throws Exception {
// // ISO-8859-1 ==> UTF-8 进行编码转换
// String filePath = extractPathFromPattern(request);
// // 其余处理略
// InputStream inputStream = null;
// OutputStream outputStream = null;
// try {
// filePath = filePath.replace("..", "");
// if (filePath.endsWith(",")) {
// filePath = filePath.substring(0, filePath.length() - 1);
// }
// String localPath = uploadpath;
// String downloadFilePath = localPath + File.separator + filePath;
// File file = new File(downloadFilePath);
// if (file.exists()) {
// response.setContentType("application/force-download");// 设置强制下载不打开            
// response.addHeader("Content-Disposition", "attachment;fileName=" + new String(file.getName().getBytes("UTF-8"),"iso-8859-1"));
// inputStream = new BufferedInputStream(new FileInputStream(file));
// outputStream = response.getOutputStream();
// byte[] buf = new byte[1024];
// int len;
// while ((len = inputStream.read(buf)) > 0) {
// outputStream.write(buf, 0, len);
// }
// response.flushBuffer();
// }
//
// } catch (Exception e) {
// log.info("文件下载失败" + e.getMessage());
// // e.printStackTrace();
// } finally {
// if (inputStream != null) {
// try {
// inputStream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// if (outputStream != null) {
// try {
// outputStream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// }
//
// }
/**
* @功能:pdf预览Iframe
* @param modelAndView
* @return
*/
@RequestMapping("/pdf/pdfPreviewIframe")
public ModelAndView pdfPreviewIframe(ModelAndView modelAndView) {
modelAndView.setViewName("pdfPreviewIframe");
return modelAndView;
}
/**
* 把指定URL后的字符串全部截断当成参数
* 这么做是为了防止URL中包含中文或者特殊字符(/等)时,匹配不了的问题
* @param request
* @return
*/
private static String extractPathFromPattern(final HttpServletRequest request) {
String path = (String) request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
String bestMatchPattern = (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
return new AntPathMatcher().extractPathWithinPattern(bestMatchPattern, path);
}
/**
* 中转HTTP请求,解决跨域问题
*
* @param url 必填:请求地址
* @return
*/
@RequestMapping("/transitRESTful")
public Result transitRESTful(@RequestParam("url") String url, HttpServletRequest request) {
try {
ServletServerHttpRequest httpRequest = new ServletServerHttpRequest(request);
// 中转请求method、body
HttpMethod method = httpRequest.getMethod();
JSONObject params;
try {
params = JSON.parseObject(JSON.toJSONString(httpRequest.getBody()));
} catch (Exception e) {
params = new JSONObject();
}
// 中转请求问号参数
JSONObject variables = JSON.parseObject(JSON.toJSONString(request.getParameterMap()));
variables.remove("url");
// 在 headers 里传递Token
String token = TokenUtils.getTokenByRequest(request);
HttpHeaders headers = new HttpHeaders();
headers.set("X-Access-Token", token);
// 发送请求
String httpURL = URLDecoder.decode(url, "UTF-8");
ResponseEntity<String> response = RestUtil.request(httpURL, method, headers , variables, params, String.class);
// 封装返回结果
Result<Object> result = new Result<>();
int statusCode = response.getStatusCodeValue();
result.setCode(statusCode);
result.setSuccess(statusCode == 200);
String responseBody = response.getBody();
try {
// 尝试将返回结果转为JSON
Object json = JSON.parse(responseBody);
result.setResult(json);
} catch (Exception e) {
// 转成JSON失败,直接返回原始数据
result.setResult(responseBody);
}
return result;
} catch (Exception e) {
log.debug("中转HTTP请求失败", e);
return Result.error(e.getMessage());
}
}
}
@@ -0,0 +1,66 @@
package com.jero.modules.system.controller;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.util.SqlInjectionUtil;
import com.jero.modules.system.mapper.SysDictMapper;
import com.jero.modules.system.model.DuplicateCheckVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
/**
* @Title: DuplicateCheckAction
* @Description: 重复校验工具
* @Author 张代浩
* @Date 2019-03-25
* @Version V1.0
*/
@Slf4j
@RestController
@RequestMapping("/sys/duplicate")
@Api(tags="重复校验")
public class DuplicateCheckController {
@Autowired
SysDictMapper sysDictMapper;
/**
* 校验数据是否在系统中是否存在
*
* @return
*/
@RequestMapping(value = "/check", method = RequestMethod.GET)
@ApiOperation("重复校验接口")
public Result<Object> doDuplicateCheck(DuplicateCheckVo duplicateCheckVo, HttpServletRequest request) {
Long num = null;
log.info("----duplicate check------"+ duplicateCheckVo.toString());
//关联表字典(举例:sys_user,realname,id
//SQL注入校验(只限制非法串改数据库)
final String[] sqlInjCheck = {duplicateCheckVo.getTableName(),duplicateCheckVo.getFieldName()};
SqlInjectionUtil.filterContent(sqlInjCheck);
if (StringUtils.isNotBlank(duplicateCheckVo.getDataId())) {
// [2].编辑页面校验
num = sysDictMapper.duplicateCheckCountSql(duplicateCheckVo);
} else {
// [1].添加页面校验
num = sysDictMapper.duplicateCheckCountSqlNoDataId(duplicateCheckVo);
}
if (num == null || num == 0) {
// 该值可用
return Result.ok("该值可用!");
} else {
// 该值不可用
log.info("该值不可用,系统中已存在!");
return Result.error("该值不可用,系统中已存在!");
}
}
}
@@ -0,0 +1,508 @@
package com.jero.modules.system.controller;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.SecureUtil;
import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.exceptions.ClientException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CacheConstant;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.api.ISysBaseAPI;
import com.jero.modules.base.service.BaseCommonService;
import com.jero.common.system.util.JwtUtil;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.*;
import com.jero.common.util.encryption.EncryptedString;
import com.jero.modules.system.entity.SysDepart;
import com.jero.modules.system.entity.SysUser;
import com.jero.modules.system.model.SysLoginModel;
import com.jero.modules.system.service.ISysDepartService;
import com.jero.modules.system.service.ISysDictService;
import com.jero.modules.system.service.ISysLogService;
import com.jero.modules.system.service.ISysUserService;
import com.jero.modules.system.util.RandImageUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
/**
* @Author scott
* @since 2018-12-17
*/
@RestController
@RequestMapping("/sys")
@Api(tags="用户登录")
@Slf4j
public class LoginController {
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysBaseAPI sysBaseAPI;
@Autowired
private ISysLogService logService;
@Autowired
private RedisUtil redisUtil;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private ISysDictService sysDictService;
@Resource
private BaseCommonService baseCommonService;
private static final String BASE_CHECK_CODES = "qwertyuiplkjhgfdsazxcvbnmQWERTYUPLKJHGFDSAZXCVBNM1234567890";
@ApiOperation("登录接口")
@RequestMapping(value = "/login", method = RequestMethod.POST)
public Result<JSONObject> login(@RequestBody SysLoginModel sysLoginModel){
Result<JSONObject> result = new Result<JSONObject>();
String username = sysLoginModel.getUsername();
String password = sysLoginModel.getPassword();
//update-begin--Author:scott Date:20190805 for:暂时注释掉密码加密逻辑,有点问题
//前端密码加密,后端进行密码解密
//password = AesEncryptUtil.desEncrypt(sysLoginModel.getPassword().replaceAll("%2B", "\\+")).trim();//密码解密
//update-begin--Author:scott Date:20190805 for:暂时注释掉密码加密逻辑,有点问题
//update-begin-author:taoyan date:20190828 for:校验验证码
String captcha = sysLoginModel.getCaptcha();
if(captcha==null){
result.error500("验证码无效");
return result;
}
String lowerCaseCaptcha = captcha.toLowerCase();
String realKey = MD5Util.MD5Encode(lowerCaseCaptcha+sysLoginModel.getCheckKey(), "utf-8");
Object checkCode = redisUtil.get(realKey);
//当进入登录页时,有一定几率出现验证码错误 #1714
if(checkCode==null || !checkCode.toString().equals(lowerCaseCaptcha)) {
result.error500("验证码错误");
return result;
}
//update-end-author:taoyan date:20190828 for:校验验证码
//1. 校验用户是否有效
//update-begin-author:wangshuai date:20200601 for: 登录代码验证用户是否注销bug,if条件永远为false
LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysUser::getUsername,username);
SysUser sysUser = sysUserService.getOne(queryWrapper);
//update-end-author:wangshuai date:20200601 for: 登录代码验证用户是否注销bug,if条件永远为false
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
//2. 校验用户名或密码是否正确
String userpassword = PasswordUtil.encrypt(username, password, sysUser.getSalt());
String syspassword = sysUser.getPassword();
if (!syspassword.equals(userpassword)) {
result.error500("用户名或密码错误");
return result;
}
//用户登录信息
userInfo(sysUser, result);
//update-begin--Author:wangshuai Date:20200714 for:登录日志没有记录人员
LoginUser loginUser = new LoginUser();
BeanUtils.copyProperties(sysUser, loginUser);
baseCommonService.addLog("用户名: " + username + ",登录成功!", CommonConstant.LOG_TYPE_1, null,loginUser);
//update-end--Author:wangshuai Date:20200714 for:登录日志没有记录人员
return result;
}
/**
* 退出登录
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/logout")
public Result<Object> logout(HttpServletRequest request,HttpServletResponse response) {
//用户退出逻辑
String token = request.getHeader(CommonConstant.X_ACCESS_TOKEN);
if(oConvertUtils.isEmpty(token)) {
return Result.error("退出登录失败!");
}
String username = JwtUtil.getUsername(token);
LoginUser sysUser = sysBaseAPI.getUserByName(username);
if(sysUser!=null) {
//update-begin--Author:wangshuai Date:20200714 for:登出日志没有记录人员
baseCommonService.addLog("用户名: "+sysUser.getRealname()+",退出成功!", CommonConstant.LOG_TYPE_1, null,sysUser);
//update-end--Author:wangshuai Date:20200714 for:登出日志没有记录人员
log.info(" 用户名: "+sysUser.getRealname()+",退出成功! ");
//清空用户登录Token缓存
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN + token);
//清空用户登录Shiro权限缓存
redisUtil.del(CommonConstant.PREFIX_USER_SHIRO_CACHE + sysUser.getId());
//清空用户的缓存信息(包括部门信息),例如sys:cache:user::<username>
redisUtil.del(String.format("%s::%s", CacheConstant.SYS_USERS_CACHE, sysUser.getUsername()));
//调用shiro的logout
SecurityUtils.getSubject().logout();
return Result.ok("退出登录成功!");
}else {
return Result.error("Token无效!");
}
}
/**
* 获取访问量
* @return
*/
@GetMapping("loginfo")
public Result<JSONObject> loginfo() {
Result<JSONObject> result = new Result<JSONObject>();
JSONObject obj = new JSONObject();
//update-begin--Author:zhangweijian Date:20190428 for:传入开始时间,结束时间参数
// 获取一天的开始和结束时间
Calendar calendar = new GregorianCalendar();
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
Date dayStart = calendar.getTime();
calendar.add(Calendar.DATE, 1);
Date dayEnd = calendar.getTime();
// 获取系统访问记录
Long totalVisitCount = logService.findTotalVisitCount();
obj.put("totalVisitCount", totalVisitCount);
Long todayVisitCount = logService.findTodayVisitCount(dayStart,dayEnd);
obj.put("todayVisitCount", todayVisitCount);
Long todayIp = logService.findTodayIp(dayStart,dayEnd);
//update-end--Author:zhangweijian Date:20190428 for:传入开始时间,结束时间参数
obj.put("todayIp", todayIp);
result.setResult(obj);
result.success("登录成功");
return result;
}
/**
* 获取访问量
* @return
*/
@GetMapping("visitInfo")
public Result<List<Map<String,Object>>> visitInfo() {
Result<List<Map<String,Object>>> result = new Result<List<Map<String,Object>>>();
Calendar calendar = new GregorianCalendar();
calendar.set(Calendar.HOUR_OF_DAY,0);
calendar.set(Calendar.MINUTE,0);
calendar.set(Calendar.SECOND,0);
calendar.set(Calendar.MILLISECOND,0);
calendar.add(Calendar.DAY_OF_MONTH, 1);
Date dayEnd = calendar.getTime();
calendar.add(Calendar.DAY_OF_MONTH, -7);
Date dayStart = calendar.getTime();
List<Map<String,Object>> list = logService.findVisitCount(dayStart, dayEnd);
result.setResult(oConvertUtils.toLowerCasePageList(list));
return result;
}
/**
* 登陆成功选择用户当前部门
* @param user
* @return
*/
@RequestMapping(value = "/selectDepart", method = RequestMethod.PUT)
public Result<JSONObject> selectDepart(@RequestBody SysUser user) {
Result<JSONObject> result = new Result<JSONObject>();
String username = user.getUsername();
if(oConvertUtils.isEmpty(username)) {
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
username = sysUser.getUsername();
}
String orgCode= user.getOrgCode();
this.sysUserService.updateUserDepart(username, orgCode);
SysUser sysUser = sysUserService.getUserByName(username);
JSONObject obj = new JSONObject();
obj.put("userInfo", sysUser);
result.setResult(obj);
return result;
}
/**
* 短信登录接口
*
* @param jsonObject
* @return
*/
@PostMapping(value = "/sms")
public Result<String> sms(@RequestBody JSONObject jsonObject) {
Result<String> result = new Result<String>();
String mobile = jsonObject.get("mobile").toString();
//手机号模式 登录模式: "2" 注册模式: "1"
String smsmode=jsonObject.get("smsmode").toString();
log.info(mobile);
if(oConvertUtils.isEmpty(mobile)){
result.setMessage("手机号不允许为空!");
result.setSuccess(false);
return result;
}
Object object = redisUtil.get(mobile);
if (object != null) {
result.setMessage("验证码10分钟内,仍然有效!");
result.setSuccess(false);
return result;
}
//随机数
String captcha = RandomUtil.randomNumbers(6);
JSONObject obj = new JSONObject();
obj.put("code", captcha);
try {
boolean b = false;
//注册模板
if (CommonConstant.SMS_TPL_TYPE_1.equals(smsmode)) {
SysUser sysUser = sysUserService.getUserByPhone(mobile);
if(sysUser!=null) {
result.error500(" 手机号已经注册,请直接登录!");
baseCommonService.addLog("手机号已经注册,请直接登录!", CommonConstant.LOG_TYPE_1, null);
return result;
}
b = DySmsHelper.sendSms(mobile, obj, DySmsEnum.REGISTER_TEMPLATE_CODE);
}else {
//登录模式,校验用户有效性
SysUser sysUser = sysUserService.getUserByPhone(mobile);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
String message = result.getMessage();
if("该用户不存在,请注册".equals(message)){
result.error500("该用户不存在或未绑定手机号");
}
return result;
}
/**
* smsmode 短信模板方式 0 .登录模板、1.注册模板、2.忘记密码模板
*/
if (CommonConstant.SMS_TPL_TYPE_0.equals(smsmode)) {
//登录模板
b = DySmsHelper.sendSms(mobile, obj, DySmsEnum.LOGIN_TEMPLATE_CODE);
} else if(CommonConstant.SMS_TPL_TYPE_2.equals(smsmode)) {
//忘记密码模板
b = DySmsHelper.sendSms(mobile, obj, DySmsEnum.FORGET_PASSWORD_TEMPLATE_CODE);
}
}
if (b == false) {
result.setMessage("短信验证码发送失败,请稍后重试");
result.setSuccess(false);
return result;
}
//验证码10分钟内有效
redisUtil.set(mobile, captcha, 600);
//update-begin--Author:scott Date:20190812 forissues#391
//result.setResult(captcha);
//update-end--Author:scott Date:20190812 forissues#391
result.setSuccess(true);
} catch (ClientException e) {
e.printStackTrace();
result.error500(" 短信接口未配置,请联系管理员!");
return result;
}
return result;
}
/**
* 手机号登录接口
*
* @param jsonObject
* @return
*/
@ApiOperation("手机号登录接口")
@PostMapping("/phoneLogin")
public Result<JSONObject> phoneLogin(@RequestBody JSONObject jsonObject) {
Result<JSONObject> result = new Result<JSONObject>();
String phone = jsonObject.getString("mobile");
//校验用户有效性
SysUser sysUser = sysUserService.getUserByPhone(phone);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
String smscode = jsonObject.getString("captcha");
Object code = redisUtil.get(phone);
if (!smscode.equals(code)) {
result.setMessage("手机验证码错误");
return result;
}
//用户信息
userInfo(sysUser, result);
//添加日志
baseCommonService.addLog("用户名: " + sysUser.getUsername() + ",登录成功!", CommonConstant.LOG_TYPE_1, null);
return result;
}
/**
* 用户信息
*
* @param sysUser
* @param result
* @return
*/
private Result<JSONObject> userInfo(SysUser sysUser, Result<JSONObject> result) {
String syspassword = sysUser.getPassword();
String username = sysUser.getUsername();
// 生成token
String token = JwtUtil.sign(username, syspassword);
// 设置token缓存有效时间
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME*2 / 1000);
// 获取用户部门信息
JSONObject obj = new JSONObject();
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
obj.put("departs", departs);
if (departs == null || departs.size() == 0) {
obj.put("multi_depart", 0);
} else if (departs.size() == 1) {
sysUserService.updateUserDepart(username, departs.get(0).getOrgCode());
obj.put("multi_depart", 1);
} else {
//查询当前是否有登录部门
// update-begin--Author:wangshuai Date:20200805 for:如果用戶为选择部门,数据库为存在上一次登录部门,则取一条存进去
SysUser sysUserById = sysUserService.getById(sysUser.getId());
if(oConvertUtils.isEmpty(sysUserById.getOrgCode())){
sysUserService.updateUserDepart(username, departs.get(0).getOrgCode());
}
// update-end--Author:wangshuai Date:20200805 for:如果用戶为选择部门,数据库为存在上一次登录部门,则取一条存进去
obj.put("multi_depart", 2);
}
obj.put("token", token);
obj.put("userInfo", sysUser);
obj.put("sysAllDictItems", sysDictService.queryAllDictItems());
result.setResult(obj);
result.success("登录成功");
return result;
}
/**
* 获取加密字符串
* @return
*/
@GetMapping(value = "/getEncryptedString")
public Result<Map<String,String>> getEncryptedString(){
Result<Map<String,String>> result = new Result<Map<String,String>>();
Map<String,String> map = new HashMap<String,String>();
map.put("key", EncryptedString.key);
map.put("iv",EncryptedString.iv);
result.setResult(map);
return result;
}
/**
* 后台生成图形验证码 :有效
* @param response
* @param key
*/
@ApiOperation("获取验证码")
@GetMapping(value = "/randomImage/{key}")
public Result<String> randomImage(HttpServletResponse response,@PathVariable String key){
Result<String> res = new Result<String>();
try {
String code = RandomUtil.randomString(BASE_CHECK_CODES,4);
String lowerCaseCode = code.toLowerCase();
String realKey = MD5Util.MD5Encode(lowerCaseCode+key, "utf-8");
redisUtil.set(realKey, lowerCaseCode, 60);
String base64 = RandImageUtil.generate(code);
res.setSuccess(true);
res.setResult(base64);
} catch (Exception e) {
res.error500("获取验证码出错"+e.getMessage());
e.printStackTrace();
}
return res;
}
/**
* app登录
* @param sysLoginModel
* @return
* @throws Exception
*/
@RequestMapping(value = "/mLogin", method = RequestMethod.POST)
public Result<JSONObject> mLogin(@RequestBody SysLoginModel sysLoginModel) throws Exception {
Result<JSONObject> result = new Result<JSONObject>();
String username = sysLoginModel.getUsername();
String password = sysLoginModel.getPassword();
//1. 校验用户是否有效
SysUser sysUser = sysUserService.getUserByName(username);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
//2. 校验用户名或密码是否正确
String userpassword = PasswordUtil.encrypt(username, password, sysUser.getSalt());
String syspassword = sysUser.getPassword();
if (!syspassword.equals(userpassword)) {
result.error500("用户名或密码错误");
return result;
}
String orgCode = sysUser.getOrgCode();
if(oConvertUtils.isEmpty(orgCode)) {
//如果当前用户无选择部门 查看部门关联信息
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
if (departs == null || departs.size() == 0) {
result.error500("用户暂未归属部门,不可登录!");
return result;
}
orgCode = departs.get(0).getOrgCode();
sysUser.setOrgCode(orgCode);
this.sysUserService.updateUserDepart(username, orgCode);
}
JSONObject obj = new JSONObject();
//用户登录信息
obj.put("userInfo", sysUser);
// 生成token
String token = JwtUtil.sign(username, syspassword);
// 设置超时时间
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME*2 / 1000);
//token 信息
obj.put("token", token);
result.setResult(obj);
result.setSuccess(true);
result.setCode(200);
baseCommonService.addLog("用户名: " + username + ",登录成功[移动端]", CommonConstant.LOG_TYPE_1, null);
return result;
}
/**
* 图形验证码
* @param sysLoginModel
* @return
*/
@RequestMapping(value = "/checkCaptcha", method = RequestMethod.POST)
public Result<?> checkCaptcha(@RequestBody SysLoginModel sysLoginModel){
String captcha = sysLoginModel.getCaptcha();
String checkKey = sysLoginModel.getCheckKey();
if(captcha==null){
return Result.error("验证码无效");
}
String lowerCaseCaptcha = captcha.toLowerCase();
String realKey = MD5Util.MD5Encode(lowerCaseCaptcha+checkKey, "utf-8");
Object checkCode = redisUtil.get(realKey);
if(checkCode==null || !checkCode.equals(lowerCaseCaptcha)) {
return Result.error("验证码错误");
}
return Result.ok();
}
}
@@ -0,0 +1,426 @@
package com.jero.modules.system.controller;
import java.io.IOException;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CommonConstant;
import com.jero.common.constant.CommonSendStatus;
import com.jero.common.constant.WebsocketConst;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.system.util.JwtUtil;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.message.websocket.WebSocket;
import com.jero.modules.system.entity.SysAnnouncement;
import com.jero.modules.system.entity.SysAnnouncementSend;
import com.jero.modules.system.service.ISysAnnouncementSendService;
import com.jero.modules.system.service.ISysAnnouncementService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* @Title: Controller
* @Description: 系统通告表
* @Author: jero-boot
* @Date: 2019-01-02
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/annountCement")
@Slf4j
public class SysAnnouncementController {
@Autowired
private ISysAnnouncementService sysAnnouncementService;
@Autowired
private ISysAnnouncementSendService sysAnnouncementSendService;
@Resource
private WebSocket webSocket;
/**
* 分页列表查询
* @param sysAnnouncement
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysAnnouncement>> queryPageList(SysAnnouncement sysAnnouncement,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
Result<IPage<SysAnnouncement>> result = new Result<IPage<SysAnnouncement>>();
sysAnnouncement.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
QueryWrapper<SysAnnouncement> queryWrapper = new QueryWrapper<SysAnnouncement>(sysAnnouncement);
Page<SysAnnouncement> page = new Page<SysAnnouncement>(pageNo,pageSize);
//排序逻辑 处理
String column = req.getParameter("column");
String order = req.getParameter("order");
if(oConvertUtils.isNotEmpty(column) && oConvertUtils.isNotEmpty(order)) {
if("asc".equals(order)) {
queryWrapper.orderByAsc(oConvertUtils.camelToUnderline(column));
}else {
queryWrapper.orderByDesc(oConvertUtils.camelToUnderline(column));
}
}
IPage<SysAnnouncement> pageList = sysAnnouncementService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param sysAnnouncement
* @return
*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysAnnouncement> add(@RequestBody SysAnnouncement sysAnnouncement) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
try {
sysAnnouncement.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
sysAnnouncement.setSendStatus(CommonSendStatus.UNPUBLISHED_STATUS_0);//未发布
sysAnnouncementService.saveAnnouncement(sysAnnouncement);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param sysAnnouncement
* @return
*/
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysAnnouncement> eidt(@RequestBody SysAnnouncement sysAnnouncement) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncementEntity = sysAnnouncementService.getById(sysAnnouncement.getId());
if(sysAnnouncementEntity==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysAnnouncementService.upDateAnnouncement(sysAnnouncement);
//TODO 返回false说明什么?
if(ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<SysAnnouncement> delete(@RequestParam(name="id",required=true) String id) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncement = sysAnnouncementService.getById(id);
if(sysAnnouncement==null) {
result.error500("未找到对应实体");
}else {
sysAnnouncement.setDelFlag(CommonConstant.DEL_FLAG_1.toString());
boolean ok = sysAnnouncementService.updateById(sysAnnouncement);
if(ok) {
result.success("删除成功!");
}
}
return result;
}
/**
* 批量删除
* @param ids
* @return
*/
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysAnnouncement> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别!");
}else {
String[] id = ids.split(",");
for(int i=0;i<id.length;i++) {
SysAnnouncement announcement = sysAnnouncementService.getById(id[i]);
announcement.setDelFlag(CommonConstant.DEL_FLAG_1.toString());
sysAnnouncementService.updateById(announcement);
}
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@RequestMapping(value = "/queryById", method = RequestMethod.GET)
public Result<SysAnnouncement> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncement = sysAnnouncementService.getById(id);
if(sysAnnouncement==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysAnnouncement);
result.setSuccess(true);
}
return result;
}
/**
* 更新发布操作
* @param id
* @return
*/
@RequestMapping(value = "/doReleaseData", method = RequestMethod.GET)
public Result<SysAnnouncement> doReleaseData(@RequestParam(name="id",required=true) String id, HttpServletRequest request) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncement = sysAnnouncementService.getById(id);
if(sysAnnouncement==null) {
result.error500("未找到对应实体");
}else {
sysAnnouncement.setSendStatus(CommonSendStatus.PUBLISHED_STATUS_1);//发布中
sysAnnouncement.setSendTime(new Date());
String currentUserName = JwtUtil.getUserNameByToken(request);
sysAnnouncement.setSender(currentUserName);
boolean ok = sysAnnouncementService.updateById(sysAnnouncement);
if(ok) {
result.success("该系统通知发布成功");
if(sysAnnouncement.getMsgType().equals(CommonConstant.MSG_TYPE_ALL)) {
JSONObject obj = new JSONObject();
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_TOPIC);
obj.put(WebsocketConst.MSG_ID, sysAnnouncement.getId());
obj.put(WebsocketConst.MSG_TXT, sysAnnouncement.getTitile());
webSocket.sendMessage(obj.toJSONString());
}else {
// 2.插入用户通告阅读标记表记录
String userId = sysAnnouncement.getUserIds();
String[] userIds = userId.substring(0, (userId.length()-1)).split(",");
String anntId = sysAnnouncement.getId();
Date refDate = new Date();
JSONObject obj = new JSONObject();
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
obj.put(WebsocketConst.MSG_ID, sysAnnouncement.getId());
obj.put(WebsocketConst.MSG_TXT, sysAnnouncement.getTitile());
webSocket.sendMessage(userIds, obj.toJSONString());
}
}
}
return result;
}
/**
* 更新撤销操作
* @param id
* @return
*/
@RequestMapping(value = "/doReovkeData", method = RequestMethod.GET)
public Result<SysAnnouncement> doReovkeData(@RequestParam(name="id",required=true) String id, HttpServletRequest request) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncement = sysAnnouncementService.getById(id);
if(sysAnnouncement==null) {
result.error500("未找到对应实体");
}else {
sysAnnouncement.setSendStatus(CommonSendStatus.REVOKE_STATUS_2);//撤销发布
sysAnnouncement.setCancelTime(new Date());
boolean ok = sysAnnouncementService.updateById(sysAnnouncement);
if(ok) {
result.success("该系统通知撤销成功");
}
}
return result;
}
/**
* @功能:补充用户数据,并返回系统消息
* @return
*/
@RequestMapping(value = "/listByUser", method = RequestMethod.GET)
public Result<Map<String,Object>> listByUser() {
Result<Map<String,Object>> result = new Result<Map<String,Object>>();
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
// 1.将系统消息补充到用户通告阅读标记表中
LambdaQueryWrapper<SysAnnouncement> querySaWrapper = new LambdaQueryWrapper<SysAnnouncement>();
querySaWrapper.eq(SysAnnouncement::getMsgType,CommonConstant.MSG_TYPE_ALL); // 全部人员
querySaWrapper.eq(SysAnnouncement::getDelFlag,CommonConstant.DEL_FLAG_0.toString()); // 未删除
querySaWrapper.eq(SysAnnouncement::getSendStatus, CommonConstant.HAS_SEND); //已发布
querySaWrapper.ge(SysAnnouncement::getEndTime, sysUser.getCreateTime()); //新注册用户不看结束通知
//update-begin--Author:liusq Date:20210108 for[JT-424] 【开源issue】bug处理--------------------
querySaWrapper.notInSql(SysAnnouncement::getId,"select annt_id from sys_announcement_send where user_id='"+userId+"'");
//update-begin--Author:liusq Date:20210108 for [JT-424] 【开源issue】bug处理--------------------
List<SysAnnouncement> announcements = sysAnnouncementService.list(querySaWrapper);
if(announcements.size()>0) {
for(int i=0;i<announcements.size();i++) {
//update-begin--Author:wangshuai Date:20200803 for 通知公告消息重复LOWCOD-759--------------------
//因为websocket没有判断是否存在这个用户,要是判断会出现问题,故在此判断逻辑
LambdaQueryWrapper<SysAnnouncementSend> query = new LambdaQueryWrapper<>();
query.eq(SysAnnouncementSend::getAnntId,announcements.get(i).getId());
query.eq(SysAnnouncementSend::getUserId,userId);
SysAnnouncementSend one = sysAnnouncementSendService.getOne(query);
if(null==one){
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(announcements.get(i).getId());
announcementSend.setUserId(userId);
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
sysAnnouncementSendService.save(announcementSend);
}
//update-end--Author:wangshuai Date:20200803 for 通知公告消息重复LOWCOD-759------------
}
}
// 2.查询用户未读的系统消息
Page<SysAnnouncement> anntMsgList = new Page<SysAnnouncement>(0,5);
anntMsgList = sysAnnouncementService.querySysCementPageByUserId(anntMsgList,userId,"1");//通知公告消息
Page<SysAnnouncement> sysMsgList = new Page<SysAnnouncement>(0,5);
sysMsgList = sysAnnouncementService.querySysCementPageByUserId(sysMsgList,userId,"2");//系统消息
Map<String,Object> sysMsgMap = new HashMap<String, Object>();
sysMsgMap.put("sysMsgList", sysMsgList.getRecords());
sysMsgMap.put("sysMsgTotal", sysMsgList.getTotal());
sysMsgMap.put("anntMsgList", anntMsgList.getRecords());
sysMsgMap.put("anntMsgTotal", anntMsgList.getTotal());
result.setSuccess(true);
result.setResult(sysMsgMap);
return result;
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysAnnouncement sysAnnouncement,HttpServletRequest request) {
// Step.1 组装查询条件
LambdaQueryWrapper<SysAnnouncement> queryWrapper = new LambdaQueryWrapper<SysAnnouncement>(sysAnnouncement);
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
queryWrapper.eq(SysAnnouncement::getDelFlag,CommonConstant.DEL_FLAG_0);
List<SysAnnouncement> pageList = sysAnnouncementService.list(queryWrapper);
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "系统通告列表");
mv.addObject(NormalExcelConstants.CLASS, SysAnnouncement.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("系统通告列表数据", "导出人:"+user.getRealname(), "导出信息"));
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
List<SysAnnouncement> listSysAnnouncements = ExcelImportUtil.importExcel(file.getInputStream(), SysAnnouncement.class, params);
for (SysAnnouncement sysAnnouncementExcel : listSysAnnouncements) {
if(sysAnnouncementExcel.getDelFlag()==null){
sysAnnouncementExcel.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
}
sysAnnouncementService.save(sysAnnouncementExcel);
}
return Result.ok("文件导入成功!数据行数:" + listSysAnnouncements.size());
} catch (Exception e) {
log.error(e.getMessage(),e);
return Result.error("文件导入失败!");
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败!");
}
/**
*同步消息
* @param anntId
* @return
*/
@RequestMapping(value = "/syncNotic", method = RequestMethod.GET)
public Result<SysAnnouncement> syncNotic(@RequestParam(name="anntId",required=false) String anntId, HttpServletRequest request) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
JSONObject obj = new JSONObject();
if(StringUtils.isNotBlank(anntId)){
SysAnnouncement sysAnnouncement = sysAnnouncementService.getById(anntId);
if(sysAnnouncement==null) {
result.error500("未找到对应实体");
}else {
if(sysAnnouncement.getMsgType().equals(CommonConstant.MSG_TYPE_ALL)) {
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_TOPIC);
obj.put(WebsocketConst.MSG_ID, sysAnnouncement.getId());
obj.put(WebsocketConst.MSG_TXT, sysAnnouncement.getTitile());
webSocket.sendMessage(obj.toJSONString());
}else {
// 2.插入用户通告阅读标记表记录
String userId = sysAnnouncement.getUserIds();
if(oConvertUtils.isNotEmpty(userId)){
String[] userIds = userId.substring(0, (userId.length()-1)).split(",");
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
obj.put(WebsocketConst.MSG_ID, sysAnnouncement.getId());
obj.put(WebsocketConst.MSG_TXT, sysAnnouncement.getTitile());
webSocket.sendMessage(userIds, obj.toJSONString());
}
}
}
}else{
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_TOPIC);
obj.put(WebsocketConst.MSG_TXT, "批量设置已读");
webSocket.sendMessage(obj.toJSONString());
}
return result;
}
}
@@ -0,0 +1,242 @@
package com.jero.modules.system.controller;
import java.util.Arrays;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import org.apache.shiro.SecurityUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysAnnouncementSend;
import com.jero.modules.system.model.AnnouncementSendModel;
import com.jero.modules.system.service.ISysAnnouncementSendService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* @Title: Controller
* @Description: 用户通告阅读标记表
* @Author: jero-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/sysAnnouncementSend")
@Slf4j
public class SysAnnouncementSendController {
@Autowired
private ISysAnnouncementSendService sysAnnouncementSendService;
/**
* 分页列表查询
* @param sysAnnouncementSend
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/list")
public Result<IPage<SysAnnouncementSend>> queryPageList(SysAnnouncementSend sysAnnouncementSend,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
Result<IPage<SysAnnouncementSend>> result = new Result<IPage<SysAnnouncementSend>>();
QueryWrapper<SysAnnouncementSend> queryWrapper = new QueryWrapper<SysAnnouncementSend>(sysAnnouncementSend);
Page<SysAnnouncementSend> page = new Page<SysAnnouncementSend>(pageNo,pageSize);
//排序逻辑 处理
String column = req.getParameter("column");
String order = req.getParameter("order");
if(oConvertUtils.isNotEmpty(column) && oConvertUtils.isNotEmpty(order)) {
if("asc".equals(order)) {
queryWrapper.orderByAsc(oConvertUtils.camelToUnderline(column));
}else {
queryWrapper.orderByDesc(oConvertUtils.camelToUnderline(column));
}
}
IPage<SysAnnouncementSend> pageList = sysAnnouncementSendService.page(page, queryWrapper);
//log.info("查询当前页:"+pageList.getCurrent());
//log.info("查询当前页数量:"+pageList.getSize());
//log.info("查询结果数量:"+pageList.getRecords().size());
//log.info("数据总数:"+pageList.getTotal());
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param sysAnnouncementSend
* @return
*/
@PostMapping(value = "/add")
public Result<SysAnnouncementSend> add(@RequestBody SysAnnouncementSend sysAnnouncementSend) {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
try {
sysAnnouncementSendService.save(sysAnnouncementSend);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param sysAnnouncementSend
* @return
*/
@PutMapping(value = "/edit")
public Result<SysAnnouncementSend> eidt(@RequestBody SysAnnouncementSend sysAnnouncementSend) {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
SysAnnouncementSend sysAnnouncementSendEntity = sysAnnouncementSendService.getById(sysAnnouncementSend.getId());
if(sysAnnouncementSendEntity==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysAnnouncementSendService.updateById(sysAnnouncementSend);
//TODO 返回false说明什么?
if(ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@DeleteMapping(value = "/delete")
public Result<SysAnnouncementSend> delete(@RequestParam(name="id",required=true) String id) {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
SysAnnouncementSend sysAnnouncementSend = sysAnnouncementSendService.getById(id);
if(sysAnnouncementSend==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysAnnouncementSendService.removeById(id);
if(ok) {
result.success("删除成功!");
}
}
return result;
}
/**
* 批量删除
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
public Result<SysAnnouncementSend> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别!");
}else {
this.sysAnnouncementSendService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@GetMapping(value = "/queryById")
public Result<SysAnnouncementSend> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
SysAnnouncementSend sysAnnouncementSend = sysAnnouncementSendService.getById(id);
if(sysAnnouncementSend==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysAnnouncementSend);
result.setSuccess(true);
}
return result;
}
/**
* @功能:更新用户系统消息阅读状态
* @param json
* @return
*/
@PutMapping(value = "/editByAnntIdAndUserId")
public Result<SysAnnouncementSend> editById(@RequestBody JSONObject json) {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
String anntId = json.getString("anntId");
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
LambdaUpdateWrapper<SysAnnouncementSend> updateWrapper = new UpdateWrapper().lambda();
updateWrapper.set(SysAnnouncementSend::getReadFlag, CommonConstant.HAS_READ_FLAG);
updateWrapper.set(SysAnnouncementSend::getReadTime, new Date());
updateWrapper.last("where annt_id ='"+anntId+"' and user_id ='"+userId+"'");
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
sysAnnouncementSendService.update(announcementSend, updateWrapper);
result.setSuccess(true);
return result;
}
/**
* @功能:获取我的消息
* @return
*/
@GetMapping(value = "/getMyAnnouncementSend")
public Result<IPage<AnnouncementSendModel>> getMyAnnouncementSend(AnnouncementSendModel announcementSendModel,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize) {
Result<IPage<AnnouncementSendModel>> result = new Result<IPage<AnnouncementSendModel>>();
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
announcementSendModel.setUserId(userId);
announcementSendModel.setPageNo((pageNo-1)*pageSize);
announcementSendModel.setPageSize(pageSize);
Page<AnnouncementSendModel> pageList = new Page<AnnouncementSendModel>(pageNo,pageSize);
pageList = sysAnnouncementSendService.getMyAnnouncementSendPage(pageList, announcementSendModel);
result.setResult(pageList);
result.setSuccess(true);
return result;
}
/**
* @功能:一键已读
* @return
*/
@PutMapping(value = "/readAll")
public Result<SysAnnouncementSend> readAll() {
Result<SysAnnouncementSend> result = new Result<SysAnnouncementSend>();
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
LambdaUpdateWrapper<SysAnnouncementSend> updateWrapper = new UpdateWrapper().lambda();
updateWrapper.set(SysAnnouncementSend::getReadFlag, CommonConstant.HAS_READ_FLAG);
updateWrapper.set(SysAnnouncementSend::getReadTime, new Date());
updateWrapper.last("where user_id ='"+userId+"'");
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
sysAnnouncementSendService.update(announcementSend, updateWrapper);
result.setSuccess(true);
result.setMessage("全部已读");
return result;
}
}
@@ -0,0 +1,484 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.system.vo.DictModel;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysCategory;
import com.jero.modules.system.model.TreeSelectModel;
import com.jero.modules.system.service.ISysCategoryService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 分类字典
* @Author: jero-boot
* @Date: 2019-05-29
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/category")
@Slf4j
public class SysCategoryController {
@Autowired
private ISysCategoryService sysCategoryService;
/**
* 分页列表查询
* @param sysCategory
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/rootList")
public Result<IPage<SysCategory>> queryPageList(SysCategory sysCategory,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
if(oConvertUtils.isEmpty(sysCategory.getPid())){
sysCategory.setPid("0");
}
Result<IPage<SysCategory>> result = new Result<IPage<SysCategory>>();
//--author:os_chengtgen---date:20190804 -----for: 分类字典页面显示错误,issues:377--------start
//QueryWrapper<SysCategory> queryWrapper = QueryGenerator.initQueryWrapper(sysCategory, req.getParameterMap());
QueryWrapper<SysCategory> queryWrapper = new QueryWrapper<SysCategory>();
queryWrapper.eq("pid", sysCategory.getPid());
//--author:os_chengtgen---date:20190804 -----for: 分类字典页面显示错误,issues:377--------end
Page<SysCategory> page = new Page<SysCategory>(pageNo, pageSize);
IPage<SysCategory> pageList = sysCategoryService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
@GetMapping(value = "/childList")
public Result<List<SysCategory>> queryPageList(SysCategory sysCategory,HttpServletRequest req) {
Result<List<SysCategory>> result = new Result<List<SysCategory>>();
QueryWrapper<SysCategory> queryWrapper = QueryGenerator.initQueryWrapper(sysCategory, req.getParameterMap());
List<SysCategory> list = sysCategoryService.list(queryWrapper);
result.setSuccess(true);
result.setResult(list);
return result;
}
/**
* 添加
* @param sysCategory
* @return
*/
@PostMapping(value = "/add")
public Result<SysCategory> add(@RequestBody SysCategory sysCategory) {
Result<SysCategory> result = new Result<SysCategory>();
try {
sysCategoryService.addSysCategory(sysCategory);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param sysCategory
* @return
*/
@PutMapping(value = "/edit")
public Result<SysCategory> edit(@RequestBody SysCategory sysCategory) {
Result<SysCategory> result = new Result<SysCategory>();
SysCategory sysCategoryEntity = sysCategoryService.getById(sysCategory.getId());
if(sysCategoryEntity==null) {
result.error500("未找到对应实体");
}else {
sysCategoryService.updateSysCategory(sysCategory);
result.success("修改成功!");
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@DeleteMapping(value = "/delete")
public Result<SysCategory> delete(@RequestParam(name="id",required=true) String id) {
Result<SysCategory> result = new Result<SysCategory>();
SysCategory sysCategory = sysCategoryService.getById(id);
if(sysCategory==null) {
result.error500("未找到对应实体");
}else {
this.sysCategoryService.deleteSysCategory(id);
result.success("删除成功!");
}
return result;
}
/**
* 批量删除
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
public Result<SysCategory> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysCategory> result = new Result<SysCategory>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别!");
}else {
this.sysCategoryService.deleteSysCategory(ids);
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@GetMapping(value = "/queryById")
public Result<SysCategory> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysCategory> result = new Result<SysCategory>();
SysCategory sysCategory = sysCategoryService.getById(id);
if(sysCategory==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysCategory);
result.setSuccess(true);
}
return result;
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysCategory sysCategory) {
// Step.1 组装查询条件查询数据
QueryWrapper<SysCategory> queryWrapper = QueryGenerator.initQueryWrapper(sysCategory, request.getParameterMap());
List<SysCategory> pageList = sysCategoryService.list(queryWrapper);
// Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
// 过滤选中数据
String selections = request.getParameter("selections");
if(oConvertUtils.isEmpty(selections)) {
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
}else {
List<String> selectionList = Arrays.asList(selections.split(","));
List<SysCategory> exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
}
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "分类字典列表");
mv.addObject(NormalExcelConstants.CLASS, SysCategory.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("分类字典列表数据", "导出人:"+user.getRealname(), "导出信息"));
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
List<SysCategory> listSysCategorys = ExcelImportUtil.importExcel(file.getInputStream(), SysCategory.class, params);
//按照编码长度排序
Collections.sort(listSysCategorys);
log.info("排序后的list====>",listSysCategorys);
for (SysCategory sysCategoryExcel : listSysCategorys) {
String code = sysCategoryExcel.getCode();
if(code.length()>3){
String pCode = sysCategoryExcel.getCode().substring(0,code.length()-3);
log.info("pCode====>",pCode);
String pId=sysCategoryService.queryIdByCode(pCode);
log.info("pId====>",pId);
if(StringUtils.isNotBlank(pId)){
sysCategoryExcel.setPid(pId);
}
}else{
sysCategoryExcel.setPid("0");
}
sysCategoryService.save(sysCategoryExcel);
}
return Result.ok("文件导入成功!数据行数:" + listSysCategorys.size());
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("文件导入失败:"+e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败!");
}
/**
* 加载单个数据 用于回显
*/
@RequestMapping(value = "/loadOne", method = RequestMethod.GET)
public Result<SysCategory> loadOne(@RequestParam(name="field") String field,@RequestParam(name="val") String val) {
Result<SysCategory> result = new Result<SysCategory>();
try {
QueryWrapper<SysCategory> query = new QueryWrapper<SysCategory>();
query.eq(field, val);
List<SysCategory> ls = this.sysCategoryService.list(query);
if(ls==null || ls.size()==0) {
result.setMessage("查询无果");
result.setSuccess(false);
}else if(ls.size()>1) {
result.setMessage("查询数据异常,["+field+"]存在多个值:"+val);
result.setSuccess(false);
}else {
result.setSuccess(true);
result.setResult(ls.get(0));
}
} catch (Exception e) {
e.printStackTrace();
result.setMessage(e.getMessage());
result.setSuccess(false);
}
return result;
}
/**
* 加载节点的子数据
*/
@RequestMapping(value = "/loadTreeChildren", method = RequestMethod.GET)
public Result<List<TreeSelectModel>> loadTreeChildren(@RequestParam(name="pid") String pid) {
Result<List<TreeSelectModel>> result = new Result<List<TreeSelectModel>>();
try {
List<TreeSelectModel> ls = this.sysCategoryService.queryListByPid(pid);
result.setResult(ls);
result.setSuccess(true);
} catch (Exception e) {
e.printStackTrace();
result.setMessage(e.getMessage());
result.setSuccess(false);
}
return result;
}
/**
* 加载一级节点/如果是同步 则所有数据
*/
@RequestMapping(value = "/loadTreeRoot", method = RequestMethod.GET)
public Result<List<TreeSelectModel>> loadTreeRoot(@RequestParam(name="async") Boolean async,@RequestParam(name="pcode") String pcode) {
Result<List<TreeSelectModel>> result = new Result<List<TreeSelectModel>>();
try {
List<TreeSelectModel> ls = this.sysCategoryService.queryListByCode(pcode);
if(!async) {
loadAllCategoryChildren(ls);
}
result.setResult(ls);
result.setSuccess(true);
} catch (Exception e) {
e.printStackTrace();
result.setMessage(e.getMessage());
result.setSuccess(false);
}
return result;
}
/**
* 递归求子节点 同步加载用到
*/
private void loadAllCategoryChildren(List<TreeSelectModel> ls) {
for (TreeSelectModel tsm : ls) {
List<TreeSelectModel> temp = this.sysCategoryService.queryListByPid(tsm.getKey());
if(temp!=null && temp.size()>0) {
tsm.setChildren(temp);
loadAllCategoryChildren(temp);
}
}
}
/**
* 校验编码
* @param pid
* @param code
* @return
*/
@GetMapping(value = "/checkCode")
public Result<?> checkCode(@RequestParam(name="pid",required = false) String pid,@RequestParam(name="code",required = false) String code) {
if(oConvertUtils.isEmpty(code)){
return Result.error("错误,类型编码为空!");
}
if(oConvertUtils.isEmpty(pid)){
return Result.ok();
}
SysCategory parent = this.sysCategoryService.getById(pid);
if(code.startsWith(parent.getCode())){
return Result.ok();
}else{
return Result.error("编码不符合规范,须以\""+parent.getCode()+"\"开头!");
}
}
/**
* 分类字典树控件 加载节点
* @param pid
* @param pcode
* @param condition
* @return
*/
@RequestMapping(value = "/loadTreeData", method = RequestMethod.GET)
public Result<List<TreeSelectModel>> loadDict(@RequestParam(name="pid",required = false) String pid,@RequestParam(name="pcode",required = false) String pcode, @RequestParam(name="condition",required = false) String condition) {
Result<List<TreeSelectModel>> result = new Result<List<TreeSelectModel>>();
//pid如果传值了 就忽略pcode的作用
if(oConvertUtils.isEmpty(pid)){
if(oConvertUtils.isEmpty(pcode)){
result.setSuccess(false);
result.setMessage("加载分类字典树参数有误.[null]!");
return result;
}else{
if(ISysCategoryService.ROOT_PID_VALUE.equals(pcode)){
pid = ISysCategoryService.ROOT_PID_VALUE;
}else{
pid = this.sysCategoryService.queryIdByCode(pcode);
}
if(oConvertUtils.isEmpty(pid)){
result.setSuccess(false);
result.setMessage("加载分类字典树参数有误.[code]!");
return result;
}
}
}
Map<String, String> query = null;
if(oConvertUtils.isNotEmpty(condition)) {
query = JSON.parseObject(condition, Map.class);
}
List<TreeSelectModel> ls = sysCategoryService.queryListByPid(pid,query);
result.setSuccess(true);
result.setResult(ls);
return result;
}
/**
* 分类字典控件数据回显[表单页面]
*
* @param ids
* @return
*/
@RequestMapping(value = "/loadDictItem", method = RequestMethod.GET)
public Result<List<String>> loadDictItem(@RequestParam(name = "ids") String ids) {
Result<List<String>> result = new Result<>();
// 非空判断
if (StringUtils.isBlank(ids)) {
result.setSuccess(false);
result.setMessage("ids 不能为空");
return result;
}
String[] idArray = ids.split(",");
LambdaQueryWrapper<SysCategory> query = new LambdaQueryWrapper<>();
query.in(SysCategory::getId, Arrays.asList(idArray));
// 查询数据
List<SysCategory> list = this.sysCategoryService.list(query);
// 取出name并返回
List<String> textList = list.stream().map(SysCategory::getName).collect(Collectors.toList());
result.setSuccess(true);
result.setResult(textList);
return result;
}
/**
* [列表页面]加载分类字典数据 用于值的替换
* @param code
* @return
*/
@RequestMapping(value = "/loadAllData", method = RequestMethod.GET)
public Result<List<DictModel>> loadAllData(@RequestParam(name="code",required = true) String code) {
Result<List<DictModel>> result = new Result<List<DictModel>>();
LambdaQueryWrapper<SysCategory> query = new LambdaQueryWrapper<SysCategory>();
if(oConvertUtils.isNotEmpty(code) && !"0".equals(code)){
query.likeRight(SysCategory::getCode,code);
}
List<SysCategory> list = this.sysCategoryService.list(query);
if(list==null || list.size()==0) {
result.setMessage("无数据,参数有误.[code]");
result.setSuccess(false);
return result;
}
List<DictModel> rdList = new ArrayList<DictModel>();
for (SysCategory c : list) {
rdList.add(new DictModel(c.getId(),c.getName()));
}
result.setSuccess(true);
result.setResult(rdList);
return result;
}
/**
* 根据父级id批量查询子节点
* @param parentIds
* @return
*/
@GetMapping("/getChildListBatch")
public Result getChildListBatch(@RequestParam("parentIds") String parentIds) {
try {
QueryWrapper<SysCategory> queryWrapper = new QueryWrapper<>();
List<String> parentIdList = Arrays.asList(parentIds.split(","));
queryWrapper.in("pid", parentIdList);
List<SysCategory> list = sysCategoryService.list(queryWrapper);
IPage<SysCategory> pageList = new Page<>(1, 10, list.size());
pageList.setRecords(list);
return Result.OK(pageList);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("批量查询子节点失败:" + e.getMessage());
}
}
}
@@ -0,0 +1,186 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.system.base.controller.JeroController;
import com.jero.common.system.query.QueryGenerator;
import com.jero.modules.system.entity.SysCheckRule;
import com.jero.modules.system.service.ISysCheckRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Arrays;
/**
* @Description: 编码校验规则
* @Author: jero-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
@Slf4j
@Api(tags = "编码校验规则")
@RestController
@RequestMapping("/sys/checkRule")
public class SysCheckRuleController extends JeroController<SysCheckRule, ISysCheckRuleService> {
@Autowired
private ISysCheckRuleService sysCheckRuleService;
/**
* 分页列表查询
*
* @param sysCheckRule
* @param pageNo
* @param pageSize
* @param request
* @return
*/
@AutoLog(value = "编码校验规则-分页列表查询")
@ApiOperation(value = "编码校验规则-分页列表查询", notes = "编码校验规则-分页列表查询")
@GetMapping(value = "/list")
public Result queryPageList(
SysCheckRule sysCheckRule,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest request
) {
QueryWrapper<SysCheckRule> queryWrapper = QueryGenerator.initQueryWrapper(sysCheckRule, request.getParameterMap());
Page<SysCheckRule> page = new Page<>(pageNo, pageSize);
IPage<SysCheckRule> pageList = sysCheckRuleService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 通过id查询
*
* @param ruleCode
* @return
*/
@AutoLog(value = "编码校验规则-通过Code校验传入的值")
@ApiOperation(value = "编码校验规则-通过Code校验传入的值", notes = "编码校验规则-通过Code校验传入的值")
@GetMapping(value = "/checkByCode")
public Result checkByCode(
@RequestParam(name = "ruleCode") String ruleCode,
@RequestParam(name = "value") String value
) throws UnsupportedEncodingException {
SysCheckRule sysCheckRule = sysCheckRuleService.getByCode(ruleCode);
if (sysCheckRule == null) {
return Result.error("该编码不存在");
}
JSONObject errorResult = sysCheckRuleService.checkValue(sysCheckRule, URLDecoder.decode(value, "UTF-8"));
if (errorResult == null) {
return Result.ok();
} else {
Result<Object> r = Result.error(errorResult.getString("message"));
r.setResult(errorResult);
return r;
}
}
/**
* 添加
*
* @param sysCheckRule
* @return
*/
@AutoLog(value = "编码校验规则-添加")
@ApiOperation(value = "编码校验规则-添加", notes = "编码校验规则-添加")
@PostMapping(value = "/add")
public Result add(@RequestBody SysCheckRule sysCheckRule) {
sysCheckRuleService.save(sysCheckRule);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param sysCheckRule
* @return
*/
@AutoLog(value = "编码校验规则-编辑")
@ApiOperation(value = "编码校验规则-编辑", notes = "编码校验规则-编辑")
@PutMapping(value = "/edit")
public Result edit(@RequestBody SysCheckRule sysCheckRule) {
sysCheckRuleService.updateById(sysCheckRule);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "编码校验规则-通过id删除")
@ApiOperation(value = "编码校验规则-通过id删除", notes = "编码校验规则-通过id删除")
@DeleteMapping(value = "/delete")
public Result delete(@RequestParam(name = "id", required = true) String id) {
sysCheckRuleService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "编码校验规则-批量删除")
@ApiOperation(value = "编码校验规则-批量删除", notes = "编码校验规则-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.sysCheckRuleService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "编码校验规则-通过id查询")
@ApiOperation(value = "编码校验规则-通过id查询", notes = "编码校验规则-通过id查询")
@GetMapping(value = "/queryById")
public Result queryById(@RequestParam(name = "id", required = true) String id) {
SysCheckRule sysCheckRule = sysCheckRuleService.getById(id);
return Result.ok(sysCheckRule);
}
/**
* 导出excel
*
* @param request
* @param sysCheckRule
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysCheckRule sysCheckRule) {
return super.exportXls(request, sysCheckRule, SysCheckRule.class, "编码校验规则");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, SysCheckRule.class);
}
}
@@ -0,0 +1,94 @@
package com.jero.modules.system.controller;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.jero.common.api.vo.Result;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysDataLog;
import com.jero.modules.system.service.ISysDataLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
@RestController
@RequestMapping("/sys/dataLog")
@Slf4j
public class SysDataLogController {
@Autowired
private ISysDataLogService service;
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysDataLog>> queryPageList(SysDataLog dataLog,@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,HttpServletRequest req) {
Result<IPage<SysDataLog>> result = new Result<IPage<SysDataLog>>();
QueryWrapper<SysDataLog> queryWrapper = QueryGenerator.initQueryWrapper(dataLog, req.getParameterMap());
Page<SysDataLog> page = new Page<SysDataLog>(pageNo, pageSize);
IPage<SysDataLog> pageList = service.page(page, queryWrapper);
log.info("查询当前页:"+pageList.getCurrent());
log.info("查询当前页数量:"+pageList.getSize());
log.info("查询结果数量:"+pageList.getRecords().size());
log.info("数据总数:"+pageList.getTotal());
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 查询对比数据
* @param req
* @return
*/
@RequestMapping(value = "/queryCompareList", method = RequestMethod.GET)
public Result<List<SysDataLog>> queryCompareList(HttpServletRequest req) {
Result<List<SysDataLog>> result = new Result<>();
String dataId1 = req.getParameter("dataId1");
String dataId2 = req.getParameter("dataId2");
List<String> idList = new ArrayList<String>();
idList.add(dataId1);
idList.add(dataId2);
try {
List<SysDataLog> list = (List<SysDataLog>) service.listByIds(idList);
result.setResult(list);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* 查询版本信息
* @param req
* @return
*/
@RequestMapping(value = "/queryDataVerList", method = RequestMethod.GET)
public Result<List<SysDataLog>> queryDataVerList(HttpServletRequest req) {
Result<List<SysDataLog>> result = new Result<>();
String dataTable = req.getParameter("dataTable");
String dataId = req.getParameter("dataId");
QueryWrapper<SysDataLog> queryWrapper = new QueryWrapper<SysDataLog>();
queryWrapper.eq("data_table", dataTable);
queryWrapper.eq("data_id", dataId);
List<SysDataLog> list = service.list(queryWrapper);
if(list==null||list.size()<=0) {
result.error500("未找到版本信息");
}else {
result.setResult(list);
result.setSuccess(true);
}
return result;
}
}
@@ -0,0 +1,215 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.system.base.controller.JeroController;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.dynamic.db.DataSourceCachePool;
import com.jero.modules.system.entity.SysDataSource;
import com.jero.modules.system.service.ISysDataSourceService;
import com.jero.modules.system.util.SecurityUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.List;
/**
* @Description: 多数据源管理
* @Author: jero-boot
* @Date: 2019-12-25
* @Version: V1.0
*/
@Slf4j
@Api(tags = "多数据源管理")
@RestController
@RequestMapping("/sys/dataSource")
public class SysDataSourceController extends JeroController<SysDataSource, ISysDataSourceService> {
@Autowired
private ISysDataSourceService sysDataSourceService;
/**
* 分页列表查询
*
* @param sysDataSource
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "多数据源管理-分页列表查询")
@ApiOperation(value = "多数据源管理-分页列表查询", notes = "多数据源管理-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(
SysDataSource sysDataSource,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req
) {
QueryWrapper<SysDataSource> queryWrapper = QueryGenerator.initQueryWrapper(sysDataSource, req.getParameterMap());
Page<SysDataSource> page = new Page<>(pageNo, pageSize);
IPage<SysDataSource> pageList = sysDataSourceService.page(page, queryWrapper);
try {
List<SysDataSource> records = pageList.getRecords();
records.forEach(item->{
String dbPassword = item.getDbPassword();
if(StringUtils.isNotBlank(dbPassword)){
String decodedStr = SecurityUtil.jiemi(dbPassword);
item.setDbPassword(decodedStr);
}
});
} catch (Exception e) {
e.printStackTrace();
}
return Result.ok(pageList);
}
@GetMapping(value = "/options")
public Result<?> queryOptions(SysDataSource sysDataSource, HttpServletRequest req) {
QueryWrapper<SysDataSource> queryWrapper = QueryGenerator.initQueryWrapper(sysDataSource, req.getParameterMap());
List<SysDataSource> pageList = sysDataSourceService.list(queryWrapper);
JSONArray array = new JSONArray(pageList.size());
for (SysDataSource item : pageList) {
JSONObject option = new JSONObject(3);
option.put("value", item.getCode());
option.put("label", item.getName());
option.put("text", item.getName());
array.add(option);
}
return Result.ok(array);
}
/**
* 添加
*
* @param sysDataSource
* @return
*/
@AutoLog(value = "多数据源管理-添加")
@ApiOperation(value = "多数据源管理-添加", notes = "多数据源管理-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDataSource sysDataSource) {
try {
String dbPassword = sysDataSource.getDbPassword();
if(StringUtils.isNotBlank(dbPassword)){
String encrypt = SecurityUtil.jiami(dbPassword);
sysDataSource.setDbPassword(encrypt);
}
sysDataSourceService.save(sysDataSource);
} catch (Exception e) {
e.printStackTrace();
}
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param sysDataSource
* @return
*/
@AutoLog(value = "多数据源管理-编辑")
@ApiOperation(value = "多数据源管理-编辑", notes = "多数据源管理-编辑")
@PutMapping(value = "/edit")
public Result<?> edit(@RequestBody SysDataSource sysDataSource) {
try {
SysDataSource d = sysDataSourceService.getById(sysDataSource.getId());
DataSourceCachePool.removeCache(d.getCode());
String dbPassword = sysDataSource.getDbPassword();
if(StringUtils.isNotBlank(dbPassword)){
String encrypt = SecurityUtil.jiami(dbPassword);
sysDataSource.setDbPassword(encrypt);
}
sysDataSourceService.updateById(sysDataSource);
} catch (Exception e) {
e.printStackTrace();
}
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "多数据源管理-通过id删除")
@ApiOperation(value = "多数据源管理-通过id删除", notes = "多数据源管理-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id") String id) {
SysDataSource sysDataSource = sysDataSourceService.getById(id);
DataSourceCachePool.removeCache(sysDataSource.getCode());
sysDataSourceService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "多数据源管理-批量删除")
@ApiOperation(value = "多数据源管理-批量删除", notes = "多数据源管理-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids") String ids) {
List<String> idList = Arrays.asList(ids.split(","));
idList.forEach(item->{
SysDataSource sysDataSource = sysDataSourceService.getById(item);
DataSourceCachePool.removeCache(sysDataSource.getCode());
});
this.sysDataSourceService.removeByIds(idList);
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "多数据源管理-通过id查询")
@ApiOperation(value = "多数据源管理-通过id查询", notes = "多数据源管理-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id") String id) {
SysDataSource sysDataSource = sysDataSourceService.getById(id);
return Result.ok(sysDataSource);
}
/**
* 导出excel
*
* @param request
* @param sysDataSource
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysDataSource sysDataSource) {
return super.exportXls(request, sysDataSource, SysDataSource.class, "多数据源管理");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, SysDataSource.class);
}
}
@@ -0,0 +1,469 @@
package com.jero.modules.system.controller;
import java.io.IOException;
import java.util.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresRoles;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CacheConstant;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.system.util.JwtUtil;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.ImportExcelUtil;
import com.jero.common.util.YouBianCodeUtil;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysDepart;
import com.jero.modules.system.entity.SysUser;
import com.jero.modules.system.model.DepartIdModel;
import com.jero.modules.system.model.SysDepartTreeModel;
import com.jero.modules.system.service.ISysDepartService;
import com.jero.modules.system.service.ISysPositionService;
import com.jero.modules.system.service.ISysUserDepartService;
import com.jero.modules.system.service.ISysUserService;
import com.jero.modules.system.util.FindsDepartsChildrenUtil;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
/**
* <p>
* 部门表 前端控制器
* <p>
*
* @Author: Steve @Since 2019-01-22
*/
@RestController
@RequestMapping("/sys/sysDepart")
@Slf4j
public class SysDepartController {
@Autowired
private ISysDepartService sysDepartService;
@Autowired
public RedisTemplate<String, Object> redisTemplate;
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysUserDepartService sysUserDepartService;
/**
* 查询数据 查出我的部门,并以树结构数据格式响应给前端
*
* @return
*/
@RequestMapping(value = "/queryMyDeptTreeList", method = RequestMethod.GET)
public Result<List<SysDepartTreeModel>> queryMyDeptTreeList() {
Result<List<SysDepartTreeModel>> result = new Result<>();
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
try {
if(oConvertUtils.isNotEmpty(user.getUserIdentity()) && user.getUserIdentity().equals( CommonConstant.USER_IDENTITY_2 )){
List<SysDepartTreeModel> list = sysDepartService.queryMyDeptTreeList(user.getDepartIds());
result.setResult(list);
result.setMessage(CommonConstant.USER_IDENTITY_2.toString());
result.setSuccess(true);
}else{
result.setMessage(CommonConstant.USER_IDENTITY_1.toString());
result.setSuccess(true);
}
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* 查询数据 查出所有部门,并以树结构数据格式响应给前端
*
* @return
*/
@RequestMapping(value = "/queryTreeList", method = RequestMethod.GET)
public Result<List<SysDepartTreeModel>> queryTreeList() {
Result<List<SysDepartTreeModel>> result = new Result<>();
try {
// 从内存中读取
// List<SysDepartTreeModel> list =FindsDepartsChildrenUtil.getSysDepartTreeList();
// if (CollectionUtils.isEmpty(list)) {
// list = sysDepartService.queryTreeList();
// }
List<SysDepartTreeModel> list = sysDepartService.queryTreeList();
result.setResult(list);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* 添加新数据 添加用户新建的部门对象数据,并保存到数据库
*
* @param sysDepart
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/add", method = RequestMethod.POST)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> add(@RequestBody SysDepart sysDepart, HttpServletRequest request) {
Result<SysDepart> result = new Result<SysDepart>();
String username = JwtUtil.getUserNameByToken(request);
try {
sysDepart.setCreateBy(username);
sysDepartService.saveDepartData(sysDepart, username);
//清除部门树内存
// FindsDepartsChildrenUtil.clearSysDepartTreeList();
// FindsDepartsChildrenUtil.clearDepartIdModel();
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑数据 编辑部门的部分数据,并保存到数据库
*
* @param sysDepart
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> edit(@RequestBody SysDepart sysDepart, HttpServletRequest request) {
String username = JwtUtil.getUserNameByToken(request);
sysDepart.setUpdateBy(username);
Result<SysDepart> result = new Result<SysDepart>();
SysDepart sysDepartEntity = sysDepartService.getById(sysDepart.getId());
if (sysDepartEntity == null) {
result.error500("未找到对应实体");
} else {
boolean ok = sysDepartService.updateDepartDataById(sysDepart, username);
// TODO 返回false说明什么?
if (ok) {
//清除部门树内存
//FindsDepartsChildrenUtil.clearSysDepartTreeList();
//FindsDepartsChildrenUtil.clearDepartIdModel();
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> delete(@RequestParam(name="id",required=true) String id) {
Result<SysDepart> result = new Result<SysDepart>();
SysDepart sysDepart = sysDepartService.getById(id);
if(sysDepart==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysDepartService.delete(id);
if(ok) {
//清除部门树内存
//FindsDepartsChildrenUtil.clearSysDepartTreeList();
// FindsDepartsChildrenUtil.clearDepartIdModel();
result.success("删除成功!");
}
}
return result;
}
/**
* 批量删除 根据前端请求的多个ID,对数据库执行删除相关部门数据的操作
*
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
Result<SysDepart> result = new Result<SysDepart>();
if (ids == null || "".equals(ids.trim())) {
result.error500("参数不识别!");
} else {
this.sysDepartService.deleteBatchWithChildren(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 查询数据 添加或编辑页面对该方法发起请求,以树结构形式加载所有部门的名称,方便用户的操作
*
* @return
*/
@RequestMapping(value = "/queryIdTree", method = RequestMethod.GET)
public Result<List<DepartIdModel>> queryIdTree() {
// Result<List<DepartIdModel>> result = new Result<List<DepartIdModel>>();
// List<DepartIdModel> idList;
// try {
// idList = FindsDepartsChildrenUtil.wrapDepartIdModel();
// if (idList != null && idList.size() > 0) {
// result.setResult(idList);
// result.setSuccess(true);
// } else {
// sysDepartService.queryTreeList();
// idList = FindsDepartsChildrenUtil.wrapDepartIdModel();
// result.setResult(idList);
// result.setSuccess(true);
// }
// return result;
// } catch (Exception e) {
// log.error(e.getMessage(),e);
// result.setSuccess(false);
// return result;
// }
Result<List<DepartIdModel>> result = new Result<>();
try {
List<DepartIdModel> list = sysDepartService.queryDepartIdTreeList();
result.setResult(list);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* <p>
* 部门搜索功能方法,根据关键字模糊搜索相关部门
* </p>
*
* @param keyWord
* @return
*/
@RequestMapping(value = "/searchBy", method = RequestMethod.GET)
public Result<List<SysDepartTreeModel>> searchBy(@RequestParam(name = "keyWord", required = true) String keyWord,@RequestParam(name = "myDeptSearch", required = false) String myDeptSearch) {
Result<List<SysDepartTreeModel>> result = new Result<List<SysDepartTreeModel>>();
//部门查询,myDeptSearch为1时为我的部门查询,登录用户为上级时查只查负责部门下数据
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String departIds = null;
if(oConvertUtils.isNotEmpty(user.getUserIdentity()) && user.getUserIdentity().equals( CommonConstant.USER_IDENTITY_2 )){
departIds = user.getDepartIds();
}
List<SysDepartTreeModel> treeList = this.sysDepartService.searhBy(keyWord,myDeptSearch,departIds);
if (treeList == null || treeList.size() == 0) {
result.setSuccess(false);
result.setMessage("未查询匹配数据!");
return result;
}
result.setResult(treeList);
return result;
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysDepart sysDepart,HttpServletRequest request) {
// Step.1 组装查询条件
QueryWrapper<SysDepart> queryWrapper = QueryGenerator.initQueryWrapper(sysDepart, request.getParameterMap());
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<SysDepart> pageList = sysDepartService.list(queryWrapper);
//按字典排序
Collections.sort(pageList, new Comparator<SysDepart>() {
@Override
public int compare(SysDepart arg0, SysDepart arg1) {
return arg0.getOrgCode().compareTo(arg1.getOrgCode());
}
});
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "部门列表");
mv.addObject(NormalExcelConstants.CLASS, SysDepart.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("部门列表数据", "导出人:"+user.getRealname(), "导出信息"));
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
List<String> errorMessageList = new ArrayList<>();
List<SysDepart> listSysDeparts = null;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
// orgCode编码长度
int codeLength = YouBianCodeUtil.zhanweiLength;
listSysDeparts = ExcelImportUtil.importExcel(file.getInputStream(), SysDepart.class, params);
//按长度排序
Collections.sort(listSysDeparts, new Comparator<SysDepart>() {
@Override
public int compare(SysDepart arg0, SysDepart arg1) {
return arg0.getOrgCode().length() - arg1.getOrgCode().length();
}
});
int num = 0;
for (SysDepart sysDepart : listSysDeparts) {
String orgCode = sysDepart.getOrgCode();
if(orgCode.length() > codeLength) {
String parentCode = orgCode.substring(0, orgCode.length()-codeLength);
QueryWrapper<SysDepart> queryWrapper = new QueryWrapper<SysDepart>();
queryWrapper.eq("org_code", parentCode);
try {
SysDepart parentDept = sysDepartService.getOne(queryWrapper);
if(!parentDept.equals(null)) {
sysDepart.setParentId(parentDept.getId());
} else {
sysDepart.setParentId("");
}
}catch (Exception e) {
//没有查找到parentDept
}
}else{
sysDepart.setParentId("");
}
//update-begin---author:liusq Date:20210223 for:批量导入部门以后,不能追加下一级部门 #2245------------
sysDepart.setOrgType(sysDepart.getOrgCode().length()/codeLength+"");
//update-end---author:liusq Date:20210223 for:批量导入部门以后,不能追加下一级部门 #2245------------
sysDepart.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
ImportExcelUtil.importDateSaveOne(sysDepart, ISysDepartService.class, errorMessageList, num, CommonConstant.SQL_INDEX_UNIQ_DEPART_ORG_CODE);
num++;
}
//清空部门缓存
Set keys3 = redisTemplate.keys(CacheConstant.SYS_DEPARTS_CACHE + "*");
Set keys4 = redisTemplate.keys(CacheConstant.SYS_DEPART_IDS_CACHE + "*");
redisTemplate.delete(keys3);
redisTemplate.delete(keys4);
return ImportExcelUtil.imporReturnRes(errorMessageList.size(), listSysDeparts.size() - errorMessageList.size(), errorMessageList);
} catch (Exception e) {
log.error(e.getMessage(),e);
return Result.error("文件导入失败:"+e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败!");
}
/**
* 查询所有部门信息
* @return
*/
@GetMapping("listAll")
public Result<List<SysDepart>> listAll(@RequestParam(name = "id", required = false) String id) {
Result<List<SysDepart>> result = new Result<>();
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
query.orderByAsc(SysDepart::getOrgCode);
if(oConvertUtils.isNotEmpty(id)){
String arr[] = id.split(",");
query.in(SysDepart::getId,arr);
}
List<SysDepart> ls = this.sysDepartService.list(query);
result.setSuccess(true);
result.setResult(ls);
return result;
}
/**
* 查询数据 查出所有部门,并以树结构数据格式响应给前端
*
* @return
*/
@RequestMapping(value = "/queryTreeByKeyWord", method = RequestMethod.GET)
public Result<Map<String,Object>> queryTreeByKeyWord(@RequestParam(name = "keyWord", required = false) String keyWord) {
Result<Map<String,Object>> result = new Result<>();
try {
Map<String,Object> map=new HashMap<String,Object>();
List<SysDepartTreeModel> list = sysDepartService.queryTreeByKeyWord(keyWord);
//根据keyWord获取用户信息
LambdaQueryWrapper<SysUser> queryUser = new LambdaQueryWrapper<SysUser>();
queryUser.eq(SysUser::getDelFlag,CommonConstant.DEL_FLAG_0);
queryUser.and(i -> i.like(SysUser::getUsername, keyWord).or().like(SysUser::getRealname, keyWord));
List<SysUser> sysUsers = this.sysUserService.list(queryUser);
map.put("userList",sysUsers);
map.put("departList",list);
result.setResult(map);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* 根据部门编码获取部门信息
*
* @param orgCode
* @return
*/
@GetMapping("/getDepartName")
public Result<SysDepart> getDepartName(@RequestParam(name = "orgCode") String orgCode) {
Result<SysDepart> result = new Result<>();
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<>();
query.eq(SysDepart::getOrgCode, orgCode);
SysDepart sysDepart = sysDepartService.getOne(query);
result.setSuccess(true);
result.setResult(sysDepart);
return result;
}
/**
* 根据部门id获取用户信息
*
* @param id
* @return
*/
@GetMapping("/getUsersByDepartId")
public Result<List<SysUser>> getUsersByDepartId(@RequestParam(name = "id") String id) {
Result<List<SysUser>> result = new Result<>();
List<SysUser> sysUsers = sysUserDepartService.queryUserByDepId(id);
result.setSuccess(true);
result.setResult(sysUsers);
return result;
}
}
@@ -0,0 +1,314 @@
package com.jero.modules.system.controller;
import java.util.*;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.base.controller.JeroController;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysDepartPermission;
import com.jero.modules.system.entity.SysDepartRolePermission;
import com.jero.modules.system.entity.SysPermission;
import com.jero.modules.system.entity.SysPermissionDataRule;
import com.jero.modules.system.model.TreeModel;
import com.jero.modules.system.service.ISysDepartPermissionService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import com.jero.modules.system.service.ISysDepartRolePermissionService;
import com.jero.modules.system.service.ISysPermissionDataRuleService;
import com.jero.modules.system.service.ISysPermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
/**
* @Description: 部门权限表
* @Author: jero-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
@Slf4j
@Api(tags="部门权限表")
@RestController
@RequestMapping("/sys/sysDepartPermission")
public class SysDepartPermissionController extends JeroController<SysDepartPermission, ISysDepartPermissionService> {
@Autowired
private ISysDepartPermissionService sysDepartPermissionService;
@Autowired
private ISysPermissionDataRuleService sysPermissionDataRuleService;
@Autowired
private ISysPermissionService sysPermissionService;
@Autowired
private ISysDepartRolePermissionService sysDepartRolePermissionService;
/**
* 分页列表查询
*
* @param sysDepartPermission
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@ApiOperation(value="部门权限表-分页列表查询", notes="部门权限表-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(SysDepartPermission sysDepartPermission,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<SysDepartPermission> queryWrapper = QueryGenerator.initQueryWrapper(sysDepartPermission, req.getParameterMap());
Page<SysDepartPermission> page = new Page<SysDepartPermission>(pageNo, pageSize);
IPage<SysDepartPermission> pageList = sysDepartPermissionService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 添加
*
* @param sysDepartPermission
* @return
*/
@ApiOperation(value="部门权限表-添加", notes="部门权限表-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDepartPermission sysDepartPermission) {
sysDepartPermissionService.save(sysDepartPermission);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param sysDepartPermission
* @return
*/
@ApiOperation(value="部门权限表-编辑", notes="部门权限表-编辑")
@PutMapping(value = "/edit")
public Result<?> edit(@RequestBody SysDepartPermission sysDepartPermission) {
sysDepartPermissionService.updateById(sysDepartPermission);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@ApiOperation(value="部门权限表-通过id删除", notes="部门权限表-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysDepartPermissionService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@ApiOperation(value="部门权限表-批量删除", notes="部门权限表-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
this.sysDepartPermissionService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@ApiOperation(value="部门权限表-通过id查询", notes="部门权限表-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name="id",required=true) String id) {
SysDepartPermission sysDepartPermission = sysDepartPermissionService.getById(id);
return Result.ok(sysDepartPermission);
}
/**
* 导出excel
*
* @param request
* @param sysDepartPermission
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysDepartPermission sysDepartPermission) {
return super.exportXls(request, sysDepartPermission, SysDepartPermission.class, "部门权限表");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, SysDepartPermission.class);
}
/**
* 部门管理授权查询数据规则数据
*/
@GetMapping(value = "/datarule/{permissionId}/{departId}")
public Result<?> loadDatarule(@PathVariable("permissionId") String permissionId,@PathVariable("departId") String departId) {
List<SysPermissionDataRule> list = sysPermissionDataRuleService.getPermRuleListByPermId(permissionId);
if(list==null || list.size()==0) {
return Result.error("未找到权限配置信息");
}else {
Map<String,Object> map = new HashMap<>();
map.put("datarule", list);
LambdaQueryWrapper<SysDepartPermission> query = new LambdaQueryWrapper<SysDepartPermission>()
.eq(SysDepartPermission::getPermissionId, permissionId)
.eq(SysDepartPermission::getDepartId,departId);
SysDepartPermission sysDepartPermission = sysDepartPermissionService.getOne(query);
if(sysDepartPermission==null) {
//return Result.error("未找到角色菜单配置信息");
}else {
String drChecked = sysDepartPermission.getDataRuleIds();
if(oConvertUtils.isNotEmpty(drChecked)) {
map.put("drChecked", drChecked.endsWith(",")?drChecked.substring(0, drChecked.length()-1):drChecked);
}
}
return Result.ok(map);
//TODO 以后按钮权限的查询也走这个请求 无非在map中多加两个key
}
}
/**
* 保存数据规则至部门菜单关联表
*/
@PostMapping(value = "/datarule")
public Result<?> saveDatarule(@RequestBody JSONObject jsonObject) {
try {
String permissionId = jsonObject.getString("permissionId");
String departId = jsonObject.getString("departId");
String dataRuleIds = jsonObject.getString("dataRuleIds");
log.info("保存数据规则>>"+"菜单ID:"+permissionId+"部门ID:"+ departId+"数据权限ID:"+dataRuleIds);
LambdaQueryWrapper<SysDepartPermission> query = new LambdaQueryWrapper<SysDepartPermission>()
.eq(SysDepartPermission::getPermissionId, permissionId)
.eq(SysDepartPermission::getDepartId,departId);
SysDepartPermission sysDepartPermission = sysDepartPermissionService.getOne(query);
if(sysDepartPermission==null) {
return Result.error("请先保存部门菜单权限!");
}else {
sysDepartPermission.setDataRuleIds(dataRuleIds);
this.sysDepartPermissionService.updateById(sysDepartPermission);
}
} catch (Exception e) {
log.error("SysDepartPermissionController.saveDatarule()发生异常:" + e.getMessage(),e);
return Result.error("保存失败");
}
return Result.ok("保存成功!");
}
/**
* 查询角色授权
*
* @return
*/
@RequestMapping(value = "/queryDeptRolePermission", method = RequestMethod.GET)
public Result<List<String>> queryDeptRolePermission(@RequestParam(name = "roleId", required = true) String roleId) {
Result<List<String>> result = new Result<>();
try {
List<SysDepartRolePermission> list = sysDepartRolePermissionService.list(new QueryWrapper<SysDepartRolePermission>().lambda().eq(SysDepartRolePermission::getRoleId, roleId));
result.setResult(list.stream().map(SysDepartRolePermission -> String.valueOf(SysDepartRolePermission.getPermissionId())).collect(Collectors.toList()));
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 保存角色授权
*
* @return
*/
@RequestMapping(value = "/saveDeptRolePermission", method = RequestMethod.POST)
public Result<String> saveDeptRolePermission(@RequestBody JSONObject json) {
long start = System.currentTimeMillis();
Result<String> result = new Result<>();
try {
String roleId = json.getString("roleId");
String permissionIds = json.getString("permissionIds");
String lastPermissionIds = json.getString("lastpermissionIds");
this.sysDepartRolePermissionService.saveDeptRolePermission(roleId, permissionIds, lastPermissionIds);
result.success("保存成功!");
log.info("======部门角色授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
} catch (Exception e) {
result.error500("授权失败!");
log.error(e.getMessage(), e);
}
return result;
}
/**
* 用户角色授权功能,查询菜单权限树
* @param request
* @return
*/
@RequestMapping(value = "/queryTreeListForDeptRole", method = RequestMethod.GET)
public Result<Map<String,Object>> queryTreeListForDeptRole(@RequestParam(name="departId",required=true) String departId,HttpServletRequest request) {
Result<Map<String,Object>> result = new Result<>();
//全部权限ids
List<String> ids = new ArrayList<>();
try {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
query.inSql(SysPermission::getId,"select permission_id from sys_depart_permission where depart_id='"+departId+"'");
List<SysPermission> list = sysPermissionService.list(query);
for(SysPermission sysPer : list) {
ids.add(sysPer.getId());
}
List<TreeModel> treeList = new ArrayList<>();
getTreeModelList(treeList, list, null);
Map<String,Object> resMap = new HashMap<String,Object>();
resMap.put("treeList", treeList); //全部树节点数据
resMap.put("ids", ids);//全部树ids
result.setResult(resMap);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
private void getTreeModelList(List<TreeModel> treeList, List<SysPermission> metaList, TreeModel temp) {
for (SysPermission permission : metaList) {
String tempPid = permission.getParentId();
TreeModel tree = new TreeModel(permission.getId(), tempPid, permission.getName(),permission.getRuleFlag(), permission.isLeaf());
if(temp==null && oConvertUtils.isEmpty(tempPid)) {
treeList.add(tree);
if(!tree.getIsLeaf()) {
getTreeModelList(treeList, metaList, tree);
}
}else if(temp!=null && tempPid!=null && tempPid.equals(temp.getKey())){
temp.getChildren().add(tree);
if(!tree.getIsLeaf()) {
getTreeModelList(treeList, metaList, tree);
}
}
}
}
}
@@ -0,0 +1,291 @@
package com.jero.modules.system.controller;
import java.util.*;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.system.base.controller.JeroController;
import org.apache.shiro.SecurityUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.*;
import com.jero.modules.system.service.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
/**
* @Description: 部门角色
* @Author: jero-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Slf4j
@Api(tags="部门角色")
@RestController
@RequestMapping("/sys/sysDepartRole")
public class SysDepartRoleController extends JeroController<SysDepartRole, ISysDepartRoleService> {
@Autowired
private ISysDepartRoleService sysDepartRoleService;
@Autowired
private ISysDepartRoleUserService departRoleUserService;
@Autowired
private ISysDepartPermissionService sysDepartPermissionService;
@Autowired
private ISysDepartRolePermissionService sysDepartRolePermissionService;
@Autowired
private ISysDepartService sysDepartService;
/**
* 分页列表查询
*
* @param sysDepartRole
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@ApiOperation(value="部门角色-分页列表查询", notes="部门角色-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(SysDepartRole sysDepartRole,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
@RequestParam(name="deptId",required=false) String deptId,
HttpServletRequest req) {
QueryWrapper<SysDepartRole> queryWrapper = QueryGenerator.initQueryWrapper(sysDepartRole, req.getParameterMap());
Page<SysDepartRole> page = new Page<SysDepartRole>(pageNo, pageSize);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
List<String> deptIds = null;
// if(oConvertUtils.isEmpty(deptId)){
// if(oConvertUtils.isNotEmpty(user.getUserIdentity()) && user.getUserIdentity().equals(CommonConstant.USER_IDENTITY_2) ){
// deptIds = sysDepartService.getMySubDepIdsByDepId(user.getDepartIds());
// }else{
// return Result.ok(null);
// }
// }else{
// deptIds = sysDepartService.getSubDepIdsByDepId(deptId);
// }
// queryWrapper.in("depart_id",deptIds);
//我的部门,选中部门只能看当前部门下的角色
queryWrapper.eq("depart_id",deptId);
IPage<SysDepartRole> pageList = sysDepartRoleService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 添加
*
* @param sysDepartRole
* @return
*/
//@RequiresRoles({"admin"})
@ApiOperation(value="部门角色-添加", notes="部门角色-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDepartRole sysDepartRole) {
sysDepartRoleService.save(sysDepartRole);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param sysDepartRole
* @return
*/
//@RequiresRoles({"admin"})
@ApiOperation(value="部门角色-编辑", notes="部门角色-编辑")
@PutMapping(value = "/edit")
public Result<?> edit(@RequestBody SysDepartRole sysDepartRole) {
sysDepartRoleService.updateById(sysDepartRole);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@AutoLog(value = "部门角色-通过id删除")
@ApiOperation(value="部门角色-通过id删除", notes="部门角色-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysDepartRoleService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@AutoLog(value = "部门角色-批量删除")
@ApiOperation(value="部门角色-批量删除", notes="部门角色-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
this.sysDepartRoleService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@ApiOperation(value="部门角色-通过id查询", notes="部门角色-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name="id",required=true) String id) {
SysDepartRole sysDepartRole = sysDepartRoleService.getById(id);
return Result.ok(sysDepartRole);
}
/**
* 获取部门下角色
* @param departId
* @return
*/
@RequestMapping(value = "/getDeptRoleList", method = RequestMethod.GET)
public Result<List<SysDepartRole>> getDeptRoleList(@RequestParam(value = "departId") String departId,@RequestParam(value = "userId") String userId){
Result<List<SysDepartRole>> result = new Result<>();
//查询选中部门的角色
List<SysDepartRole> deptRoleList = sysDepartRoleService.list(new LambdaQueryWrapper<SysDepartRole>().eq(SysDepartRole::getDepartId,departId));
result.setSuccess(true);
result.setResult(deptRoleList);
return result;
}
/**
* 设置
* @param json
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deptRoleUserAdd", method = RequestMethod.POST)
public Result<?> deptRoleAdd(@RequestBody JSONObject json) {
String newRoleId = json.getString("newRoleId");
String oldRoleId = json.getString("oldRoleId");
String userId = json.getString("userId");
departRoleUserService.deptRoleUserAdd(userId,newRoleId,oldRoleId);
return Result.ok("添加成功!");
}
/**
* 根据用户id获取已设置部门角色
* @param userId
* @return
*/
@RequestMapping(value = "/getDeptRoleByUserId", method = RequestMethod.GET)
public Result<List<SysDepartRoleUser>> getDeptRoleByUserId(@RequestParam(value = "userId") String userId,@RequestParam(value = "departId") String departId){
Result<List<SysDepartRoleUser>> result = new Result<>();
//查询部门下角色
List<SysDepartRole> roleList = sysDepartRoleService.list(new QueryWrapper<SysDepartRole>().eq("depart_id",departId));
List<String> roleIds = roleList.stream().map(SysDepartRole::getId).collect(Collectors.toList());
//根据角色id,用户id查询已授权角色
List<SysDepartRoleUser> roleUserList = departRoleUserService.list(new QueryWrapper<SysDepartRoleUser>().eq("user_id",userId).in("drole_id",roleIds));
result.setSuccess(true);
result.setResult(roleUserList);
return result;
}
/**
* 查询数据规则数据
*/
@GetMapping(value = "/datarule/{permissionId}/{departId}/{roleId}")
public Result<?> loadDatarule(@PathVariable("permissionId") String permissionId,@PathVariable("departId") String departId,@PathVariable("roleId") String roleId) {
//查询已授权的部门规则
List<SysPermissionDataRule> list = sysDepartPermissionService.getPermRuleListByDeptIdAndPermId(departId,permissionId);
if(list==null || list.size()==0) {
return Result.error("未找到权限配置信息");
}else {
Map<String,Object> map = new HashMap<>();
map.put("datarule", list);
LambdaQueryWrapper<SysDepartRolePermission> query = new LambdaQueryWrapper<SysDepartRolePermission>()
.eq(SysDepartRolePermission::getPermissionId, permissionId)
.eq(SysDepartRolePermission::getRoleId,roleId);
SysDepartRolePermission sysRolePermission = sysDepartRolePermissionService.getOne(query);
if(sysRolePermission==null) {
//return Result.error("未找到角色菜单配置信息");
}else {
String drChecked = sysRolePermission.getDataRuleIds();
if(oConvertUtils.isNotEmpty(drChecked)) {
map.put("drChecked", drChecked.endsWith(",")?drChecked.substring(0, drChecked.length()-1):drChecked);
}
}
return Result.ok(map);
//TODO 以后按钮权限的查询也走这个请求 无非在map中多加两个key
}
}
/**
* 保存数据规则至角色菜单关联表
*/
@PostMapping(value = "/datarule")
public Result<?> saveDatarule(@RequestBody JSONObject jsonObject) {
try {
String permissionId = jsonObject.getString("permissionId");
String roleId = jsonObject.getString("roleId");
String dataRuleIds = jsonObject.getString("dataRuleIds");
log.info("保存数据规则>>"+"菜单ID:"+permissionId+"角色ID:"+ roleId+"数据权限ID:"+dataRuleIds);
LambdaQueryWrapper<SysDepartRolePermission> query = new LambdaQueryWrapper<SysDepartRolePermission>()
.eq(SysDepartRolePermission::getPermissionId, permissionId)
.eq(SysDepartRolePermission::getRoleId,roleId);
SysDepartRolePermission sysRolePermission = sysDepartRolePermissionService.getOne(query);
if(sysRolePermission==null) {
return Result.error("请先保存角色菜单权限!");
}else {
sysRolePermission.setDataRuleIds(dataRuleIds);
this.sysDepartRolePermissionService.updateById(sysRolePermission);
}
} catch (Exception e) {
log.error("SysRoleController.saveDatarule()发生异常:" + e.getMessage(),e);
return Result.error("保存失败");
}
return Result.ok("保存成功!");
}
/**
* 导出excel
*
* @param request
* @param sysDepartRole
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysDepartRole sysDepartRole) {
return super.exportXls(request, sysDepartRole, SysDepartRole.class, "部门角色");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, SysDepartRole.class);
}
}
@@ -0,0 +1,565 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresRoles;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CacheConstant;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.system.vo.DictModel;
import com.jero.common.system.vo.DictQuery;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.ImportExcelUtil;
import com.jero.common.util.SqlInjectionUtil;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysDict;
import com.jero.modules.system.entity.SysDictItem;
import com.jero.modules.system.model.SysDictTree;
import com.jero.modules.system.model.TreeSelectModel;
import com.jero.modules.system.service.ISysDictItemService;
import com.jero.modules.system.service.ISysDictService;
import com.jero.modules.system.vo.SysDictPage;
import org.jeecgframework.poi.excel.ExcelImportCheckUtil;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
/**
* <p>
* 字典表 前端控制器
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@RestController
@RequestMapping("/sys/dict")
@Slf4j
public class SysDictController {
@Autowired
private ISysDictService sysDictService;
@Autowired
private ISysDictItemService sysDictItemService;
@Autowired
public RedisTemplate<String, Object> redisTemplate;
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysDict>> queryPageList(SysDict sysDict, @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize, HttpServletRequest req) {
Result<IPage<SysDict>> result = new Result<IPage<SysDict>>();
QueryWrapper<SysDict> queryWrapper = QueryGenerator.initQueryWrapper(sysDict, req.getParameterMap());
Page<SysDict> page = new Page<SysDict>(pageNo, pageSize);
IPage<SysDict> pageList = sysDictService.page(page, queryWrapper);
log.debug("查询当前页:"+pageList.getCurrent());
log.debug("查询当前页数量:"+pageList.getSize());
log.debug("查询结果数量:"+pageList.getRecords().size());
log.debug("数据总数:"+pageList.getTotal());
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* @功能:获取树形字典数据
* @param sysDict
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@SuppressWarnings("unchecked")
@RequestMapping(value = "/treeList", method = RequestMethod.GET)
public Result<List<SysDictTree>> treeList(SysDict sysDict, @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize, HttpServletRequest req) {
Result<List<SysDictTree>> result = new Result<>();
LambdaQueryWrapper<SysDict> query = new LambdaQueryWrapper<>();
// 构造查询条件
String dictName = sysDict.getDictName();
if(oConvertUtils.isNotEmpty(dictName)) {
query.like(true, SysDict::getDictName, dictName);
}
query.orderByDesc(true, SysDict::getCreateTime);
List<SysDict> list = sysDictService.list(query);
List<SysDictTree> treeList = new ArrayList<>();
for (SysDict node : list) {
treeList.add(new SysDictTree(node));
}
result.setSuccess(true);
result.setResult(treeList);
return result;
}
/**
* 获取字典数据
* @param dictCode 字典code
* @param dictCode 表名,文本字段,code字段 | 举例:sys_user,realname,id
* @return
*/
@RequestMapping(value = "/getDictItems/{dictCode}", method = RequestMethod.GET)
public Result<List<DictModel>> getDictItems(@PathVariable String dictCode, @RequestParam(value = "sign",required = false) String sign, HttpServletRequest request) {
log.info(" dictCode : "+ dictCode);
Result<List<DictModel>> result = new Result<List<DictModel>>();
List<DictModel> ls = null;
try {
if(dictCode.indexOf(",")!=-1) {
//关联表字典(举例:sys_user,realname,id
String[] params = dictCode.split(",");
if(params.length<3) {
result.error500("字典Code格式不正确!");
return result;
}
//SQL注入校验(只限制非法串改数据库)
final String[] sqlInjCheck = {params[0],params[1],params[2]};
SqlInjectionUtil.filterContent(sqlInjCheck);
if(params.length==4) {
//SQL注入校验(查询条件SQL 特殊check,此方法仅供此处使用)
SqlInjectionUtil.specialFilterContent(params[3]);
ls = sysDictService.queryTableDictItemsByCodeAndFilter(params[0],params[1],params[2],params[3]);
}else if (params.length==3) {
ls = sysDictService.queryTableDictItemsByCode(params[0],params[1],params[2]);
}else{
result.error500("字典Code格式不正确!");
return result;
}
}else {
//字典表
ls = sysDictService.queryDictItemsByCode(dictCode);
}
result.setSuccess(true);
result.setResult(ls);
log.debug(result.toString());
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
return result;
}
return result;
}
/**
* 获取全部字典数据
*
* @return
*/
@RequestMapping(value = "/queryAllDictItems", method = RequestMethod.GET)
public Result<?> queryAllDictItems(HttpServletRequest request) {
Map<String, List<DictModel>> res = new HashMap<String, List<DictModel>>();
res = sysDictService.queryAllDictItems();
return Result.ok(res);
}
/**
* 获取字典数据
* @param dictCode
* @return
*/
@RequestMapping(value = "/getDictText/{dictCode}/{key}", method = RequestMethod.GET)
public Result<String> getDictText(@PathVariable("dictCode") String dictCode, @PathVariable("key") String key) {
log.info(" dictCode : "+ dictCode);
Result<String> result = new Result<String>();
String text = null;
try {
text = sysDictService.queryDictTextByKey(dictCode, key);
result.setSuccess(true);
result.setResult(text);
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
return result;
}
return result;
}
/**
* 大数据量的字典表 走异步加载 即前端输入内容过滤数据
* @param dictCode
* @return
*/
@RequestMapping(value = "/loadDict/{dictCode}", method = RequestMethod.GET)
public Result<List<DictModel>> loadDict(@PathVariable String dictCode,
@RequestParam(name="keyword") String keyword,
@RequestParam(value = "sign",required = false) String sign,
@RequestParam(value = "pageSize", required = false) Integer pageSize) {
log.info(" 加载字典表数据,加载关键字: "+ keyword);
Result<List<DictModel>> result = new Result<List<DictModel>>();
List<DictModel> ls = null;
try {
if(dictCode.indexOf(",")!=-1) {
String[] params = dictCode.split(",");
if(params.length!=3) {
result.error500("字典Code格式不正确!");
return result;
}
if(pageSize!=null){
ls = sysDictService.queryLittleTableDictItems(params[0],params[1],params[2],keyword, pageSize);
}else{
ls = sysDictService.queryTableDictItems(params[0],params[1],params[2],keyword);
}
result.setSuccess(true);
result.setResult(ls);
log.info(result.toString());
}else {
result.error500("字典Code格式不正确!");
}
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
return result;
}
return result;
}
/**
* 根据字典code加载字典text 返回
*/
@RequestMapping(value = "/loadDictItem/{dictCode}", method = RequestMethod.GET)
public Result<List<String>> loadDictItem(@PathVariable String dictCode, @RequestParam(name="key") String keys, @RequestParam(value = "sign",required = false) String sign, HttpServletRequest request) {
Result<List<String>> result = new Result<>();
try {
if(dictCode.indexOf(",")!=-1) {
String[] params = dictCode.split(",");
if(params.length!=3) {
result.error500("字典Code格式不正确!");
return result;
}
List<String> texts = sysDictService.queryTableDictByKeys(params[0], params[1], params[2], keys);
result.setSuccess(true);
result.setResult(texts);
log.info(result.toString());
}else {
result.error500("字典Code格式不正确!");
}
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
return result;
}
return result;
}
/**
* 根据表名——显示字段-存储字段 pid 加载树形数据
*/
@SuppressWarnings("unchecked")
@RequestMapping(value = "/loadTreeData", method = RequestMethod.GET)
public Result<List<TreeSelectModel>> loadTreeData(@RequestParam(name="pid") String pid, @RequestParam(name="pidField") String pidField,
@RequestParam(name="tableName") String tbname,
@RequestParam(name="text") String text,
@RequestParam(name="code") String code,
@RequestParam(name="hasChildField") String hasChildField,
@RequestParam(name="condition") String condition,
@RequestParam(value = "sign",required = false) String sign, HttpServletRequest request) {
Result<List<TreeSelectModel>> result = new Result<List<TreeSelectModel>>();
Map<String, String> query = null;
if(oConvertUtils.isNotEmpty(condition)) {
query = JSON.parseObject(condition, Map.class);
}
// SQL注入漏洞 sign签名校验(表名,label字段,val字段,条件)
String dictCode = tbname+","+text+","+code+","+condition;
SqlInjectionUtil.filterContent(dictCode);
List<TreeSelectModel> ls = sysDictService.queryTreeList(query,tbname, text, code, pidField, pid,hasChildField);
result.setSuccess(true);
result.setResult(ls);
return result;
}
/**
* 【APP接口】根据字典配置查询表字典数据(目前暂未找到调用的地方)
* @param query
* @param pageNo
* @param pageSize
* @return
*/
@Deprecated
@GetMapping("/queryTableData")
public Result<List<DictModel>> queryTableData(DictQuery query,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
@RequestParam(value = "sign",required = false) String sign, HttpServletRequest request){
Result<List<DictModel>> res = new Result<List<DictModel>>();
// SQL注入漏洞 sign签名校验
String dictCode = query.getTable()+","+query.getText()+","+query.getCode();
SqlInjectionUtil.filterContent(dictCode);
List<DictModel> ls = this.sysDictService.queryDictTablePageList(query,pageSize,pageNo);
res.setResult(ls);
res.setSuccess(true);
return res;
}
/**
* @功能:新增
* @param sysDict
* @return
*/
@RequiresRoles({"admin"})
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysDict> add(@RequestBody SysDict sysDict) {
Result<SysDict> result = new Result<SysDict>();
try {
sysDict.setCreateTime(new Date());
sysDict.setDelFlag(CommonConstant.DEL_FLAG_0);
sysDictService.save(sysDict);
result.success("保存成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* @功能:编辑
* @param sysDict
* @return
*/
@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysDict> edit(@RequestBody SysDict sysDict) {
Result<SysDict> result = new Result<SysDict>();
SysDict sysdict = sysDictService.getById(sysDict.getId());
if(sysdict==null) {
result.error500("未找到对应实体");
}else {
sysDict.setUpdateTime(new Date());
boolean ok = sysDictService.updateById(sysDict);
if(ok) {
result.success("编辑成功!");
}
}
return result;
}
/**
* @功能:删除
* @param id
* @return
*/
@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDict> delete(@RequestParam(name="id",required=true) String id) {
Result<SysDict> result = new Result<SysDict>();
boolean ok = sysDictService.removeById(id);
if(ok) {
result.success("删除成功!");
}else{
result.error500("删除失败!");
}
return result;
}
/**
* @功能:批量删除
* @param ids
* @return
*/
@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value= CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDict> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysDict> result = new Result<SysDict>();
if(oConvertUtils.isEmpty(ids)) {
result.error500("参数不识别!");
}else {
sysDictService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* @功能:刷新缓存
* @return
*/
@RequestMapping(value = "/refleshCache")
public Result<?> refleshCache() {
Result<?> result = new Result<SysDict>();
//清空字典缓存
Set keys = redisTemplate.keys(CacheConstant.SYS_DICT_CACHE + "*");
Set keys2 = redisTemplate.keys(CacheConstant.SYS_DICT_TABLE_CACHE + "*");
Set keys3 = redisTemplate.keys(CacheConstant.SYS_DEPARTS_CACHE + "*");
Set keys4 = redisTemplate.keys(CacheConstant.SYS_DEPART_IDS_CACHE + "*");
Set keys5 = redisTemplate.keys( "jmreport:cache:dict*");
Set keys6 = redisTemplate.keys( "jmreport:cache:dictTable*");
redisTemplate.delete(keys);
redisTemplate.delete(keys2);
redisTemplate.delete(keys3);
redisTemplate.delete(keys4);
redisTemplate.delete(keys5);
redisTemplate.delete(keys6);
return result;
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysDict sysDict, HttpServletRequest request) {
// Step.1 组装查询条件
QueryWrapper<SysDict> queryWrapper = QueryGenerator.initQueryWrapper(sysDict, request.getParameterMap());
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<SysDictPage> pageList = new ArrayList<SysDictPage>();
List<SysDict> sysDictList = sysDictService.list(queryWrapper);
for (SysDict dictMain : sysDictList) {
SysDictPage vo = new SysDictPage();
BeanUtils.copyProperties(dictMain, vo);
// 查询机票
List<SysDictItem> sysDictItemList = sysDictItemService.selectItemsByMainId(dictMain.getId());
vo.setSysDictItemList(sysDictItemList);
pageList.add(vo);
}
// 导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "数据字典");
// 注解对象Class
mv.addObject(NormalExcelConstants.CLASS, SysDictPage.class);
// 自定义表格参数
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("数据字典列表", "导出人:"+user.getRealname(), "数据字典"));
// 导出数据列表
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param
* @return
*/
@RequiresRoles({"admin"})
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(2);
params.setNeedSave(true);
try {
//导入Excel格式校验,看匹配的字段文本概率
Boolean t = ExcelImportCheckUtil.check(file.getInputStream(), SysDictPage.class, params);
if(!t){
throw new RuntimeException("导入Excel校验失败 ");
}
List<SysDictPage> list = ExcelImportUtil.importExcel(file.getInputStream(), SysDictPage.class, params);
// 错误信息
List<String> errorMessage = new ArrayList<>();
int successLines = 0, errorLines = 0;
for (int i=0;i< list.size();i++) {
SysDict po = new SysDict();
BeanUtils.copyProperties(list.get(i), po);
po.setDelFlag(CommonConstant.DEL_FLAG_0);
try {
Integer integer = sysDictService.saveMain(po, list.get(i).getSysDictItemList());
if(integer>0){
successLines++;
}else{
errorLines++;
int lineNumber = i + 1;
errorMessage.add("" + lineNumber + " 行:字典编码已经存在,忽略导入。");
}
} catch (Exception e) {
errorLines++;
int lineNumber = i + 1;
errorMessage.add("" + lineNumber + " 行:字典编码已经存在,忽略导入。");
}
}
return ImportExcelUtil.imporReturnRes(errorLines,successLines,errorMessage);
} catch (Exception e) {
log.error(e.getMessage(),e);
return Result.error("文件导入失败:"+e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败!");
}
/**
* 查询被删除的列表
* @return
*/
@RequestMapping(value = "/deleteList", method = RequestMethod.GET)
public Result<List<SysDict>> deleteList() {
Result<List<SysDict>> result = new Result<List<SysDict>>();
List<SysDict> list = this.sysDictService.queryDeleteList();
result.setSuccess(true);
result.setResult(list);
return result;
}
/**
* 物理删除
* @param id
* @return
*/
@RequestMapping(value = "/deletePhysic/{id}", method = RequestMethod.DELETE)
public Result<?> deletePhysic(@PathVariable String id) {
try {
sysDictService.deleteOneDictPhysically(id);
return Result.ok("删除成功!");
} catch (Exception e) {
e.printStackTrace();
return Result.error("删除失败!");
}
}
/**
* 取回
* @param id
* @return
*/
@RequestMapping(value = "/back/{id}", method = RequestMethod.PUT)
public Result<?> back(@PathVariable String id) {
try {
sysDictService.updateDictDelFlag(0,id);
return Result.ok("操作成功!");
} catch (Exception e) {
e.printStackTrace();
return Result.error("操作失败!");
}
}
}
@@ -0,0 +1,183 @@
package com.jero.modules.system.controller;
import java.util.Arrays;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresRoles;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CacheConstant;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysDictItem;
import com.jero.modules.system.service.ISysDictItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* <p>
* 前端控制器
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@RestController
@RequestMapping("/sys/dictItem")
@Slf4j
public class SysDictItemController {
@Autowired
private ISysDictItemService sysDictItemService;
/**
* @功能:查询字典数据
* @param sysDictItem
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysDictItem>> queryPageList(SysDictItem sysDictItem,@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,HttpServletRequest req) {
Result<IPage<SysDictItem>> result = new Result<IPage<SysDictItem>>();
QueryWrapper<SysDictItem> queryWrapper = QueryGenerator.initQueryWrapper(sysDictItem, req.getParameterMap());
queryWrapper.orderByAsc("sort_order");
Page<SysDictItem> page = new Page<SysDictItem>(pageNo, pageSize);
IPage<SysDictItem> pageList = sysDictItemService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* @功能:新增
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/add", method = RequestMethod.POST)
@CacheEvict(value= CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> add(@RequestBody SysDictItem sysDictItem) {
Result<SysDictItem> result = new Result<SysDictItem>();
try {
sysDictItem.setCreateTime(new Date());
sysDictItemService.save(sysDictItem);
result.success("保存成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* @功能:编辑
* @param sysDictItem
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> edit(@RequestBody SysDictItem sysDictItem) {
Result<SysDictItem> result = new Result<SysDictItem>();
SysDictItem sysdict = sysDictItemService.getById(sysDictItem.getId());
if(sysdict==null) {
result.error500("未找到对应实体");
}else {
sysDictItem.setUpdateTime(new Date());
boolean ok = sysDictItemService.updateById(sysDictItem);
//TODO 返回false说明什么?
if(ok) {
result.success("编辑成功!");
}
}
return result;
}
/**
* @功能:删除字典数据
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> delete(@RequestParam(name="id",required=true) String id) {
Result<SysDictItem> result = new Result<SysDictItem>();
SysDictItem joinSystem = sysDictItemService.getById(id);
if(joinSystem==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysDictItemService.removeById(id);
if(ok) {
result.success("删除成功!");
}
}
return result;
}
/**
* @功能:批量删除字典数据
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysDictItem> result = new Result<SysDictItem>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别!");
}else {
this.sysDictItemService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 字典值重复校验
* @param sysDictItem
* @param request
* @return
*/
@RequestMapping(value = "/dictItemCheck", method = RequestMethod.GET)
@ApiOperation("字典重复校验接口")
public Result<Object> doDictItemCheck(SysDictItem sysDictItem, HttpServletRequest request) {
int num = 0;
LambdaQueryWrapper<SysDictItem> queryWrapper = new LambdaQueryWrapper<SysDictItem>();
queryWrapper.eq(SysDictItem::getItemValue,sysDictItem.getItemValue());
queryWrapper.eq(SysDictItem::getDictId,sysDictItem.getDictId());
if (StringUtils.isNotBlank(sysDictItem.getId())) {
// 编辑页面校验
queryWrapper.ne(SysDictItem::getId,sysDictItem.getId());
}
num = sysDictItemService.count(queryWrapper);
if (num == 0) {
// 该值可用
return Result.ok("该值可用!");
} else {
// 该值不可用
log.info("该值不可用,系统中已存在!");
return Result.error("该值不可用,系统中已存在!");
}
}
}
@@ -0,0 +1,213 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.system.base.controller.JeroController;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.FillRuleUtil;
import com.jero.modules.system.entity.SysFillRule;
import com.jero.modules.system.service.ISysFillRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
/**
* @Description: 填值规则
* @Author: jero-boot
* @Date: 2019-11-07
* @Version: V1.0
*/
@Slf4j
@Api(tags = "填值规则")
@RestController
@RequestMapping("/sys/fillRule")
public class SysFillRuleController extends JeroController<SysFillRule, ISysFillRuleService> {
@Autowired
private ISysFillRuleService sysFillRuleService;
/**
* 分页列表查询
*
* @param sysFillRule
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "填值规则-分页列表查询")
@ApiOperation(value = "填值规则-分页列表查询", notes = "填值规则-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(SysFillRule sysFillRule,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<SysFillRule> queryWrapper = QueryGenerator.initQueryWrapper(sysFillRule, req.getParameterMap());
Page<SysFillRule> page = new Page<>(pageNo, pageSize);
IPage<SysFillRule> pageList = sysFillRuleService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 测试 ruleCode
*
* @param ruleCode
* @return
*/
@GetMapping(value = "/testFillRule")
public Result testFillRule(@RequestParam("ruleCode") String ruleCode) {
Object result = FillRuleUtil.executeRule(ruleCode, new JSONObject());
return Result.ok(result);
}
/**
* 添加
*
* @param sysFillRule
* @return
*/
@AutoLog(value = "填值规则-添加")
@ApiOperation(value = "填值规则-添加", notes = "填值规则-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysFillRule sysFillRule) {
sysFillRuleService.save(sysFillRule);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param sysFillRule
* @return
*/
@AutoLog(value = "填值规则-编辑")
@ApiOperation(value = "填值规则-编辑", notes = "填值规则-编辑")
@PutMapping(value = "/edit")
public Result<?> edit(@RequestBody SysFillRule sysFillRule) {
sysFillRuleService.updateById(sysFillRule);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "填值规则-通过id删除")
@ApiOperation(value = "填值规则-通过id删除", notes = "填值规则-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
sysFillRuleService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "填值规则-批量删除")
@ApiOperation(value = "填值规则-批量删除", notes = "填值规则-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.sysFillRuleService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "填值规则-通过id查询")
@ApiOperation(value = "填值规则-通过id查询", notes = "填值规则-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
SysFillRule sysFillRule = sysFillRuleService.getById(id);
return Result.ok(sysFillRule);
}
/**
* 导出excel
*
* @param request
* @param sysFillRule
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysFillRule sysFillRule) {
return super.exportXls(request, sysFillRule, SysFillRule.class, "填值规则");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, SysFillRule.class);
}
/**
* 通过 ruleCode 执行自定义填值规则
*
* @param ruleCode 要执行的填值规则编码
* @param formData 表单数据,可根据表单数据的不同生成不同的填值结果
* @return 运行后的结果
*/
@PutMapping("/executeRuleByCode/{ruleCode}")
public Result executeByRuleCode(@PathVariable("ruleCode") String ruleCode, @RequestBody JSONObject formData) {
Object result = FillRuleUtil.executeRule(ruleCode, formData);
return Result.ok(result);
}
/**
* 批量通过 ruleCode 执行自定义填值规则
*
* @param ruleData 要执行的填值规则JSON数组:
* 示例: { "commonFormData": {}, rules: [ { "ruleCode": "xxx", "formData": null } ] }
* @return 运行后的结果,返回示例: [{"ruleCode": "order_num_rule", "result": "CN2019111117212984"}]
*
*/
@PutMapping("/executeRuleByCodeBatch")
public Result executeByRuleCodeBatch(@RequestBody JSONObject ruleData) {
JSONObject commonFormData = ruleData.getJSONObject("commonFormData");
JSONArray rules = ruleData.getJSONArray("rules");
// 遍历 rules ,批量执行规则
JSONArray results = new JSONArray(rules.size());
for (int i = 0; i < rules.size(); i++) {
JSONObject rule = rules.getJSONObject(i);
String ruleCode = rule.getString("ruleCode");
JSONObject formData = rule.getJSONObject("formData");
// 如果没有传递 formData,就用common的
if (formData == null) {
formData = commonFormData;
}
// 执行填值规则
Object result = FillRuleUtil.executeRule(ruleCode, formData);
JSONObject obj = new JSONObject(rules.size());
obj.put("ruleCode", ruleCode);
obj.put("result", result);
results.add(obj);
}
return Result.ok(results);
}
}
@@ -0,0 +1,76 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.system.base.controller.JeroController;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import com.jero.common.api.vo.Result;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysGatewayRoute;
import com.jero.modules.system.service.ISysGatewayRouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* @Description: gateway路由管理
* @Author: jero-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
@Api(tags = "gateway路由管理")
@RestController
@RequestMapping("/sys/gatewayRoute")
@Slf4j
public class SysGatewayRouteController extends JeroController<SysGatewayRoute, ISysGatewayRouteService> {
@Autowired
private ISysGatewayRouteService sysGatewayRouteService;
@PostMapping(value = "/updateAll")
public Result<?> updateAll(@RequestBody JSONObject json) {
sysGatewayRouteService.updateAll(json);
return Result.ok("操作成功!");
}
@GetMapping(value = "/list")
public Result<?> queryPageList(SysGatewayRoute sysGatewayRoute) {
LambdaQueryWrapper<SysGatewayRoute> query = new LambdaQueryWrapper<>();
List<SysGatewayRoute> ls = sysGatewayRouteService.list(query);
JSONArray array = new JSONArray();
for(SysGatewayRoute rt: ls){
JSONObject obj = (JSONObject) JSONObject.toJSON(rt);
if(oConvertUtils.isNotEmpty(rt.getPredicates())){
obj.put("predicates", JSONArray.parseArray(rt.getPredicates()));
}
if(oConvertUtils.isNotEmpty(rt.getFilters())){
obj.put("filters", JSONArray.parseArray(rt.getFilters()));
}
array.add(obj);
}
return Result.ok(array);
}
@GetMapping(value = "/clearRedis")
public Result<?> clearRedis() {
sysGatewayRouteService.clearRedis();
return Result.ok("清除成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
sysGatewayRouteService.deleteById(id);
return Result.ok("删除路由成功");
}
}
@@ -0,0 +1,117 @@
package com.jero.modules.system.controller;
import java.util.Arrays;
import javax.servlet.http.HttpServletRequest;
import com.jero.common.api.vo.Result;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysLog;
import com.jero.modules.system.entity.SysRole;
import com.jero.modules.system.service.ISysLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* <p>
* 系统日志表 前端控制器
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
@RestController
@RequestMapping("/sys/log")
@Slf4j
public class SysLogController {
@Autowired
private ISysLogService sysLogService;
/**
* @功能:查询日志记录
* @param syslog
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysLog>> queryPageList(SysLog syslog,@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,HttpServletRequest req) {
Result<IPage<SysLog>> result = new Result<IPage<SysLog>>();
QueryWrapper<SysLog> queryWrapper = QueryGenerator.initQueryWrapper(syslog, req.getParameterMap());
Page<SysLog> page = new Page<SysLog>(pageNo, pageSize);
//日志关键词
String keyWord = req.getParameter("keyWord");
if(oConvertUtils.isNotEmpty(keyWord)) {
queryWrapper.like("log_content",keyWord);
}
//TODO 过滤逻辑处理
//TODO begin、end逻辑处理
//TODO 一个强大的功能,前端传一个字段字符串,后台只返回这些字符串对应的字段
//创建时间/创建人的赋值
IPage<SysLog> pageList = sysLogService.page(page, queryWrapper);
log.info("查询当前页:"+pageList.getCurrent());
log.info("查询当前页数量:"+pageList.getSize());
log.info("查询结果数量:"+pageList.getRecords().size());
log.info("数据总数:"+pageList.getTotal());
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* @功能:删除单个日志记录
* @param id
* @return
*/
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<SysLog> delete(@RequestParam(name="id",required=true) String id) {
Result<SysLog> result = new Result<SysLog>();
SysLog sysLog = sysLogService.getById(id);
if(sysLog==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysLogService.removeById(id);
if(ok) {
result.success("删除成功!");
}
}
return result;
}
/**
* @功能:批量,全部清空日志记录
* @param ids
* @return
*/
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysRole> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysRole> result = new Result<SysRole>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别!");
}else {
if("allclear".equals(ids)) {
this.sysLogService.removeAll();
result.success("清除成功!");
}
this.sysLogService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
}
@@ -0,0 +1,807 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresRoles;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.util.JwtUtil;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.MD5Util;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysDepartPermission;
import com.jero.modules.system.entity.SysPermission;
import com.jero.modules.system.entity.SysPermissionDataRule;
import com.jero.modules.system.entity.SysRolePermission;
import com.jero.modules.system.model.SysPermissionTree;
import com.jero.modules.system.model.TreeModel;
import com.jero.modules.system.service.*;
import com.jero.modules.system.util.PermissionDataUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 菜单权限表 前端控制器
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Slf4j
@RestController
@RequestMapping("/sys/permission")
public class SysPermissionController {
@Autowired
private ISysPermissionService sysPermissionService;
@Autowired
private ISysRolePermissionService sysRolePermissionService;
@Autowired
private ISysPermissionDataRuleService sysPermissionDataRuleService;
@Autowired
private ISysDepartPermissionService sysDepartPermissionService;
/**
* 加载数据节点
*
* @return
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<List<SysPermissionTree>> list() {
long start = System.currentTimeMillis();
Result<List<SysPermissionTree>> result = new Result<>();
try {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
List<SysPermission> list = sysPermissionService.list(query);
List<SysPermissionTree> treeList = new ArrayList<>();
getTreeList(treeList, list, null);
result.setResult(treeList);
result.setSuccess(true);
log.info("======获取全部菜单数据=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/*update_begin author:wuxianquan date:20190908 for:先查询一级菜单,当用户点击展开菜单时加载子菜单 */
/**
* 系统菜单列表(一级菜单)
*
* @return
*/
@RequestMapping(value = "/getSystemMenuList", method = RequestMethod.GET)
public Result<List<SysPermissionTree>> getSystemMenuList() {
long start = System.currentTimeMillis();
Result<List<SysPermissionTree>> result = new Result<>();
try {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getMenuType,CommonConstant.MENU_TYPE_0);
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
List<SysPermission> list = sysPermissionService.list(query);
List<SysPermissionTree> sysPermissionTreeList = new ArrayList<SysPermissionTree>();
for(SysPermission sysPermission : list){
SysPermissionTree sysPermissionTree = new SysPermissionTree(sysPermission);
sysPermissionTreeList.add(sysPermissionTree);
}
result.setResult(sysPermissionTreeList);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
log.info("======获取一级菜单数据=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
return result;
}
/**
* 查询子菜单
* @param parentId
* @return
*/
@RequestMapping(value = "/getSystemSubmenu", method = RequestMethod.GET)
public Result<List<SysPermissionTree>> getSystemSubmenu(@RequestParam("parentId") String parentId){
Result<List<SysPermissionTree>> result = new Result<>();
try{
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getParentId,parentId);
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
List<SysPermission> list = sysPermissionService.list(query);
List<SysPermissionTree> sysPermissionTreeList = new ArrayList<SysPermissionTree>();
for(SysPermission sysPermission : list){
SysPermissionTree sysPermissionTree = new SysPermissionTree(sysPermission);
sysPermissionTreeList.add(sysPermissionTree);
}
result.setResult(sysPermissionTreeList);
result.setSuccess(true);
}catch (Exception e){
log.error(e.getMessage(), e);
}
return result;
}
/*update_end author:wuxianquan date:20190908 for:先查询一级菜单,当用户点击展开菜单时加载子菜单 */
// update_begin author:sunjianlei date:20200108 for: 新增批量根据父ID查询子级菜单的接口 -------------
/**
* 查询子菜单
*
* @param parentIds 父ID(多个采用半角逗号分割)
* @return 返回 key-value 的 Map
*/
@GetMapping("/getSystemSubmenuBatch")
public Result getSystemSubmenuBatch(@RequestParam("parentIds") String parentIds) {
try {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<>();
List<String> parentIdList = Arrays.asList(parentIds.split(","));
query.in(SysPermission::getParentId, parentIdList);
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
List<SysPermission> list = sysPermissionService.list(query);
Map<String, List<SysPermissionTree>> listMap = new HashMap<>();
for (SysPermission item : list) {
String pid = item.getParentId();
if (parentIdList.contains(pid)) {
List<SysPermissionTree> mapList = listMap.get(pid);
if (mapList == null) {
mapList = new ArrayList<>();
}
mapList.add(new SysPermissionTree(item));
listMap.put(pid, mapList);
}
}
return Result.ok(listMap);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("批量查询子菜单失败:" + e.getMessage());
}
}
// update_end author:sunjianlei date:20200108 for: 新增批量根据父ID查询子级菜单的接口 -------------
// /**
// * 查询用户拥有的菜单权限和按钮权限(根据用户账号)
// *
// * @return
// */
// @RequestMapping(value = "/queryByUser", method = RequestMethod.GET)
// public Result<JSONArray> queryByUser(HttpServletRequest req) {
// Result<JSONArray> result = new Result<>();
// try {
// String username = req.getParameter("username");
// List<SysPermission> metaList = sysPermissionService.queryByUser(username);
// JSONArray jsonArray = new JSONArray();
// this.getPermissionJsonArray(jsonArray, metaList, null);
// result.setResult(jsonArray);
// result.success("查询成功");
// } catch (Exception e) {
// result.error500("查询失败:" + e.getMessage());
// log.error(e.getMessage(), e);
// }
// return result;
// }
/**
* 查询用户拥有的菜单权限和按钮权限
*
* @return
*/
@RequestMapping(value = "/getUserPermissionByToken", method = RequestMethod.GET)
public Result<?> getUserPermissionByToken() {
Result<JSONObject> result = new Result<JSONObject>();
try {
//直接获取当前用户不适用前端token
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
if (oConvertUtils.isEmpty(loginUser)) {
return Result.error("请登录系统!");
}
List<SysPermission> metaList = sysPermissionService.queryByUser(loginUser.getUsername());
//添加首页路由
//update-begin-author:taoyan date:20200211 for: TASK #3368 【路由缓存】首页的缓存设置有问题,需要根据后台的路由配置来实现是否缓存
if(!PermissionDataUtil.hasIndexPage(metaList)){
SysPermission indexMenu = sysPermissionService.list(new LambdaQueryWrapper<SysPermission>().eq(SysPermission::getName,"首页")).get(0);
metaList.add(0,indexMenu);
}
//update-end-author:taoyan date:20200211 for: TASK #3368 【路由缓存】首页的缓存设置有问题,需要根据后台的路由配置来实现是否缓存
JSONObject json = new JSONObject();
JSONArray menujsonArray = new JSONArray();
this.getPermissionJsonArray(menujsonArray, metaList, null);
JSONArray authjsonArray = new JSONArray();
this.getAuthJsonArray(authjsonArray, metaList);
//查询所有的权限
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.eq(SysPermission::getMenuType, CommonConstant.MENU_TYPE_2);
//query.eq(SysPermission::getStatus, "1");
List<SysPermission> allAuthList = sysPermissionService.list(query);
JSONArray allauthjsonArray = new JSONArray();
this.getAllAuthJsonArray(allauthjsonArray, allAuthList);
//路由菜单
json.put("menu", menujsonArray);
//按钮权限(用户拥有的权限集合)
json.put("auth", authjsonArray);
//全部权限配置集合(按钮权限,访问权限)
json.put("allAuth", allauthjsonArray);
result.setResult(json);
result.success("查询成功");
} catch (Exception e) {
result.error500("查询失败:" + e.getMessage());
log.error(e.getMessage(), e);
}
return result;
}
/**
* 添加菜单
* @param permission
* @return
*/
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysPermission> add(@RequestBody SysPermission permission) {
Result<SysPermission> result = new Result<SysPermission>();
try {
permission = PermissionDataUtil.intelligentProcessData(permission);
sysPermissionService.addPermission(permission);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑菜单
* @param permission
* @return
*/
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/edit", method = { RequestMethod.PUT, RequestMethod.POST })
public Result<SysPermission> edit(@RequestBody SysPermission permission) {
Result<SysPermission> result = new Result<>();
try {
permission = PermissionDataUtil.intelligentProcessData(permission);
sysPermissionService.editPermission(permission);
result.success("修改成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 删除菜单
* @param id
* @return
*/
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<SysPermission> delete(@RequestParam(name = "id", required = true) String id) {
Result<SysPermission> result = new Result<>();
try {
sysPermissionService.deletePermission(id);
result.success("删除成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500(e.getMessage());
}
return result;
}
/**
* 批量删除菜单
* @param ids
* @return
*/
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysPermission> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
Result<SysPermission> result = new Result<>();
try {
String[] arr = ids.split(",");
for (String id : arr) {
if (oConvertUtils.isNotEmpty(id)) {
sysPermissionService.deletePermission(id);
}
}
result.success("删除成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("删除成功!");
}
return result;
}
/**
* 获取全部的权限树
*
* @return
*/
@RequestMapping(value = "/queryTreeList", method = RequestMethod.GET)
public Result<Map<String, Object>> queryTreeList() {
Result<Map<String, Object>> result = new Result<>();
// 全部权限ids
List<String> ids = new ArrayList<>();
try {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
List<SysPermission> list = sysPermissionService.list(query);
for (SysPermission sysPer : list) {
ids.add(sysPer.getId());
}
List<TreeModel> treeList = new ArrayList<>();
getTreeModelList(treeList, list, null);
Map<String, Object> resMap = new HashMap<String, Object>();
resMap.put("treeList", treeList); // 全部树节点数据
resMap.put("ids", ids);// 全部树ids
result.setResult(resMap);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 异步加载数据节点
*
* @return
*/
@RequestMapping(value = "/queryListAsync", method = RequestMethod.GET)
public Result<List<TreeModel>> queryAsync(@RequestParam(name = "pid", required = false) String parentId) {
Result<List<TreeModel>> result = new Result<>();
try {
List<TreeModel> list = sysPermissionService.queryListByParentId(parentId);
if (list == null || list.size() <= 0) {
result.error500("未找到角色信息");
} else {
result.setResult(list);
result.setSuccess(true);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 查询角色授权
*
* @return
*/
@RequestMapping(value = "/queryRolePermission", method = RequestMethod.GET)
public Result<List<String>> queryRolePermission(@RequestParam(name = "roleId", required = true) String roleId) {
Result<List<String>> result = new Result<>();
try {
List<SysRolePermission> list = sysRolePermissionService.list(new QueryWrapper<SysRolePermission>().lambda().eq(SysRolePermission::getRoleId, roleId));
result.setResult(list.stream().map(SysRolePermission -> String.valueOf(SysRolePermission.getPermissionId())).collect(Collectors.toList()));
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 保存角色授权
*
* @return
*/
@RequestMapping(value = "/saveRolePermission", method = RequestMethod.POST)
//@RequiresRoles({ "admin" })
public Result<String> saveRolePermission(@RequestBody JSONObject json) {
long start = System.currentTimeMillis();
Result<String> result = new Result<>();
try {
String roleId = json.getString("roleId");
String permissionIds = json.getString("permissionIds");
String lastPermissionIds = json.getString("lastpermissionIds");
this.sysRolePermissionService.saveRolePermission(roleId, permissionIds, lastPermissionIds);
result.success("保存成功!");
log.info("======角色授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
} catch (Exception e) {
result.error500("授权失败!");
log.error(e.getMessage(), e);
}
return result;
}
private void getTreeList(List<SysPermissionTree> treeList, List<SysPermission> metaList, SysPermissionTree temp) {
for (SysPermission permission : metaList) {
String tempPid = permission.getParentId();
SysPermissionTree tree = new SysPermissionTree(permission);
if (temp == null && oConvertUtils.isEmpty(tempPid)) {
treeList.add(tree);
if (!tree.getIsLeaf()) {
getTreeList(treeList, metaList, tree);
}
} else if (temp != null && tempPid != null && tempPid.equals(temp.getId())) {
temp.getChildren().add(tree);
if (!tree.getIsLeaf()) {
getTreeList(treeList, metaList, tree);
}
}
}
}
private void getTreeModelList(List<TreeModel> treeList, List<SysPermission> metaList, TreeModel temp) {
for (SysPermission permission : metaList) {
String tempPid = permission.getParentId();
TreeModel tree = new TreeModel(permission);
if (temp == null && oConvertUtils.isEmpty(tempPid)) {
treeList.add(tree);
if (!tree.getIsLeaf()) {
getTreeModelList(treeList, metaList, tree);
}
} else if (temp != null && tempPid != null && tempPid.equals(temp.getKey())) {
temp.getChildren().add(tree);
if (!tree.getIsLeaf()) {
getTreeModelList(treeList, metaList, tree);
}
}
}
}
/**
* 获取权限JSON数组
* @param jsonArray
* @param allList
*/
private void getAllAuthJsonArray(JSONArray jsonArray,List<SysPermission> allList) {
JSONObject json = null;
for (SysPermission permission : allList) {
json = new JSONObject();
json.put("action", permission.getPerms());
json.put("status", permission.getStatus());
//1显示2禁用
json.put("type", permission.getPermsType());
json.put("describe", permission.getName());
jsonArray.add(json);
}
}
/**
* 获取权限JSON数组
* @param jsonArray
* @param metaList
*/
private void getAuthJsonArray(JSONArray jsonArray,List<SysPermission> metaList) {
for (SysPermission permission : metaList) {
if(permission.getMenuType()==null) {
continue;
}
JSONObject json = null;
if(permission.getMenuType().equals(CommonConstant.MENU_TYPE_2) &&CommonConstant.STATUS_1.equals(permission.getStatus())) {
json = new JSONObject();
json.put("action", permission.getPerms());
json.put("type", permission.getPermsType());
json.put("describe", permission.getName());
jsonArray.add(json);
}
}
}
/**
* 获取菜单JSON数组
* @param jsonArray
* @param metaList
* @param parentJson
*/
private void getPermissionJsonArray(JSONArray jsonArray, List<SysPermission> metaList, JSONObject parentJson) {
for (SysPermission permission : metaList) {
if (permission.getMenuType() == null) {
continue;
}
String tempPid = permission.getParentId();
JSONObject json = getPermissionJsonObject(permission);
if(json==null) {
continue;
}
if (parentJson == null && oConvertUtils.isEmpty(tempPid)) {
jsonArray.add(json);
if (!permission.isLeaf()) {
getPermissionJsonArray(jsonArray, metaList, json);
}
} else if (parentJson != null && oConvertUtils.isNotEmpty(tempPid) && tempPid.equals(parentJson.getString("id"))) {
// 类型( 0:一级菜单 1:子菜单 2:按钮 )
if (permission.getMenuType().equals(CommonConstant.MENU_TYPE_2)) {
JSONObject metaJson = parentJson.getJSONObject("meta");
if (metaJson.containsKey("permissionList")) {
metaJson.getJSONArray("permissionList").add(json);
} else {
JSONArray permissionList = new JSONArray();
permissionList.add(json);
metaJson.put("permissionList", permissionList);
}
// 类型( 0:一级菜单 1:子菜单 2:按钮 )
} else if (permission.getMenuType().equals(CommonConstant.MENU_TYPE_1) || permission.getMenuType().equals(CommonConstant.MENU_TYPE_0)) {
if (parentJson.containsKey("children")) {
parentJson.getJSONArray("children").add(json);
} else {
JSONArray children = new JSONArray();
children.add(json);
parentJson.put("children", children);
}
if (!permission.isLeaf()) {
getPermissionJsonArray(jsonArray, metaList, json);
}
}
}
}
}
/**
* 根据菜单配置生成路由json
* @param permission
* @return
*/
private JSONObject getPermissionJsonObject(SysPermission permission) {
JSONObject json = new JSONObject();
// 类型(0:一级菜单 1:子菜单 2:按钮)
if (permission.getMenuType().equals(CommonConstant.MENU_TYPE_2)) {
//json.put("action", permission.getPerms());
//json.put("type", permission.getPermsType());
//json.put("describe", permission.getName());
return null;
} else if (permission.getMenuType().equals(CommonConstant.MENU_TYPE_0) || permission.getMenuType().equals(CommonConstant.MENU_TYPE_1)) {
json.put("id", permission.getId());
if (permission.isRoute()) {
json.put("route", "1");// 表示生成路由
} else {
json.put("route", "0");// 表示不生成路由
}
if (isWWWHttpUrl(permission.getUrl())) {
json.put("path", MD5Util.MD5Encode(permission.getUrl(), "utf-8"));
} else {
json.put("path", permission.getUrl());
}
// 重要规则:路由name (通过URL生成路由name,路由name供前端开发,页面跳转使用)
if (oConvertUtils.isNotEmpty(permission.getComponentName())) {
json.put("name", permission.getComponentName());
} else {
json.put("name", urlToRouteName(permission.getUrl()));
}
// 是否隐藏路由,默认都是显示的
if (permission.isHidden()) {
json.put("hidden", true);
}
// 聚合路由
if (permission.isAlwaysShow()) {
json.put("alwaysShow", true);
}
json.put("component", permission.getComponent());
JSONObject meta = new JSONObject();
// 由用户设置是否缓存页面 用布尔值
if (permission.isKeepAlive()) {
meta.put("keepAlive", true);
} else {
meta.put("keepAlive", false);
}
/*update_begin author:wuxianquan date:20190908 for:往菜单信息里添加外链菜单打开方式 */
//外链菜单打开方式
if (permission.isInternalOrExternal()) {
meta.put("internalOrExternal", true);
} else {
meta.put("internalOrExternal", false);
}
/* update_end author:wuxianquan date:20190908 for: 往菜单信息里添加外链菜单打开方式*/
meta.put("title", permission.getName());
//update-begin--Author:scott Date:20201015 for:路由缓存问题,关闭了tab页时再打开就不刷新 #842
String component = permission.getComponent();
if(oConvertUtils.isNotEmpty(permission.getComponentName()) || oConvertUtils.isNotEmpty(component)){
meta.put("componentName", oConvertUtils.getString(permission.getComponentName(),component.substring(component.lastIndexOf("/")+1)));
}
//update-end--Author:scott Date:20201015 for:路由缓存问题,关闭了tab页时再打开就不刷新 #842
if (oConvertUtils.isEmpty(permission.getParentId())) {
// 一级菜单跳转地址
json.put("redirect", permission.getRedirect());
if (oConvertUtils.isNotEmpty(permission.getIcon())) {
meta.put("icon", permission.getIcon());
}
} else {
if (oConvertUtils.isNotEmpty(permission.getIcon())) {
meta.put("icon", permission.getIcon());
}
}
if (isWWWHttpUrl(permission.getUrl())) {
meta.put("url", permission.getUrl());
}
json.put("meta", meta);
}
return json;
}
/**
* 判断是否外网URL 例如: http://localhost:8080/jero-boot/swagger-ui.html#/ 支持特殊格式: {{
* window._CONFIG['domianURL'] }}/druid/ {{ JS代码片段 }},前台解析会自动执行JS代码片段
*
* @return
*/
private boolean isWWWHttpUrl(String url) {
if (url != null && (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("{{"))) {
return true;
}
return false;
}
/**
* 通过URL生成路由name(去掉URL前缀斜杠,替换内容中的斜杠‘/’为-) 举例: URL = /isystem/role RouteName =
* isystem-role
*
* @return
*/
private String urlToRouteName(String url) {
if (oConvertUtils.isNotEmpty(url)) {
if (url.startsWith("/")) {
url = url.substring(1);
}
url = url.replace("/", "-");
// 特殊标记
url = url.replace(":", "@");
return url;
} else {
return null;
}
}
/**
* 根据菜单id来获取其对应的权限数据
*
* @param sysPermissionDataRule
* @return
*/
@RequestMapping(value = "/getPermRuleListByPermId", method = RequestMethod.GET)
public Result<List<SysPermissionDataRule>> getPermRuleListByPermId(SysPermissionDataRule sysPermissionDataRule) {
List<SysPermissionDataRule> permRuleList = sysPermissionDataRuleService.getPermRuleListByPermId(sysPermissionDataRule.getPermissionId());
Result<List<SysPermissionDataRule>> result = new Result<>();
result.setSuccess(true);
result.setResult(permRuleList);
return result;
}
/**
* 添加菜单权限数据
*
* @param sysPermissionDataRule
* @return
*/
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/addPermissionRule", method = RequestMethod.POST)
public Result<SysPermissionDataRule> addPermissionRule(@RequestBody SysPermissionDataRule sysPermissionDataRule) {
Result<SysPermissionDataRule> result = new Result<SysPermissionDataRule>();
try {
sysPermissionDataRule.setCreateTime(new Date());
sysPermissionDataRuleService.savePermissionDataRule(sysPermissionDataRule);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/editPermissionRule", method = { RequestMethod.PUT, RequestMethod.POST })
public Result<SysPermissionDataRule> editPermissionRule(@RequestBody SysPermissionDataRule sysPermissionDataRule) {
Result<SysPermissionDataRule> result = new Result<SysPermissionDataRule>();
try {
sysPermissionDataRuleService.saveOrUpdate(sysPermissionDataRule);
result.success("更新成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 删除菜单权限数据
*
* @param id
* @return
*/
//@RequiresRoles({ "admin" })
@RequestMapping(value = "/deletePermissionRule", method = RequestMethod.DELETE)
public Result<SysPermissionDataRule> deletePermissionRule(@RequestParam(name = "id", required = true) String id) {
Result<SysPermissionDataRule> result = new Result<SysPermissionDataRule>();
try {
sysPermissionDataRuleService.deletePermissionDataRule(id);
result.success("删除成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 查询菜单权限数据
*
* @param sysPermissionDataRule
* @return
*/
@RequestMapping(value = "/queryPermissionRule", method = RequestMethod.GET)
public Result<List<SysPermissionDataRule>> queryPermissionRule(SysPermissionDataRule sysPermissionDataRule) {
Result<List<SysPermissionDataRule>> result = new Result<>();
try {
List<SysPermissionDataRule> permRuleList = sysPermissionDataRuleService.queryPermissionRule(sysPermissionDataRule);
result.setResult(permRuleList);
result.success("查询成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 部门权限表
* @param departId
* @return
*/
@RequestMapping(value = "/queryDepartPermission", method = RequestMethod.GET)
public Result<List<String>> queryDepartPermission(@RequestParam(name = "departId", required = true) String departId) {
Result<List<String>> result = new Result<>();
try {
List<SysDepartPermission> list = sysDepartPermissionService.list(new QueryWrapper<SysDepartPermission>().lambda().eq(SysDepartPermission::getDepartId, departId));
result.setResult(list.stream().map(SysDepartPermission -> String.valueOf(SysDepartPermission.getPermissionId())).collect(Collectors.toList()));
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 保存部门授权
*
* @return
*/
@RequestMapping(value = "/saveDepartPermission", method = RequestMethod.POST)
//@RequiresRoles({ "admin" })
public Result<String> saveDepartPermission(@RequestBody JSONObject json) {
long start = System.currentTimeMillis();
Result<String> result = new Result<>();
try {
String departId = json.getString("departId");
String permissionIds = json.getString("permissionIds");
String lastPermissionIds = json.getString("lastpermissionIds");
this.sysDepartPermissionService.saveDepartPermission(departId, permissionIds, lastPermissionIds);
result.success("保存成功!");
log.info("======部门授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
} catch (Exception e) {
result.error500("授权失败!");
log.error(e.getMessage(), e);
}
return result;
}
}
@@ -0,0 +1,280 @@
package com.jero.modules.system.controller;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.ImportExcelUtil;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.quartz.service.IQuartzJobService;
import com.jero.modules.system.entity.SysPosition;
import com.jero.modules.system.service.ISysPositionService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* @Description: 职务表
* @Author: jero-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
@Slf4j
@Api(tags = "职务表")
@RestController
@RequestMapping("/sys/position")
public class SysPositionController {
@Autowired
private ISysPositionService sysPositionService;
/**
* 分页列表查询
*
* @param sysPosition
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "职务表-分页列表查询")
@ApiOperation(value = "职务表-分页列表查询", notes = "职务表-分页列表查询")
@GetMapping(value = "/list")
public Result<IPage<SysPosition>> queryPageList(SysPosition sysPosition,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
Result<IPage<SysPosition>> result = new Result<IPage<SysPosition>>();
QueryWrapper<SysPosition> queryWrapper = QueryGenerator.initQueryWrapper(sysPosition, req.getParameterMap());
Page<SysPosition> page = new Page<SysPosition>(pageNo, pageSize);
IPage<SysPosition> pageList = sysPositionService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
*
* @param sysPosition
* @return
*/
@AutoLog(value = "职务表-添加")
@ApiOperation(value = "职务表-添加", notes = "职务表-添加")
@PostMapping(value = "/add")
public Result<SysPosition> add(@RequestBody SysPosition sysPosition) {
Result<SysPosition> result = new Result<SysPosition>();
try {
sysPositionService.save(sysPosition);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
*
* @param sysPosition
* @return
*/
@AutoLog(value = "职务表-编辑")
@ApiOperation(value = "职务表-编辑", notes = "职务表-编辑")
@PutMapping(value = "/edit")
public Result<SysPosition> edit(@RequestBody SysPosition sysPosition) {
Result<SysPosition> result = new Result<SysPosition>();
SysPosition sysPositionEntity = sysPositionService.getById(sysPosition.getId());
if (sysPositionEntity == null) {
result.error500("未找到对应实体");
} else {
boolean ok = sysPositionService.updateById(sysPosition);
//TODO 返回false说明什么?
if (ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "职务表-通过id删除")
@ApiOperation(value = "职务表-通过id删除", notes = "职务表-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
try {
sysPositionService.removeById(id);
} catch (Exception e) {
log.error("删除失败", e.getMessage());
return Result.error("删除失败!");
}
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "职务表-批量删除")
@ApiOperation(value = "职务表-批量删除", notes = "职务表-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<SysPosition> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
Result<SysPosition> result = new Result<SysPosition>();
if (ids == null || "".equals(ids.trim())) {
result.error500("参数不识别!");
} else {
this.sysPositionService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "职务表-通过id查询")
@ApiOperation(value = "职务表-通过id查询", notes = "职务表-通过id查询")
@GetMapping(value = "/queryById")
public Result<SysPosition> queryById(@RequestParam(name = "id", required = true) String id) {
Result<SysPosition> result = new Result<SysPosition>();
SysPosition sysPosition = sysPositionService.getById(id);
if (sysPosition == null) {
result.error500("未找到对应实体");
} else {
result.setResult(sysPosition);
result.setSuccess(true);
}
return result;
}
/**
* 导出excel
*
* @param request
* @param response
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
// Step.1 组装查询条件
QueryWrapper<SysPosition> queryWrapper = null;
try {
String paramsStr = request.getParameter("paramsStr");
if (oConvertUtils.isNotEmpty(paramsStr)) {
String deString = URLDecoder.decode(paramsStr, "UTF-8");
SysPosition sysPosition = JSON.parseObject(deString, SysPosition.class);
queryWrapper = QueryGenerator.initQueryWrapper(sysPosition, request.getParameterMap());
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<SysPosition> pageList = sysPositionService.list(queryWrapper);
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "职务表列表");
mv.addObject(NormalExcelConstants.CLASS, SysPosition.class);
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("职务表列表数据", "导出人:Jeecg", "导出信息"));
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response)throws IOException {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
// 错误信息
List<String> errorMessage = new ArrayList<>();
int successLines = 0, errorLines = 0;
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
List<Object> listSysPositions = ExcelImportUtil.importExcel(file.getInputStream(), SysPosition.class, params);
List<String> list = ImportExcelUtil.importDateSave(listSysPositions, ISysPositionService.class, errorMessage,CommonConstant.SQL_INDEX_UNIQ_CODE);
errorLines+=list.size();
successLines+=(listSysPositions.size()-errorLines);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("文件导入失败:" + e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return ImportExcelUtil.imporReturnRes(errorLines,successLines,errorMessage);
}
/**
* 通过code查询
*
* @param code
* @return
*/
@AutoLog(value = "职务表-通过code查询")
@ApiOperation(value = "职务表-通过code查询", notes = "职务表-通过code查询")
@GetMapping(value = "/queryByCode")
public Result<SysPosition> queryByCode(@RequestParam(name = "code", required = true) String code) {
Result<SysPosition> result = new Result<SysPosition>();
QueryWrapper<SysPosition> queryWrapper = new QueryWrapper<SysPosition>();
queryWrapper.eq("code",code);
SysPosition sysPosition = sysPositionService.getOne(queryWrapper);
if (sysPosition == null) {
result.error500("未找到对应实体");
} else {
result.setResult(sysPosition);
result.setSuccess(true);
}
return result;
}
}
@@ -0,0 +1,409 @@
package com.jero.modules.system.controller;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.authz.annotation.RequiresRoles;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CacheConstant;
import com.jero.common.constant.CommonConstant;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.PmsUtil;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysPermission;
import com.jero.modules.system.entity.SysPermissionDataRule;
import com.jero.modules.system.entity.SysRole;
import com.jero.modules.system.entity.SysRolePermission;
import com.jero.modules.system.model.TreeModel;
import com.jero.modules.system.service.ISysPermissionDataRuleService;
import com.jero.modules.system.service.ISysPermissionService;
import com.jero.modules.system.service.ISysRolePermissionService;
import com.jero.modules.system.service.ISysRoleService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
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.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.jero.common.system.vo.LoginUser;
import org.apache.shiro.SecurityUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* <p>
* 角色表 前端控制器
* </p>
*
* @Author scott
* @since 2018-12-19
*/
@RestController
@RequestMapping("/sys/role")
@Slf4j
public class SysRoleController {
@Autowired
private ISysRoleService sysRoleService;
@Autowired
private ISysPermissionDataRuleService sysPermissionDataRuleService;
@Autowired
private ISysRolePermissionService sysRolePermissionService;
@Autowired
private ISysPermissionService sysPermissionService;
/**
* 分页列表查询
* @param role
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysRole>> queryPageList(SysRole role,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
Result<IPage<SysRole>> result = new Result<IPage<SysRole>>();
QueryWrapper<SysRole> queryWrapper = QueryGenerator.initQueryWrapper(role, req.getParameterMap());
Page<SysRole> page = new Page<SysRole>(pageNo, pageSize);
IPage<SysRole> pageList = sysRoleService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param role
* @return
*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
//@RequiresRoles({"admin"})
public Result<SysRole> add(@RequestBody SysRole role) {
Result<SysRole> result = new Result<SysRole>();
try {
role.setCreateTime(new Date());
sysRoleService.save(role);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param role
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysRole> edit(@RequestBody SysRole role) {
Result<SysRole> result = new Result<SysRole>();
SysRole sysrole = sysRoleService.getById(role.getId());
if(sysrole==null) {
result.error500("未找到对应实体");
}else {
role.setUpdateTime(new Date());
boolean ok = sysRoleService.updateById(role);
//TODO 返回false说明什么?
if(ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysRoleService.deleteRole(id);
return Result.ok("删除角色成功");
}
/**
* 批量删除
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysRole> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysRole> result = new Result<SysRole>();
if(oConvertUtils.isEmpty(ids)) {
result.error500("未选中角色!");
}else {
sysRoleService.deleteBatchRole(ids.split(","));
result.success("删除角色成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@RequestMapping(value = "/queryById", method = RequestMethod.GET)
public Result<SysRole> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysRole> result = new Result<SysRole>();
SysRole sysrole = sysRoleService.getById(id);
if(sysrole==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysrole);
result.setSuccess(true);
}
return result;
}
@RequestMapping(value = "/queryall", method = RequestMethod.GET)
public Result<List<SysRole>> queryall() {
Result<List<SysRole>> result = new Result<>();
List<SysRole> list = sysRoleService.list();
if(list==null||list.size()<=0) {
result.error500("未找到角色信息");
}else {
result.setResult(list);
result.setSuccess(true);
}
return result;
}
/**
* 校验角色编码唯一
*/
@RequestMapping(value = "/checkRoleCode", method = RequestMethod.GET)
public Result<Boolean> checkUsername(String id,String roleCode) {
Result<Boolean> result = new Result<>();
result.setResult(true);//如果此参数为false则程序发生异常
log.info("--验证角色编码是否唯一---id:"+id+"--roleCode:"+roleCode);
try {
SysRole role = null;
if(oConvertUtils.isNotEmpty(id)) {
role = sysRoleService.getById(id);
}
SysRole newRole = sysRoleService.getOne(new QueryWrapper<SysRole>().lambda().eq(SysRole::getRoleCode, roleCode));
if(newRole!=null) {
//如果根据传入的roleCode查询到信息了,那么就需要做校验了。
if(role==null) {
//role为空=>新增模式=>只要roleCode存在则返回false
result.setSuccess(false);
result.setMessage("角色编码已存在");
return result;
}else if(!id.equals(newRole.getId())) {
//否则=>编辑模式=>判断两者ID是否一致-
result.setSuccess(false);
result.setMessage("角色编码已存在");
return result;
}
}
} catch (Exception e) {
result.setSuccess(false);
result.setResult(false);
result.setMessage(e.getMessage());
return result;
}
result.setSuccess(true);
return result;
}
/**
* 导出excel
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysRole sysRole,HttpServletRequest request) {
// Step.1 组装查询条件
QueryWrapper<SysRole> queryWrapper = QueryGenerator.initQueryWrapper(sysRole, request.getParameterMap());
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<SysRole> pageList = sysRoleService.list(queryWrapper);
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME,"角色列表");
mv.addObject(NormalExcelConstants.CLASS,SysRole.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
mv.addObject(NormalExcelConstants.PARAMS,new ExportParams("角色列表数据","导出人:"+user.getRealname(),"导出信息"));
mv.addObject(NormalExcelConstants.DATA_LIST,pageList);
return mv;
}
/**
* 通过excel导入数据
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
return sysRoleService.importExcelCheckRoleCode(file, params);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("文件导入失败:" + e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
}
return Result.error("文件导入失败!");
}
/**
* 查询数据规则数据
*/
@GetMapping(value = "/datarule/{permissionId}/{roleId}")
public Result<?> loadDatarule(@PathVariable("permissionId") String permissionId,@PathVariable("roleId") String roleId) {
List<SysPermissionDataRule> list = sysPermissionDataRuleService.getPermRuleListByPermId(permissionId);
if(list==null || list.size()==0) {
return Result.error("未找到权限配置信息");
}else {
Map<String,Object> map = new HashMap<>();
map.put("datarule", list);
LambdaQueryWrapper<SysRolePermission> query = new LambdaQueryWrapper<SysRolePermission>()
.eq(SysRolePermission::getPermissionId, permissionId)
.isNotNull(SysRolePermission::getDataRuleIds)
.eq(SysRolePermission::getRoleId,roleId);
SysRolePermission sysRolePermission = sysRolePermissionService.getOne(query);
if(sysRolePermission==null) {
//return Result.error("未找到角色菜单配置信息");
}else {
String drChecked = sysRolePermission.getDataRuleIds();
if(oConvertUtils.isNotEmpty(drChecked)) {
map.put("drChecked", drChecked.endsWith(",")?drChecked.substring(0, drChecked.length()-1):drChecked);
}
}
return Result.ok(map);
//TODO 以后按钮权限的查询也走这个请求 无非在map中多加两个key
}
}
/**
* 保存数据规则至角色菜单关联表
*/
@PostMapping(value = "/datarule")
public Result<?> saveDatarule(@RequestBody JSONObject jsonObject) {
try {
String permissionId = jsonObject.getString("permissionId");
String roleId = jsonObject.getString("roleId");
String dataRuleIds = jsonObject.getString("dataRuleIds");
log.info("保存数据规则>>"+"菜单ID:"+permissionId+"角色ID:"+ roleId+"数据权限ID:"+dataRuleIds);
LambdaQueryWrapper<SysRolePermission> query = new LambdaQueryWrapper<SysRolePermission>()
.eq(SysRolePermission::getPermissionId, permissionId)
.eq(SysRolePermission::getRoleId,roleId);
SysRolePermission sysRolePermission = sysRolePermissionService.getOne(query);
if(sysRolePermission==null) {
return Result.error("请先保存角色菜单权限!");
}else {
sysRolePermission.setDataRuleIds(dataRuleIds);
this.sysRolePermissionService.updateById(sysRolePermission);
}
} catch (Exception e) {
log.error("SysRoleController.saveDatarule()发生异常:" + e.getMessage(),e);
return Result.error("保存失败");
}
return Result.ok("保存成功!");
}
/**
* 用户角色授权功能,查询菜单权限树
* @param request
* @return
*/
@RequestMapping(value = "/queryTreeList", method = RequestMethod.GET)
public Result<Map<String,Object>> queryTreeList(HttpServletRequest request) {
Result<Map<String,Object>> result = new Result<>();
//全部权限ids
List<String> ids = new ArrayList<>();
try {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.orderByAsc(SysPermission::getSortNo);
List<SysPermission> list = sysPermissionService.list(query);
for(SysPermission sysPer : list) {
ids.add(sysPer.getId());
}
List<TreeModel> treeList = new ArrayList<>();
getTreeModelList(treeList, list, null);
Map<String,Object> resMap = new HashMap<String,Object>();
resMap.put("treeList", treeList); //全部树节点数据
resMap.put("ids", ids);//全部树ids
result.setResult(resMap);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
private void getTreeModelList(List<TreeModel> treeList,List<SysPermission> metaList,TreeModel temp) {
for (SysPermission permission : metaList) {
String tempPid = permission.getParentId();
TreeModel tree = new TreeModel(permission.getId(), tempPid, permission.getName(),permission.getRuleFlag(), permission.isLeaf());
if(temp==null && oConvertUtils.isEmpty(tempPid)) {
treeList.add(tree);
if(!tree.getIsLeaf()) {
getTreeModelList(treeList, metaList, tree);
}
}else if(temp!=null && tempPid!=null && tempPid.equals(temp.getKey())){
temp.getChildren().add(tree);
if(!tree.getIsLeaf()) {
getTreeModelList(treeList, metaList, tree);
}
}
}
}
}
@@ -0,0 +1,161 @@
package com.jero.modules.system.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.PermissionData;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysTenant;
import com.jero.modules.system.service.ISysTenantService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
/**
* 租户配置信息
*/
@Slf4j
@RestController
@RequestMapping("/sys/tenant")
public class SysTenantController {
@Autowired
private ISysTenantService sysTenantService;
/**
* 获取列表数据
* @param sysTenant
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@PermissionData(pageComponent = "system/TenantList")
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysTenant>> queryPageList(SysTenant sysTenant,@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,HttpServletRequest req) {
Result<IPage<SysTenant>> result = new Result<IPage<SysTenant>>();
QueryWrapper<SysTenant> queryWrapper = QueryGenerator.initQueryWrapper(sysTenant, req.getParameterMap());
Page<SysTenant> page = new Page<SysTenant>(pageNo, pageSize);
IPage<SysTenant> pageList = sysTenantService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param
* @return
*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysTenant> add(@RequestBody SysTenant sysTenant) {
Result<SysTenant> result = new Result<SysTenant>();
if(sysTenantService.getById(sysTenant.getId())!=null){
return result.error500("该编号已存在!");
}
try {
sysTenantService.save(sysTenant);
result.success("添加成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param
* @return
*/
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysTenant> edit(@RequestBody SysTenant tenant) {
Result<SysTenant> result = new Result<SysTenant>();
SysTenant sysTenant = sysTenantService.getById(tenant.getId());
if(sysTenant==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysTenantService.updateById(tenant);
if(ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysTenantService.removeById(id);
return Result.ok("删除成功");
}
/**
* 批量删除
* @param ids
* @return
*/
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<?> result = new Result<>();
if(oConvertUtils.isEmpty(ids)) {
result.error500("未选中租户!");
}else {
List<String> ls = Arrays.asList(ids.split(","));
sysTenantService.removeByIds(ls);
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@RequestMapping(value = "/queryById", method = RequestMethod.GET)
public Result<SysTenant> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysTenant> result = new Result<SysTenant>();
SysTenant sysTenant = sysTenantService.getById(id);
if(sysTenant==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysTenant);
result.setSuccess(true);
}
return result;
}
/**
* 查询有效的 租户数据
* @return
*/
@RequestMapping(value = "/queryList", method = RequestMethod.GET)
public Result<List<SysTenant>> queryList(@RequestParam(name="ids",required=false) String ids) {
Result<List<SysTenant>> result = new Result<List<SysTenant>>();
LambdaQueryWrapper<SysTenant> query = new LambdaQueryWrapper<>();
query.eq(SysTenant::getStatus, 1);
if(oConvertUtils.isNotEmpty(ids)){
query.in(SysTenant::getId, ids.split(","));
}
//此处查询忽略时间条件
List<SysTenant> ls = sysTenantService.list(query);
result.setSuccess(true);
result.setResult(ls);
return result;
}
}
@@ -0,0 +1,57 @@
package com.jero.modules.system.controller;
import lombok.extern.slf4j.Slf4j;
import com.jero.common.api.vo.Result;
import com.jero.common.util.CommonUtils;
import com.jero.common.util.MinioUtil;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.oss.entity.OSSFile;
import com.jero.modules.oss.service.IOSSFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import javax.servlet.http.HttpServletRequest;
/**
* minio文件上传示例
*/
@Slf4j
@RestController
@RequestMapping("/sys/upload")
public class SysUploadController {
@Autowired
private IOSSFileService ossFileService;
/**
* 上传
* @param request
*/
@PostMapping(value = "/uploadMinio")
public Result<?> uploadMinio(HttpServletRequest request) {
Result<?> result = new Result<>();
String bizPath = request.getParameter("biz");
if(oConvertUtils.isEmpty(bizPath)){
bizPath = "";
}
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("file");// 获取上传文件对象
String orgName = file.getOriginalFilename();// 获取文件名
orgName = CommonUtils.getFileName(orgName);
String file_url = MinioUtil.upload(file,bizPath);
if(oConvertUtils.isEmpty(file_url)){
return Result.error("上传失败,请检查配置信息是否正确!");
}
//保存文件信息
OSSFile minioFile = new OSSFile();
minioFile.setFileName(orgName);
minioFile.setUrl(file_url);
ossFileService.save(minioFile);
result.setMessage(file_url);
result.setSuccess(true);
return result;
}
}
@@ -0,0 +1,264 @@
package com.jero.modules.system.controller;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.SecurityUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.oConvertUtils;
import com.jero.modules.system.entity.SysUserAgent;
import com.jero.modules.system.service.ISysUserAgentService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* @Title: Controller
* @Description: 用户代理人设置
* @Author: jero-boot
* @Date: 2019-04-17
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/sysUserAgent")
@Slf4j
public class SysUserAgentController {
@Autowired
private ISysUserAgentService sysUserAgentService;
@Value("${jero.path.upload}")
private String upLoadPath;
/**
* 分页列表查询
* @param sysUserAgent
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/list")
public Result<IPage<SysUserAgent>> queryPageList(SysUserAgent sysUserAgent,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
Result<IPage<SysUserAgent>> result = new Result<IPage<SysUserAgent>>();
QueryWrapper<SysUserAgent> queryWrapper = QueryGenerator.initQueryWrapper(sysUserAgent, req.getParameterMap());
Page<SysUserAgent> page = new Page<SysUserAgent>(pageNo, pageSize);
IPage<SysUserAgent> pageList = sysUserAgentService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param sysUserAgent
* @return
*/
@PostMapping(value = "/add")
public Result<SysUserAgent> add(@RequestBody SysUserAgent sysUserAgent) {
Result<SysUserAgent> result = new Result<SysUserAgent>();
try {
sysUserAgentService.save(sysUserAgent);
result.success("代理人设置成功!");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param sysUserAgent
* @return
*/
@PutMapping(value = "/edit")
public Result<SysUserAgent> edit(@RequestBody SysUserAgent sysUserAgent) {
Result<SysUserAgent> result = new Result<SysUserAgent>();
SysUserAgent sysUserAgentEntity = sysUserAgentService.getById(sysUserAgent.getId());
if(sysUserAgentEntity==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysUserAgentService.updateById(sysUserAgent);
//TODO 返回false说明什么?
if(ok) {
result.success("代理人设置成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@DeleteMapping(value = "/delete")
public Result<SysUserAgent> delete(@RequestParam(name="id",required=true) String id) {
Result<SysUserAgent> result = new Result<SysUserAgent>();
SysUserAgent sysUserAgent = sysUserAgentService.getById(id);
if(sysUserAgent==null) {
result.error500("未找到对应实体");
}else {
boolean ok = sysUserAgentService.removeById(id);
if(ok) {
result.success("删除成功!");
}
}
return result;
}
/**
* 批量删除
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
public Result<SysUserAgent> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysUserAgent> result = new Result<SysUserAgent>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别!");
}else {
this.sysUserAgentService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@GetMapping(value = "/queryById")
public Result<SysUserAgent> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysUserAgent> result = new Result<SysUserAgent>();
SysUserAgent sysUserAgent = sysUserAgentService.getById(id);
if(sysUserAgent==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysUserAgent);
result.setSuccess(true);
}
return result;
}
/**
* 通过userName查询
* @param userName
* @return
*/
@GetMapping(value = "/queryByUserName")
public Result<SysUserAgent> queryByUserName(@RequestParam(name="userName",required=true) String userName) {
Result<SysUserAgent> result = new Result<SysUserAgent>();
LambdaQueryWrapper<SysUserAgent> queryWrapper = new LambdaQueryWrapper<SysUserAgent>();
queryWrapper.eq(SysUserAgent::getUserName, userName);
SysUserAgent sysUserAgent = sysUserAgentService.getOne(queryWrapper);
if(sysUserAgent==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysUserAgent);
result.setSuccess(true);
}
return result;
}
/**
* 导出excel
*
* @param sysUserAgent
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysUserAgent sysUserAgent,HttpServletRequest request) {
// Step.1 组装查询条件
QueryWrapper<SysUserAgent> queryWrapper = QueryGenerator.initQueryWrapper(sysUserAgent, request.getParameterMap());
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<SysUserAgent> pageList = sysUserAgentService.list(queryWrapper);
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "用户代理人设置列表");
mv.addObject(NormalExcelConstants.CLASS, SysUserAgent.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
ExportParams exportParams = new ExportParams("用户代理人设置列表数据", "导出人:"+user.getRealname(), "导出信息");
exportParams.setImageBasePath(upLoadPath);
mv.addObject(NormalExcelConstants.PARAMS, exportParams);
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
List<SysUserAgent> listSysUserAgents = ExcelImportUtil.importExcel(file.getInputStream(), SysUserAgent.class, params);
for (SysUserAgent sysUserAgentExcel : listSysUserAgents) {
sysUserAgentService.save(sysUserAgentExcel);
}
return Result.ok("文件导入成功!数据行数:" + listSysUserAgents.size());
} catch (Exception e) {
log.error(e.getMessage(),e);
return Result.error("文件导入失败!");
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败!");
}
}
@@ -0,0 +1,280 @@
package com.jero.modules.system.controller;
import cn.hutool.crypto.SecureUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xkcoding.justauth.AuthRequestFactory;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import me.zhyd.oauth.model.AuthCallback;
import me.zhyd.oauth.model.AuthResponse;
import me.zhyd.oauth.request.AuthRequest;
import me.zhyd.oauth.utils.AuthStateUtils;
import com.jero.common.api.vo.Result;
import com.jero.common.constant.CacheConstant;
import com.jero.common.constant.CommonConstant;
import com.jero.common.util.*;
import com.jero.modules.base.service.BaseCommonService;
import com.jero.common.system.util.JwtUtil;
import com.jero.common.system.vo.LoginUser;
import com.jero.modules.system.entity.SysThirdAccount;
import com.jero.modules.system.entity.SysUser;
import com.jero.modules.system.model.ThirdLoginModel;
import com.jero.modules.system.service.ISysThirdAccountService;
import com.jero.modules.system.service.ISysUserService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;
import java.util.List;
/**
* @Author scott
* @since 2018-12-17
*/
@Controller
@RequestMapping("/sys/thirdLogin")
@Slf4j
public class ThirdLoginController {
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysThirdAccountService sysThirdAccountService;
@Autowired
private BaseCommonService baseCommonService;
@Autowired
private RedisUtil redisUtil;
@Autowired
private AuthRequestFactory factory;
@RequestMapping("/render/{source}")
public void render(@PathVariable("source") String source, HttpServletResponse response) throws IOException {
log.info("第三方登录进入render" + source);
AuthRequest authRequest = factory.get(source);
String authorizeUrl = authRequest.authorize(AuthStateUtils.createState());
log.info("第三方登录认证地址:" + authorizeUrl);
response.sendRedirect(authorizeUrl);
}
@RequestMapping("/{source}/callback")
public String loginThird(@PathVariable("source") String source, AuthCallback callback,ModelMap modelMap) {
log.info("第三方登录进入callback" + source + " params" + JSONObject.toJSONString(callback));
AuthRequest authRequest = factory.get(source);
AuthResponse response = authRequest.login(callback);
log.info(JSONObject.toJSONString(response));
Result<JSONObject> result = new Result<JSONObject>();
if(response.getCode()==2000) {
JSONObject data = JSONObject.parseObject(JSONObject.toJSONString(response.getData()));
String username = data.getString("username");
String avatar = data.getString("avatar");
String uuid = data.getString("uuid");
//构造第三方登录信息存储对象
ThirdLoginModel tlm = new ThirdLoginModel(source, uuid, username, avatar);
//判断有没有这个人
//update-begin-author:wangshuai date:20201118 for:修改成查询第三方账户表
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<SysThirdAccount>();
query.eq(SysThirdAccount::getThirdUserUuid, uuid);
query.eq(SysThirdAccount::getThirdType, source);
List<SysThirdAccount> thridList = sysThirdAccountService.list(query);
SysThirdAccount user = null;
if(thridList==null || thridList.size()==0) {
//否则直接创建新账号
user = saveThirdUser(tlm);
}else {
//已存在 只设置用户名 不设置头像
user = thridList.get(0);
}
// 生成token
//update-begin-author:wangshuai date:20201118 for:从第三方登录查询是否存在用户id,不存在绑定手机号
if(oConvertUtils.isNotEmpty(user.getSysUserId())) {
String sysUserId = user.getSysUserId();
SysUser sysUser = sysUserService.getById(sysUserId);
String token = saveToken(sysUser);
modelMap.addAttribute("token", token);
}else{
modelMap.addAttribute("token", "绑定手机号,"+""+uuid);
}
//update-end-author:wangshuai date:20201118 for:从第三方登录查询是否存在用户id,不存在绑定手机号
//update-begin--Author:wangshuai Date:20200729 for:接口在签名校验失败时返回失败的标识码 issues#1441--------------------
}else{
modelMap.addAttribute("token", "登录失败");
}
//update-end--Author:wangshuai Date:20200729 for:接口在签名校验失败时返回失败的标识码 issues#1441--------------------
result.setSuccess(false);
result.setMessage("第三方登录异常,请联系管理员");
return "thirdLogin";
}
/**
* 创建新账号
* @param model
* @return
*/
@PostMapping("/user/create")
@ResponseBody
public Result<String> thirdUserCreate(@RequestBody ThirdLoginModel model) {
log.info("第三方登录创建新账号:" );
Result<String> res = new Result<>();
Object operateCode = redisUtil.get(CommonConstant.THIRD_LOGIN_CODE);
if(operateCode==null || !operateCode.toString().equals(model.getOperateCode())){
res.setSuccess(false);
res.setMessage("校验失败");
return res;
}
//创建新账号
//update-begin-author:wangshuai date:20201118 for:修改成从第三方登录查出来的user_id,在查询用户表尽行token
SysThirdAccount user = saveThirdUser(model);
if(oConvertUtils.isNotEmpty(user.getSysUserId())){
String sysUserId = user.getSysUserId();
SysUser sysUser = sysUserService.getById(sysUserId);
// 生成token
String token = saveToken(sysUser);
//update-end-author:wangshuai date:20201118 for:修改成从第三方登录查出来的user_id,在查询用户表尽行token
res.setResult(token);
res.setSuccess(true);
}
return res;
}
/**
* 绑定账号 需要设置密码 需要走一遍校验
* @param json
* @return
*/
@PostMapping("/user/checkPassword")
@ResponseBody
public Result<String> checkPassword(@RequestBody JSONObject json) {
Result<String> result = new Result<>();
Object operateCode = redisUtil.get(CommonConstant.THIRD_LOGIN_CODE);
if(operateCode==null || !operateCode.toString().equals(json.getString("operateCode"))){
result.setSuccess(false);
result.setMessage("校验失败");
return result;
}
String username = json.getString("uuid");
SysUser user = this.sysUserService.getUserByName(username);
if(user==null){
result.setMessage("用户未找到");
result.setSuccess(false);
return result;
}
String password = json.getString("password");
String salt = user.getSalt();
String passwordEncode = PasswordUtil.encrypt(user.getUsername(), password, salt);
if(!passwordEncode.equals(user.getPassword())){
result.setMessage("密码不正确");
result.setSuccess(false);
return result;
}
sysUserService.updateById(user);
result.setSuccess(true);
// 生成token
String token = saveToken(user);
result.setResult(token);
return result;
}
/**
* 创建新用户
* @param tlm 第三方登录信息
*/
private SysThirdAccount saveThirdUser(ThirdLoginModel tlm){
SysThirdAccount user = new SysThirdAccount();
user.setDelFlag(CommonConstant.DEL_FLAG_0);
user.setStatus(1);
user.setThirdType(tlm.getSource());
user.setAvatar(tlm.getAvatar());
user.setRealname(tlm.getUsername());
user.setThirdUserUuid(tlm.getUuid());
sysThirdAccountService.save(user);
return user;
}
private String saveToken(SysUser user) {
// 生成token
String token = JwtUtil.sign(user.getUsername(), user.getPassword());
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
// 设置超时时间
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME / 1000);
return token;
}
@SuppressWarnings("unchecked")
@RequestMapping(value = "/getLoginUser/{token}/{thirdType}", method = RequestMethod.GET)
@ResponseBody
public Result<JSONObject> getThirdLoginUser(@PathVariable("token") String token,@PathVariable("thirdType") String thirdType) throws Exception {
Result<JSONObject> result = new Result<JSONObject>();
String username = JwtUtil.getUsername(token);
//1. 校验用户是否有效
SysUser sysUser = sysUserService.getUserByName(username);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
//update-begin-author:wangshuai date:20201118 for:如果真实姓名和头像不存在就取第三方登录的
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAccount::getSysUserId,sysUser.getId());
query.eq(SysThirdAccount::getThirdType,thirdType);
SysThirdAccount account = sysThirdAccountService.getOne(query);
if(oConvertUtils.isEmpty(sysUser.getRealname())){
sysUser.setRealname(account.getRealname());
}
if(oConvertUtils.isEmpty(sysUser.getAvatar())){
sysUser.setAvatar(account.getAvatar());
}
//update-end-author:wangshuai date:20201118 for:如果真实姓名和头像不存在就取第三方登录的
JSONObject obj = new JSONObject();
//用户登录信息
obj.put("userInfo", sysUser);
//token 信息
obj.put("token", token);
result.setResult(obj);
result.setSuccess(true);
result.setCode(200);
baseCommonService.addLog("用户名: " + username + ",登录成功[第三方用户]", CommonConstant.LOG_TYPE_1, null);
return result;
}
/**
* 第三方绑定手机号返回token
*
* @param jsonObject
* @return
*/
@ApiOperation("手机号登录接口")
@PostMapping("/bindingThirdPhone")
@ResponseBody
public Result<String> bindingThirdPhone(@RequestBody JSONObject jsonObject) {
Result<String> result = new Result<String>();
String phone = jsonObject.getString("mobile");
String thirdUserUuid = jsonObject.getString("thirdUserUuid");
//校验用户有效性
SysUser sysUser = sysUserService.getUserByPhone(phone);
if(sysUser != null){
sysThirdAccountService.updateThirdUserId(sysUser,thirdUserUuid);
}else{
// 不存在手机号,创建用户
String smscode = jsonObject.getString("captcha");
Object code = redisUtil.get(phone);
if (!smscode.equals(code)) {
result.setMessage("手机验证码错误");
result.setSuccess(false);
return result;
}
//创建用户
sysUser = sysThirdAccountService.createUser(phone,thirdUserUuid);
}
String token = saveToken(sysUser);
result.setSuccess(true);
result.setResult(token);
return result;
}
}
@@ -0,0 +1,147 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 系统通告表
* @Author: jero-boot
* @Date: 2019-01-02
* @Version: V1.0
*/
@Data
@TableName("sys_announcement")
public class SysAnnouncement implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**
* 标题
*/
@Excel(name = "标题", width = 15)
private java.lang.String titile;
/**
* 内容
*/
@Excel(name = "内容", width = 30)
private java.lang.String msgContent;
/**
* 开始时间
*/
@Excel(name = "开始时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date startTime;
/**
* 结束时间
*/
@Excel(name = "结束时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date endTime;
/**
* 发布人
*/
@Excel(name = "发布人", width = 15)
private java.lang.String sender;
/**
* 优先级(L低,M中,H高)
*/
@Excel(name = "优先级", width = 15, dicCode = "priority")
@Dict(dicCode = "priority")
private java.lang.String priority;
/**
* 消息类型1:通知公告2:系统消息
*/
@Excel(name = "消息类型", width = 15, dicCode = "msg_category")
@Dict(dicCode = "msg_category")
private java.lang.String msgCategory;
/**
* 通告对象类型(USER:指定用户,ALL:全体用户)
*/
@Excel(name = "通告对象类型", width = 15, dicCode = "msg_type")
@Dict(dicCode = "msg_type")
private java.lang.String msgType;
/**
* 发布状态(0未发布,1已发布,2已撤销)
*/
@Excel(name = "发布状态", width = 15, dicCode = "send_status")
@Dict(dicCode = "send_status")
private java.lang.String sendStatus;
/**
* 发布时间
*/
@Excel(name = "发布时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date sendTime;
/**
* 撤销时间
*/
@Excel(name = "撤销时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date cancelTime;
/**
* 删除状态(0,正常,1已删除)
*/
private java.lang.String delFlag;
/**
* 创建人
*/
private java.lang.String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**
* 更新人
*/
private java.lang.String updateBy;
/**
* 更新时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
/**
* 指定用户
**/
private java.lang.String userIds;
/**
* 业务类型(email:邮件 bpm:流程)
*/
private java.lang.String busType;
/**
* 业务id
*/
private java.lang.String busId;
/**
* 打开方式 组件:component 路由:url
*/
private java.lang.String openType;
/**
* 组件/路由 地址
*/
private java.lang.String openPage;
/**
* 摘要
*/
private java.lang.String msgAbstract;
}
@@ -0,0 +1,48 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 用户通告阅读标记表
* @Author: jero-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
@Data
@TableName("sys_announcement_send")
public class SysAnnouncementSend implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**通告id*/
private java.lang.String anntId;
/**用户id*/
private java.lang.String userId;
/**阅读状态(0未读,1已读)*/
private java.lang.String readFlag;
/**阅读时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date readTime;
/**创建人*/
private java.lang.String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**更新人*/
private java.lang.String updateBy;
/**更新时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
}
@@ -0,0 +1,66 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
* @Description: 分类字典
* @Author: jero-boot
* @Date: 2019-05-29
* @Version: V1.0
*/
@Data
@TableName("sys_category")
public class SysCategory implements Serializable,Comparable<SysCategory>{
private static final long serialVersionUID = 1L;
/**主键*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**父级节点*/
private java.lang.String pid;
/**类型名称*/
@Excel(name = "类型名称", width = 15)
private java.lang.String name;
/**类型编码*/
@Excel(name = "类型编码", width = 15)
private java.lang.String code;
/**创建人*/
private java.lang.String createBy;
/**创建日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**更新人*/
private java.lang.String updateBy;
/**更新日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
/**所属部门*/
private java.lang.String sysOrgCode;
/**是否有子节点*/
@Excel(name = "是否有子节点(1:有)", width = 15)
private java.lang.String hasChild;
@Override
public int compareTo(SysCategory o) {
//比较条件我们定的是按照code的长度升序
// <0:当前对象比传入对象小。
// =0:当前对象等于传入对象。
// >0:当前对象比传入对象大。
int s = this.code.length() - o.code.length();
return s;
}
@Override
public String toString() {
return "SysCategory [code=" + code + ", name=" + name + "]";
}
}
@@ -0,0 +1,88 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* @Description: 编码校验规则
* @Author: jero-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
@Data
@TableName("sys_check_rule")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "sys_check_rule对象", description = "编码校验规则")
public class SysCheckRule {
/**
* 主键id
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键id")
private String id;
/**
* 规则名称
*/
@Excel(name = "规则名称", width = 15)
@ApiModelProperty(value = "规则名称")
private String ruleName;
/**
* 规则Code
*/
@Excel(name = "规则Code", width = 15)
@ApiModelProperty(value = "规则Code")
private String ruleCode;
/**
* 规则JSON
*/
@Excel(name = "规则JSON", width = 15)
@ApiModelProperty(value = "规则JSON")
private String ruleJson;
/**
* 规则描述
*/
@Excel(name = "规则描述", width = 15)
@ApiModelProperty(value = "规则描述")
private String ruleDescription;
/**
* 更新人
*/
@Excel(name = "更新人", width = 15)
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@Excel(name = "更新时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 创建人
*/
@Excel(name = "创建人", width = 15)
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "创建时间")
private Date createTime;
}
@@ -0,0 +1,36 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysDataLog implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
private String id; //id'
private String createBy; //创建人登录名称
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime; //创建日期
private String updateBy; //更新人登录名称
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date updateTime; //更新日期
private String dataTable; //表名
private String dataId; //数据ID
private String dataContent; //数据内容
private String dataVersion; //版本号
}
@@ -0,0 +1,120 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 多数据源管理
* @Author: jero-boot
* @Date: 2019-12-25
* @Version: V1.0
*/
@Data
@TableName("sys_data_source")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "sys_data_source对象", description = "多数据源管理")
public class SysDataSource {
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "id")
private java.lang.String id;
/**
* 数据源编码
*/
@Excel(name = "数据源编码", width = 15)
@ApiModelProperty(value = "数据源编码")
private java.lang.String code;
/**
* 数据源名称
*/
@Excel(name = "数据源名称", width = 15)
@ApiModelProperty(value = "数据源名称")
private java.lang.String name;
/**
* 描述
*/
@Excel(name = "备注", width = 15)
@ApiModelProperty(value = "备注")
private java.lang.String remark;
/**
* 数据库类型
*/
@Dict(dicCode = "database_type")
@Excel(name = "数据库类型", width = 15, dicCode = "database_type")
@ApiModelProperty(value = "数据库类型")
private java.lang.String dbType;
/**
* 驱动类
*/
@Excel(name = "驱动类", width = 15)
@ApiModelProperty(value = "驱动类")
private java.lang.String dbDriver;
/**
* 数据源地址
*/
@Excel(name = "数据源地址", width = 15)
@ApiModelProperty(value = "数据源地址")
private java.lang.String dbUrl;
/**
* 数据库名称
*/
@Excel(name = "数据库名称", width = 15)
@ApiModelProperty(value = "数据库名称")
private java.lang.String dbName;
/**
* 用户名
*/
@Excel(name = "用户名", width = 15)
@ApiModelProperty(value = "用户名")
private java.lang.String dbUsername;
/**
* 密码
*/
@Excel(name = "密码", width = 15)
@ApiModelProperty(value = "密码")
private java.lang.String dbPassword;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private java.lang.String createBy;
/**
* 创建日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "创建日期")
private java.util.Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private java.lang.String updateBy;
/**
* 更新日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新日期")
private java.util.Date updateTime;
/**
* 所属部门
*/
@Excel(name = "所属部门", width = 15)
@ApiModelProperty(value = "所属部门")
private java.lang.String sysOrgCode;
}
@@ -0,0 +1,137 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import com.jero.common.aspect.annotation.Dict;
import com.jero.modules.system.model.SysDepartTreeModel;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Objects;
/**
* <p>
* 部门表
* <p>
*
* @Author Steve
* @Since 2019-01-22
*/
@Data
@TableName("sys_depart")
public class SysDepart implements Serializable {
private static final long serialVersionUID = 1L;
/**ID*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**父机构ID*/
private String parentId;
/**机构/部门名称*/
@Excel(name="机构/部门名称",width=15)
private String departName;
/**英文名*/
@Excel(name="英文名",width=15)
private String departNameEn;
/**缩写*/
private String departNameAbbr;
/**排序*/
@Excel(name="排序",width=15)
private Integer departOrder;
/**描述*/
@Excel(name="描述",width=15)
private String description;
/**机构类别 1公司,2组织机构,2岗位*/
@Excel(name="机构类别",width=15,dicCode="org_category")
private String orgCategory;
/**机构类型*/
private String orgType;
/**机构编码*/
@Excel(name="机构编码",width=15)
private String orgCode;
/**手机号*/
@Excel(name="手机号",width=15)
private String mobile;
/**传真*/
@Excel(name="传真",width=15)
private String fax;
/**地址*/
@Excel(name="地址",width=15)
private String address;
/**备注*/
@Excel(name="备注",width=15)
private String memo;
/**状态(1启用,0不启用)*/
@Dict(dicCode = "depart_status")
private String status;
/**删除状态(0,正常,1已删除)*/
@Dict(dicCode = "del_flag")
private String delFlag;
/**创建人*/
private String createBy;
/**创建日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**更新人*/
private String updateBy;
/**更新日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* 重写equals方法
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
if (!super.equals(o)) {
return false;
}
SysDepart depart = (SysDepart) o;
return Objects.equals(id, depart.id) &&
Objects.equals(parentId, depart.parentId) &&
Objects.equals(departName, depart.departName) &&
Objects.equals(departNameEn, depart.departNameEn) &&
Objects.equals(departNameAbbr, depart.departNameAbbr) &&
Objects.equals(departOrder, depart.departOrder) &&
Objects.equals(description, depart.description) &&
Objects.equals(orgCategory, depart.orgCategory) &&
Objects.equals(orgType, depart.orgType) &&
Objects.equals(orgCode, depart.orgCode) &&
Objects.equals(mobile, depart.mobile) &&
Objects.equals(fax, depart.fax) &&
Objects.equals(address, depart.address) &&
Objects.equals(memo, depart.memo) &&
Objects.equals(status, depart.status) &&
Objects.equals(delFlag, depart.delFlag) &&
Objects.equals(createBy, depart.createBy) &&
Objects.equals(createTime, depart.createTime) &&
Objects.equals(updateBy, depart.updateBy) &&
Objects.equals(updateTime, depart.updateTime);
}
/**
* 重写hashCode方法
*/
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), id, parentId, departName,
departNameEn, departNameAbbr, departOrder, description,orgCategory,
orgType, orgCode, mobile, fax, address, memo, status,
delFlag, createBy, createTime, updateBy, updateTime);
}
}
@@ -0,0 +1,55 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门权限表
* @Author: jero-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
@Data
@TableName("sys_depart_permission")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="sys_depart_permission对象", description="部门权限表")
public class SysDepartPermission {
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "id")
private java.lang.String id;
/**部门id*/
@Excel(name = "部门id", width = 15)
@ApiModelProperty(value = "部门id")
private java.lang.String departId;
/**权限id*/
@Excel(name = "权限id", width = 15)
@ApiModelProperty(value = "权限id")
private java.lang.String permissionId;
/**数据规则id*/
@ApiModelProperty(value = "数据规则id")
private java.lang.String dataRuleIds;
public SysDepartPermission() {
}
public SysDepartPermission(String departId, String permissionId) {
this.departId = departId;
this.permissionId = permissionId;
}
}
@@ -0,0 +1,75 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门角色
* @Author: jero-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Data
@TableName("sys_depart_role")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="sys_depart_role对象", description="部门角色")
public class SysDepartRole {
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "id")
private java.lang.String id;
/**部门id*/
@Excel(name = "部门id", width = 15)
@ApiModelProperty(value = "部门id")
@Dict(dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
private java.lang.String departId;
/**部门角色名称*/
@Excel(name = "部门角色名称", width = 15)
@ApiModelProperty(value = "部门角色名称")
private java.lang.String roleName;
/**部门角色编码*/
@Excel(name = "部门角色编码", width = 15)
@ApiModelProperty(value = "部门角色编码")
private java.lang.String roleCode;
/**描述*/
@Excel(name = "描述", width = 15)
@ApiModelProperty(value = "描述")
private java.lang.String description;
/**创建人*/
@Excel(name = "创建人", width = 15)
@ApiModelProperty(value = "创建人")
private java.lang.String createBy;
/**创建时间*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "创建时间")
private java.util.Date createTime;
/**更新人*/
@Excel(name = "更新人", width = 15)
@ApiModelProperty(value = "更新人")
private java.lang.String updateBy;
/**更新时间*/
@Excel(name = "更新时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新时间")
private java.util.Date updateTime;
}
@@ -0,0 +1,67 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门角色权限
* @Author: jero-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Data
@TableName("sys_depart_role_permission")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="sys_depart_role_permission对象", description="部门角色权限")
public class SysDepartRolePermission {
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "id")
private java.lang.String id;
/**部门id*/
@Excel(name = "部门id", width = 15)
@ApiModelProperty(value = "部门id")
private java.lang.String departId;
/**角色id*/
@Excel(name = "角色id", width = 15)
@ApiModelProperty(value = "角色id")
private java.lang.String roleId;
/**权限id*/
@Excel(name = "权限id", width = 15)
@ApiModelProperty(value = "权限id")
private java.lang.String permissionId;
/**dataRuleIds*/
@Excel(name = "dataRuleIds", width = 15)
@ApiModelProperty(value = "dataRuleIds")
private java.lang.String dataRuleIds;
/** 操作时间 */
@Excel(name = "操作时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "操作时间")
private java.util.Date operateDate;
/** 操作ip */
private java.lang.String operateIp;
public SysDepartRolePermission() {
}
public SysDepartRolePermission(String roleId, String permissionId) {
this.roleId = roleId;
this.permissionId = permissionId;
}
}
@@ -0,0 +1,52 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门角色人员信息
* @Author: jero-boot
* @Date: 2020-02-13
* @Version: V1.0
*/
@Data
@TableName("sys_depart_role_user")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="sys_depart_role_user对象", description="部门角色人员信息")
public class SysDepartRoleUser {
/**主键id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键id")
private java.lang.String id;
/**用户id*/
@Excel(name = "用户id", width = 15)
@ApiModelProperty(value = "用户id")
private java.lang.String userId;
/**角色id*/
@Excel(name = "角色id", width = 15)
@ApiModelProperty(value = "角色id")
private java.lang.String droleId;
public SysDepartRoleUser() {
}
public SysDepartRoleUser(String userId, String droleId) {
this.userId = userId;
this.droleId = droleId;
}
}
@@ -0,0 +1,85 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 字典表
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysDict implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* [预留字段,暂时无用]
* 字典类型,0 string,1 number类型,2 boolean
* 前端js对stirng类型和number类型 boolean 类型敏感,需要区分。在select 标签匹配的时候会用到
* 默认为string类型
*/
private Integer type;
/**
* 字典名称
*/
private String dictName;
/**
* 字典编码
*/
private String dictCode;
/**
* 描述
*/
private String description;
/**
* 删除状态
*/
@TableLogic
private Integer delFlag;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
}
@@ -0,0 +1,82 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* <p>
*
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysDictItem implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 字典id
*/
private String dictId;
/**
* 字典项文本
*/
@Excel(name = "字典项文本", width = 20)
private String itemText;
/**
* 字典项值
*/
@Excel(name = "字典项值", width = 30)
private String itemValue;
/**
* 描述
*/
@Excel(name = "描述", width = 40)
private String description;
/**
* 排序
*/
@Excel(name = "排序", width = 15,type=4)
private Integer sortOrder;
/**
* 状态(1启用 0不启用)
*/
@Dict(dicCode = "dict_item_status")
private Integer status;
private String createBy;
private Date createTime;
private String updateBy;
private Date updateTime;
}
@@ -0,0 +1,86 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 填值规则
* @Author: jero-boot
* @Date: 2019-11-07
* @Version: V1.0
*/
@Data
@TableName("sys_fill_rule")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "sys_fill_rule对象", description = "填值规则")
public class SysFillRule {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private java.lang.String id;
/**
* 规则名称
*/
@Excel(name = "规则名称", width = 15)
@ApiModelProperty(value = "规则名称")
private java.lang.String ruleName;
/**
* 规则Code
*/
@Excel(name = "规则Code", width = 15)
@ApiModelProperty(value = "规则Code")
private java.lang.String ruleCode;
/**
* 规则实现类
*/
@Excel(name = "规则实现类", width = 15)
@ApiModelProperty(value = "规则实现类")
private java.lang.String ruleClass;
/**
* 规则参数
*/
@Excel(name = "规则参数", width = 15)
@ApiModelProperty(value = "规则参数")
private java.lang.String ruleParams;
/**
* 修改人
*/
@Excel(name = "修改人", width = 15)
@ApiModelProperty(value = "修改人")
private java.lang.String updateBy;
/**
* 修改时间
*/
@Excel(name = "修改时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "修改时间")
private java.util.Date updateTime;
/**
* 创建人
*/
@Excel(name = "创建人", width = 15)
@ApiModelProperty(value = "创建人")
private java.lang.String createBy;
/**
* 创建时间
*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "创建时间")
private java.util.Date createTime;
}
@@ -0,0 +1,111 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* @Description: gateway路由管理
* @Author: jero-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
@Data
@TableName("sys_gateway_route")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="sys_gateway_route对象", description="gateway路由管理")
public class SysGatewayRoute implements Serializable {
private static final long serialVersionUID = 1L;
/**主键*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键")
private String id;
/**routerKEy*/
@ApiModelProperty(value = "路由ID")
private String routerId;
/**服务名*/
@Excel(name = "服务名", width = 15)
@ApiModelProperty(value = "服务名")
private String name;
/**服务地址*/
@Excel(name = "服务地址", width = 15)
@ApiModelProperty(value = "服务地址")
private String uri;
/**
* 断言配置
*/
private String predicates;
/**
* 过滤配置
*/
private String filters;
/**是否忽略前缀0-否 1-是*/
@Excel(name = "忽略前缀", width = 15)
@ApiModelProperty(value = "忽略前缀")
@Dict(dicCode = "yn")
private Integer stripPrefix;
/**是否重试0-否 1-是*/
@Excel(name = "是否重试", width = 15)
@ApiModelProperty(value = "是否重试")
@Dict(dicCode = "yn")
private Integer retryable;
/**是否为保留数据:0-否 1-是*/
@Excel(name = "保留数据", width = 15)
@ApiModelProperty(value = "保留数据")
@Dict(dicCode = "yn")
private Integer persistable;
/**是否在接口文档中展示:0-否 1-是*/
@Excel(name = "在接口文档中展示", width = 15)
@ApiModelProperty(value = "在接口文档中展示")
@Dict(dicCode = "yn")
private Integer showApi;
/**状态 1有效 0无效*/
@Excel(name = "状态", width = 15)
@ApiModelProperty(value = "状态")
@Dict(dicCode = "yn")
private Integer status;
/**创建人*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**创建日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "创建日期")
private Date createTime;
/* *//**更新人*//*
@ApiModelProperty(value = "更新人")
private String updateBy;
*//**更新日期*//*
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新日期")
private Date updateTime;
*//**所属部门*//*
@ApiModelProperty(value = "所属部门")
private String sysOrgCode;*/
}
@@ -0,0 +1,112 @@
package com.jero.modules.system.entity;
import java.util.Date;
import com.jero.common.aspect.annotation.Dict;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 系统日志表
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysLog implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**
* 耗时
*/
private Long costTime;
/**
* IP
*/
private String ip;
/**
* 请求参数
*/
private String requestParam;
/**
* 请求类型
*/
private String requestType;
/**
* 请求路径
*/
private String requestUrl;
/**
* 请求方法
*/
private String method;
/**
* 操作人用户名称
*/
private String username;
/**
* 操作人用户账户
*/
private String userid;
/**
* 操作详细日志
*/
private String logContent;
/**
* 日志类型(1登录日志,2操作日志)
*/
@Dict(dicCode = "log_type")
private Integer logType;
/**
* 操作类型(1查询,2添加,3修改,4删除,5导入,6导出)
*/
@Dict(dicCode = "operate_type")
private Integer operateType;
}
@@ -0,0 +1,182 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* <p>
* 菜单权限表
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysPermission implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 父id
*/
private String parentId;
/**
* 菜单名称
*/
private String name;
/**
* 菜单权限编码,例如:“sys:schedule:list,sys:schedule:info”,多个逗号隔开
*/
private String perms;
/**
* 权限策略1显示2禁用
*/
private String permsType;
/**
* 菜单图标
*/
private String icon;
/**
* 组件
*/
private String component;
/**
* 组件名字
*/
private String componentName;
/**
* 路径
*/
private String url;
/**
* 一级菜单跳转地址
*/
private String redirect;
/**
* 菜单排序
*/
private Double sortNo;
/**
* 类型(0:一级菜单;1:子菜单 ;2:按钮权限)
*/
@Dict(dicCode = "menu_type")
private Integer menuType;
/**
* 是否叶子节点: 1:是 0:不是
*/
@TableField(value="is_leaf")
private boolean leaf;
/**
* 是否路由菜单: 0:不是 1:是(默认值1)
*/
@TableField(value="is_route")
private boolean route;
/**
* 是否缓存页面: 0:不是 1:是(默认值1)
*/
@TableField(value="keep_alive")
private boolean keepAlive;
/**
* 描述
*/
private String description;
/**
* 创建人
*/
private String createBy;
/**
* 删除状态 0正常 1已删除
*/
private Integer delFlag;
/**
* 是否配置菜单的数据权限 1是0否 默认0
*/
private Integer ruleFlag;
/**
* 是否隐藏路由菜单: 0否,1是(默认值0)
*/
private boolean hidden;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**按钮权限状态(0无效1有效)*/
private java.lang.String status;
/**alwaysShow*/
private boolean alwaysShow;
/*update_begin author:wuxianquan date:20190908 for:实体增加字段 */
/** 外链菜单打开方式 0/内部打开 1/外部打开 */
private boolean internalOrExternal;
/*update_end author:wuxianquan date:20190908 for:实体增加字段 */
public SysPermission() {
}
public SysPermission(boolean index) {
if(index) {
this.id = "9502685863ab87f0ad1134142788a385";
this.name="首页";
this.component="dashboard/Analysis";
this.componentName="dashboard-analysis";
this.url="/dashboard/analysis";
this.icon="home";
this.menuType=0;
this.sortNo=0.0;
this.ruleFlag=0;
this.delFlag=0;
this.alwaysShow=false;
this.route=true;
this.keepAlive=true;
this.leaf=true;
this.hidden=false;
}
}
}
@@ -0,0 +1,83 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 菜单权限规则表
* </p>
*
* @Author huangzhilin
* @since 2019-03-29
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysPermissionDataRule implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 对应的菜单id
*/
private String permissionId;
/**
* 规则名称
*/
private String ruleName;
/**
* 字段
*/
private String ruleColumn;
/**
* 条件
*/
private String ruleConditions;
/**
* 规则值
*/
private String ruleValue;
/**
* 状态值 1有效 0无效
*/
private String status;
/**
* 创建时间
*/
private Date createTime;
/**
* 创建人
*/
private String createBy;
/**
* 修改时间
*/
private Date updateTime;
/**
* 修改人
*/
private String updateBy;
}
@@ -0,0 +1,90 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 职务表
* @Author: jero-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
@Data
@TableName("sys_position")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "sys_position对象", description = "职务表")
public class SysPosition {
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "id")
private java.lang.String id;
/**
* 职务编码
*/
@Excel(name = "职务编码", width = 15)
@ApiModelProperty(value = "职务编码")
private java.lang.String code;
/**
* 职务名称
*/
@Excel(name = "职务名称", width = 15)
@ApiModelProperty(value = "职务名称")
private java.lang.String name;
/**
* 职级
*/
@Excel(name = "职级", width = 15,dicCode ="position_rank")
@ApiModelProperty(value = "职级")
@Dict(dicCode = "position_rank")
private java.lang.String postRank;
/**
* 公司id
*/
@Excel(name = "公司id", width = 15)
@ApiModelProperty(value = "公司id")
private java.lang.String companyId;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private java.lang.String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "创建时间")
private java.util.Date createTime;
/**
* 修改人
*/
@ApiModelProperty(value = "修改人")
private java.lang.String updateBy;
/**
* 修改时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "修改时间")
private java.util.Date updateTime;
/**
* 组织机构编码
*/
@Excel(name = "组织机构编码", width = 15)
@ApiModelProperty(value = "组织机构编码")
private java.lang.String sysOrgCode;
}
@@ -0,0 +1,82 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Date;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 角色表
* </p>
*
* @Author scott
* @since 2018-12-19
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysRole implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 角色名称
*/
@Excel(name="角色名",width=15)
private String roleName;
/**
* 角色编码
*/
@Excel(name="角色编码",width=15)
private String roleCode;
/**
* 描述
*/
@Excel(name="描述",width=60)
private String description;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
@@ -0,0 +1,71 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 角色权限表
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysRolePermission implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 角色id
*/
private String roleId;
/**
* 权限id
*/
private String permissionId;
/**
* 数据权限
*/
private String dataRuleIds;
/**
* 操作时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date operateDate;
/**
* 操作ip
*/
private String operateIp;
public SysRolePermission() {
}
public SysRolePermission(String roleId, String permissionId) {
this.roleId = roleId;
this.permissionId = permissionId;
}
}
@@ -0,0 +1,64 @@
package com.jero.modules.system.entity;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import com.jero.common.aspect.annotation.Dict;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* 租户信息
*/
@Data
@TableName("sys_tenant")
public class SysTenant implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 编码
*/
private Integer id;
/**
* 名称
*/
private String name;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 开始时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date beginDate;
/**
* 结束时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date endDate;
/**
* 状态 1正常 0冻结
*/
@Dict(dicCode = "tenant_status")
private Integer status;
}
@@ -0,0 +1,63 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 第三方登录账号表
* @Author: jero-boot
* @Date: 2020-11-17
* @Version: V1.0
*/
@Data
@TableName("sys_third_account")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="sys_third_account对象", description="第三方登录账号表")
public class SysThirdAccount {
/**编号*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "编号")
private java.lang.String id;
/**第三方登录id*/
@Excel(name = "第三方登录id", width = 15)
@ApiModelProperty(value = "第三方登录id")
private java.lang.String sysUserId;
/**登录来源*/
@Excel(name = "登录来源", width = 15)
@ApiModelProperty(value = "登录来源")
private java.lang.String thirdType;
/**头像*/
@Excel(name = "头像", width = 15)
@ApiModelProperty(value = "头像")
private java.lang.String avatar;
/**状态(1-正常,2-冻结)*/
@Excel(name = "状态(1-正常,2-冻结)", width = 15)
@ApiModelProperty(value = "状态(1-正常,2-冻结)")
private java.lang.Integer status;
/**删除状态(0-正常,1-已删除)*/
@Excel(name = "删除状态(0-正常,1-已删除)", width = 15)
@ApiModelProperty(value = "删除状态(0-正常,1-已删除)")
private java.lang.Integer delFlag;
/**真实姓名*/
@Excel(name = "真实姓名", width = 15)
@ApiModelProperty(value = "真实姓名")
private java.lang.String realname;
/**真实姓名*/
@Excel(name = "真实姓名", width = 15)
@ApiModelProperty(value = "真实姓名")
private java.lang.String thirdUserUuid;
}
@@ -0,0 +1,185 @@
package com.jero.modules.system.entity;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 用户表
* </p>
*
* @Author scott
* @since 2018-12-20
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysUser implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 登录账号
*/
@Excel(name = "登录账号", width = 15)
private String username;
/**
* 真实姓名
*/
@Excel(name = "真实姓名", width = 15)
private String realname;
/**
* 密码
*/
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String password;
/**
* md5密码盐
*/
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String salt;
/**
* 头像
*/
@Excel(name = "头像", width = 15,type = 2)
private String avatar;
/**
* 生日
*/
@Excel(name = "生日", width = 15, format = "yyyy-MM-dd")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date birthday;
/**
* 性别(1:男 2:女)
*/
@Excel(name = "性别", width = 15,dicCode="sex")
@Dict(dicCode = "sex")
private Integer sex;
/**
* 电子邮件
*/
@Excel(name = "电子邮件", width = 15)
private String email;
/**
* 电话
*/
@Excel(name = "电话", width = 15)
private String phone;
/**
* 部门code(当前选择登录部门)
*/
private String orgCode;
/**部门名称*/
private transient String orgCodeTxt;
/**
* 状态(1:正常 2:冻结 )
*/
@Excel(name = "状态", width = 15,dicCode="user_status")
@Dict(dicCode = "user_status")
private Integer status;
/**
* 删除状态(0,正常,1已删除)
*/
@Excel(name = "删除状态", width = 15,dicCode="del_flag")
@TableLogic
private Integer delFlag;
/**
* 工号,唯一键
*/
@Excel(name = "工号", width = 15)
private String workNo;
/**
* 职务,关联职务表
*/
@Excel(name = "职务", width = 15)
@Dict(dictTable ="sys_position",dicText = "name",dicCode = "code")
private String post;
/**
* 座机号
*/
@Excel(name = "座机号", width = 15)
private String telephone;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**
* 同步工作流引擎1同步0不同步
*/
private Integer activitiSync;
/**
* 身份(0 普通成员 1 上级)
*/
@Excel(name="1普通成员 2上级)",width = 15)
private Integer userIdentity;
/**
* 负责部门
*/
@Excel(name="负责部门",width = 15,dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
@Dict(dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
private String departIds;
/**
* 多租户id配置,编辑用户的时候设置
*/
private String relTenantIds;
/**设备id uniapp推送用*/
private String clientId;
}
@@ -0,0 +1,74 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 用户代理人设置
* @Author: jero-boot
* @Date: 2019-04-17
* @Version: V1.0
*/
@Data
@TableName("sys_user_agent")
public class SysUserAgent implements Serializable {
private static final long serialVersionUID = 1L;
/**序号*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**用户名*/
@Excel(name = "用户名", width = 15)
private java.lang.String userName;
/**代理人用户名*/
@Excel(name = "代理人用户名", width = 15)
private java.lang.String agentUserName;
/**代理开始时间*/
@Excel(name = "代理开始时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date startTime;
/**代理结束时间*/
@Excel(name = "代理结束时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date endTime;
/**状态0无效1有效*/
@Excel(name = "状态0无效1有效", width = 15)
private java.lang.String status;
/**创建人名称*/
@Excel(name = "创建人名称", width = 15)
private java.lang.String createName;
/**创建人登录名称*/
@Excel(name = "创建人登录名称", width = 15)
private java.lang.String createBy;
/**创建日期*/
@Excel(name = "创建日期", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**更新人名称*/
@Excel(name = "更新人名称", width = 15)
private java.lang.String updateName;
/**更新人登录名称*/
@Excel(name = "更新人登录名称", width = 15)
private java.lang.String updateBy;
/**更新日期*/
@Excel(name = "更新日期", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
/**所属部门*/
@Excel(name = "所属部门", width = 15)
private java.lang.String sysOrgCode;
/**所属公司*/
@Excel(name = "所属公司", width = 15)
private java.lang.String sysCompanyCode;
}
@@ -0,0 +1,33 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
@Data
@TableName("sys_user_depart")
public class SysUserDepart implements Serializable {
private static final long serialVersionUID = 1L;
/**主键id*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**用户id*/
private String userId;
/**部门id*/
private String depId;
public SysUserDepart(String id, String userId, String depId) {
super();
this.id = id;
this.userId = userId;
this.depId = depId;
}
public SysUserDepart(String id, String departId) {
this.userId = id;
this.depId = departId;
}
}
@@ -0,0 +1,50 @@
package com.jero.modules.system.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 用户角色表
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysUserRole implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 用户id
*/
private String userId;
/**
* 角色id
*/
private String roleId;
public SysUserRole() {
}
public SysUserRole(String userId, String roleId) {
this.userId = userId;
this.roleId = roleId;
}
}
@@ -0,0 +1,22 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysAnnouncement;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* @Description: 系统通告表
* @Author: jero-boot
* @Date: 2019-01-02
* @Version: V1.0
*/
public interface SysAnnouncementMapper extends BaseMapper<SysAnnouncement> {
List<SysAnnouncement> querySysCementListByUserId(Page<SysAnnouncement> page, @Param("userId")String userId,@Param("msgCategory")String msgCategory);
}
@@ -0,0 +1,31 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysAnnouncementSend;
import com.jero.modules.system.model.AnnouncementSendModel;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* @Description: 用户通告阅读标记表
* @Author: jero-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
public interface SysAnnouncementSendMapper extends BaseMapper<SysAnnouncementSend> {
public List<String> queryByUserId(@Param("userId") String userId);
/**
* @功能:获取我的消息
* @param announcementSendModel
* @param pageSize
* @param pageNo
* @return
*/
public List<AnnouncementSendModel> getMyAnnouncementSendList(Page<AnnouncementSendModel> page,@Param("announcementSendModel") AnnouncementSendModel announcementSendModel);
}
@@ -0,0 +1,32 @@
package com.jero.modules.system.mapper;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.jero.modules.system.entity.SysCategory;
import com.jero.modules.system.model.TreeSelectModel;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 分类字典
* @Author: jero-boot
* @Date: 2019-05-29
* @Version: V1.0
*/
public interface SysCategoryMapper extends BaseMapper<SysCategory> {
/**
* 根据父级ID查询树节点数据
* @param pid
* @return
*/
public List<TreeSelectModel> queryListByPid(@Param("pid") String pid,@Param("query") Map<String, String> query);
@Select("SELECT ID FROM sys_category WHERE CODE = #{code,jdbcType=VARCHAR}")
public String queryIdByCode(@Param("code") String code);
}
@@ -0,0 +1,14 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.entity.SysCheckRule;
/**
* @Description: 编码校验规则
* @Author: jero-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
public interface SysCheckRuleMapper extends BaseMapper<SysCheckRule> {
}
@@ -0,0 +1,17 @@
package com.jero.modules.system.mapper;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysDataLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface SysDataLogMapper extends BaseMapper<SysDataLog>{
/**
* 通过表名及数据Id获取最大版本
* @param tableName
* @param dataId
* @return
*/
public String queryMaxDataVer(@Param("tableName") String tableName,@Param("dataId") String dataId);
}
@@ -0,0 +1,14 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.entity.SysDataSource;
/**
* @Description: 多数据源管理
* @Author: jero-boot
* @Date: 2019-12-25
* @Version: V1.0
*/
public interface SysDataSourceMapper extends BaseMapper<SysDataSource> {
}
@@ -0,0 +1,55 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Select;
import com.jero.modules.system.entity.SysDepart;
import com.jero.modules.system.model.SysDepartTreeModel;
import com.jero.modules.system.model.TreeModel;
import org.springframework.data.repository.query.Param;
import java.util.List;
/**
* <p>
* 部门 Mapper 接口
* <p>
*
* @Author: Steve
* @Since 2019-01-22
*/
public interface SysDepartMapper extends BaseMapper<SysDepart> {
/**
* 根据用户ID查询部门集合
*/
public List<SysDepart> queryUserDeparts(@Param("userId") String userId);
/**
* 根据用户名查询部门
*
* @param username
* @return
*/
public List<SysDepart> queryDepartsByUsername(@Param("username") String username);
@Select("select id from sys_depart where org_code=#{orgCode}")
public String queryDepartIdByOrgCode(@Param("orgCode") String orgCode);
@Select("select id,parent_id from sys_depart where id=#{departId}")
public SysDepart getParentDepartId(@Param("departId") String departId);
/**
* 根据部门Id查询,当前和下级所有部门IDS
* @param departId
* @return
*/
List<String> getSubDepIdsByDepId(@Param("departId") String departId);
/**
* 根据部门编码获取部门下所有IDS
* @param orgCodes
* @return
*/
List<String> getSubDepIdsByOrgCodes(@org.apache.ibatis.annotations.Param("orgCodes") String[] orgCodes);
}
@@ -0,0 +1,17 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysDepartPermission;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 部门权限表
* @Author: jero-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
public interface SysDepartPermissionMapper extends BaseMapper<SysDepartPermission> {
}
@@ -0,0 +1,23 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysDepartRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 部门角色
* @Author: jero-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
public interface SysDepartRoleMapper extends BaseMapper<SysDepartRole> {
/**
* 根据用户id,部门id查询可授权所有部门角色
* @param orgCode
* @param userId
* @return
*/
public List<SysDepartRole> queryDeptRoleByDeptAndUser(@Param("orgCode") String orgCode, @Param("userId") String userId);
}
@@ -0,0 +1,17 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysDepartRolePermission;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 部门角色权限
* @Author: jero-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
public interface SysDepartRolePermissionMapper extends BaseMapper<SysDepartRolePermission> {
}
@@ -0,0 +1,17 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysDepartRoleUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 部门角色人员信息
* @Author: jero-boot
* @Date: 2020-02-13
* @Version: V1.0
*/
public interface SysDepartRoleUserMapper extends BaseMapper<SysDepartRoleUser> {
}
@@ -0,0 +1,20 @@
package com.jero.modules.system.mapper;
import org.apache.ibatis.annotations.Select;
import com.jero.modules.system.entity.SysDictItem;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
/**
* <p>
* Mapper 接口
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
public interface SysDictItemMapper extends BaseMapper<SysDictItem> {
@Select("SELECT * FROM sys_dict_item WHERE DICT_ID = #{mainId} order by sort_order asc, item_value asc")
public List<SysDictItem> selectItemsByMainId(String mainId);
}
@@ -0,0 +1,135 @@
package com.jero.modules.system.mapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.ResultType;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import com.jero.common.system.vo.DictModel;
import com.jero.common.system.vo.DictQuery;
import com.jero.modules.system.entity.SysDict;
import com.jero.modules.system.model.DuplicateCheckVo;
import com.jero.modules.system.model.TreeSelectModel;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 字典表 Mapper 接口
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
public interface SysDictMapper extends BaseMapper<SysDict> {
/**
* 重复检查SQL
* @return
*/
public Long duplicateCheckCountSql(DuplicateCheckVo duplicateCheckVo);
public Long duplicateCheckCountSqlNoDataId(DuplicateCheckVo duplicateCheckVo);
public List<DictModel> queryDictItemsByCode(@Param("code") String code);
@Deprecated
public List<DictModel> queryTableDictItemsByCode(@Param("table") String table,@Param("text") String text,@Param("code") String code);
@Deprecated
public List<DictModel> queryTableDictItemsByCodeAndFilter(@Param("table") String table,@Param("text") String text,@Param("code") String code,@Param("filterSql") String filterSql);
@Deprecated
@Select("select ${key} as \"label\",${value} as \"value\" from ${table}")
public List<Map<String,String>> getDictByTableNgAlain(@Param("table") String table, @Param("key") String key, @Param("value") String value);
public String queryDictTextByKey(@Param("code") String code,@Param("key") String key);
@Deprecated
public String queryTableDictTextByKey(@Param("table") String table,@Param("text") String text,@Param("code") String code,@Param("key") String key);
@Deprecated
public List<DictModel> queryTableDictByKeys(@Param("table") String table, @Param("text") String text, @Param("code") String code, @Param("keyArray") String[] keyArray);
/**
* 查询所有部门 作为字典信息 id -->value,departName -->text
* @return
*/
public List<DictModel> queryAllDepartBackDictModel();
/**
* 查询所有用户 作为字典信息 username -->value,realname -->text
* @return
*/
public List<DictModel> queryAllUserBackDictModel();
/**
* 通过关键字查询出字典表
* @param table
* @param text
* @param code
* @param keyword
* @return
*/
@Deprecated
public List<DictModel> queryTableDictItems(@Param("table") String table,@Param("text") String text,@Param("code") String code,@Param("keyword") String keyword);
/**
* 通过关键字查询出字典表
* @param page
* @param table
* @param text
* @param code
* @param keyword
* @return
*/
IPage<DictModel> queryTableDictItems(Page<DictModel> page, @Param("table") String table, @Param("text") String text, @Param("code") String code, @Param("keyword") String keyword);
/**
* 根据表名、显示字段名、存储字段名 查询树
* @param table
* @param text
* @param code
* @param pid
* @param hasChildField
* @return
*/
@Deprecated
List<TreeSelectModel> queryTreeList(@Param("query") Map<String, String> query,@Param("table") String table,@Param("text") String text,@Param("code") String code,@Param("pidField") String pidField,@Param("pid") String pid,@Param("hasChildField") String hasChildField);
/**
* 删除
* @param id
*/
@Select("delete from sys_dict where id = #{id}")
public void deleteOneById(@Param("id") String id);
/**
* 查询被逻辑删除的数据
* @return
*/
@Select("select * from sys_dict where del_flag = 1")
public List<SysDict> queryDeleteList();
/**
* 修改状态值
* @param delFlag
* @param id
*/
@Update("update sys_dict set del_flag = #{flag,jdbcType=INTEGER} where id = #{id,jdbcType=VARCHAR}")
public void updateDictDelFlag(@Param("flag") int delFlag, @Param("id") String id);
/**
* 分页查询字典表数据
* @param page
* @param query
* @return
*/
@Deprecated
public Page<DictModel> queryDictTablePageList(Page page, @Param("query") DictQuery query);
}
@@ -0,0 +1,14 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.entity.SysFillRule;
/**
* @Description: 填值规则
* @Author: jero-boot
* @Date: 2019-11-07
* @Version: V1.0
*/
public interface SysFillRuleMapper extends BaseMapper<SysFillRule> {
}
@@ -0,0 +1,14 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.entity.SysGatewayRoute;
/**
* @Description: gateway路由管理
* @Author: jero-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
public interface SysGatewayRouteMapper extends BaseMapper<SysGatewayRoute> {
}
@@ -0,0 +1,57 @@
package com.jero.modules.system.mapper;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 系统日志表 Mapper 接口
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
public interface SysLogMapper extends BaseMapper<SysLog> {
/**
* @功能:清空所有日志记录
*/
public void removeAll();
/**
* 获取系统总访问次数
*
* @return Long
*/
Long findTotalVisitCount();
//update-begin--Author:zhangweijian Date:20190428 for:传入开始时间,结束时间参数
/**
* 获取系统今日访问次数
*
* @return Long
*/
Long findTodayVisitCount(@Param("dayStart") Date dayStart, @Param("dayEnd") Date dayEnd);
/**
* 获取系统今日访问 IP数
*
* @return Long
*/
Long findTodayIp(@Param("dayStart") Date dayStart, @Param("dayEnd") Date dayEnd);
//update-end--Author:zhangweijian Date:20190428 for:传入开始时间,结束时间参数
/**
* 首页:根据时间统计访问数量/ip数量
* @param dayStart
* @param dayEnd
* @return
*/
List<Map<String,Object>> findVisitCount(@Param("dayStart") Date dayStart, @Param("dayEnd") Date dayEnd, @Param("dbType") String dbType);
}
@@ -0,0 +1,28 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysPermissionDataRule;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 权限规则 Mapper 接口
* </p>
*
* @Author huangzhilin
* @since 2019-04-01
*/
public interface SysPermissionDataRuleMapper extends BaseMapper<SysPermissionDataRule> {
/**
* 根据用户名和权限id查询
* @param username
* @param permissionId
* @return
*/
public List<String> queryDataRuleIds(@Param("username") String username,@Param("permissionId") String permissionId);
}
@@ -0,0 +1,57 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import com.jero.modules.system.entity.SysPermission;
import com.jero.modules.system.model.TreeModel;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 菜单权限表 Mapper 接口
* </p>
*
* @Author scott
* @since 2018-12-21
*/
public interface SysPermissionMapper extends BaseMapper<SysPermission> {
/**
* 通过父菜单ID查询子菜单
* @param parentId
* @return
*/
public List<TreeModel> queryListByParentId(@Param("parentId") String parentId);
/**
* 根据用户查询用户权限
*/
public List<SysPermission> queryByUser(@Param("username") String username);
/**
* 修改菜单状态字段: 是否子节点
*/
@Update("update sys_permission set is_leaf=#{leaf} where id = #{id}")
public int setMenuLeaf(@Param("id") String id,@Param("leaf") int leaf);
/**
* 获取模糊匹配规则的数据权限URL
*/
@Select("SELECT url FROM sys_permission WHERE del_flag = 0 and menu_type = 2 and url like '%*%'")
public List<String> queryPermissionUrlWithStar();
/**
* 根据用户账号查询菜单权限
* @param sysPermission
* @param username
* @return
*/
public int queryCountByUsername(@Param("username") String username, @Param("permission") SysPermission sysPermission);
}
@@ -0,0 +1,14 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.entity.SysPosition;
/**
* @Description: 职务表
* @Author: jero-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
public interface SysPositionMapper extends BaseMapper<SysPosition> {
}
@@ -0,0 +1,37 @@
package com.jero.modules.system.mapper;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
import com.jero.modules.system.entity.SysRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 角色表 Mapper 接口
* </p>
*
* @Author scott
* @since 2018-12-19
*/
public interface SysRoleMapper extends BaseMapper<SysRole> {
/**
* @Author scott
* @Date 2019/12/13 16:12
* @Description: 删除角色与用户关系
*/
@Delete("delete from sys_user_role where role_id = #{roleId}")
void deleteRoleUserRelation(@Param("roleId") String roleId);
/**
* @Author scott
* @Date 2019/12/13 16:12
* @Description: 删除角色与权限关系
*/
@Delete("delete from sys_role_permission where role_id = #{roleId}")
void deleteRolePermissionRelation(@Param("roleId") String roleId);
}
@@ -0,0 +1,16 @@
package com.jero.modules.system.mapper;
import com.jero.modules.system.entity.SysRolePermission;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 角色权限表 Mapper 接口
* </p>
*
* @Author scott
* @since 2018-12-21
*/
public interface SysRolePermissionMapper extends BaseMapper<SysRolePermission> {
}
@@ -0,0 +1,8 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.entity.SysTenant;
public interface SysTenantMapper extends BaseMapper<SysTenant> {
}
@@ -0,0 +1,17 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysThirdAccount;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 第三方登录账号表
* @Author: jero-boot
* @Date: 2020-11-17
* @Version: V1.0
*/
public interface SysThirdAccountMapper extends BaseMapper<SysThirdAccount> {
}
@@ -0,0 +1,17 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysUserAgent;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 用户代理人设置
* @Author: jero-boot
* @Date: 2019-04-17
* @Version: V1.0
*/
public interface SysUserAgentMapper extends BaseMapper<SysUserAgent> {
}
@@ -0,0 +1,11 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysUserDepart;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface SysUserDepartMapper extends BaseMapper<SysUserDepart>{
List<SysUserDepart> getUserDepartByUid(@Param("userId") String userId);
}
@@ -0,0 +1,142 @@
package com.jero.modules.system.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import com.jero.modules.system.entity.SysUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.system.model.SysUserSysDepartModel;
import com.jero.modules.system.vo.SysUserDepVo;
import java.util.List;
/**
* <p>
* 用户表 Mapper 接口
* </p>
*
* @Author scott
* @since 2018-12-20
*/
public interface SysUserMapper extends BaseMapper<SysUser> {
/**
* 通过用户账号查询用户信息
* @param username
* @return
*/
public SysUser getUserByName(@Param("username") String username);
/**
* 根据部门Id查询用户信息
* @param page
* @param departId
* @return
*/
IPage<SysUser> getUserByDepId(Page page, @Param("departId") String departId, @Param("username") String username);
/**
* 根据用户Ids,查询用户所属部门名称信息
* @param userIds
* @return
*/
List<SysUserDepVo> getDepNamesByUserIds(@Param("userIds")List<String> userIds);
/**
* 根据部门Ids,查询部门下用户信息
* @param page
* @param departIds
* @return
*/
IPage<SysUser> getUserByDepIds(Page page, @Param("departIds") List<String> departIds, @Param("username") String username);
/**
* 根据角色Id查询用户信息
* @param page
* @param
* @return
*/
IPage<SysUser> getUserByRoleId(Page page, @Param("roleId") String roleId, @Param("username") String username);
/**
* 根据用户名设置部门ID
* @param username
* @param departId
*/
void updateUserDepart(@Param("username") String username,@Param("orgCode") String orgCode);
/**
* 根据手机号查询用户信息
* @param phone
* @return
*/
public SysUser getUserByPhone(@Param("phone") String phone);
/**
* 根据邮箱查询用户信息
* @param email
* @return
*/
public SysUser getUserByEmail(@Param("email")String email);
/**
* 根据 orgCode 查询用户,包括子部门下的用户
*
* @param page 分页对象, xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位(你可以继承Page实现自己的分页对象)
* @param orgCode
* @param userParams 用户查询条件,可为空
* @return
*/
List<SysUserSysDepartModel> getUserByOrgCode(IPage page, @Param("orgCode") String orgCode, @Param("userParams") SysUser userParams);
/**
* 查询 getUserByOrgCode 的Total
*
* @param orgCode
* @param userParams 用户查询条件,可为空
* @return
*/
Integer getUserByOrgCodeTotal(@Param("orgCode") String orgCode, @Param("userParams") SysUser userParams);
/**
* @Author scott
* @Date 2019/12/13 16:10
* @Description: 批量删除角色与用户关系
*/
void deleteBathRoleUserRelation(@Param("roleIdArray") String[] roleIdArray);
/**
* @Author scott
* @Date 2019/12/13 16:10
* @Description: 批量删除角色与权限关系
*/
void deleteBathRolePermissionRelation(@Param("roleIdArray") String[] roleIdArray);
/**
* 查询被逻辑删除的用户
*/
List<SysUser> selectLogicDeleted(@Param(Constants.WRAPPER) Wrapper<SysUser> wrapper);
/**
* 还原被逻辑删除的用户
*/
int revertLogicDeleted(@Param("userIds") String userIds, @Param("entity") SysUser entity);
/**
* 彻底删除被逻辑删除的用户
*/
int deleteLogicDeleted(@Param("userIds") String userIds);
/** 更新空字符串为null【此写法有sql注入风险,禁止随便用】 */
int updateNullByEmptyString(@Param("fieldName") String fieldName);
/**
* 根据部门Ids,查询部门下用户信息
* @param departIds
* @return
*/
List<SysUser> queryByDepIds(@Param("departIds")List<String> departIds,@Param("username") String username);
}
@@ -0,0 +1,25 @@
package com.jero.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.jero.modules.system.entity.SysUserRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 用户角色表 Mapper 接口
* </p>
*
* @Author scott
* @since 2018-12-21
*/
public interface SysUserRoleMapper extends BaseMapper<SysUserRole> {
@Select("select role_code from sys_role where id in (select role_id from sys_user_role where user_id = (select id from sys_user where username=#{username}))")
List<String> getRoleByUserName(@Param("username") String username);
@Select("select id from sys_role where id in (select role_id from sys_user_role where user_id = (select id from sys_user where username=#{username}))")
List<String> getRoleIdByUserName(@Param("username") String username);
}
@@ -0,0 +1,40 @@
<?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.jero.modules.system.mapper.SysAnnouncementMapper">
<resultMap id="SysAnnouncement" type="com.jero.modules.system.entity.SysAnnouncement" >
<result column="id" property="id" jdbcType="VARCHAR"/>
<result column="titile" property="titile" jdbcType="VARCHAR"/>
<result column="msg_content" property="msgContent" jdbcType="VARCHAR"/>
<result column="start_time" property="startTime" jdbcType="TIMESTAMP"/>
<result column="end_time" property="endTime" jdbcType="TIMESTAMP"/>
<result column="sender" property="sender" jdbcType="VARCHAR"/>
<result column="priority" property="priority" jdbcType="VARCHAR"/>
<result column="msg_category" property="msgCategory" jdbcType="VARCHAR"/>
<result column="msg_type" property="msgType" jdbcType="VARCHAR"/>
<result column="send_status" property="sendStatus" jdbcType="VARCHAR"/>
<result column="send_time" property="sendTime" jdbcType="VARCHAR"/>
<result column="cancel_time" property="cancelTime" jdbcType="VARCHAR"/>
<result column="del_flag" property="delFlag" jdbcType="VARCHAR"/>
<result column="create_by" property="createBy" jdbcType="VARCHAR"/>
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
<result column="update_by" property="updateBy" jdbcType="VARCHAR"/>
<result column="update_time" property="updateTime" jdbcType="TIMESTAMP"/>
<result column="user_ids" property="userIds" jdbcType="VARCHAR"/>
<result column="bus_type" property="busType" jdbcType="VARCHAR"/>
<result column="bus_id" property="busId" jdbcType="VARCHAR"/>
<result column="open_type" property="openType" jdbcType="VARCHAR"/>
<result column="open_page" property="openPage" jdbcType="VARCHAR"/>
</resultMap>
<select id="querySysCementListByUserId" parameterType="String" resultMap="SysAnnouncement">
select * from sys_announcement
where send_status = '1'
and del_flag = '0'
and msg_category = #{msgCategory}
and id IN ( select annt_id from sys_announcement_send where user_id = #{userId} and read_flag = '0')
order by create_time DESC
</select>
</mapper>
@@ -0,0 +1,67 @@
<?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.jero.modules.system.mapper.SysAnnouncementSendMapper">
<resultMap id="AnnouncementSendModel" type="com.jero.modules.system.model.AnnouncementSendModel" >
<result column="id" property="id" jdbcType="VARCHAR"/>
<result column="annt_id" property="anntId" jdbcType="VARCHAR"/>
<result column="user_id" property="userId" jdbcType="VARCHAR"/>
<result column="titile" property="titile" jdbcType="VARCHAR"/>
<result column="msg_content" property="msgContent" jdbcType="VARCHAR"/>
<result column="sender" property="sender" jdbcType="VARCHAR"/>
<result column="priority" property="priority" jdbcType="VARCHAR"/>
<result column="msg_category" property="msgCategory" jdbcType="VARCHAR"/>
<result column="send_time" property="sendTime" jdbcType="TIMESTAMP"/>
<result column="bus_id" property="busId" jdbcType="VARCHAR"/>
<result column="open_type" property="openType" jdbcType="VARCHAR"/>
<result column="open_page" property="openPage" jdbcType="VARCHAR"/>
</resultMap>
<select id="queryByUserId" parameterType="String" resultType="String">
select sas.annt_id from sys_announcement_send sas
where sas.user_id = #{userId}
</select>
<select id="getMyAnnouncementSendList" parameterType="Object" resultMap="AnnouncementSendModel">
select
sas.id,
sas.annt_id,
sas.user_id,
sas.read_flag,
sa.titile as titile,
sa.msg_content as msg_content,
sa.sender as sender,
sa.priority as priority,
sa.msg_category,
sa.send_time as send_time,
sa.bus_id as bus_id,
sa.open_type as open_type,
sa.open_page as open_page,
sa.msg_abstract
from sys_announcement_send sas
left join sys_announcement sa ON sas.annt_id = sa.id
where sa.send_status = '1'
and sa.del_flag = '0'
and sas.user_id = #{announcementSendModel.userId}
<if test="announcementSendModel.titile !=null and announcementSendModel.titile != ''">
and sa.titile LIKE concat(concat('%',#{announcementSendModel.titile}),'%')
</if>
<if test="announcementSendModel.sender !=null and announcementSendModel.sender != ''">
and sa.sender LIKE concat(concat('%',#{announcementSendModel.sender}),'%')
</if>
<if test="announcementSendModel.readFlag !=null and announcementSendModel.readFlag != ''">
and sas.read_flag = #{announcementSendModel.readFlag}
</if>
<if test="announcementSendModel.busType !=null and announcementSendModel.busType != ''">
and sa.bus_type = #{announcementSendModel.busType}
</if>
<if test="announcementSendModel.bizSource !=null and announcementSendModel.bizSource =='isNoBpm'">
and (sa.bus_type != 'bpm' or sa.bus_type is null)
</if>
<if test="announcementSendModel.msgCategory !=null and announcementSendModel.msgCategory != ''">
and sa.msg_category = #{announcementSendModel.msgCategory}
</if>
order by sas.read_flag,sa.send_time desc
</select>
</mapper>
@@ -0,0 +1,21 @@
<?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.jero.modules.system.mapper.SysCategoryMapper">
<select id="queryListByPid" parameterType="Object" resultType="com.jero.modules.system.model.TreeSelectModel">
select code,
name as "title",
id as "key",
(case when has_child = '1' then 0 else 1 end) as isLeaf,
pid as parentId
from sys_category
where pid = #{pid}
<if test="query!= null">
<foreach collection="query.entrySet()" item="value" index="key" >
and ${key} = #{value}
</foreach>
</if>
</select>
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysCheckRuleMapper">
</mapper>
@@ -0,0 +1,10 @@
<?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.jero.modules.system.mapper.SysDataLogMapper">
<!-- 通过表名及数据Id获取最大版本 -->
<select id="queryMaxDataVer" parameterType="String" resultType="String">
select max(data_version) as mvn from sys_data_log
where data_table = #{tableName} and data_id =#{dataId}
</select>
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysDataSourceMapper">
</mapper>
@@ -0,0 +1,37 @@
<?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.jero.modules.system.mapper.SysDepartMapper">
<select id="queryUserDeparts" parameterType="String" resultType="com.jero.modules.system.entity.SysDepart">
select * from sys_depart where id IN ( select dep_id from sys_user_depart where user_id = #{userId} )
</select>
<!-- 根据username查询所拥有的部门 -->
<select id="queryDepartsByUsername" parameterType="String" resultType="com.jero.modules.system.entity.SysDepart">
SELECT *
FROM sys_depart
WHERE id IN (
SELECT dep_id
FROM sys_user_depart
WHERE user_id = (
SELECT id
FROM sys_user
WHERE username = #{username}
)
)
</select>
<!-- 根据部门Id查询,当前和下级所有部门IDS -->
<select id="getSubDepIdsByDepId" resultType="java.lang.String">
select id from sys_depart where del_flag = '0' and org_code like concat((select org_code from sys_depart where id=#{departId}),'%')
</select>
<!--根据部门编码获取我的部门下所有部门ids -->
<select id="getSubDepIdsByOrgCodes" resultType="java.lang.String">
select id from sys_depart where del_flag = '0' and
<foreach collection="orgCodes" item="item" index="index" open="(" separator="or" close=")">
org_code LIKE CONCAT(#{item},'%')
</foreach>
</select>
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysDepartPermissionMapper">
</mapper>
@@ -0,0 +1,12 @@
<?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.jero.modules.system.mapper.SysDepartRoleMapper">
<!--根据用户id,部门id查询可授权所有部门角色 -->
<select id="queryDeptRoleByDeptAndUser" resultType="com.jero.modules.system.entity.SysDepartRole">
SELECT * FROM sys_depart_role WHERE depart_id IN (
SELECT id FROM sys_depart WHERE id IN (SELECT dep_id FROM sys_user_depart WHERE user_id=#{userId})
AND org_code LIKE CONCAT(#{orgCode},'%')
)
</select>
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysDepartRolePermissionMapper">
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysDepartRoleUserMapper">
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysDictItemMapper">
</mapper>
@@ -0,0 +1,109 @@
<?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.jero.modules.system.mapper.SysDictMapper">
<!-- 通过字典code获取字典数据 -->
<select id="queryDictItemsByCode" parameterType="String" resultType="com.jero.common.system.vo.DictModel">
select s.item_value as "value",s.item_text as "text" from sys_dict_item s
where dict_id = (select id from sys_dict where dict_code = #{code})
order by s.sort_order asc
</select>
<!-- 通过字典code获取字典数据 -->
<select id="queryDictTextByKey" parameterType="String" resultType="String">
select s.item_text from sys_dict_item s
where s.dict_id = (select id from sys_dict where dict_code = #{code})
and s.item_value = #{key}
</select>
<!--通过查询指定table的 text code 获取字典-->
<select id="queryTableDictItemsByCode" parameterType="String" resultType="com.jero.common.system.vo.DictModel">
select ${text} as "text",${code} as "value" from ${table}
</select>
<!--通过查询指定table的 text code 获取字典(指定查询条件)-->
<select id="queryTableDictItemsByCodeAndFilter" parameterType="String" resultType="com.jero.common.system.vo.DictModel">
select ${text} as "text",${code} as "value" from ${table}
<if test="filterSql != null and filterSql != ''">
where ${filterSql}
</if>
</select>
<!--通过查询指定table的 text code key 获取字典值-->
<select id="queryTableDictTextByKey" parameterType="String" resultType="String">
select ${text} as "text" from ${table} where ${code}= #{key}
</select>
<!--通过查询指定table的 text code key 获取字典值,包含value-->
<select id="queryTableDictByKeys" parameterType="String" resultType="com.jero.common.system.vo.DictModel">
select ${text} as "text", ${code} as "value" from ${table} where ${code} in
<foreach item="key" collection="keyArray" open="(" separator="," close=")">
#{key}
</foreach>
</select>
<!-- 重复校验 sql语句 -->
<select id="duplicateCheckCountSql" resultType="Long" parameterType="com.jero.modules.system.model.DuplicateCheckVo">
SELECT COUNT(*) FROM ${tableName} WHERE ${fieldName} = #{fieldVal} and id &lt;&gt; #{dataId}
</select>
<!-- 重复校验 sql语句 -->
<select id="duplicateCheckCountSqlNoDataId" resultType="Long" parameterType="com.jero.modules.system.model.DuplicateCheckVo">
SELECT COUNT(*) FROM ${tableName} WHERE ${fieldName} = #{fieldVal}
</select>
<!-- 查询部门信息 作为字典数据 -->
<select id="queryAllDepartBackDictModel" resultType="com.jero.common.system.vo.DictModel">
select id as "value",depart_name as "text" from sys_depart where del_flag = '0'
</select>
<!-- 查询用户信息 作为字典数据 -->
<select id="queryAllUserBackDictModel" resultType="com.jero.common.system.vo.DictModel">
select username as "value",realname as "text" from sys_user where del_flag = '0'
</select>
<!--通过查询指定table的 text code 获取字典数据,且支持关键字查询 -->
<select id="queryTableDictItems" parameterType="String" resultType="com.jero.common.system.vo.DictModel">
select ${text} as "text",${code} as "value" from ${table} where ${text} like #{keyword}
</select>
<!-- 根据表名、显示字段名、存储字段名、父ID查询树 -->
<select id="queryTreeList" parameterType="Object" resultType="com.jero.modules.system.model.TreeSelectModel">
select ${text} as "title",
${code} as "key",
<if test="hasChildField != null and hasChildField != ''">
(case when ${hasChildField} = '1' then 0 else 1 end) as isLeaf,
</if>
${pidField} as parentId
from ${table}
where
<choose>
<when test="pid != null and pid != ''">
${pidField} = #{pid}
</when>
<otherwise>
(${pidField} = '' OR ${pidField} IS NULL)
</otherwise>
</choose>
<if test="query!= null">
<foreach collection="query.entrySet()" item="value" index="key" >
and ${key} = #{value}
</foreach>
</if>
</select>
<!-- 分页查询字典表数据 -->
<select id="queryDictTablePageList" parameterType="Object" resultType="com.jero.common.system.vo.DictModel">
select ${query.text} as "text",${query.code} as "value" from ${query.table}
where 1 = 1
<if test="query.keyword != null and query.keyword != ''">
and (${query.text} like '%${query.keyword}%' or ${query.code} like '%${query.keyword}%')
</if>
<if test="query.codeValue != null and query.codeValue != ''">
and ${query.code} = #{query.codeValue}
</if>
</select>
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysFillRuleMapper">
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysGatewayRouteMapper">
</mapper>
@@ -0,0 +1,69 @@
<?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.jero.modules.system.mapper.SysLogMapper">
<!-- 清空所有日志记录 -->
<delete id="removeAll">
DELETE FROM sys_log
</delete>
<!-- 获取访问总数 -->
<select id="findTotalVisitCount" resultType="long">
select count(1) from sys_log where log_type = 1
</select>
<!-- 获取今日访问总数 -->
<select id="findTodayVisitCount" resultType="long">
select count(1) from sys_log where log_type = 1 and create_time &gt;= #{dayStart} and create_time &lt; #{dayEnd}
</select>
<!-- 获取今日访问总IP数 -->
<select id="findTodayIp" resultType="long">
select count(distinct(ip)) from sys_log where log_type = 1 and create_time &gt;= #{dayStart} and create_time &lt; #{dayEnd}
</select>
<!-- 首页访问统计 -->
<select id="findVisitCount" resultType="java.util.HashMap">
<if test="dbType == 'MYSQL'">
select count(*) as visit
,count(distinct(ip)) as ip
,DATE_FORMAT(create_time, '%Y-%m-%d') as tian
,DATE_FORMAT(create_time, '%m-%d') as type
from sys_log
where log_type = 1 and create_time &gt;= #{dayStart} and create_time &lt; #{dayEnd}
group by tian,type
order by tian asc
</if>
<if test="dbType == 'ORACLE'">
select count(*) as visit
,count(distinct(ip)) as ip
,to_char(create_time, 'yyyy-mm-dd') as tian
,to_char(create_time, 'mm-dd') as type
from sys_log
where log_type = 1 and create_time &gt;= #{dayStart} and create_time &lt; #{dayEnd}
group by to_char(create_time, 'yyyy-mm-dd'),to_char(create_time, 'mm-dd')
order by to_char(create_time, 'yyyy-mm-dd') asc
</if>
<if test="dbType == 'POSTGRESQL'">
select count(*) as visit
,count(distinct(ip)) as ip
,to_char(create_time, 'yyyy-mm-dd') as tian
,to_char(create_time, 'mm-dd') as type
from sys_log
where log_type = 1 and create_time &gt;= #{dayStart} and create_time &lt; #{dayEnd}
group by tian,type
order by tian asc
</if>
<if test="dbType == 'SQLSERVER'">
select count(*) as visit
,count(distinct(ip)) as ip
,CONVERT(varchar(100), create_time, 23) as tian
,RIGHT(CONVERT(varchar(100), create_time, 23),5) as type
from sys_log
where log_type = 1 and create_time &gt;= #{dayStart} and create_time &lt; #{dayEnd}
group by CONVERT(varchar(100), create_time, 23),RIGHT(CONVERT(varchar(100), create_time, 23),5)
order by CONVERT(varchar(100), create_time, 23) asc
</if>
</select>
</mapper>
@@ -0,0 +1,26 @@
<?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.jero.modules.system.mapper.SysPermissionDataRuleMapper">
<!-- 查询权限 TODO 这里是不是可以不关联查找 sys_role 表 -->
<select id="queryDataRuleIds" resultType="java.lang.String">
select data_rule_ids
from sys_role_permission a
join sys_permission b on a.permission_id = b.id
join sys_role c on a.role_id = c.id
join sys_user_role d on d.role_id = c.id
join sys_user e on d.user_id = e.id
where e.username = #{username} and b.id = #{permissionId}
<!--update begin Author:lvdandan Date:20200213 for:加入部门权限 -->
union
select data_rule_ids
from sys_depart_role_permission a
join sys_permission b on a.permission_id = b.id
join sys_depart_role c on a.role_id = c.id
join sys_depart_role_user d on d.drole_id = c.id
join sys_user e on d.user_id = e.id
where e.username = #{username} and b.id = #{permissionId}
<!--update end Author:lvdandan Date:20200213 for:加入部门权限 -->
</select>
</mapper>
@@ -0,0 +1,108 @@
<?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.jero.modules.system.mapper.SysPermissionMapper">
<resultMap id="TreeModel" type="com.jero.modules.system.model.TreeModel" >
<result column="id" property="key" jdbcType="VARCHAR"/>
<result column="name" property="title" jdbcType="VARCHAR"/>
<result column="icon" property="icon" jdbcType="VARCHAR"/>
<result column="parent_id" property="parentId" jdbcType="VARCHAR"/>
<result column="leaf_flag" property="isLeaf" jdbcType="INTEGER"/>
</resultMap>
<!-- 通过<resultMap>映射实体类属性名和表的字段名对应关系 -->
<resultMap id="SysPermission" type="com.jero.modules.system.entity.SysPermission">
<!-- result属性映射非匹配字段 -->
<result column="is_route" property="route"/>
<result column="keep_alive" property="keepAlive"/>
<result column="is_leaf" property="leaf"/>
</resultMap>
<select id="queryListByParentId" parameterType="Object" resultMap="TreeModel">
SELECT
id
,parent_id
,name
,icon
,leaf_flag
FROM sys_permission
WHERE 1=1
<choose>
<when test="parentId != null and parentId != ''">
AND parent_id = #{parentId,jdbcType=VARCHAR}
</when>
<otherwise>
AND parent_id is null
</otherwise>
</choose>
</select>
<!-- 获取登录用户拥有的权限 -->
<select id="queryByUser" parameterType="Object" resultMap="SysPermission">
SELECT * FROM (
SELECT p.*
FROM sys_permission p
WHERE (exists(
select a.id from sys_role_permission a
join sys_role b on a.role_id = b.id
join sys_user_role c on c.role_id = b.id
join sys_user d on d.id = c.user_id
where p.id = a.permission_id AND d.username = #{username,jdbcType=VARCHAR}
)
or (p.url like '%:code' and p.url like '/online%' and p.hidden = 1)
or p.url = '/online')
and p.del_flag = 0
<!--update begin Author:lvdandan Date:20200213 for:加入部门权限 -->
UNION
SELECT p.*
FROM sys_permission p
WHERE exists(
select a.id from sys_depart_role_permission a
join sys_depart_role b on a.role_id = b.id
join sys_depart_role_user c on c.drole_id = b.id
join sys_user d on d.id = c.user_id
where p.id = a.permission_id AND d.username = #{username,jdbcType=VARCHAR}
)
and p.del_flag = 0
<!--update end Author:lvdandan Date:20200213 for:加入部门权限 -->
) h order by h.sort_no ASC
</select>
<!-- 根据用户账号查询菜单权限 -->
<select id="queryCountByUsername" parameterType="Object" resultType="int">
select sum(cnt) from (
select count(*) as cnt
from sys_role_permission a
join sys_permission b on a.permission_id = b.id
join sys_role c on a.role_id = c.id
join sys_user_role d on d.role_id = c.id
join sys_user e on d.user_id = e.id
where e.username = #{username}
<if test="permission.id !=null and permission.id != ''">
and b.id = #{permission.id}
</if>
<if test="permission.url !=null and permission.url != ''">
and b.url = #{permission.url}
</if>
union all
select count(*) as cnt
from sys_permission z
join sys_depart_role_permission y on z.id = y.permission_id
join sys_depart_role x on y.role_id = x.id
join sys_depart_role_user w on w.drole_id = x.id
join sys_user v on w.user_id = v.id
where v.username = #{username}
<if test="permission.id !=null and permission.id != ''">
and z.id = #{permission.id}
</if>
<if test="permission.url !=null and permission.url != ''">
and z.url = #{permission.url}
</if>
) temp
</select>
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysPositionMapper">
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysTenantMapper">
</mapper>
@@ -0,0 +1,5 @@
<?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.jero.modules.system.mapper.SysThirdAccountMapper">
</mapper>

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