repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/filters/JwtFilter.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/shiro/filters/JwtFilter.java | package org.jeecg.config.shiro.filters;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.shiro.JwtToken;
import org.jeecg.config.shiro.ignore.InMemoryIgnoreAuth;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
/**
* @Description: 鉴权登录拦截器
* @Author: Scott
* @Date: 2018/10/7
**/
@Slf4j
public class JwtFilter extends BasicHttpAuthenticationFilter {
/**
* 默认开启跨域设置（使用单体）
* 微服务情况下，此属性设置为false
*/
private boolean allowOrigin = true;
public JwtFilter(){}
public JwtFilter(boolean allowOrigin){
this.allowOrigin = allowOrigin;
}
/**
* 执行登录认证
*
* @param request
* @param response
* @param mappedValue
* @return
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
try {
// 判断当前路径是不是注解了@IngoreAuth路径，如果是，则放开验证
if (InMemoryIgnoreAuth.contains(((HttpServletRequest) request).getServletPath())) {
return true;
}
executeLogin(request, response);
return true;
} catch (Exception e) {
// 使用异常中的具体错误信息，保留"不允许同一账号多地同时登录"等具体提示
String errorMsg = e.getMessage();
if (oConvertUtils.isEmpty(errorMsg)) {
errorMsg = CommonConstant.TOKEN_IS_INVALID_MSG;
}
JwtUtil.responseError((HttpServletResponse)response, 401, errorMsg);
return false;
}
}
/**
*
*/
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader(CommonConstant.X_ACCESS_TOKEN);
// 代码逻辑说明: JT-355 OA聊天添加token验证，获取token参数
if (oConvertUtils.isEmpty(token)) {
token = httpServletRequest.getParameter("token");
}
JwtToken jwtToken = new JwtToken(token);
// 提交给realm进行登入，如果错误他会抛出异常并被捕获
getSubject(request, response).login(jwtToken);
// 如果没有抛出异常则代表登入成功，返回true
return true;
}
/**
* 对跨域提供支持
*/
@Override
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
HttpServletResponse httpServletResponse = (HttpServletResponse) response;
if(allowOrigin){
httpServletResponse.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, httpServletRequest.getHeader(HttpHeaders.ORIGIN));
// 允许客户端请求方法
httpServletResponse.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "GET,POST,OPTIONS,PUT,DELETE");
// 允许客户端提交的Header
String requestHeaders = httpServletRequest.getHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS);
if (StringUtils.isNotEmpty(requestHeaders)) {
httpServletResponse.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, requestHeaders);
}
// 允许客户端携带凭证信息(是否允许发送Cookie)
httpServletResponse.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
}
// 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
if (RequestMethod.OPTIONS.name().equalsIgnoreCase(httpServletRequest.getMethod())) {
httpServletResponse.setStatus(HttpStatus.OK.value());
return false;
}
// 代码逻辑说明: 多租户用到
String tenantId = httpServletRequest.getHeader(CommonConstant.TENANT_ID);
TenantContext.setTenant(tenantId);
return super.preHandle(request, response);
}
/**
* JwtFilter中ThreadLocal需要及时清除 #3634
*
* @param request
* @param response
* @param exception
* @throws Exception
*/
@Override
public void afterCompletion(ServletRequest request, ServletResponse response, Exception exception) throws Exception {
//log.info("------清空线程中多租户的ID={}------",TenantContext.getTenant());
TenantContext.clear();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/SignUtil.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/SignUtil.java | package org.jeecg.config.sign.util;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.JeecgBaseConfig;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import java.io.UnsupportedEncodingException;
import java.util.SortedMap;
/**
* 签名工具类
*
* @author jeecg
* @date 20210621
*/
@Slf4j
public class SignUtil {
public static final String X_PATH_VARIABLE = "x-path-variable";
/**
* @param params
* 所有的请求参数都会在这里进行排序加密
* @return 验证签名结果
*/
public static boolean verifySign(SortedMap<String, String> params,String headerSign) {
if (params == null || StringUtils.isEmpty(headerSign)) {
return false;
}
// 把参数加密
String paramsSign = getParamsSign(params);
log.debug("Param Sign : {}", paramsSign);
return !StringUtils.isEmpty(paramsSign) && headerSign.equals(paramsSign);
}
/**
* @param params
* 所有的请求参数都会在这里进行排序加密
* @return 得到签名
*/
public static String getParamsSign(SortedMap<String, String> params) {
//去掉 Url 里的时间戳
params.remove("_t");
String paramsJsonStr = JSONObject.toJSONString(params);
log.debug("Param paramsJsonStr : {}", paramsJsonStr);
//设置签名秘钥
JeecgBaseConfig jeecgBaseConfig = SpringContextUtils.getBean(JeecgBaseConfig.class);
String signatureSecret = jeecgBaseConfig.getSignatureSecret();
String curlyBracket = SymbolConstant.DOLLAR + SymbolConstant.LEFT_CURLY_BRACKET;
if(oConvertUtils.isEmpty(signatureSecret) || signatureSecret.contains(curlyBracket)){
throw new JeecgBootException("签名密钥 ${jeecg.signatureSecret} 缺少配置 ！！");
}
try {
//【issues/I484RW】2.4.6部署后，下拉搜索框提示“sign签名检验失败”
return DigestUtils.md5DigestAsHex((paramsJsonStr + signatureSecret).getBytes("UTF-8")).toUpperCase();
} catch (UnsupportedEncodingException e) {
log.error(e.getMessage(),e);
return null;
}
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/HttpUtils.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/HttpUtils.java | package org.jeecg.config.sign.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.http.HttpMethod;
import com.alibaba.fastjson.JSONObject;
/**
* http 工具类 获取请求中的参数
*
* @author jeecg
* @date 20210621
*/
@Slf4j
public class HttpUtils {
/**
* 将URL的参数和body参数合并
*
* @author jeecg
* @date 20210621
* @param request
*/
public static SortedMap<String, String> getAllParams(HttpServletRequest request) throws IOException {
SortedMap<String, String> result = new TreeMap<>();
// 获取URL上最后带逗号的参数变量 sys/dict/getDictItems/sys_user,realname,username
String pathVariable = request.getRequestURI().substring(request.getRequestURI().lastIndexOf("/") + 1);
if (pathVariable.contains(SymbolConstant.COMMA)) {
log.debug(" pathVariable: {}",pathVariable);
String deString = URLDecoder.decode(pathVariable, "UTF-8");
//https://www.52dianzi.com/category/article/37/565371.html
if(deString.contains("%")){
try {
deString = URLDecoder.decode(deString, "UTF-8");
log.debug("存在%情况下，执行两次解码 — pathVariable decode: {}",deString);
} catch (Exception e) {
//e.printStackTrace();
}
}
log.debug(" pathVariable decode: {}",deString);
result.put(SignUtil.X_PATH_VARIABLE, deString);
}
// 获取URL上的参数
Map<String, String> urlParams = getUrlParams(request);
for (Map.Entry entry : urlParams.entrySet()) {
//不能直接转成String,否则会有类型转换错误
result.put((String)entry.getKey(), String.valueOf(entry.getValue()));
}
Map<String, String> allRequestParam = new HashMap<>(16);
// get请求不需要拿body参数
if (!HttpMethod.GET.name().equals(request.getMethod())) {
allRequestParam = getAllRequestParam(request);
}
// 将URL的参数和body参数进行合并
if (allRequestParam != null) {
for (Map.Entry entry : allRequestParam.entrySet()) {
//不能直接转成String,否则会有类型转换错误
result.put((String)entry.getKey(), String.valueOf(entry.getValue()));
}
}
return result;
}
/**
* 将URL的参数和body参数合并
*
* @author jeecg
* @date 20210621
* @param queryString
*/
public static SortedMap<String, String> getAllParams(String url, String queryString, byte[] body, String method)
throws IOException {
SortedMap<String, String> result = new TreeMap<>();
// 获取URL上最后带逗号的参数变量 sys/dict/getDictItems/sys_user,realname,username
String pathVariable = url.substring(url.lastIndexOf("/") + 1);
if (pathVariable.contains(SymbolConstant.COMMA)) {
log.debug(" pathVariable: {}",pathVariable);
String deString = URLDecoder.decode(pathVariable, "UTF-8");
//https://www.52dianzi.com/category/article/37/565371.html
if(deString.contains("%")){
deString = URLDecoder.decode(deString, "UTF-8");
log.debug("存在%情况下，执行两次解码 — pathVariable decode: {}",deString);
}
log.debug(" pathVariable decode: {}",deString);
result.put(SignUtil.X_PATH_VARIABLE, deString);
}
// 获取URL上的参数
Map<String, String> urlParams = getUrlParams(queryString);
for (Map.Entry entry : urlParams.entrySet()) {
result.put((String)entry.getKey(), (String)entry.getValue());
}
Map<String, String> allRequestParam = new HashMap<>(16);
// get请求不需要拿body参数
if (!HttpMethod.GET.name().equals(method)) {
allRequestParam = getAllRequestParam(body);
}
// 将URL的参数和body参数进行合并
if (allRequestParam != null) {
for (Map.Entry entry : allRequestParam.entrySet()) {
result.put((String)entry.getKey(), (String)entry.getValue());
}
}
return result;
}
/**
* 获取 Body 参数
*
* @date 15:04 20210621
* @param request
*/
public static Map<String, String> getAllRequestParam(final HttpServletRequest request) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()));
String str = "";
StringBuilder wholeStr = new StringBuilder();
// 一行一行的读取body体里面的内容；
while ((str = reader.readLine()) != null) {
wholeStr.append(str);
}
// 转化成json对象
return JSONObject.parseObject(wholeStr.toString(), Map.class);
}
/**
* 获取 Body 参数
*
* @date 15:04 20210621
* @param body
*/
public static Map<String, String> getAllRequestParam(final byte[] body) throws IOException {
if(body==null){
return null;
}
String wholeStr = new String(body);
// 转化成json对象
return JSONObject.parseObject(wholeStr.toString(), Map.class);
}
/**
* 将URL请求参数转换成Map
*
* @param request
*/
public static Map<String, String> getUrlParams(HttpServletRequest request) {
Map<String, String> result = new HashMap<>(16);
if (oConvertUtils.isEmpty(request.getQueryString())) {
return result;
}
String param = "";
try {
param = URLDecoder.decode(request.getQueryString(), "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String[] params = param.split("&");
for (String s : params) {
int index = s.indexOf("=");
// 代码逻辑说明: [issues/5879]数据查询传ds=“”造成的异常------------
if (index != -1) {
result.put(s.substring(0, index), s.substring(index + 1));
}
}
return result;
}
/**
* 将URL请求参数转换成Map
*
* @param queryString
*/
public static Map<String, String> getUrlParams(String queryString) {
Map<String, String> result = new HashMap<>(16);
if (oConvertUtils.isEmpty(queryString)) {
return result;
}
String param = "";
try {
param = URLDecoder.decode(queryString, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String[] params = param.split("&");
for (String s : params) {
int index = s.indexOf("=");
// 代码逻辑说明: [issues/5879]数据查询传ds=“”造成的异常------------
if (index != -1) {
result.put(s.substring(0, index), s.substring(index + 1));
}
}
return result;
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/BodyReaderHttpServletRequestWrapper.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/util/BodyReaderHttpServletRequestWrapper.java | package org.jeecg.config.sign.util;
import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
/**
* 保存过滤器里面的流
*
* @author jeecg
* @date 20210621
*/
public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {
private final byte[] body;
public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) {
super(request);
String sessionStream = getBodyString(request);
body = sessionStream.getBytes(Charset.forName("UTF-8"));
}
/**
* 获取请求Body
*
* @param request
* @return
*/
public String getBodyString(final ServletRequest request) {
StringBuilder sb = new StringBuilder();
try (InputStream inputStream = cloneInputStream(request.getInputStream());
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")))) {
String line;
while ((line = reader.readLine()) != null) {
sb.append(line);
}
} catch (IOException e) {
e.printStackTrace();
}
return sb.toString();
}
/**
* Description: 复制输入流</br>
*
* @param inputStream
* @return</br>
*/
public InputStream cloneInputStream(ServletInputStream inputStream) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
try {
while ((len = inputStream.read(buffer)) > -1) {
byteArrayOutputStream.write(buffer, 0, len);
}
byteArrayOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
return new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
}
@Override
public BufferedReader getReader() {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
@Override
public ServletInputStream getInputStream() {
final ByteArrayInputStream bais = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() {
return bais.read();
}
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
};
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthConfiguration.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthConfiguration.java | package org.jeecg.config.sign.interceptor;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.common.util.PathMatcherUtil;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.filter.RequestBodyReserveFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import jakarta.annotation.Resource;
/**
* 签名 拦截器配置
* @author: jeecg-boot
*/
@Configuration
public class SignAuthConfiguration implements WebMvcConfigurer {
@Resource
JeecgBaseConfig jeecgBaseConfig;
@Bean
public SignAuthInterceptor signAuthInterceptor() {
return new SignAuthInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
//------------------------------------------------------------
//查询需要进行签名拦截的接口 signUrls
String signUrls = jeecgBaseConfig.getSignUrls();
String[] signUrlsArray = null;
if (StringUtils.isNotBlank(signUrls)) {
signUrlsArray = signUrls.split(",");
} else {
signUrlsArray = PathMatcherUtil.SIGN_URL_LIST;
}
//------------------------------------------------------------
registry.addInterceptor(signAuthInterceptor()).addPathPatterns(signUrlsArray);
}
// 代码逻辑说明: issues/I53J5E post请求X_SIGN签名拦截校验后报错, request body 为空
@Bean
public RequestBodyReserveFilter requestBodyReserveFilter(){
return new RequestBodyReserveFilter();
}
@Bean
public FilterRegistrationBean reqBodyFilterRegistrationBean(){
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(requestBodyReserveFilter());
registration.setName("requestBodyReserveFilter");
//------------------------------------------------------------
//查询需要进行签名拦截的接口 signUrls
String signUrls = jeecgBaseConfig.getSignUrls();
String[] signUrlsArray = null;
if (StringUtils.isNotBlank(signUrls)) {
signUrlsArray = signUrls.split(",");
} else {
signUrlsArray = PathMatcherUtil.SIGN_URL_LIST;
}
//------------------------------------------------------------
// 建议此处只添加post请求地址而不是所有的都需要走过滤器
registration.addUrlPatterns(signUrlsArray);
return registration;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthInterceptor.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/interceptor/SignAuthInterceptor.java | package org.jeecg.config.sign.interceptor;
import com.alibaba.fastjson.JSON;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.sign.util.BodyReaderHttpServletRequestWrapper;
import org.jeecg.config.sign.util.HttpUtils;
import org.jeecg.config.sign.util.SignUtil;
import org.springframework.web.servlet.HandlerInterceptor;
import java.io.PrintWriter;
import java.util.SortedMap;
/**
* 签名拦截器
* @author qinfeng
*/
@Slf4j
public class SignAuthInterceptor implements HandlerInterceptor {
/**
* 5分钟有效期
*/
private final static long MAX_EXPIRE = 5 * 60;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
log.info("签名拦截器 Interceptor request URI = " + request.getRequestURI());
try {
// 调用验证逻辑
validateSignature(request);
return true;
} catch (IllegalArgumentException e) {
// 验证失败，返回错误响应
log.error("Sign 签名校验失败！{}", e.getMessage());
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
PrintWriter out = response.getWriter();
Result<?> result = Result.error(e.getMessage());
out.print(JSON.toJSON(result));
return false;
}
}
/**
* 签名验证核心逻辑
* 提取出来供AOP切面复用
* @param request HTTP请求
* @throws IllegalArgumentException 验证失败时抛出异常
*/
public void validateSignature(HttpServletRequest request) throws IllegalArgumentException {
try {
log.debug("开始签名验证: {} {}", request.getMethod(), request.getRequestURI());
HttpServletRequest requestWrapper = new BodyReaderHttpServletRequestWrapper(request);
//获取全部参数(包括URL和body上的)
SortedMap<String, String> allParams = HttpUtils.getAllParams(requestWrapper);
log.debug("提取参数: {}", allParams);
//对参数进行签名验证
String headerSign = request.getHeader(CommonConstant.X_SIGN);
String xTimestamp = request.getHeader(CommonConstant.X_TIMESTAMP);
if(oConvertUtils.isEmpty(xTimestamp)){
log.error("Sign签名校验失败，时间戳为空！");
throw new IllegalArgumentException("Sign签名校验失败，请求参数不完整！");
}
//客户端时间
Long clientTimestamp = Long.parseLong(xTimestamp);
int length = 14;
int length1000 = 1000;
//1.校验签名时间（兼容X_TIMESTAMP的新老格式）
if (xTimestamp.length() == length) {
//a. X_TIMESTAMP格式是 yyyyMMddHHmmss (例子：20220308152143)
long currentTimestamp = DateUtils.getCurrentTimestamp();
long timeDiff = currentTimestamp - clientTimestamp;
log.debug("时间戳验证(yyyyMMddHHmmss): 时间差{}秒", timeDiff);
if (timeDiff > MAX_EXPIRE) {
log.error("时间戳已过期: {}秒 > {}秒", timeDiff, MAX_EXPIRE);
throw new IllegalArgumentException("签名验证失败，请求时效性验证失败！");
}
} else {
//b. X_TIMESTAMP格式是 时间戳 (例子：1646552406000)
long currentTime = System.currentTimeMillis();
long timeDiff = currentTime - clientTimestamp;
long maxExpireMs = MAX_EXPIRE * length1000;
log.debug("时间戳验证(Unix): 时间差{}ms", timeDiff);
if (timeDiff > maxExpireMs) {
log.error("时间戳已过期: {}ms > {}ms", timeDiff, maxExpireMs);
throw new IllegalArgumentException("签名验证失败，请求时效性验证失败！");
}
}
//2.校验签名
boolean isSigned = SignUtil.verifySign(allParams,headerSign);
if (isSigned) {
log.debug("签名验证通过");
} else {
log.error("签名验证失败, 参数: {}", allParams);
throw new IllegalArgumentException("Sign签名校验失败！");
}
} catch (IllegalArgumentException e) {
// 重新抛出签名验证异常
throw e;
} catch (Exception e) {
// 包装其他异常（如IOException）
log.error("签名验证异常: {}", e.getMessage());
throw new IllegalArgumentException("Sign签名校验失败：" + e.getMessage());
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/aspect/SignatureCheckAspect.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/aspect/SignatureCheckAspect.java | package org.jeecg.config.sign.aspect;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.jeecg.config.sign.annotation.SignatureCheck;
import org.jeecg.config.sign.interceptor.SignAuthInterceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import java.lang.reflect.Method;
/**
* 基于AOP的签名验证切面
* 复用SignAuthInterceptor的成熟签名验证逻辑
*
* @author GitHub Copilot
* @since 2025-12-15
*/
@Aspect
@Slf4j
@Component("signatureCheckAspect")
public class SignatureCheckAspect {
/**
* 复用SignAuthInterceptor的签名验证逻辑
*/
private final SignAuthInterceptor signAuthInterceptor = new SignAuthInterceptor();
/**
* 验签切点：拦截所有标记了@SignatureCheck注解的方法
*/
@Pointcut("@annotation(org.jeecg.config.sign.annotation.SignatureCheck)")
private void signatureCheckPointCut() {
}
/**
* 开始验签
*/
@Before("signatureCheckPointCut()")
public void doSignatureValidation(JoinPoint point) throws Exception {
// 获取方法上的注解
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
SignatureCheck signatureCheck = method.getAnnotation(SignatureCheck.class);
log.info("AOP签名验证: {}.{}", method.getDeclaringClass().getSimpleName(), method.getName());
// 如果注解被禁用，直接返回
if (!signatureCheck.enabled()) {
log.info("签名验证已禁用，跳过");
return;
}
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
if (attributes == null) {
log.error("无法获取请求上下文");
throw new IllegalArgumentException("无法获取请求上下文");
}
HttpServletRequest request = attributes.getRequest();
log.info("X-SIGN: {}, X-TIMESTAMP: {}", request.getHeader("X-SIGN"), request.getHeader("X-TIMESTAMP"));
try {
// 直接调用SignAuthInterceptor的验证逻辑
signAuthInterceptor.validateSignature(request);
log.info("AOP签名验证通过");
} catch (IllegalArgumentException e) {
// 使用注解中配置的错误消息，或者保留原始错误消息
String errorMessage = signatureCheck.errorMessage();
log.error("AOP签名验证失败: {}", e.getMessage());
if ("Sign签名校验失败！".equals(errorMessage)) {
// 如果是默认错误消息，使用原始的详细错误信息
throw e;
} else {
// 如果是自定义错误消息，使用自定义消息
throw new IllegalArgumentException(errorMessage, e);
}
} catch (Exception e) {
// 包装其他异常
String errorMessage = signatureCheck.errorMessage();
log.error("AOP签名验证异常: {}", e.getMessage());
throw new IllegalArgumentException(errorMessage, e);
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/annotation/SignatureCheck.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/sign/annotation/SignatureCheck.java | package org.jeecg.config.sign.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 签名校验注解
* 用于方法级别的签名验证，功能等同于yml中的jeecg.signUrls配置
* 参考DragSignatureAspect的设计思路，使用AOP切面实现
*
* @author GitHub Copilot
* @since 2025-12-15
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SignatureCheck {
/**
* 是否启用签名校验
* @return true-启用(默认), false-禁用
*/
boolean enabled() default true;
/**
* 签名校验失败时的错误消息
* @return 错误消息
*/
String errorMessage() default "Sign签名校验失败！";
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/filter/WebsocketFilter.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/filter/WebsocketFilter.java | package org.jeecg.config.filter;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.CommonAPI;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* websocket 前端将token放到子协议里传入 与后端建立连接时需要用到http协议，此处用于校验token的有效性
* @Author taoYan
* @Date 2022/4/21 17:01
**/
@Slf4j
public class WebsocketFilter implements Filter {
private static final String TOKEN_KEY = "Sec-WebSocket-Protocol";
private static CommonAPI commonApi;
private static RedisUtil redisUtil;
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
if (commonApi == null) {
commonApi = SpringContextUtils.getBean(CommonAPI.class);
}
if (redisUtil == null) {
redisUtil = SpringContextUtils.getBean(RedisUtil.class);
}
HttpServletRequest request = (HttpServletRequest)servletRequest;
String token = request.getHeader(TOKEN_KEY);
log.debug("Websocket连接 Token安全校验，Path = {}，token:{}", request.getRequestURI(), token);
try {
TokenUtils.verifyToken(token, commonApi, redisUtil);
} catch (Exception exception) {
//log.error("Websocket连接 Token安全校验失败，IP:{}, Token:{}, Path = {}，异常：{}", oConvertUtils.getIpAddrByRequest(request), token, request.getRequestURI(), exception.getMessage());
log.debug("Websocket连接 Token安全校验失败，IP:{}, Token:{}, Path = {}，异常：{}", oConvertUtils.getIpAddrByRequest(request), token, request.getRequestURI(), exception.getMessage());
return;
}
HttpServletResponse response = (HttpServletResponse)servletResponse;
response.setHeader(TOKEN_KEY, token);
filterChain.doFilter(servletRequest, servletResponse);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/filter/RequestBodyReserveFilter.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/filter/RequestBodyReserveFilter.java | package org.jeecg.config.filter;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.config.sign.util.BodyReaderHttpServletRequestWrapper;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
* 针对post请求，将HttpServletRequest包一层 保留body里的参数
* @Author taoYan
* @Date 2022/4/25 19:19
**/
public class RequestBodyReserveFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if(servletRequest instanceof HttpServletRequest) {
HttpServletRequest req = (HttpServletRequest) servletRequest;
// POST请求类型，才获取POST请求体
if(CommonConstant.HTTP_POST.equals(req.getMethod())){
requestWrapper = new BodyReaderHttpServletRequestWrapper(req);
}
}
if(requestWrapper == null) {
filterChain.doFilter(servletRequest, servletResponse);
} else {
filterChain.doFilter(requestWrapper, servletResponse);
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/JeecgTenantParser.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/JeecgTenantParser.java | //package org.jeecg.config.mybatis;
//
//import com.baomidou.mybatisplus.extension.plugins.tenant.TenantSqlParser;
//import net.sf.jsqlparser.expression.BinaryExpression;
//import net.sf.jsqlparser.expression.Expression;
//import net.sf.jsqlparser.expression.Parenthesis;
//import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
//import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
//import net.sf.jsqlparser.expression.operators.relational.*;
//import net.sf.jsqlparser.schema.Column;
//import net.sf.jsqlparser.schema.Table;
//import net.sf.jsqlparser.statement.select.*;
//
//import java.util.List;
//
///**
// * 复写租户条件
// */
//public class JeecgTenantParser extends TenantSqlParser {
//
// /**
// * @param expression
// * @param table
// * @return
// */
// protected Expression processTableAlias(Expression expression, Table table) {
// String tableAliasName;
// if (table.getAlias() == null) {
// tableAliasName = table.getName();
// } else {
// tableAliasName = table.getAlias().getName();
// }
//
// // in
// if (expression instanceof InExpression) {
// InExpression in = (InExpression) expression;
// if (in.getLeftExpression() instanceof Column) {
// setTableAliasNameForColumn((Column) in.getLeftExpression(), tableAliasName);
// }
//
// // 比较操作
// } else if (expression instanceof BinaryExpression) {
// BinaryExpression compare = (BinaryExpression) expression;
// if (compare.getLeftExpression() instanceof Column) {
// setTableAliasNameForColumn((Column) compare.getLeftExpression(), tableAliasName);
// } else if (compare.getRightExpression() instanceof Column) {
// setTableAliasNameForColumn((Column) compare.getRightExpression(), tableAliasName);
// }
//
// // between
// } else if (expression instanceof Between) {
// Between between = (Between) expression;
// if (between.getLeftExpression() instanceof Column) {
// setTableAliasNameForColumn((Column) between.getLeftExpression(), tableAliasName);
// }
// }
// return expression;
// }
//
// private void setTableAliasNameForColumn(Column column, String tableAliasName) {
// column.setColumnName(tableAliasName + "." + column.getColumnName());
// }
//
// /**
// * 默认是按 tenant_id=1 按等于条件追加
// *
// * @param currentExpression 现有的条件：比如你原来的sql查询条件
// * @param table
// * @return
// */
// @Override
// protected Expression builderExpression(Expression currentExpression, Table table) {
// final Expression tenantExpression = this.getTenantHandler().getTenantId(true);
// Expression appendExpression;
// if (!(tenantExpression instanceof SupportsOldOracleJoinSyntax)) {
// appendExpression = new EqualsTo();
// ((EqualsTo) appendExpression).setLeftExpression(this.getAliasColumn(table));
// ((EqualsTo) appendExpression).setRightExpression(tenantExpression);
// } else {
// appendExpression = processTableAlias(tenantExpression, table);
// }
// if (currentExpression == null) {
// return appendExpression;
// }
// if (currentExpression instanceof BinaryExpression) {
// BinaryExpression binaryExpression = (BinaryExpression) currentExpression;
// if (binaryExpression.getLeftExpression() instanceof FromItem) {
// processFromItem((FromItem) binaryExpression.getLeftExpression());
// }
// if (binaryExpression.getRightExpression() instanceof FromItem) {
// processFromItem((FromItem) binaryExpression.getRightExpression());
// }
// } else if (currentExpression instanceof InExpression) {
// InExpression inExp = (InExpression) currentExpression;
// ItemsList rightItems = inExp.getRightItemsList();
// if (rightItems instanceof SubSelect) {
// processSelectBody(((SubSelect) rightItems).getSelectBody());
// }
// }
// if (currentExpression instanceof OrExpression) {
// return new AndExpression(new Parenthesis(currentExpression), appendExpression);
// } else {
// return new AndExpression(currentExpression, appendExpression);
// }
// }
//
// @Override
// protected void processPlainSelect(PlainSelect plainSelect, boolean addColumn) {
// FromItem fromItem = plainSelect.getFromItem();
// if (fromItem instanceof Table) {
// Table fromTable = (Table) fromItem;
// if (!this.getTenantHandler().doTableFilter(fromTable.getName())) {
// plainSelect.setWhere(builderExpression(plainSelect.getWhere(), fromTable));
// if (addColumn) {
// plainSelect.getSelectItems().add(new SelectExpressionItem(new Column(this.getTenantHandler().getTenantIdColumn())));
// }
// }
// } else {
// processFromItem(fromItem);
// }
// List<Join> joins = plainSelect.getJoins();
// if (joins != null && joins.size() > 0) {
// joins.forEach(j -> {
// processJoin(j);
// processFromItem(j.getRightItem());
// });
// }
// }
//
//}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/ThreadLocalDataHelper.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/ThreadLocalDataHelper.java | package org.jeecg.config.mybatis;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import java.util.concurrent.ConcurrentHashMap;
/**
* @Description: 本地线程变量存储工具类
* @author: lsq
* @date: 2022年03月25日 11:42
*/
public class ThreadLocalDataHelper {
/**
* 线程的本地变量
*/
private static final ThreadLocal<ConcurrentHashMap> REQUEST_DATA = new ThreadLocal<>();
/**
* 存储本地参数
*/
private static final ConcurrentHashMap DATA_MAP = new ConcurrentHashMap<>();
/**
* 设置请求参数
*
* @param key 参数key
* @param value 参数值
*/
public static void put(String key, Object value) {
if(ObjectUtil.isNotEmpty(value)) {
DATA_MAP.put(key, value);
REQUEST_DATA.set(DATA_MAP);
}
}
/**
* 获取请求参数值
*
* @param key 请求参数
* @return
*/
public static <T> T get(String key) {
ConcurrentHashMap dataMap = REQUEST_DATA.get();
if (CollectionUtils.isNotEmpty(dataMap)) {
return (T) dataMap.get(key);
}
return null;
}
/**
* 获取请求参数
*
* @return 请求参数 MAP 对象
*/
public static void clear() {
DATA_MAP.clear();
REQUEST_DATA.remove();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisInterceptor.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisInterceptor.java | package org.jeecg.config.mybatis;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.binding.MapperMethod.ParamMap;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.TenantConstant;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.util.Date;
import java.util.Properties;
/**
* mybatis拦截器，自动注入创建人、创建时间、修改人、修改时间
* @Author scott
* @Date 2019-01-19
*
*/
@Slf4j
@Component
@Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }) })
public class MybatisInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
String sqlId = mappedStatement.getId();
log.debug("------sqlId------" + sqlId);
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
Object parameter = invocation.getArgs()[1];
log.debug("------sqlCommandType------" + sqlCommandType);
if (parameter == null) {
return invocation.proceed();
}
if (SqlCommandType.INSERT == sqlCommandType) {
LoginUser sysUser = this.getLoginUser();
Field[] fields = oConvertUtils.getAllFields(parameter);
for (Field field : fields) {
log.debug("------field.name------" + field.getName());
try {
if ("createBy".equals(field.getName())) {
field.setAccessible(true);
Object localCreateBy = field.get(parameter);
field.setAccessible(false);
if (localCreateBy == null || "".equals(localCreateBy)) {
if (sysUser != null) {
// 登录人账号
field.setAccessible(true);
field.set(parameter, sysUser.getUsername());
field.setAccessible(false);
}
}
}
// 注入创建时间
if ("createTime".equals(field.getName())) {
field.setAccessible(true);
Object localCreateDate = field.get(parameter);
field.setAccessible(false);
if (localCreateDate == null || "".equals(localCreateDate)) {
field.setAccessible(true);
field.set(parameter, new Date());
field.setAccessible(false);
}
}
//注入部门编码
if ("sysOrgCode".equals(field.getName())) {
field.setAccessible(true);
Object localSysOrgCode = field.get(parameter);
field.setAccessible(false);
if (localSysOrgCode == null || "".equals(localSysOrgCode)) {
// 获取登录用户信息
if (sysUser != null) {
field.setAccessible(true);
field.set(parameter, sysUser.getOrgCode());
field.setAccessible(false);
}
}
}
//------------------------------------------------------------------------------------------------
//注入租户ID（是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】）
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
if (TenantConstant.TENANT_ID.equals(field.getName())) {
field.setAccessible(true);
Object localTenantId = field.get(parameter);
field.setAccessible(false);
if (localTenantId == null) {
field.setAccessible(true);
String tenantId = TenantContext.getTenant();
//如果通过线程获取租户ID为空，则通过当前请求的request获取租户（shiro排除拦截器的请求会获取不到租户ID）
if(oConvertUtils.isEmpty(tenantId) && MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
try {
tenantId = TokenUtils.getTenantIdByRequest(SpringContextUtils.getHttpServletRequest());
} catch (Exception e) {
//e.printStackTrace();
}
}
if (field.getType().equals(String.class)) {
// 字段类型为String
field.set(parameter, tenantId);
} else {
// 字段类型不是String
field.set(parameter, oConvertUtils.getInt(tenantId, 0));
}
field.setAccessible(false);
}
}
}
//------------------------------------------------------------------------------------------------
} catch (Exception e) {
}
}
}
if (SqlCommandType.UPDATE == sqlCommandType) {
LoginUser sysUser = this.getLoginUser();
Field[] fields = null;
if (parameter instanceof ParamMap) {
ParamMap<?> p = (ParamMap<?>) parameter;
// 代码逻辑说明: 批量更新报错issues/IZA3Q--
String et = "et";
if (p.containsKey(et)) {
parameter = p.get(et);
} else {
parameter = p.get("param1");
}
// 代码逻辑说明: 更新指定字段时报错 issues/#516-
if (parameter == null) {
return invocation.proceed();
}
fields = oConvertUtils.getAllFields(parameter);
} else {
fields = oConvertUtils.getAllFields(parameter);
}
for (Field field : fields) {
log.debug("------field.name------" + field.getName());
try {
if ("updateBy".equals(field.getName())) {
//获取登录用户信息
if (sysUser != null) {
// 登录账号
field.setAccessible(true);
field.set(parameter, sysUser.getUsername());
field.setAccessible(false);
}
}
if ("updateTime".equals(field.getName())) {
field.setAccessible(true);
field.set(parameter, new Date());
field.setAccessible(false);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
// TODO Auto-generated method stub
}
/**
* 获取登录用户
* @return
*/
private LoginUser getLoginUser() {
LoginUser sysUser = null;
try {
sysUser = SecurityUtils.getSubject().getPrincipal() != null ? (LoginUser) SecurityUtils.getSubject().getPrincipal() : null;
} catch (Exception e) {
//e.printStackTrace();
sysUser = null;
}
return sysUser;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/TenantContext.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/TenantContext.java | //package org.jeecg.config.mybatis;
//
//import lombok.extern.slf4j.Slf4j;
//
///**
// * 多租户 tenant_id存储器
// * @author: jeecg-boot
// */
//@Slf4j
//public class TenantContext {
// private static ThreadLocal<String> currentTenant = new ThreadLocal<>();
//
// public static void setTenant(String tenant) {
// log.debug(" setting tenant to " + tenant);
// currentTenant.set(tenant);
// }
//
// public static String getTenant() {
// return currentTenant.get();
// }
//
// public static void clear(){
// currentTenant.remove();
// }
//}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisPlusSaasConfig.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/MybatisPlusSaasConfig.java | package org.jeecg.config.mybatis;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
import com.baomidou.mybatisplus.extension.plugins.inner.DynamicTableNameInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
import com.baomidou.mybatisplus.extension.toolkit.JdbcUtils;
import lombok.extern.slf4j.Slf4j;
import me.zhyd.oauth.log.Log;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.TenantConstant;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
* 单数据源配置（jeecg.datasource.open = false时生效）
* @Author zhoujf
*
*/
@Slf4j
@Configuration
@MapperScan(value={"org.jeecg.**.mapper*"})
public class MybatisPlusSaasConfig {
@Autowired
private DataSource dataSource;
/**
* 是否开启系统模块的租户隔离
* 控制范围：用户、角色、部门、我的部门、字典、分类字典、多数据源、职务、通知公告
*
* 实现功能
* 1.用户表通过硬编码实现租户ID隔离
* 2.角色、部门、我的部门、字典、分类字典、多数据源、职务、通知公告除了硬编码还加入的 TENANT_TABLE 配置中，实现租户隔离更安全
* 3.菜单表、租户表不做租户隔离
* 4.通过拦截器MybatisInterceptor实现，增删改查数据 自动注入租户ID
*/
public static final Boolean OPEN_SYSTEM_TENANT_CONTROL = false;
/**
* 哪些表需要做多租户 表需要添加一个字段 tenant_id
*/
public static final List<String> TENANT_TABLE = new ArrayList<String>();
static {
//1.需要租户隔离的表请在此配置
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
//a.系统管理表
//TENANT_TABLE.add("sys_role");
//TENANT_TABLE.add("sys_user_role");
TENANT_TABLE.add("sys_depart");
TENANT_TABLE.add("sys_category");
TENANT_TABLE.add("sys_data_source");
TENANT_TABLE.add("sys_position");
//b-2.仪表盘
TENANT_TABLE.add("onl_drag_page");
TENANT_TABLE.add("onl_drag_dataset_head");
TENANT_TABLE.add("jimu_report_data_source");
TENANT_TABLE.add("jimu_report");
TENANT_TABLE.add("jimu_dict");
//b-4.AIRAG
TENANT_TABLE.add("airag_app");
TENANT_TABLE.add("airag_flow");
TENANT_TABLE.add("airag_knowledge");
TENANT_TABLE.add("airag_knowledge_doc");
TENANT_TABLE.add("airag_model");
}
//2.示例测试
//TENANT_TABLE.add("demo");
//3.online租户隔离测试
//TENANT_TABLE.add("ceapp_issue");
}
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 先 add TenantLineInnerInterceptor 再 add PaginationInnerInterceptor
interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new TenantLineHandler() {
@Override
public Expression getTenantId() {
String tenantId = TenantContext.getTenant();
//如果通过线程获取租户ID为空，则通过当前请求的request获取租户（shiro排除拦截器的请求会获取不到租户ID）
if(oConvertUtils.isEmpty(tenantId)){
try {
tenantId = TokenUtils.getTenantIdByRequest(SpringContextUtils.getHttpServletRequest());
} catch (Exception e) {
//e.printStackTrace();
}
}
if(oConvertUtils.isEmpty(tenantId)){
tenantId = "0";
}
return new LongValue(tenantId);
}
@Override
public String getTenantIdColumn(){
return TenantConstant.TENANT_ID_TABLE;
}
// 返回 true 表示不走租户逻辑
@Override
public boolean ignoreTable(String tableName) {
for(String temp: TENANT_TABLE){
if(temp.equalsIgnoreCase(tableName)){
return false;
}
}
return true;
}
}));
//update-begin-author:zyf date:20220425 for:【VUEN-606】注入动态表名适配拦截器解决多表名问题
interceptor.addInnerInterceptor(dynamicTableNameInnerInterceptor());
//update-end-author:zyf date:20220425 for:【VUEN-606】注入动态表名适配拦截器解决多表名问题
//update-begin---author:scott ---date:2025-08-02 for：【issues/8666】升级mybatisPlus后SqlServer分页使用OFFSET ？ ROWS FETCH NEXT ？ ROWS ONLY，导致online报表报错---
DbType dbType = null;
try {
dbType = JdbcUtils.getDbType(dataSource.getConnection().getMetaData().getURL());
log.info("当前数据库类型: {}", dbType);
} catch (SQLException e) {
Log.error(e.getMessage(), e);
}
if (dbType!=null && (dbType == DbType.SQL_SERVER || dbType == DbType.SQL_SERVER2005)) {
// 如果是SQL Server则覆盖为2005分页方式
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQL_SERVER2005));
} else {
interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
}
//update-end---author:scott ---date::2025-08-02 for：【issues/8666】升级mybatisPlus后SqlServer分页使用OFFSET ？ ROWS FETCH NEXT ？ ROWS ONLY，导致online报表报错---
//【jeecg-boot/issues/3847】增加@Version乐观锁支持
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return interceptor;
}
/**
* 动态表名切换拦截器,用于适配vue2和vue3同一个表有多个的情况,如sys_role_index在vue3情况下表名为sys_role_index_v3
* @return
*/
private DynamicTableNameInnerInterceptor dynamicTableNameInnerInterceptor() {
DynamicTableNameInnerInterceptor dynamicTableNameInnerInterceptor = new DynamicTableNameInnerInterceptor();
dynamicTableNameInnerInterceptor.setTableNameHandler((sql, tableName) -> {
//获取需要动态解析的表名
String dynamicTableName = ThreadLocalDataHelper.get(CommonConstant.DYNAMIC_TABLE_NAME);
//当dynamicTableName不为空时才走动态表名处理逻辑,否则返回原始表名
if (ObjectUtil.isNotEmpty(dynamicTableName) && dynamicTableName.equals(tableName)) {
// 获取前端传递的版本号标识
Object version = ThreadLocalDataHelper.get(CommonConstant.VERSION);
if (ObjectUtil.isNotEmpty(version)) {
//拼接表名规则(原始表名+下划线+前端传递的版本号)
return tableName + "_" + version;
}
}
return tableName;
});
return dynamicTableNameInnerInterceptor;
}
// /**
// * 下个版本会删除，现在为了避免缓存出现问题不得不配置
// * @return
// */
// @Bean
// public ConfigurationCustomizer configurationCustomizer() {
// return configuration -> configuration.setUseDeprecatedExecutor(false);
// }
// /**
// * mybatis-plus SQL执行效率插件【生产环境可以关闭】
// */
// @Bean
// public PerformanceInterceptor performanceInterceptor() {
// return new PerformanceInterceptor();
// }
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/interceptor/DynamicDatasourceInterceptor.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/interceptor/DynamicDatasourceInterceptor.java | package org.jeecg.config.mybatis.interceptor;
import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
/**
* 动态数据源切换拦截器
*
* 测试：拦截参数，自动切换数据源
* 未来规划：后面通过此机制，实现多租户切换数据源功能
* @author zyf
*/
@Slf4j
public class DynamicDatasourceInterceptor implements HandlerInterceptor {
/**
* 在请求处理之前进行调用（Controller方法调用之前）
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
String requestURI = request.getRequestURI();
log.info("经过多数据源Interceptor,当前路径是{}", requestURI);
//获取动态数据源名称
String dsName = request.getParameter("dsName");
String dsKey = "master";
if (StringUtils.isNotEmpty(dsName)) {
dsKey = dsName;
}
DynamicDataSourceContextHolder.push(dsKey);
return true;
}
/**
* 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
}
/**
* 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
DynamicDataSourceContextHolder.clear();
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/aspect/DynamicTableAspect.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/mybatis/aspect/DynamicTableAspect.java | package org.jeecg.config.mybatis.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.jeecg.common.aspect.annotation.DynamicTable;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.config.mybatis.ThreadLocalDataHelper;
import org.springframework.stereotype.Component;
import jakarta.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
/**
* 动态table切换 切面处理
*
* @author :zyf
* @date:2020-04-25
*/
@Aspect
@Component
public class DynamicTableAspect {
/**
* 定义切面拦截切入点
*/
@Pointcut("@annotation(org.jeecg.common.aspect.annotation.DynamicTable)")
public void dynamicTable() {
}
@Around("dynamicTable()")
public Object around(ProceedingJoinPoint point) throws Throwable {
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
DynamicTable dynamicTable = method.getAnnotation(DynamicTable.class);
HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
//获取前端传递的版本标记
String version = request.getHeader(CommonConstant.VERSION);
//存储版本号到本地线程变量
ThreadLocalDataHelper.put(CommonConstant.VERSION, version);
//存储表名到本地线程变量
ThreadLocalDataHelper.put(CommonConstant.DYNAMIC_TABLE_NAME, dynamicTable.value());
//执行方法
Object result = point.proceed();
//清空本地变量
ThreadLocalDataHelper.clear();
return result;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/tencent/JeecgTencent.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/tencent/JeecgTencent.java | package org.jeecg.config.tencent;
import lombok.Data;
/**
* @Description: 腾讯短信配置
*
* @author: wangshuai
* @date: 2025/10/30 18:22
*/
@Data
public class JeecgTencent {
/**
* 接入域名
*/
private String endpoint;
/**
* api秘钥id
*/
private String secretId;
/**
* api秘钥key
*/
private String secretKey;
/**
* 应用id
*/
private String sdkAppId;
/**
* 地域信息
*/
private String region;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/SqlInjection/IDictTableWhiteListHandler.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/SqlInjection/IDictTableWhiteListHandler.java | package org.jeecg.config.firewall.SqlInjection;
/**
* 字典表查询 :: 白名单配置
*
* @Author taoYan
* @Date 2022/3/17 11:21
**/
public interface IDictTableWhiteListHandler {
/**
* 校验【表名】【字段】是否合法允许查询，允许则返回 true
*
* @param sql
* @return
*/
boolean isPassBySql(String sql);
/**
* 校验字典是否通过
*
* @param dictCodeString 字典表配置
* @return
*/
boolean isPassByDict(String dictCodeString);
boolean isPassByDict(String tableName, String... fields);
/**
* 清空缓存，使更改生效
*
* @return
*/
boolean clear();
String getErrorMsg();
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/SqlInjection/SysDictTableWhite.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/SqlInjection/SysDictTableWhite.java | package org.jeecg.config.firewall.SqlInjection;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.util.oConvertUtils;
import java.util.HashSet;
import java.util.Set;
/**
* 查询的表的信息
*/
@Slf4j
public class SysDictTableWhite {
//表名
private String name;
//表的别名
private String alias;
// 字段名集合
private Set<String> fields;
// 是否查询所有字段
private boolean all;
public SysDictTableWhite() {
}
public SysDictTableWhite(String name, String alias) {
this.name = name;
this.alias = alias;
this.all = false;
this.fields = new HashSet<>();
}
public void addField(String field) {
this.fields.add(field);
}
public String getName() {
return name;
}
public Set<String> getFields() {
return new HashSet<>(fields);
}
public void setName(String name) {
this.name = name;
}
public void setFields(Set<String> fields) {
this.fields = fields;
}
public String getAlias() {
return alias;
}
public void setAlias(String alias) {
this.alias = alias;
}
public boolean isAll() {
return all;
}
public void setAll(boolean all) {
this.all = all;
}
/**
* 判断是否有相同字段
*
* @param fieldControlString
* @return
*/
public boolean isAllFieldsValid(String fieldControlString) {
//如果白名单中没有配置字段，则返回false
String[] controlFields = fieldControlString.split(",");
if (oConvertUtils.isEmpty(fieldControlString)) {
return false;
}
for (String queryField : fields) {
if (oConvertUtils.isIn(queryField, controlFields)) {
log.warn("字典表白名单校验，表【" + name + "】中字段【" + queryField + "】无权限查询");
return false;
}
}
return true;
}
@Override
public String toString() {
return "QueryTable{" +
"name='" + name + '\'' +
", alias='" + alias + '\'' +
", fields=" + fields +
", all=" + all +
'}';
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/LowCodeModeInterceptor.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/LowCodeModeInterceptor.java | package org.jeecg.config.firewall.interceptor;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.CommonAPI;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.config.JeecgBaseConfig;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Set;
/**
* 低代码模式（dev:开发模式，prod:发布模式——关闭所有在线开发配置能力）
* <p>
* prod开启后会关闭以下功能，只保留功能测试（拥有admin角色账号，可以使用配置能力）
* 1.online表单的所有配置功能，代码生成和导入表功能
* 2.online报表的所有配置功能，和sql解析
* 3.online图表的所有配置功能，和sql解析
* 4.仪表盘的在线配置功能，和sql解析
* 5.大屏的在线配置功能，和sql解析
*
* 积木的逻辑单独处理
* 1.积木报表的在线配置功能，和sql解析
*
* @author qinfeng
* @date 20230904
*/
@Slf4j
@Component
public class LowCodeModeInterceptor implements HandlerInterceptor {
/**
* 低代码开发模式
*/
public static final String LOW_CODE_MODE_DEV = "dev";
public static final String LOW_CODE_MODE_PROD = "prod";
@Resource
private JeecgBaseConfig jeecgBaseConfig;
/**
* 在请求处理之前进行调用
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
CommonAPI commonAPI = null;
log.info("低代码模式，拦截请求路径：" + request.getRequestURI());
//1、验证是否开启低代码开发模式控制
if (jeecgBaseConfig == null) {
jeecgBaseConfig = SpringContextUtils.getBean(JeecgBaseConfig.class);
}
if (commonAPI == null) {
commonAPI = SpringContextUtils.getBean(CommonAPI.class);
}
if (jeecgBaseConfig.getFirewall()!=null && LowCodeModeInterceptor.LOW_CODE_MODE_PROD.equals(jeecgBaseConfig.getFirewall().getLowCodeMode())) {
String requestURI = request.getRequestURI().substring(request.getContextPath().length());
log.info("低代码模式，拦截请求路径：" + requestURI);
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
Set<String> hasRoles = null;
if (loginUser == null) {
loginUser = commonAPI.getUserByName(JwtUtil.getUserNameByToken(SpringContextUtils.getHttpServletRequest()));
}
if (loginUser != null) {
//当前登录人拥有的角色
hasRoles = commonAPI.queryUserRolesById(loginUser.getId());
}
log.info("get loginUser info: {}", loginUser);
log.info("get loginRoles info: {}", hasRoles != null ? hasRoles.toArray() : "空");
//拥有的角色 和 允许开发角色存在交集
boolean hasIntersection = CommonUtils.hasIntersection(hasRoles, CommonConstant.allowDevRoles);
//如果是超级管理员 或者 允许开发的角色，则不做限制
if (loginUser!=null && ("admin".equals(loginUser.getUsername()) || hasIntersection)) {
return true;
}
this.returnErrorMessage(response);
return false;
}
return true;
}
/**
* 返回结果
*
* @param response
*/
private void returnErrorMessage(HttpServletResponse response) {
//校验失败返回前端
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
PrintWriter out = null;
try {
out = response.getWriter();
Result<?> result = Result.error("低代码开发模式为发布模式，不允许使用在线配置！！");
out.print(JSON.toJSON(result));
} catch (IOException e) {
e.printStackTrace();
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/LowCodeModeConfiguration.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/LowCodeModeConfiguration.java | package org.jeecg.config.firewall.interceptor;
import org.jeecg.config.firewall.interceptor.enums.LowCodeUrlsEnum;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class LowCodeModeConfiguration implements WebMvcConfigurer {
private final LowCodeModeInterceptor lowCodeModeInterceptor;
public LowCodeModeConfiguration(LowCodeModeInterceptor lowCodeModeInterceptor) {
this.lowCodeModeInterceptor = lowCodeModeInterceptor;
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(lowCodeModeInterceptor).addPathPatterns(LowCodeUrlsEnum.getLowCodeInterceptUrls());
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/enums/LowCodeUrlsEnum.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/firewall/interceptor/enums/LowCodeUrlsEnum.java | package org.jeecg.config.firewall.interceptor.enums;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
*
* @author: qinfeng
* @date: 2023/09/04 11:44
*/
public enum LowCodeUrlsEnum {
/**
* online表单配置请求 TODO 增改删
*/
NEW_LOW_APP_ADD_URL("/online/cgform/api/addAll", "添加online表单"),
NEW_LOW_APP_EDIT_URL("/online/cgform/api/editAll", "编辑online表单"),
ONLINE_DB_SYNC("/online/cgform/api/doDbSynch/**/**", "online表单同步数据库"),
ONLINE_DEL_BATCH("/online/cgform/head/deleteBatch", "online表单批量删除"),
ONLINE_DELETE("/online/cgform/head/delete", "online表单删除"),
ONLINE_REMOVE("/online/cgform/head/removeRecord", "online表单移除"),
ONLINE_COPY("/online/cgform/head/copyOnline", "online表单生成视图"),
ONLINE_TABLE("/online/cgform/head/copyOnlineTable", "online表单复制表"),
ONLINE_BUTTON_AI_TEST("/online/cgform/button/aitest", "online表单自定义按钮生成数据"),
ONLINE_BUTTON_ADD("/online/cgform/button/add", "online表单自定义按钮新增"),
ONLINE_BUTTON_EDIT("/online/cgform/button/edit", "online表单自定义按钮编辑"),
ONLINE_BUTTON_DEL("/online/cgform/button/deleteBatch", "online表单自定义按钮删除"),
ONLINE_ENHANCE_JS("/online/cgform/head/enhanceJs/**", "online表单JS增强"),
ONLINE_ENHANCE_JAVA("/online/cgform/head/enhanceJava/**", "online表单JAVA增强"),
/**
* online报表配置请求
*/
ONLINE_CG_REPORT_ADD("/online/cgreport/head/add", "online报表新增"),
ONLINE_CG_REPORT_EDIT("/online/cgreport/head/editAll", "online报表编辑"),
ONLINE_CG_REPORT_DEL("/online/cgreport/head/delete", "online报表删除"),
ONLINE_CG_REPORT_PARSE_SQL("/online/cgreport/head/parseSql", "online报表SQL解析"),
/**
* online图表配置请求
*/
ONLINE_GRAPH_REPORT_ADD("/online/graphreport/head/add", "online图表新增"),
ONLINE_GRAPH_REPORT_EDIT("/online/graphreport/head/edit", "online图表编辑"),
ONLINE_GRAPH_REPORT_DEL("/online/graphreport/head/deleteBatch", "online图表删除"),
ONLINE_GRAPH_REPORT_PARSE_SQL("/online/cgreport/head/parseSql", "online图表解析SQL"),
/**
* 大屏配置请求
*/
BIG_SCREEN_DB_ADD("/bigscreen/bigScreenDb/add", "大屏数据源新增"),
BIG_SCREEN_DB_EDIT("/bigscreen/bigScreenDb/edit", "大屏数据源编辑"),
BIG_SCREEN_DB_DEL("/bigscreen/bigScreenDb/delete", "大屏数据源删除"),
BIG_SCREEN_DB_TEST_CONNECTION("/bigscreen/bigScreenDb/testConnection", "大屏数据源连接测试"),
// BIG_SCREEN_SAVE("/bigscreen/visual/save", "大屏新增"),
// BIG_SCREEN_EDIT("/bigscreen/visual/update", "大屏编辑"),
// BIG_SCREEN_COPY("/bigscreen/visual/copy", "大屏复制"),
// BIG_SCREEN_REMOVE("/bigscreen/visual/remove", "大屏移除"),
// BIG_SCREEN_DEL("/bigscreen/visual/deleteById", "大屏删除"),
/**
* 仪表盘配置请求
*/
DRAG_DB_ADD("/drag/onlDragDataSource/add", "仪表盘数据源新增"),
DRAG_DB_TEST_CONNECTION("/drag/onlDragDataSource/testConnection", "仪表盘数据源连接测试"),
DRAG_PARSE_SQL("/drag/onlDragDatasetHead/queryFieldBySql", "仪表盘数据集SQL解析"),
DRAG_DATASET_ADD("/drag/onlDragDatasetHead/add", "仪表盘数据集新增");
/**
* 其他配置请求
*/
private String url;
private String title;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
LowCodeUrlsEnum(String url, String title) {
this.url = url;
this.title = title;
}
/**
* 根据code获取可用的数量
*
* @return
*/
public static List<String> getLowCodeInterceptUrls() {
return Arrays.stream(LowCodeUrlsEnum.values()).map(LowCodeUrlsEnum::getUrl).collect(Collectors.toList());
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Path.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Path.java | package org.jeecg.config.vo;
import javax.print.DocFlavor;
/**
*
* @author: scott
* @date: 2022年04月18日 20:35
*/
public class Path {
private String upload;
private String webapp;
public String getUpload() {
return upload;
}
public void setUpload(String upload) {
this.upload = upload;
}
public String getWebapp() {
return webapp;
}
public void setWebapp(String webapp) {
this.webapp = webapp;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/GaoDeApi.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/GaoDeApi.java | package org.jeecg.config.vo;
import lombok.Data;
/**
* @Description: 高德开放api配置
*
* @author: wangshuai
* @date: 2025/7/17 20:32
*/
@Data
public class GaoDeApi {
/**应用key*/
private String apiKey;
/**应用秘钥*/
private String secretKey;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/BaiduApi.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/BaiduApi.java | package org.jeecg.config.vo;
import lombok.Data;
/**
* 百度开放api配置
*/
@Data
public class BaiduApi {
private String appId;
private String apiKey;
private String secretKey;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Firewall.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Firewall.java | package org.jeecg.config.vo;
/**
* 平台安全配置
*
* @author: scott
* @date: 2023年09月05日 9:25
*/
public class Firewall {
/**
* 数据源安全 (开启后，Online报表和图表的数据源为必填)
*/
private Boolean dataSourceSafe = false;
/**
* 是否禁止使用 * 查询所有字段
*/
private Boolean disableSelectAll = false;
/**
* 低代码模式（dev:开发模式，prod:发布模式——关闭所有在线开发配置能力）
*/
private String lowCodeMode;
/**
* 是否允许同一账号多地同时登录 （为 true 时允许一起登录, 为 false 时新登录挤掉旧登录）
*/
private Boolean isConcurrent = true;
/**
* 是否开启默认密码登录提醒（true 登录后提示必须修改默认密码）
*/
private Boolean enableDefaultPwdCheck = false;
/**
* 是否开启登录验证码校验（true 开启；false 关闭并跳过验证码逻辑）
*/
private Boolean enableLoginCaptcha = true;
// /**
// * 表字典安全模式（white:白名单——配置了白名单的表才能通过表字典方式访问，black:黑名单——配置了黑名单的表不允许表字典方式访问）
// */
// private String tableDictMode;
public Boolean getEnableLoginCaptcha() {
return enableLoginCaptcha;
}
public void setEnableLoginCaptcha(Boolean enableLoginCaptcha) {
this.enableLoginCaptcha = enableLoginCaptcha;
}
public Boolean getEnableDefaultPwdCheck() {
return enableDefaultPwdCheck;
}
public void setEnableDefaultPwdCheck(Boolean enableDefaultPwdCheck) {
this.enableDefaultPwdCheck = enableDefaultPwdCheck;
}
public Boolean getDataSourceSafe() {
return dataSourceSafe;
}
public void setDataSourceSafe(Boolean dataSourceSafe) {
this.dataSourceSafe = dataSourceSafe;
}
public String getLowCodeMode() {
return lowCodeMode;
}
public void setLowCodeMode(String lowCodeMode) {
this.lowCodeMode = lowCodeMode;
}
public Boolean getDisableSelectAll() {
return disableSelectAll;
}
public void setDisableSelectAll(Boolean disableSelectAll) {
this.disableSelectAll = disableSelectAll;
}
public Boolean getIsConcurrent() {
return isConcurrent;
}
public void setIsConcurrent(Boolean isConcurrent) {
this.isConcurrent = isConcurrent;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgOSS.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgOSS.java | package org.jeecg.config.vo;
import lombok.Data;
@Data
public class JeecgOSS {
private String endpoint;
private String bucketName;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/DomainUrl.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/DomainUrl.java | package org.jeecg.config.vo;
import lombok.Data;
/**
* @Author taoYan
* @Date 2022/7/5 21:16
**/
@Data
public class DomainUrl {
private String pc;
private String app;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Shiro.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Shiro.java | package org.jeecg.config.vo;
/**
* @Description: TODO
* @author: scott
* @date: 2022年01月21日 14:23
*/
public class Shiro {
private String excludeUrls = "";
public String getExcludeUrls() {
return excludeUrls;
}
public void setExcludeUrls(String excludeUrls) {
this.excludeUrls = excludeUrls;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Elasticsearch.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/Elasticsearch.java | package org.jeecg.config.vo;
/**
* @author: scott
* @date: 2023年05月10日 16:06
*/
public class Elasticsearch {
private String clusterNodes;
private boolean checkEnabled;
public String getClusterNodes() {
return clusterNodes;
}
public void setClusterNodes(String clusterNodes) {
this.clusterNodes = clusterNodes;
}
public boolean isCheckEnabled() {
return checkEnabled;
}
public void setCheckEnabled(boolean checkEnabled) {
this.checkEnabled = checkEnabled;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgMinio.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/JeecgMinio.java | package org.jeecg.config.vo;
import lombok.Data;
@Data
public class JeecgMinio {
private String minio_url;
private String bucketName;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/WeiXinPay.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/vo/WeiXinPay.java | package org.jeecg.config.vo;
import lombok.Data;
@Data
public class WeiXinPay {
/**
* 微信公众号id
*/
private String appId;
/**
* 商户号id
*/
private String mchId;
/**
* 商户号秘钥
*/
private String apiKey;
/**
* 回调地址
*/
private String notifyUrl;
/**
* 是否开启会员认证
*/
private Boolean openVipLimit;
/**
* 证书路径
*/
private String certPath;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/oss/MinioConfig.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/oss/MinioConfig.java | package org.jeecg.config.oss;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.util.MinioUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
/**
* Minio文件上传配置文件
* @author: jeecg-boot
*/
@Lazy(false)
@Slf4j
@Configuration
@ConditionalOnProperty(prefix = "jeecg.minio", name = "minio_url")
public class MinioConfig {
@Value(value = "${jeecg.minio.minio_url}")
private String minioUrl;
@Value(value = "${jeecg.minio.minio_name}")
private String minioName;
@Value(value = "${jeecg.minio.minio_pass}")
private String minioPass;
@Value(value = "${jeecg.minio.bucketName}")
private String bucketName;
@PostConstruct
public void initMinio(){
if(!minioUrl.startsWith(CommonConstant.STR_HTTP)){
minioUrl = "http://" + minioUrl;
}
if(!minioUrl.endsWith(SymbolConstant.SINGLE_SLASH)){
minioUrl = minioUrl.concat(SymbolConstant.SINGLE_SLASH);
}
MinioUtil.setMinioUrl(minioUrl);
MinioUtil.setMinioName(minioName);
MinioUtil.setMinioPass(minioPass);
MinioUtil.setBucketName(bucketName);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/oss/OssConfiguration.java | jeecg-boot/jeecg-boot-base-core/src/main/java/org/jeecg/config/oss/OssConfiguration.java | package org.jeecg.config.oss;
import jakarta.annotation.PostConstruct;
import org.jeecg.common.util.oss.OssBootUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
/**
* 云存储 配置
* @author: jeecg-boot
*/
@Lazy(false)
@Configuration
@ConditionalOnProperty(prefix = "jeecg.oss", name = "endpoint")
public class OssConfiguration {
@Value("${jeecg.oss.endpoint}")
private String endpoint;
@Value("${jeecg.oss.accessKey}")
private String accessKeyId;
@Value("${jeecg.oss.secretKey}")
private String accessKeySecret;
@Value("${jeecg.oss.bucketName}")
private String bucketName;
@Value("${jeecg.oss.staticDomain:}")
private String staticDomain;
@PostConstruct
public void initOssBootConfiguration() {
OssBootUtil.setEndPoint(endpoint);
OssBootUtil.setAccessKeyId(accessKeyId);
OssBootUtil.setAccessKeySecret(accessKeySecret);
OssBootUtil.setBucketName(bucketName);
OssBootUtil.setStaticDomain(staticDomain);
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-local-api/src/main/java/org/jeecg/common/system/api/ISysBaseAPI.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-local-api/src/main/java/org/jeecg/common/system/api/ISysBaseAPI.java | package org.jeecg.common.system.api;
import com.alibaba.fastjson.JSONObject;
import org.jeecg.common.api.CommonAPI;
import org.jeecg.common.api.dto.AiragFlowDTO;
import org.jeecg.common.api.dto.DataLogDTO;
import org.jeecg.common.api.dto.OnlineAuthDTO;
import org.jeecg.common.api.dto.PushMessageDTO;
import org.jeecg.common.api.dto.message.*;
import org.jeecg.common.constant.enums.DySmsEnum;
import org.jeecg.common.constant.enums.EmailTemplateEnum;
import org.jeecg.common.system.vo.*;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @Description 底层共通业务API，提供其他独立模块调用
* @Author scott
* @Date 2019-4-20
* @Version V1.0
*/
public interface ISysBaseAPI extends CommonAPI {
//=======OLD 系统消息推送接口============================
/**
* 1发送系统消息
* @param message 使用构造器赋值参数 如果不设置category(消息类型)则默认为2 发送系统消息
*/
void sendSysAnnouncement(MessageDTO message);
/**
* 2发送消息 附带业务参数
* @param message 使用构造器赋值参数
*/
void sendBusAnnouncement(BusMessageDTO message);
/**
* 3通过模板发送消息
* @param message 使用构造器赋值参数
*/
void sendTemplateAnnouncement(TemplateMessageDTO message);
/**
* 4通过模板发送消息 附带业务参数
* @param message 使用构造器赋值参数
*/
void sendBusTemplateAnnouncement(BusTemplateMessageDTO message);
/**
* 5通过消息中心模板，生成推送内容
* @param templateDTO 使用构造器赋值参数
* @return
*/
String parseTemplateByCode(TemplateDTO templateDTO);
//=======OLD 系统消息推送接口============================
//=======TY NEW 自定义消息推送接口，邮件、钉钉、企业微信、系统消息============================
/**
* NEW发送模板消息【新，支持自定义推送类型: 邮件、钉钉、企业微信、系统消息】
* @param message
*/
void sendTemplateMessage(MessageDTO message);
/**
* NEW根据模板编码获取模板内容【新，支持自定义推送类型】
* @param templateCode
* @return
*/
String getTemplateContent(String templateCode);
//=======TY NEW 自定义消息推送接口，邮件、钉钉、企业微信、系统消息============================
/**
* 6根据用户id查询用户信息
* @param id
* @return
*/
LoginUser getUserById(String id);
/**
* 7通过用户账号查询角色集合
* @param username
* @return
*/
List<String> getRolesByUsername(String username);
/**
* 7通过用户账号查询角色集合
* @param userId
* @return
*/
List<String> getRolesByUserId(String userId);
/**
* 8通过用户账号查询部门集合
* @param username
* @return 部门 id
*/
List<String> getDepartIdsByUsername(String username);
/**
* 8通过用户账号查询部门集合
* @param userId
* @return 部门 id
*/
List<String> getDepartIdsByUserId(String userId);
/**
* 8.2 通过用户账号查询部门父ID集合
* @param username
* @return 部门 parentIds
*/
Set<String> getDepartParentIdsByUsername(String username);
/**
* 8.2 查询部门父ID集合
* @param depIds
* @return 部门 parentIds
*/
Set<String> getDepartParentIdsByDepIds(Set<String> depIds);
/**
* 9通过用户账号查询部门 name
* @param username
* @return 部门 name
*/
List<String> getDepartNamesByUsername(String username);
/** 11查询所有的父级字典，按照create_time排序
* @return List<DictModel> 字典集合
*/
public List<DictModel> queryAllDict();
/**
* 12查询所有分类字典
* @return
*/
public List<SysCategoryModel> queryAllSysCategory();
/**
* 14查询所有部门 作为字典信息 id -->value,departName -->text
* @return
*/
public List<DictModel> queryAllDepartBackDictModel();
/**
* 15根据业务类型及业务id修改消息已读
* @param busType
* @param busId
*/
public void updateSysAnnounReadFlag(String busType, String busId);
/**
* 16查询表字典 支持过滤数据
* @param table
* @param text
* @param code
* @param filterSql
* @return
*/
public List<DictModel> queryFilterTableDictInfo(String table, String text, String code, String filterSql);
/**
* 17查询指定table的 text code 获取字典，包含text和value
* @param table
* @param text
* @param code
* @param keyArray
* @return
*/
@Deprecated
public List<String> queryTableDictByKeys(String table, String text, String code, String[] keyArray);
/**
* 18查询所有用户 返回ComboModel
* @return
*/
public List<ComboModel> queryAllUserBackCombo();
/**
* 19分页查询用户 返回JSONObject
* @param userIds 多个用户id
* @param pageNo 当前页数
* @param pageSize 每页显示条数
* @return
*/
public JSONObject queryAllUser(String userIds, Integer pageNo, Integer pageSize);
/**
* 20获取所有角色
* @return
*/
public List<ComboModel> queryAllRole();
/**
* 21获取所有角色 带参
* @param roleIds 默认选中角色
* @return
*/
public List<ComboModel> queryAllRole(String[] roleIds );
/**
* 22通过用户账号查询角色Id集合
* @param username
* @return
*/
public List<String> getRoleIdsByUsername(String username);
/**
* 23通过部门编号查询部门id
* @param orgCode
* @return
*/
public String getDepartIdsByOrgCode(String orgCode);
/**
* 24查询所有部门
* @return
*/
public List<SysDepartModel> getAllSysDepart();
/**
* 25查找父级部门
* @param departId
* @return
*/
DictModel getParentDepartId(String departId);
/**
* 26根据部门Id获取部门负责人
* @param deptId
* @return
*/
public List<String> getDeptHeadByDepId(String deptId);
/**
* 27给指定用户发消息
* @param userIds
* @param cmd
*/
public void sendWebSocketMsg(String[] userIds, String cmd);
/**
* 28根据id获取所有参与用户
* @param userIds 多个用户id
* @return
*/
public List<UserAccountInfo> queryAllUserByIds(String[] userIds);
/**
* 29将会议签到信息推动到预览
* userIds
* @return
* @param userId
*/
void meetingSignWebsocket(String userId);
/**
* 30根据name获取所有参与用户
* @param userNames 多个用户账户
* @return
*/
List<UserAccountInfo> queryUserByNames(String[] userNames);
/**
* 根据高级查询条件查询用户
* @param superQuery
* @param matchType
* @return
*/
List<JSONObject> queryUserBySuperQuery(String superQuery,String matchType);
/**
* 根据ID查询用户
* @param id
* @return
*/
JSONObject queryUserById(String id);
/**
* 根据高级查询条件查询部门
* @param superQuery
* @param matchType
* @return
*/
List<JSONObject> queryDeptBySuperQuery(String superQuery,String matchType);
/**
* 根据高级查询条件查询角色
* @param superQuery
* @param matchType
* @return
*/
List<JSONObject> queryRoleBySuperQuery(String superQuery,String matchType);
/**
* 根据租户ID查询用户ID
* @param tenantId 租户ID
* @return List<String>
*/
List<String> selectUserIdByTenantId(String tenantId);
/**
* 31获取用户的角色集合
* @param username
* @return
*/
Set<String> getUserRoleSet(String username);
/**
* 31获取用户的角色集合
* @param useId
* @return
*/
Set<String> getUserRoleSetById(String useId);
/**
* 32获取用户的权限集合
* @param userId
* @return
*/
Set<String> getUserPermissionSet(String userId);
/**
* 33判断是否有online访问的权限
* @param onlineAuthDTO
* @return
*/
boolean hasOnlineAuth(OnlineAuthDTO onlineAuthDTO);
/**
* 34通过部门id获取部门全部信息
* @param id 部门id
* @return SysDepartModel对象
*/
SysDepartModel selectAllById(String id);
/**
* 35根据用户id查询用户所属公司下所有用户ids
* @param userId
* @return
*/
List<String> queryDeptUsersByUserId(String userId);
/**
* 36根据多个用户账号(逗号分隔)，查询返回多个用户信息
* @param usernames
* @return
*/
List<JSONObject> queryUsersByUsernames(String usernames);
/**
* 37根据多个用户ID(逗号分隔)，查询返回多个用户信息
* @param ids
* @return
*/
List<JSONObject> queryUsersByIds(String ids);
/**
* 38根据多个部门编码(逗号分隔)，查询返回多个部门信息
* @param orgCodes
* @return
*/
List<JSONObject> queryDepartsByOrgcodes(String orgCodes);
/**
* 39根据多个部门id(逗号分隔)，查询返回多个部门信息
* @param ids
* @return
*/
List<JSONObject> queryDepartsByIds(String ids);
/**
* 40发送邮件消息
* @param email
* @param title
* @param content
*/
void sendEmailMsg(String email,String title,String content);
/**
* 40发送模版邮件消息
*
* @param email 接收邮箱
* @param title 邮件标题
* @param emailTemplateEnum 邮件模版枚举
* @param params 模版参数
*/
void sendHtmlTemplateEmail(String email, String title, EmailTemplateEnum emailTemplateEnum, JSONObject params);
/**
* 41 获取公司下级部门和公司下所有用户信息
* @param orgCode
* @return List<Map>
*/
List<Map> getDeptUserByOrgCode(String orgCode);
/**
* 42 发送短信消息
* @param phone 手机号
* @param param 模版参数
* @param dySmsEnum 短信模版
*/
void sendSmsMsg(String phone, JSONObject param, DySmsEnum dySmsEnum);
/**
* 查询分类字典翻译
* @param ids 多个分类字典id
* @return List<String>
*/
List<String> loadCategoryDictItem(String ids);
/**
* 反向翻译分类字典，用于导入
*
* @param names 名称，逗号分割
*/
List<String> loadCategoryDictItemByNames(String names, boolean delNotExist);
/**
* 根据字典code加载字典text
*
* @param dictCode 顺序：tableName,text,code
* @param keys 要查询的key
* @return
*/
List<String> loadDictItem(String dictCode, String keys);
/**
* 复制应用下的所有字典配置到新的租户下
*
* @param originalAppId 原始低代码应用ID
* @param appId 新的低代码应用ID
* @param tenantId 新的租户ID
* @return Map<String, String> Map<原字典编码, 新字典编码>
*/
Map<String, String> copyLowAppDict(String originalAppId, String appId, String tenantId);
/**
* 根据字典code查询字典项
*
* @param dictCode 顺序：tableName,text,code
* @param dictCode 要查询的key
* @return
*/
List<DictModel> getDictItems(String dictCode);
/**
* 根据多个字典code查询多个字典项
* @param dictCodeList
* @return key = dictCode ； value=对应的字典项
*/
Map<String, List<DictModel>> getManyDictItems(List<String> dictCodeList);
/**
* 【JSearchSelectTag下拉搜索组件专用接口】
* 大数据量的字典表 走异步加载 即前端输入内容过滤数据
*
* @param dictCode 字典code格式：table,text,code
* @param keyword 过滤关键字
* @param pageSize 分页条数
* @return
*/
List<DictModel> loadDictItemByKeyword(String dictCode, String keyword, Integer pageNo, Integer pageSize);
/**
* 新增数据日志
* @param dataLogDto
*/
void saveDataLog(DataLogDTO dataLogDto);
/**
* 更新头像
* @param loginUser
*/
void updateAvatar(LoginUser loginUser);
/**
* 向app端 websocket推送聊天刷新消息
* @param userId
*/
void sendAppChatSocket(String userId);
/**
* 根据角色id查询角色code
* @param id
* @return
*/
String getRoleCodeById(String id);
/**
* 根据roleCode查询角色信息，可逗号分隔多个
*
* @param roleCodes
* @return
*/
List<DictModel> queryRoleDictByCode(String roleCodes);
/**
* 根据部门ID查询用户ID
* @param deptIds
* @return
*/
List<String> queryUserIdsByDeptIds(List<String> deptIds);
/**
* 根据用户ID查询用户名称
* @param userIds
* @return
*/
List<String> queryUsernameByIds(List<String> userIds);
/**
* 根据部门ID查询部门及其子部门下用户ID <br/>
* @param deptIds
* @return
*/
List<String> queryUserIdsByCascadeDeptIds(List<String> deptIds);
/**
* 根据部门ID查询用户账号
* @param deptIds
* @return
*/
List<String> queryUserAccountsByDeptIds(List<String> deptIds);
/**
* 根据角色编码 查询用户ID
* @param roleCodes
* @return
*/
List<String> queryUserIdsByRoleds(List<String> roleCodes);
/**
* 根据部门岗位ID查询用户
* @param deptPostIds
* @return
*/
public List<String> queryUserIdsByDeptPostIds(List<String> deptPostIds);
/**
* 根据主岗位和兼职岗位ID查询用户ID
* @param departPositIds
* @return
*/
List<String> queryUsernameByDepartPositIds(List<String> departPositIds);
/**
* 根据职位ID查询用户信息（老方法）
* @param positionIds
* @return
*/
public List<String> queryUserIdsByPositionIds(List<String> positionIds);
/**
* 根据部门和子部门下的所有用户账号
*
* @param orgCode 部门编码
* @return
*/
public List<String> getUserAccountsByDepCode(String orgCode);
/**
* 检查查询sql的表和字段是否在白名单中
*
* @param selectSql
* @return
*/
boolean dictTableWhiteListCheckBySql(String selectSql);
/**
* 根据字典表或者字典编码，校验是否在白名单中
*
* @param tableOrDictCode 表名或dictCode
* @param fields 如果传的是dictCode，则该参数必须传null
* @return
*/
boolean dictTableWhiteListCheckByDict(String tableOrDictCode, String... fields);
/**
* 消息自动发布
* @param dataId
* @param currentUserName
*/
void announcementAutoRelease(String dataId, String currentUserName);
/**
* 根据部门编码查询公司信息
* @param orgCode 部门编码
* @return
* @author chenrui
* @date 2025/8/12 14:53
*/
SysDepartModel queryCompByOrgCode(@RequestParam(name = "sysCode") String orgCode);
/**
* 根据部门编码和层次查询上级公司
*
* @param orgCode 部门编码
* @param level 可以传空 默认为1级 最小值为1
* @return
*/
SysDepartModel queryCompByOrgCodeAndLevel(String orgCode, Integer level);
/**
* 16 运行AIRag流程
* for [QQYUN-13634]在baseapi里面封装方法，方便其他模块调用
*
* @param airagFlowDTO
* @return 流程执行结果,可能是String或者Map
* @author chenrui
* @date 2025/9/2 11:43
*/
Object runAiragFlow(AiragFlowDTO airagFlowDTO);
/**
* 根据部门code或部门id获取部门名称(当前和上级部门)
*
* @param orgCode 部门编码
* @param depId 部门id
* @return String 部门名称
*/
String getDepartPathNameByOrgCode(String orgCode, String depId);
/**
* 根据用户信息推送PUSH消息
*
* @param pushMessageDTO 推送消息
*/
void uniPushMsgToUser(PushMessageDTO pushMessageDTO);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-local-api/src/main/java/org/jeecg/common/online/api/IOnlineBaseExtApi.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-local-api/src/main/java/org/jeecg/common/online/api/IOnlineBaseExtApi.java | package org.jeecg.common.online.api;
import com.alibaba.fastjson.JSONObject;
import org.jeecg.common.system.vo.DictModel;
import java.util.List;
import java.util.Map;
/**
* 表单设计器【Online】翻译API接口
*
* @author sunjianlei
*/
public interface IOnlineBaseExtApi {
/**
* 【Online】 表单设计器专用：同步新增
* @param tableName 表名
* @param jsonObject
* @throws Exception
* @return String
*/
String cgformPostCrazyForm(String tableName, JSONObject jsonObject) throws Exception;
/**
* 【Online】 表单设计器专用：同步编辑
* @param tableName 表名
* @param jsonObject
* @throws Exception
* @return String
*/
String cgformPutCrazyForm(String tableName, JSONObject jsonObject) throws Exception;
/**
* online表单删除数据
*
* @param cgformCode Online表单code
* @param dataIds 数据ID，可逗号分割
* @return
*/
String cgformDeleteDataByCode(String cgformCode, String dataIds);
/**
* 通过online表名查询数据，同时查询出子表的数据
*
* @param tableName online表名
* @param dataIds online数据ID
* @return
*/
JSONObject cgformQueryAllDataByTableName(String tableName, String dataIds);
/**
* 对 cgreportGetData 的返回值做优化，封装 DictModel 集合
* @param code
* @param dictCode
* @param dataList
* @param dictText 字典文本
* @return
*/
List<DictModel> cgreportGetDataPackage(String code, String dictText, String dictCode, String dataList);
/**
* 【cgreport】通过 head code 获取 sql语句，并执行该语句返回查询数据
*
* @param code 报表Code，如果没传ID就通过code查
* @param forceKey
* @param dataList
* @return
*/
Map<String, Object> cgreportGetData(String code, String forceKey, String dataList);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/system/api/ISysBaseAPI.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/system/api/ISysBaseAPI.java | package org.jeecg.common.system.api;
import com.alibaba.fastjson.JSONObject;
import org.jeecg.common.api.CommonAPI;
import org.jeecg.common.api.dto.AiragFlowDTO;
import org.jeecg.common.api.dto.DataLogDTO;
import org.jeecg.common.api.dto.OnlineAuthDTO;
import org.jeecg.common.api.dto.PushMessageDTO;
import org.jeecg.common.api.dto.message.*;
import org.jeecg.common.constant.ServiceNameConstants;
import org.jeecg.common.constant.enums.DySmsEnum;
import org.jeecg.common.constant.enums.EmailTemplateEnum;
import org.jeecg.common.desensitization.annotation.SensitiveDecode;
import org.jeecg.common.system.api.factory.SysBaseAPIFallbackFactory;
import org.jeecg.common.system.vo.*;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
*
* 1、cloud接口数量43 local：35 common：9 额外一个特殊queryAllRole一个当两个用
* - 相比较local版
* - 去掉了一些方法：addLog、getDatabaseType、queryAllDepart、queryAllUser(Wrapper wrapper)、queryAllUser(String[] userIds, int pageNo, int pageSize)
* - 修改了一些方法：createLog、sendSysAnnouncement（只保留了一个，其余全部干掉）
* 2、@ConditionalOnMissingClass("org.jeecg.modules.system.service.impl.SysBaseApiImpl")=> 有实现类的时候，不实例化Feign接口
* @author: jeecg-boot
*/
@Component
@FeignClient(contextId = "sysBaseRemoteApi", value = ServiceNameConstants.SERVICE_SYSTEM, fallbackFactory = SysBaseAPIFallbackFactory.class)
@ConditionalOnMissingClass("org.jeecg.modules.system.service.impl.SysBaseApiImpl")
public interface ISysBaseAPI extends CommonAPI {
/**
* 1发送系统消息
* @param message 使用构造器赋值参数 如果不设置category(消息类型)则默认为2 发送系统消息
*/
@PostMapping("/sys/api/sendSysAnnouncement")
void sendSysAnnouncement(@RequestBody MessageDTO message);
/**
* 2发送消息 附带业务参数
* @param message 使用构造器赋值参数
*/
@PostMapping("/sys/api/sendBusAnnouncement")
void sendBusAnnouncement(@RequestBody BusMessageDTO message);
/**
* 3通过模板发送消息
* @param message 使用构造器赋值参数
*/
@PostMapping("/sys/api/sendTemplateAnnouncement")
void sendTemplateAnnouncement(@RequestBody TemplateMessageDTO message);
/**
* 4通过模板发送消息 附带业务参数
* @param message 使用构造器赋值参数
*/
@PostMapping("/sys/api/sendBusTemplateAnnouncement")
void sendBusTemplateAnnouncement(@RequestBody BusTemplateMessageDTO message);
/**
* 5通过消息中心模板，生成推送内容
* @param templateDTO 使用构造器赋值参数
* @return
*/
@PostMapping("/sys/api/parseTemplateByCode")
String parseTemplateByCode(@RequestBody TemplateDTO templateDTO);
/**
* 6根据用户id查询用户信息
* @param id
* @return
*/
@SensitiveDecode
@GetMapping("/sys/api/getUserById")
LoginUser getUserById(@RequestParam("id") String id);
/**
* 7通过用户账号查询角色集合
* @param username
* @return
*/
@GetMapping("/sys/api/getRolesByUsername")
List<String> getRolesByUsername(@RequestParam("username") String username);
/**
* 7通过用户账号查询角色集合
* @param userId
* @return
*/
@GetMapping("/sys/api/getRolesByUserId")
List<String> getRolesByUserId(@RequestParam("userId") String userId);
/**
* 8通过用户账号查询部门集合
* @param username
* @return 部门 id
*/
@GetMapping("/sys/api/getDepartIdsByUsername")
List<String> getDepartIdsByUsername(@RequestParam("username") String username);
/**
* 8通过用户账号查询部门集合
* @param userId
* @return 部门 id
*/
@GetMapping("/sys/api/getDepartIdsByUserId")
List<String> getDepartIdsByUserId(@RequestParam("userId") String userId);
/**
* 8.2 通过用户账号查询部门父ID集合
* @param username
* @return 部门 parentIds
*/
@GetMapping("/sys/api/getDepartParentIdsByUsername")
Set<String> getDepartParentIdsByUsername(@RequestParam("username")String username);
/**
* 8.3 查询部门父ID集合
* @param depIds
* @return 部门 parentIds
*/
@GetMapping("/sys/api/getDepartParentIdsByDepIds")
Set<String> getDepartParentIdsByDepIds(@RequestParam("depIds") Set<String> depIds);
/**
* 9通过用户账号查询部门 name
* @param username
* @return 部门 name
*/
@GetMapping("/sys/api/getDepartNamesByUsername")
List<String> getDepartNamesByUsername(@RequestParam("username") String username);
/**
* 10获取数据字典
* @param code
* @return
*/
@Override
@GetMapping("/sys/api/queryDictItemsByCode")
List<DictModel> queryDictItemsByCode(@RequestParam("code") String code);
/**
* 获取有效的数据字典项
* @param code
* @return
*/
@Override
@GetMapping("/sys/api/queryEnableDictItemsByCode")
public List<DictModel> queryEnableDictItemsByCode(@RequestParam("code") String code);
/** 11查询所有的父级字典，按照create_time排序
* @return List<DictModel> 字典值集合
*/
@GetMapping("/sys/api/queryAllDict")
List<DictModel> queryAllDict();
/**
* 12查询所有分类字典
* @return
*/
@GetMapping("/sys/api/queryAllSysCategory")
List<SysCategoryModel> queryAllSysCategory();
/**
* 13获取表数据字典
* @param tableFilterSql
* @param text
* @param code
* @return
*/
@Override
@GetMapping("/sys/api/queryTableDictItemsByCode")
List<DictModel> queryTableDictItemsByCode(@RequestParam("tableFilterSql") String tableFilterSql, @RequestParam("text") String text, @RequestParam("code") String code);
/**
* 14查询所有部门 作为字典信息 id -->value,departName -->text
* @return
*/
@GetMapping("/sys/api/queryAllDepartBackDictModel")
List<DictModel> queryAllDepartBackDictModel();
/**
* 15根据业务类型 busType 及业务 busId 修改消息已读
* @param busType 业务类型
* @param busId 业务id
*/
@GetMapping("/sys/api/updateSysAnnounReadFlag")
public void updateSysAnnounReadFlag(@RequestParam("busType") String busType, @RequestParam("busId")String busId);
/**
* 16查询表字典 支持过滤数据
* @param table
* @param text
* @param code
* @param filterSql
* @return
*/
@GetMapping("/sys/api/queryFilterTableDictInfo")
List<DictModel> queryFilterTableDictInfo(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("filterSql") String filterSql);
/**
* 17查询指定table的 text code 获取字典，包含text和value
* @param table
* @param text
* @param code
* @param keyArray
* @return
*/
@Deprecated
@GetMapping("/sys/api/queryTableDictByKeys")
public List<String> queryTableDictByKeys(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("keyArray") String[] keyArray);
/**
* 18查询所有用户 返回ComboModel
* @return
*/
@GetMapping("/sys/api/queryAllUserBackCombo")
public List<ComboModel> queryAllUserBackCombo();
/**
* 19分页查询用户 返回JSONObject
* @param userIds 多个用户id
* @param pageNo 当前页数
* @param pageSize 每页条数
* @return
*/
@GetMapping("/sys/api/queryAllUser")
public JSONObject queryAllUser(@RequestParam(name="userIds",required=false)String userIds, @RequestParam(name="pageNo",required=false) Integer pageNo,@RequestParam(name="pageSize",required=false) Integer pageSize);
/**
* 20获取所有角色 带参
* @param roleIds 默认选中角色
* @return
*/
@GetMapping("/sys/api/queryAllRole")
public List<ComboModel> queryAllRole(@RequestParam(name = "roleIds",required = false)String[] roleIds);
/**
* 21通过用户账号查询角色Id集合
* @param username
* @return
*/
@GetMapping("/sys/api/getRoleIdsByUsername")
public List<String> getRoleIdsByUsername(@RequestParam("username")String username);
/**
* 22通过部门编号查询部门id
* @param orgCode
* @return
*/
@GetMapping("/sys/api/getDepartIdsByOrgCode")
public String getDepartIdsByOrgCode(@RequestParam("orgCode")String orgCode);
/**
* 23查询所有部门
* @return
*/
@GetMapping("/sys/api/getAllSysDepart")
public List<SysDepartModel> getAllSysDepart();
/**
* 24查找父级部门
* @param departId
* @return
*/
@GetMapping("/sys/api/getParentDepartId")
DictModel getParentDepartId(@RequestParam("departId")String departId);
/**
* 25根据部门Id获取部门负责人
* @param deptId
* @return
*/
@GetMapping("/sys/api/getDeptHeadByDepId")
public List<String> getDeptHeadByDepId(@RequestParam("deptId") String deptId);
/**
* 26给指定用户发消息
* @param userIds
* @param cmd
*/
@GetMapping("/sys/api/sendWebSocketMsg")
public void sendWebSocketMsg(@RequestParam("userIds")String[] userIds, @RequestParam("cmd") String cmd);
/**
* 27根据id获取所有参与用户
* @param userIds 多个用户id
* @return
*/
@GetMapping("/sys/api/queryAllUserByIds")
public List<UserAccountInfo> queryAllUserByIds(@RequestParam("userIds") String[] userIds);
/**
* 28将会议签到信息推动到预览
* userIds
* @return
* @param userId
*/
@GetMapping("/sys/api/meetingSignWebsocket")
void meetingSignWebsocket(@RequestParam("userId")String userId);
/**
* 29根据name获取所有参与用户
* @param userNames 多个用户账号
* @return
*/
@GetMapping("/sys/api/queryUserByNames")
List<UserAccountInfo> queryUserByNames(@RequestParam("userNames")String[] userNames);
/**
* 30获取用户的角色集合
* @param username
* @return
*/
@GetMapping("/sys/api/getUserRoleSet")
Set<String> getUserRoleSet(@RequestParam("username")String username);
/**
* 30获取用户的角色集合
* @param userId
* @return
*/
@GetMapping("/sys/api/getUserRoleSetById")
Set<String> getUserRoleSetById(@RequestParam("userId")String userId);
/**
* 31获取用户的权限集合
* @param userId
* @return
*/
@GetMapping("/sys/api/getUserPermissionSet")
Set<String> getUserPermissionSet(@RequestParam("userId") String userId);
/**
* 32判断是否有online访问的权限
* @param onlineAuthDTO
* @return
*/
@PostMapping("/sys/api/hasOnlineAuth")
boolean hasOnlineAuth(@RequestBody OnlineAuthDTO onlineAuthDTO);
/**
* 33通过部门id获取部门全部信息
* @param id 部门id
* @return SysDepartModel 部门信息
*/
@GetMapping("/sys/api/selectAllById")
SysDepartModel selectAllById(@RequestParam("id") String id);
/**
* 34根据用户id查询用户所属公司下所有用户ids
* @param userId
* @return
*/
@GetMapping("/sys/api/queryDeptUsersByUserId")
List<String> queryDeptUsersByUserId(@RequestParam("userId") String userId);
//---
/**
* 35查询用户角色信息
* @param username
* @return
*/
@Override
@GetMapping("/sys/api/queryUserRoles")
Set<String> queryUserRoles(@RequestParam("username")String username);
/**
* 35查询用户角色信息
* @param userId
* @return
*/
@Override
@GetMapping("/sys/api/queryUserRolesById")
Set<String> queryUserRolesById(@RequestParam("userId")String userId);
/**
* 36查询用户权限信息
* @param userId
* @return
*/
@Override
@GetMapping("/sys/api/queryUserAuths")
Set<String> queryUserAuths(@RequestParam("userId")String userId);
/**
* 37根据 id 查询数据库中存储的 DynamicDataSourceModel
*
* @param dbSourceId
* @return
*/
@Override
@GetMapping("/sys/api/getDynamicDbSourceById")
DynamicDataSourceModel getDynamicDbSourceById(@RequestParam("dbSourceId") String dbSourceId);
/**
* 38根据 code 查询数据库中存储的 DynamicDataSourceModel
*
* @param dbSourceCode
* @return
*/
@Override
@GetMapping("/sys/api/getDynamicDbSourceByCode")
DynamicDataSourceModel getDynamicDbSourceByCode(@RequestParam("dbSourceCode") String dbSourceCode);
/**
* 39根据用户账号查询用户信息 CommonAPI中定义
* @param username
* @return LoginUser 用户信息
*/
@Override
@SensitiveDecode
@GetMapping("/sys/api/getUserByName")
LoginUser getUserByName(@RequestParam("username") String username);
/**
* 39根据用户账号查询用户ID CommonAPI中定义
* @param username
* @return 用户ID
*/
@Override
@GetMapping("/sys/api/getUserIdByName")
String getUserIdByName(@RequestParam("username") String username);
/**
* 40字典表的 翻译
* @param table
* @param text
* @param code
* @param key
* @return
*/
@Override
@GetMapping("/sys/api/translateDictFromTable")
String translateDictFromTable(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("key") String key);
/**
* 41普通字典的翻译
* @param code
* @param key
* @return
*/
@Override
@GetMapping("/sys/api/translateDict")
String translateDict(@RequestParam("code") String code, @RequestParam("key") String key);
/**
* 42查询数据权限
* @param component
* @param requestPath
* @param username 用户姓名
* @return
*/
@Override
@GetMapping("/sys/api/queryPermissionDataRule")
List<SysPermissionDataRuleModel> queryPermissionDataRule(@RequestParam("component") String component, @RequestParam("requestPath")String requestPath, @RequestParam("username") String username);
/**
* 43查询用户信息
* @param username
* @return
*/
@Override
@GetMapping("/sys/api/getCacheUser")
SysUserCacheInfo getCacheUser(@RequestParam("username") String username);
/**
* 36根据多个用户账号(逗号分隔)，查询返回多个用户信息
* @param usernames
* @return
*/
@GetMapping("/sys/api/queryUsersByUsernames")
List<JSONObject> queryUsersByUsernames(@RequestParam("usernames") String usernames);
/**
* 37根据多个用户ID(逗号分隔)，查询返回多个用户信息
* @param ids
* @return
*/
@RequestMapping("/sys/api/queryUsersByIds")
List<JSONObject> queryUsersByIds(@RequestParam("ids") String ids);
/**
* 38根据多个部门编码(逗号分隔)，查询返回多个部门信息
* @param orgCodes
* @return
*/
@RequestMapping("/sys/api/queryDepartsByOrgcodes")
List<JSONObject> queryDepartsByOrgcodes(@RequestParam("orgCodes") String orgCodes);
// /**
// * 39根据多个部门编码(逗号分隔)，查询返回多个部门信息
// * @param ids
// * @return
// */
// @GetMapping("/sys/api/queryDepartsByOrgIds")
// List<JSONObject> queryDepartsByOrgIds(@RequestParam("ids") String ids);
/**
* 40发送邮件消息
* @param email
* @param title
* @param content
*/
@GetMapping("/sys/api/sendEmailMsg")
void sendEmailMsg(@RequestParam("email")String email,@RequestParam("title")String title,@RequestParam("content")String content);
/**
* 发送html模版邮件消息
*
* @param email
* @param title
* @param emailTemplateEnum 邮件模版枚举
* @param params 模版参数
*/
@GetMapping("/sys/api/sendHtmlTemplateEmail")
void sendHtmlTemplateEmail(@RequestParam("email") String email, @RequestParam("title") String title, @RequestParam("emailEnum") EmailTemplateEnum emailTemplateEnum, @RequestParam("params") JSONObject params);
/**
/**
* 发送短信消息
*
* @param phone 手机号码
* @param params 模版参数
* @param dySmsEnum 短信模版枚举
*/
@GetMapping("/sys/api/sendSmsMsg")
void sendSmsMsg(@RequestParam("phone") String phone, @RequestParam("params") JSONObject params,@RequestParam("dySmsEnum") DySmsEnum dySmsEnum);
/**
* 41 获取公司下级部门和公司下所有用户id
* @param orgCode 部门编号
* @return List<Map>
*/
@GetMapping("/sys/api/getDeptUserByOrgCode")
List<Map> getDeptUserByOrgCode(@RequestParam("orgCode")String orgCode);
/**
* 42 查询分类字典翻译
* @param ids 多个分类字典id
* @return List<String>
*/
@GetMapping("/sys/api/loadCategoryDictItem")
List<String> loadCategoryDictItem(@RequestParam("ids") String ids);
/**
* 44 反向翻译分类字典，用于导入
*
* @param names 名称，逗号分割
*/
@GetMapping("/sys/api/loadCategoryDictItemByNames")
List<String> loadCategoryDictItemByNames(@RequestParam("names") String names, @RequestParam("delNotExist") boolean delNotExist);
/**
* 43 根据字典code加载字典text
*
* @param dictCode 顺序：tableName,text,code
* @param keys 要查询的key
* @return
*/
@GetMapping("/sys/api/loadDictItem")
List<String> loadDictItem(@RequestParam("dictCode") String dictCode, @RequestParam("keys") String keys);
/**
* 复制应用下的所有字典配置到新的租户下
*
* @param originalAppId 原始低代码应用ID
* @param appId 新的低代码应用ID
* @param tenantId 新的租户ID
* @return Map<String, String> Map<原字典编码, 新字典编码>
*/
@GetMapping("/sys/api/copyLowAppDict")
Map<String, String> copyLowAppDict(@RequestParam("originalAppId") String originalAppId, @RequestParam("appId") String appId, @RequestParam("tenantId") String tenantId);
/**
* 44 根据字典code查询字典项
*
* @param dictCode 顺序：tableName,text,code
* @param dictCode 要查询的key
* @return
*/
@GetMapping("/sys/api/getDictItems")
List<DictModel> getDictItems(@RequestParam("dictCode") String dictCode);
/**
* 45 根据多个字典code查询多个字典项
*
* @param dictCodeList
* @return key = dictCode ； value=对应的字典项
*/
@RequestMapping("/sys/api/getManyDictItems")
Map<String, List<DictModel>> getManyDictItems(@RequestParam("dictCodeList") List<String> dictCodeList);
/**
* 46 【JSearchSelectTag下拉搜索组件专用接口】
* 大数据量的字典表 走异步加载 即前端输入内容过滤数据
*
* @param dictCode 字典code格式：table,text,code
* @param keyword 过滤关键字
* @param pageSize 每页条数
* @return
*/
@GetMapping("/sys/api/loadDictItemByKeyword")
List<DictModel> loadDictItemByKeyword(@RequestParam("dictCode") String dictCode, @RequestParam("keyword") String keyword, @RequestParam(value = "pageNo", defaultValue = "1", required = false) Integer pageNo, @RequestParam(value = "pageSize", required = false) Integer pageSize);
/**
* 47 根据多个部门id(逗号分隔)，查询返回多个部门信息
* @param ids
* @return
*/
@GetMapping("/sys/api/queryDepartsByIds")
List<JSONObject> queryDepartsByIds(@RequestParam("ids") String ids);
/**
* 48 普通字典的翻译，根据多个dictCode和多条数据，多个以逗号分割
* @param dictCodes
* @param keys
* @return
*/
@Override
@GetMapping("/sys/api/translateManyDict")
Map<String, List<DictModel>> translateManyDict(@RequestParam("dictCodes") String dictCodes, @RequestParam("keys") String keys);
/**
* 49 字典表的 翻译，可批量
* @param table
* @param text
* @param code
* @param keys 多个用逗号分割
* @param ds
* @return
*/
@Override
@GetMapping("/sys/api/translateDictFromTableByKeys")
List<DictModel> translateDictFromTableByKeys(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("keys") String keys, @RequestParam("ds") String ds);
/**
* 发送模板消息
*/
@PostMapping("/sys/api/sendTemplateMessage")
void sendTemplateMessage(@RequestBody MessageDTO message);
/**
* 获取模板内容
* @param code
* @return
*/
@GetMapping("/sys/api/getTemplateContent")
String getTemplateContent(@RequestParam("code") String code);
/**
* 新增数据日志
* @param dataLogDto
*/
@PostMapping("/sys/api/saveDataLog")
void saveDataLog(@RequestBody DataLogDTO dataLogDto);
/**
* 更新头像
* @param loginUser
* @return
*/
@PutMapping("/sys/api/updateAvatar")
void updateAvatar(@RequestBody LoginUser loginUser);
@GetMapping("/sys/api/sendAppChatSocket")
void sendAppChatSocket(@RequestParam(name="userId") String userId);
/**
* 根据角色id查询角色code
* @param id
* @return
*/
@GetMapping("/sys/api/getRoleCode")
String getRoleCodeById(@RequestParam(name = "id") String id);
/**
* 根据roleCode查询角色信息，可逗号分隔多个
*
* @param roleCodes
* @return
*/
@GetMapping("/sys/api/queryRoleDictByCode")
List<DictModel> queryRoleDictByCode(@RequestParam(name = "roleCodes") String roleCodes);
/**
* 根据高级查询条件查询用户
* @param superQuery
* @param matchType
* @return
*/
@GetMapping("/sys/api/queryUserBySuperQuery")
List<JSONObject> queryUserBySuperQuery(@RequestParam(name="superQuery")String superQuery,@RequestParam(name="matchType")String matchType);
/**
* 根据ID条件查询用户
* @param id
* @return JSONObject
*/
@GetMapping("/sys/api/queryUserById")
JSONObject queryUserById(@RequestParam(name="id") String id);
/**
* 根据高级查询条件查询部门
* @param superQuery
* @param matchType
* @return
*/
@GetMapping("/sys/api/queryDeptBySuperQuery")
List<JSONObject> queryDeptBySuperQuery(@RequestParam(name="superQuery")String superQuery,@RequestParam(name="matchType")String matchType);
/**
* 根据高级查询条件查询角色
* @param superQuery
* @param matchType
* @return
*/
@GetMapping("/sys/api/queryRoleBySuperQuery")
List<JSONObject> queryRoleBySuperQuery(@RequestParam(name="superQuery")String superQuery,@RequestParam(name="matchType")String matchType);
/**
* 根据租户ID查询用户ID
* @param tenantId 租户ID
* @return List<String>
*/
@GetMapping("/sys/api/selectUserIdByTenantId")
List<String> selectUserIdByTenantId(@RequestParam("tenantId")String tenantId);
/**
* 根据部门ID查询用户ID
* @param deptIds
* @return
*/
@GetMapping("/sys/api/queryUserIdsByDeptIds")
List<String> queryUserIdsByDeptIds(@RequestParam("deptIds") List<String> deptIds);
/**
* 根据部门ID查询用户账号
* @param deptIds
* @return
*/
@GetMapping("/sys/api/queryUserAccountsByDeptIds")
List<String> queryUserAccountsByDeptIds(@RequestParam("deptIds") List<String> deptIds);
/**
* 根据角色编码 查询用户ID
* @param roleCodes
* @return
*/
@GetMapping("/sys/api/queryUserIdsByRoleds")
List<String> queryUserIdsByRoleds(@RequestParam("roleCodes") List<String> roleCodes);
/**
* 根据用户ID查询用户名称
* @param userIds
* @return
*/
@GetMapping("/sys/api/queryUsernameByIds")
List<String> queryUsernameByIds(@RequestParam("userIds") List<String> userIds);
/**
* 根据部门岗位ID查询用户ID
* @param deptPostIds
* @return
*/
@GetMapping("/sys/api/queryUserIdsByDeptPostIds")
public List<String> queryUserIdsByDeptPostIds(@RequestParam("deptPostIds") List<String> deptPostIds);
/**
* 根据部门主岗位和兼职岗位，查询用户账号
* @param positionIds
* @return
*/
@GetMapping("/sys/api/queryUsernameByDepartPositIds")
List<String> queryUsernameByDepartPositIds(@RequestParam("departPositIds") List<String> positionIds);
/**
* 根据职务ID查询用户账号
* @param positionIds
* @return
*/
@GetMapping("/sys/api/queryUserIdsByPositionIds")
List<String> queryUserIdsByPositionIds(@RequestParam("positionIds") List<String> positionIds);
/**
* 根据部门和子部门下的所有用户账号
*
* @param orgCode 部门编码
* @return
*/
@GetMapping("/sys/api/getUserAccountsByDepCode")
public List<String> getUserAccountsByDepCode(@RequestParam("orgCode")String orgCode);
/**
* 检查查询sql的表和字段是否在白名单中
*
* @param selectSql
* @return
*/
@GetMapping("/sys/api/dictTableWhiteListCheckBySql")
boolean dictTableWhiteListCheckBySql(@RequestParam("selectSql") String selectSql);
/**
* 根据字典表或者字典编码，校验是否在白名单中
*
* @param tableOrDictCode 表名或dictCode
* @param fields 如果传的是dictCode，则该参数必须传null
* @return
*/
@GetMapping("/sys/api/dictTableWhiteListCheckByDict")
boolean dictTableWhiteListCheckByDict(
@RequestParam("tableOrDictCode") String tableOrDictCode,
@RequestParam(value = "fields", required = false) String... fields
);
/**
* 自动发布通告
*
* @param dataId 通告ID
* @param currentUserName 发送人
* @return
*/
@GetMapping("/sys/api/announcementAutoRelease")
void announcementAutoRelease(
@RequestParam("dataId") String dataId,
@RequestParam(value = "currentUserName") String currentUserName
);
/**
* 根据部门编码查询公司信息
* @param orgCode 部门编码
* @return
* @author chenrui
* @date 2025/8/12 14:45
*/
@GetMapping(value = "/sys/api/queryCompByOrgCode")
SysDepartModel queryCompByOrgCode(@RequestParam(name = "sysCode") String orgCode);
/**
* 根据部门编码和层次查询上级公司
*
* @param orgCode 部门编码
* @param level 可以传空 默认为1级 最小值为1
* @return
*/
@GetMapping(value = "/sys/api/queryCompByOrgCodeAndLevel")
SysDepartModel queryCompByOrgCodeAndLevel(@RequestParam("orgCode") String orgCode, @RequestParam("level") Integer level);
/**
* 16 运行AIRag流程
* for [QQYUN-13634]在baseapi里面封装方法，方便其他模块调用
*
* @param airagFlowDTO
* @return 流程执行结果,可能是String或者Map
* @author chenrui
* @date 2025/9/2 11:43
*/
@PostMapping(value = "/sys/api/runAiragFlow")
Object runAiragFlow(@RequestBody AiragFlowDTO airagFlowDTO);
/**
* 根据部门code或部门id获取部门名称(当前和上级部门)
*
* @param orgCode 部门编码
* @param depId 部门id
* @return String 部门名称
*/
@GetMapping("/getDepartPathNameByOrgCode")
String getDepartPathNameByOrgCode(@RequestParam(name = "orgCode", required = false) String orgCode, @RequestParam(name = "depId", required = false) String depId);
/**
* 根据部门ID查询部门及其子部门下用户ID <br/>
* @param deptIds
* @return
* @author chenrui
* @date 2025/09/08 15:28
*/
@GetMapping("/sys/api/queryUserIdsByCascadeDeptIds")
List<String> queryUserIdsByCascadeDeptIds(@RequestParam("deptIds") List<String> deptIds);
/**
* 根据用户信息推送移动端Push消息
* @param pushMessageDTO
* @return
*/
@PostMapping("/sys/api/uniPushMsgToUser")
void uniPushMsgToUser(@RequestBody PushMessageDTO pushMessageDTO);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/system/api/fallback/SysBaseAPIFallback.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/system/api/fallback/SysBaseAPIFallback.java | package org.jeecg.common.system.api.fallback;
import com.alibaba.fastjson.JSONObject;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.dto.AiragFlowDTO;
import org.jeecg.common.api.dto.DataLogDTO;
import org.jeecg.common.api.dto.OnlineAuthDTO;
import org.jeecg.common.api.dto.PushMessageDTO;
import org.jeecg.common.api.dto.message.*;
import org.jeecg.common.constant.enums.DySmsEnum;
import org.jeecg.common.constant.enums.EmailTemplateEnum;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.vo.*;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 进入fallback的方法 检查是否token未设置
* @author: jeecg-boot
*/
@Slf4j
public class SysBaseAPIFallback implements ISysBaseAPI {
@Setter
private Throwable cause;
@Override
public void sendSysAnnouncement(MessageDTO message) {
log.error("发送消息失败 {}", cause);
}
@Override
public void sendBusAnnouncement(BusMessageDTO message) {
log.error("发送消息失败 {}", cause);
}
@Override
public void sendTemplateAnnouncement(TemplateMessageDTO message) {
log.error("发送消息失败 {}", cause);
}
@Override
public void sendBusTemplateAnnouncement(BusTemplateMessageDTO message) {
log.error("发送消息失败 {}", cause);
}
@Override
public String parseTemplateByCode(TemplateDTO templateDTO) {
log.error("通过模板获取消息内容失败 {}", cause);
return null;
}
@Override
public LoginUser getUserById(String id) {
return null;
}
@Override
public List<String> getRolesByUsername(String username) {
return null;
}
@Override
public List<String> getRolesByUserId(String userId) {
return null;
}
@Override
public List<String> getDepartIdsByUsername(String username) {
return null;
}
@Override
public List<String> getDepartIdsByUserId(String userId) {
return null;
}
@Override
public Set<String> getDepartParentIdsByUsername(String username) {
return null;
}
@Override
public Set<String> getDepartParentIdsByDepIds(Set<String> depIds) {
return null;
}
@Override
public List<String> getDepartNamesByUsername(String username) {
return null;
}
@Override
public List<DictModel> queryDictItemsByCode(String code) {
return null;
}
@Override
public List<DictModel> queryEnableDictItemsByCode(String code) {
return null;
}
@Override
public List<DictModel> queryAllDict() {
log.error("fegin接口queryAllDict失败："+cause.getMessage(), cause);
return null;
}
@Override
public List<SysCategoryModel> queryAllSysCategory() {
return null;
}
@Override
public List<DictModel> queryTableDictItemsByCode(String tableFilterSql, String text, String code) {
return null;
}
@Override
public List<DictModel> queryAllDepartBackDictModel() {
return null;
}
@Override
public void updateSysAnnounReadFlag(String busType, String busId) {
}
@Override
public List<DictModel> queryFilterTableDictInfo(String table, String text, String code, String filterSql) {
return null;
}
@Override
public List<String> queryTableDictByKeys(String table, String text, String code, String[] keyArray) {
log.error("queryTableDictByKeys查询失败 {}", cause);
return null;
}
@Override
public List<ComboModel> queryAllUserBackCombo() {
return null;
}
@Override
public JSONObject queryAllUser(String userIds, Integer pageNo, Integer pageSize) {
return null;
}
@Override
public List<ComboModel> queryAllRole(String[] roleIds) {
log.error("获取角色信息失败 {}", cause);
return null;
}
@Override
public List<String> getRoleIdsByUsername(String username) {
return null;
}
@Override
public String getDepartIdsByOrgCode(String orgCode) {
return null;
}
@Override
public List<SysDepartModel> getAllSysDepart() {
return null;
}
@Override
public DictModel getParentDepartId(String departId) {
return null;
}
@Override
public List<String> getDeptHeadByDepId(String deptId) {
return null;
}
@Override
public void sendWebSocketMsg(String[] userIds, String cmd) {
}
@Override
public List<UserAccountInfo> queryAllUserByIds(String[] userIds) {
return null;
}
@Override
public void meetingSignWebsocket(String userId) {
}
@Override
public List<UserAccountInfo> queryUserByNames(String[] userNames) {
return null;
}
@Override
public Set<String> getUserRoleSet(String username) {
return null;
}
@Override
public Set<String> getUserRoleSetById(String userId) {
return null;
}
@Override
public Set<String> getUserPermissionSet(String userId) {
return null;
}
@Override
public boolean hasOnlineAuth(OnlineAuthDTO onlineAuthDTO) {
return false;
}
@Override
public SysDepartModel selectAllById(String id) {
return null;
}
@Override
public List<String> queryDeptUsersByUserId(String userId) {
return null;
}
@Override
public Set<String> queryUserRoles(String username) {
return null;
}
@Override
public Set<String> queryUserRolesById(String userId) {
return null;
}
@Override
public Set<String> queryUserAuths(String userId) {
return null;
}
@Override
public DynamicDataSourceModel getDynamicDbSourceById(String dbSourceId) {
return null;
}
@Override
public DynamicDataSourceModel getDynamicDbSourceByCode(String dbSourceCode) {
return null;
}
@Override
public LoginUser getUserByName(String username) {
log.error("jeecg-system服务节点不通，导致获取登录用户信息失败： " + cause.getMessage(), cause);
return null;
}
@Override
public String getUserIdByName(String username) {
return null;
}
@Override
public String translateDictFromTable(String table, String text, String code, String key) {
return null;
}
@Override
public String translateDict(String code, String key) {
return null;
}
@Override
public List<SysPermissionDataRuleModel> queryPermissionDataRule(String component, String requestPath, String username) {
return null;
}
@Override
public SysUserCacheInfo getCacheUser(String username) {
log.error("获取用户信息失败 {}", cause);
return null;
}
@Override
public List<JSONObject> queryUsersByUsernames(String usernames) {
return null;
}
@Override
public List<JSONObject> queryUsersByIds(String ids) {
return null;
}
@Override
public List<JSONObject> queryDepartsByOrgcodes(String orgCodes) {
return null;
}
@Override
public List<JSONObject> queryDepartsByIds(String ids) {
return null;
}
@Override
public Map<String, List<DictModel>> translateManyDict(String dictCodes, String keys) {
return null;
}
// 代码逻辑说明: [issues/#5643]解决分布式下表字典跨库无法查询问题------------
@Override
public List<DictModel> translateDictFromTableByKeys(String table, String text, String code, String keys, String dataSource) {
return null;
}
@Override
public void sendTemplateMessage(MessageDTO message) {
}
@Override
public String getTemplateContent(String code) {
return null;
}
@Override
public void saveDataLog(DataLogDTO dataLogDto) {
}
@Override
public void sendEmailMsg(String email,String title,String content) {
}
@Override
public void sendHtmlTemplateEmail(String email, String title, EmailTemplateEnum emailTemplateEnum, JSONObject params) {
}
@Override
public void sendSmsMsg(String phone, JSONObject params, DySmsEnum dySmsEnum) {
}
@Override
public List<Map> getDeptUserByOrgCode(String orgCode) {
return null;
}
// @Override
// public List<JSONObject> queryDepartsByOrgIds(String ids) {
// return null;
// }
@Override
public List<String> loadCategoryDictItem(String ids) {
return null;
}
@Override
public List<String> loadCategoryDictItemByNames(String names, boolean delNotExist) {
return null;
}
@Override
public List<String> loadDictItem(String dictCode, String keys) {
return null;
}
@Override
public Map<String, String> copyLowAppDict(String originalAppId, String appId, String tenantId) {
return null;
}
@Override
public List<DictModel> getDictItems(String dictCode) {
return null;
}
@Override
public Map<String, List<DictModel>> getManyDictItems(List<String> dictCodeList) {
return null;
}
@Override
public List<DictModel> loadDictItemByKeyword(String dictCode, String keyword, Integer pageNo, Integer pageSize) {
return null;
}
@Override
public void updateAvatar(LoginUser loginUser) { }
@Override
public void sendAppChatSocket(String userId) {
}
@Override
public String getRoleCodeById(String id) {
return null;
}
@Override
public List<DictModel> queryRoleDictByCode(String roleCodes) {
return null;
}
@Override
public List<JSONObject> queryUserBySuperQuery(String superQuery, String matchType) {
return null;
}
@Override
public JSONObject queryUserById(String id) {
return null;
}
@Override
public List<JSONObject> queryDeptBySuperQuery(String superQuery, String matchType) {
return null;
}
@Override
public List<JSONObject> queryRoleBySuperQuery(String superQuery, String matchType) {
return null;
}
@Override
public List<String> selectUserIdByTenantId(String tenantId) {
return null;
}
@Override
public List<String> queryUserIdsByDeptIds(List<String> deptIds) {
return null;
}
@Override
public List<String> queryUserIdsByDeptPostIds(List<String> deptPostIds) {
return List.of();
}
@Override
public List<String> queryUserAccountsByDeptIds(List<String> deptIds) {
return null;
}
@Override
public List<String> queryUserIdsByRoleds(List<String> roleCodes) {
return null;
}
@Override
public List<String> queryUsernameByIds(List<String> userIds) {
return List.of();
}
@Override
public List<String> queryUsernameByDepartPositIds(List<String> positionIds) {
return null;
}
@Override
public List<String> queryUserIdsByPositionIds(List<String> positionIds) {
return null;
}
@Override
public List<String> getUserAccountsByDepCode(String orgCode) {
return null;
}
@Override
public boolean dictTableWhiteListCheckBySql(String selectSql) {
return false;
}
@Override
public boolean dictTableWhiteListCheckByDict(String tableOrDictCode, String... fields) {
return false;
}
@Override
public void announcementAutoRelease(String dataId, String currentUserName) {
}
@Override
public SysDepartModel queryCompByOrgCode(String orgCode) {
return null;
}
@Override
public SysDepartModel queryCompByOrgCodeAndLevel(String orgCode, Integer level) {
return null;
}
@Override
public Object runAiragFlow(AiragFlowDTO airagFlowDTO) {
return null;
}
@Override
public void uniPushMsgToUser(PushMessageDTO pushMessageDTO) {
}
@Override
public String getDepartPathNameByOrgCode(String orgCode, String depId) {
return "";
}
@Override
public List<String> queryUserIdsByCascadeDeptIds(List<String> deptIds) {
return null;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/system/api/factory/SysBaseAPIFallbackFactory.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/system/api/factory/SysBaseAPIFallbackFactory.java | package org.jeecg.common.system.api.factory;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.api.fallback.SysBaseAPIFallback;
import org.springframework.stereotype.Component;
/**
* @Description: SysBaseAPIFallbackFactory
* @author: jeecg-boot
*/
@Component
public class SysBaseAPIFallbackFactory implements FallbackFactory<ISysBaseAPI> {
@Override
public ISysBaseAPI create(Throwable throwable) {
SysBaseAPIFallback fallback = new SysBaseAPIFallback();
fallback.setCause(throwable);
return fallback;
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/online/api/IOnlineBaseExtApi.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/online/api/IOnlineBaseExtApi.java | package org.jeecg.common.online.api;
import com.alibaba.fastjson.JSONObject;
import org.jeecg.common.constant.ServiceNameConstants;
import org.jeecg.common.online.api.factory.OnlineBaseExtApiFallbackFactory;
import org.jeecg.common.system.vo.DictModel;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* @Description: 【Online】Feign API接口
*
* @ConditionalOnMissingClass("org.jeecg.modules.online.cgform.service.impl.OnlineBaseExtApiImpl") => 有实现类的时候，不实例化Feign接口
* @author: jeecg-boot
*/
@Component
//@FeignClient(contextId = "onlineBaseRemoteApi", value = ServiceNameConstants.SERVICE_ONLINE, fallbackFactory = OnlineBaseExtApiFallbackFactory.class)
@FeignClient(contextId = "onlineBaseRemoteApi", value = ServiceNameConstants.SERVICE_SYSTEM, fallbackFactory = OnlineBaseExtApiFallbackFactory.class)
@ConditionalOnMissingClass("org.jeecg.modules.online.cgform.service.impl.OnlineBaseExtApiImpl")
public interface IOnlineBaseExtApi {
/**
* 【Online】 表单设计器专用：同步新增
* @param tableName 表名
* @param jsonObject
* @throws Exception
* @return String
*/
@PostMapping(value = "/online/api/cgform/crazyForm/{name}")
String cgformPostCrazyForm(@PathVariable("name") String tableName, @RequestBody JSONObject jsonObject) throws Exception;
/**
* 【Online】 表单设计器专用：同步编辑
* @param tableName 表名
* @param jsonObject
* @throws Exception
* @return String
*/
@PutMapping(value = "/online/api/cgform/crazyForm/{name}")
String cgformPutCrazyForm(@PathVariable("name") String tableName, @RequestBody JSONObject jsonObject) throws Exception;
/**
* 通过online表名查询数据，同时查询出子表的数据
*
* @param tableName online表名
* @param dataIds online数据ID
* @return
*/
@GetMapping(value = "/online/api/cgform/queryAllDataByTableName")
JSONObject cgformQueryAllDataByTableName(@RequestParam("tableName") String tableName, @RequestParam("dataIds") String dataIds);
/**
* online表单删除数据
*
* @param cgformCode Online表单code
* @param dataIds 数据ID，可逗号分割
* @return
*/
@DeleteMapping("/online/api/cgform/cgformDeleteDataByCode")
String cgformDeleteDataByCode(@RequestParam("cgformCode") String cgformCode, @RequestParam("dataIds") String dataIds);
/**
* 【cgreport】通过 head code 获取 sql语句，并执行该语句返回查询数据
*
* @param code 报表Code，如果没传ID就通过code查
* @param forceKey
* @param dataList
* @return
*/
@GetMapping("/online/api/cgreportGetData")
Map<String, Object> cgreportGetData(@RequestParam("code") String code, @RequestParam("forceKey") String forceKey, @RequestParam("dataList") String dataList);
/**
* 【cgreport】对 cgreportGetData 的返回值做优化，封装 DictModel 集合
* @param code
* @param dictText
* @param dictCode
* @param dataList
* @return
*/
@GetMapping("/online/api/cgreportGetDataPackage")
List<DictModel> cgreportGetDataPackage(@RequestParam("code") String code, @RequestParam("dictText") String dictText, @RequestParam("dictCode") String dictCode, @RequestParam("dataList") String dataList);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/online/api/fallback/OnlineBaseExtApiFallback.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/online/api/fallback/OnlineBaseExtApiFallback.java | package org.jeecg.common.online.api.fallback;
import com.alibaba.fastjson.JSONObject;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.online.api.IOnlineBaseExtApi;
import org.jeecg.common.system.vo.DictModel;
import java.util.List;
import java.util.Map;
/**
* 进入fallback的方法 检查是否token未设置
* @author: jeecg-boot
*/
@Slf4j
public class OnlineBaseExtApiFallback implements IOnlineBaseExtApi {
@Setter
private Throwable cause;
@Override
public String cgformPostCrazyForm(String tableName, JSONObject jsonObject) {
return null;
}
@Override
public String cgformPutCrazyForm(String tableName, JSONObject jsonObject) {
return null;
}
@Override
public JSONObject cgformQueryAllDataByTableName(String tableName, String dataIds) {
return null;
}
@Override
public String cgformDeleteDataByCode(String cgformCode, String dataIds) {
return null;
}
@Override
public Map<String, Object> cgreportGetData(String code, String forceKey, String dataList) {
return null;
}
@Override
public List<DictModel> cgreportGetDataPackage(String code, String dictText, String dictCode, String dataList) {
return null;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/online/api/factory/OnlineBaseExtApiFallbackFactory.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/common/online/api/factory/OnlineBaseExtApiFallbackFactory.java | package org.jeecg.common.online.api.factory;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.jeecg.common.online.api.IOnlineBaseExtApi;
import org.jeecg.common.online.api.fallback.OnlineBaseExtApiFallback;
import org.springframework.stereotype.Component;
/**
* @Description: OnlineBaseExtAPIFallbackFactory
* @author: jeecg-boot
*/
@Component
public class OnlineBaseExtApiFallbackFactory implements FallbackFactory<IOnlineBaseExtApi> {
@Override
public IOnlineBaseExtApi create(Throwable throwable) {
OnlineBaseExtApiFallback fallback = new OnlineBaseExtApiFallback();
fallback.setCause(throwable);
return fallback;
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/config/FeignConfig.java | jeecg-boot/jeecg-module-system/jeecg-system-api/jeecg-system-cloud-api/src/main/java/org/jeecg/config/FeignConfig.java | //package org.jeecg.config;
//
//import java.io.IOException;
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//import java.util.SortedMap;
//
//import jakarta.servlet.http.HttpServletRequest;
//
//import org.jeecg.common.config.mqtoken.UserTokenContext;
//import org.jeecg.common.constant.CommonConstant;
//import org.jeecg.common.util.DateUtils;
//import org.jeecg.common.util.PathMatcherUtil;
//import org.jeecg.config.sign.interceptor.SignAuthConfiguration;
//import org.jeecg.config.sign.util.HttpUtils;
//import org.jeecg.config.sign.util.SignUtil;
//import org.springframework.beans.factory.ObjectFactory;
//import org.springframework.boot.autoconfigure.AutoConfigureBefore;
//import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
//import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
//import org.springframework.cloud.openfeign.FeignAutoConfiguration;
//import org.springframework.cloud.openfeign.support.SpringDecoder;
//import org.springframework.cloud.openfeign.support.SpringEncoder;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.context.annotation.Primary;
//import org.springframework.context.annotation.Scope;
//import org.springframework.http.MediaType;
//import org.springframework.web.context.request.RequestContextHolder;
//import org.springframework.web.context.request.ServletRequestAttributes;
//
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.serializer.SerializerFeature;
//import com.alibaba.fastjson.support.config.FastJsonConfig;
//import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
//import com.alibaba.fastjson.support.springfox.SwaggerJsonSerializer;
//
//import feign.Feign;
//import feign.Logger;
//import feign.RequestInterceptor;
//import feign.codec.Decoder;
//import feign.codec.Encoder;
//import feign.form.spring.SpringFormEncoder;
//import lombok.extern.slf4j.Slf4j;
//
///**
// * @Description: FeignConfig
// * @author: JeecgBoot
// */
//@ConditionalOnClass(Feign.class)
//@AutoConfigureBefore(FeignAutoConfiguration.class)
//@Slf4j
//@Configuration
//public class FeignConfig {
//
// /**
// * 设置feign header参数
// * 【X_ACCESS_TOKEN】【X_SIGN】【X_TIMESTAMP】
// * @return
// */
// @Bean
// public RequestInterceptor requestInterceptor() {
// return requestTemplate -> {
// ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
// if (null != attributes) {
// HttpServletRequest request = attributes.getRequest();
// log.debug("Feign request: {}", request.getRequestURI());
// // 将token信息放入header中
// String token = request.getHeader(CommonConstant.X_ACCESS_TOKEN);
// if(token==null || "".equals(token)){
// token = request.getParameter("token");
// }
// log.info("Feign Login Request token: {}", token);
// requestTemplate.header(CommonConstant.X_ACCESS_TOKEN, token);
// }else{
// //解决后台任务、MQ中调用feign接口，无会话token的问题
// String token = UserTokenContext.getToken();
// log.info("Feign No Login token: {}", token);
// requestTemplate.header(CommonConstant.X_ACCESS_TOKEN, token);
// }
//
// //================================================================================================================
// //针对特殊接口，进行加签验证 ——根据URL地址过滤请求 【字典表参数签名验证】
// if (PathMatcherUtil.matches(Arrays.asList(SignAuthConfiguration.SIGN_URL_LIST),requestTemplate.path())) {
// try {
// log.info("============================ [begin] fegin api url ============================");
// log.info(requestTemplate.path());
// log.info(requestTemplate.method());
// String queryLine = requestTemplate.queryLine();
// String questionMark="?";
// if(queryLine!=null && queryLine.startsWith(questionMark)){
// queryLine = queryLine.substring(1);
// }
// log.info(queryLine);
// if(requestTemplate.body()!=null){
// log.info(new String(requestTemplate.body()));
// }
// SortedMap<String, String> allParams = HttpUtils.getAllParams(requestTemplate.path(),queryLine,requestTemplate.body(),requestTemplate.method());
// String sign = SignUtil.getParamsSign(allParams);
// log.info(" Feign request params sign: {}",sign);
// log.info("============================ [end] fegin api url ============================");
// requestTemplate.header(CommonConstant.X_SIGN, sign);
// requestTemplate.header(CommonConstant.X_TIMESTAMP, String.valueOf(System.currentTimeMillis()));
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// //================================================================================================================
// };
// }
//
//
//
// /**
// * Feign 客户端的日志记录，默认级别为NONE
// * Logger.Level 的具体级别如下：
// * NONE：不记录任何信息
// * BASIC：仅记录请求方法、URL以及响应状态码和执行时间
// * HEADERS：除了记录 BASIC级别的信息外，还会记录请求和响应的头信息
// * FULL：记录所有请求与响应的明细，包括头信息、请求体、元数据
// */
// @Bean
// Logger.Level feignLoggerLevel() {
// return Logger.Level.FULL;
// }
//
// /**
// * Feign支持文件上传
// * @param messageConverters
// * @return
// */
// @Bean
// @Primary
// @Scope("prototype")
// public Encoder multipartFormEncoder(ObjectFactory<HttpMessageConverters> messageConverters) {
// return new SpringFormEncoder(new SpringEncoder(messageConverters));
// }
//
// /**
// * 给 Feign 添加 FastJson 的解析支持
// */
// @Bean
// public Encoder feignEncoder() {
// return new SpringEncoder(feignHttpMessageConverter());
// }
//
// @Bean("apiFeignDecoder")
// public Decoder feignDecoder() {
// return new SpringDecoder(feignHttpMessageConverter());
// }
//
// /**
// * 设置解码器为fastjson
// *
// * @return
// */
// private ObjectFactory<HttpMessageConverters> feignHttpMessageConverter() {
// final HttpMessageConverters httpMessageConverters = new HttpMessageConverters(this.getFastJsonConverter());
// return () -> httpMessageConverters;
// }
//
// private FastJsonHttpMessageConverter getFastJsonConverter() {
// FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
//
// List<MediaType> supportedMediaTypes = new ArrayList<>();
// MediaType mediaTypeJson = MediaType.valueOf(MediaType.APPLICATION_JSON_VALUE);
// supportedMediaTypes.add(mediaTypeJson);
// converter.setSupportedMediaTypes(supportedMediaTypes);
// FastJsonConfig config = new FastJsonConfig();
// config.getSerializeConfig().put(JSON.class, new SwaggerJsonSerializer());
// config.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect);
// converter.setFastJsonConfig(config);
//
// return converter;
// }
//
//
//}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysCheckRuleController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysCheckRuleController.java | package org.jeecg.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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.system.entity.SysCheckRule;
import org.jeecg.modules.system.service.ISysCheckRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Arrays;
/**
* @Description: 编码校验规则
* @Author: jeecg-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
@Slf4j
@Tag(name = "编码校验规则")
@RestController
@RequestMapping("/sys/checkRule")
public class SysCheckRuleController extends JeecgController<SysCheckRule, ISysCheckRuleService> {
@Autowired
private ISysCheckRuleService sysCheckRuleService;
/**
* 分页列表查询
*
* @param sysCheckRule
* @param pageNo
* @param pageSize
* @param request
* @return
*/
@AutoLog(value = "编码校验规则-分页列表查询")
@Operation(summary = "编码校验规则-分页列表查询")
@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校验传入的值")
@Operation(summary = "编码校验规则-通过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 = "编码校验规则-添加")
@Operation(summary = "编码校验规则-添加")
@PostMapping(value = "/add")
public Result add(@RequestBody SysCheckRule sysCheckRule) {
sysCheckRuleService.save(sysCheckRule);
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param sysCheckRule
* @return
*/
@AutoLog(value = "编码校验规则-编辑")
@Operation(summary = "编码校验规则-编辑")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
public Result edit(@RequestBody SysCheckRule sysCheckRule) {
sysCheckRuleService.updateById(sysCheckRule);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "编码校验规则-通过id删除")
@Operation(summary = "编码校验规则-通过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 = "编码校验规则-批量删除")
@Operation(summary = "编码校验规则-批量删除")
@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查询")
@Operation(summary = "编码校验规则-通过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);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/ThirdLoginController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/ThirdLoginController.java | package org.jeecg.modules.system.controller;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xkcoding.justauth.AuthRequestFactory;
import io.swagger.v3.oas.annotations.Operation;
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 me.zhyd.oauth.utils.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.enums.MessageTypeEnum;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.*;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysThirdAccount;
import org.jeecg.modules.system.entity.SysThirdAppConfig;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.model.ThirdLoginModel;
import org.jeecg.modules.system.service.ISysDictService;
import org.jeecg.modules.system.service.ISysThirdAccountService;
import org.jeecg.modules.system.service.ISysThirdAppConfigService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.impl.ThirdAppDingtalkServiceImpl;
import org.jeecg.modules.system.service.impl.ThirdAppWechatEnterpriseServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
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 ISysDictService sysDictService;
@Autowired
private BaseCommonService baseCommonService;
@Autowired
private RedisUtil redisUtil;
@Autowired
private AuthRequestFactory factory;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private ThirdAppWechatEnterpriseServiceImpl thirdAppWechatEnterpriseService;
@Autowired
private ThirdAppDingtalkServiceImpl thirdAppDingtalkService;
@Autowired
private ISysThirdAppConfigService appConfigService;
@Autowired
public ISysBaseAPI sysBaseAPI;
@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);
//判断有没有这个人
// 代码逻辑说明: 修改成查询第三方账户表
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<SysThirdAccount>();
query.eq(SysThirdAccount::getThirdType, source);
// 代码逻辑说明: 【QQYUN-6667】敲敲云，线上解绑重新绑定一直提示这个---
query.eq(SysThirdAccount::getTenantId, CommonConstant.TENANT_ID_DEFAULT_VALUE);
query.and(q -> q.eq(SysThirdAccount::getThirdUserUuid, uuid).or().eq(SysThirdAccount::getThirdUserId, uuid));
List<SysThirdAccount> thridList = sysThirdAccountService.list(query);
SysThirdAccount user = null;
if(thridList==null || thridList.size()==0) {
//否则直接创建新账号
user = sysThirdAccountService.saveThirdUser(tlm,CommonConstant.TENANT_ID_DEFAULT_VALUE);
}else {
//已存在 只设置用户名 不设置头像
user = thridList.get(0);
}
// 生成token
// 代码逻辑说明: 从第三方登录查询是否存在用户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);
}
}else{
modelMap.addAttribute("token", "登录失败");
}
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;
}
//创建新账号
// 代码逻辑说明: 修改成从第三方登录查出来的user_id，在查询用户表尽行token
SysThirdAccount user = sysThirdAccountService.saveThirdUser(model,CommonConstant.TENANT_ID_DEFAULT_VALUE);
if(oConvertUtils.isNotEmpty(user.getSysUserId())){
String sysUserId = user.getSysUserId();
SysUser sysUser = sysUserService.getById(sysUserId);
// 生成token
String token = saveToken(sysUser);
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;
}
private String saveToken(SysUser user) {
// 生成token
String token = JwtUtil.sign(user.getUsername(), user.getPassword(), CommonConstant.CLIENT_TYPE_PC);
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
// 设置超时时间
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME * 2 / 1000);
return token;
}
/**
* 第三方登录回调接口
* @param token
* @param thirdType
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
@RequestMapping(value = "/getLoginUser/{token}/{thirdType}/{tenantId}", method = RequestMethod.GET)
@ResponseBody
public Result<JSONObject> getThirdLoginUser(@PathVariable("token") String token,@PathVariable("thirdType") String thirdType,@PathVariable("tenantId") String tenantId) throws Exception {
Result<JSONObject> result = new Result<JSONObject>();
String username = JwtUtil.getUsername(token);
// 代码逻辑说明: [QQYUN-11021]三方登录接口通过token获取用户信息漏洞修复------------
if (!TokenUtils.verifyToken(token, sysBaseAPI, redisUtil)) {
return Result.noauth("token验证失败");
}
//1. 校验用户是否有效
SysUser sysUser = sysUserService.getUserByName(username);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
// 代码逻辑说明: 如果真实姓名和头像不存在就取第三方登录的
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAccount::getSysUserId,sysUser.getId());
query.eq(SysThirdAccount::getThirdType,thirdType);
query.eq(SysThirdAccount::getTenantId,oConvertUtils.getInt(tenantId,CommonConstant.TENANT_ID_DEFAULT_VALUE));
// 代码逻辑说明: [QQYUN-4883]钉钉auth登录同一个租户下有同一个用户id------------
List<SysThirdAccount> accountList = sysThirdAccountService.list(query);
SysThirdAccount account = new SysThirdAccount();
if(CollectionUtil.isNotEmpty(accountList)){
account = accountList.get(0);
}
if(oConvertUtils.isEmpty(sysUser.getRealname())){
sysUser.setRealname(account.getRealname());
}
if(oConvertUtils.isEmpty(sysUser.getAvatar())){
sysUser.setAvatar(account.getAvatar());
}
JSONObject obj = new JSONObject();
//第三方登确定登录租户和部门逻辑
this.setUserTenantAndDepart(sysUser,obj,result);
//用户登录信息
obj.put("userInfo", sysUser);
//获取字典缓存【解决 #jeecg-boot/issues/3998】
obj.put("sysAllDictItems", sysDictService.queryAllDictItems());
//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
*/
@Operation(summary="手机号登录接口")
@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");
// 校验验证码
String captcha = jsonObject.getString("captcha");
// 代码逻辑说明: VUEN-2245 【漏洞】发现新漏洞待处理20220906
String redisKey = CommonConstant.PHONE_REDIS_KEY_PRE+phone;
Object captchaCache = redisUtil.get(redisKey);
if (oConvertUtils.isEmpty(captcha) || !captcha.equals(captchaCache)) {
result.setMessage("验证码错误");
result.setSuccess(false);
return result;
}
//校验用户有效性
SysUser sysUser = sysUserService.getUserByPhone(phone);
if(sysUser != null){
// 存在用户，直接绑定
sysThirdAccountService.updateThirdUserId(sysUser,thirdUserUuid);
}else{
// 不存在手机号，创建用户
sysUser = sysThirdAccountService.createUser(phone,thirdUserUuid,CommonConstant.TENANT_ID_DEFAULT_VALUE);
}
String token = saveToken(sysUser);
result.setSuccess(true);
result.setResult(token);
return result;
}
/**
* 企业微信/钉钉 OAuth2登录
*
* @param source
* @param state
* @return
*/
@ResponseBody
@GetMapping("/oauth2/{source}/login")
public String oauth2LoginCallback(@PathVariable("source") String source, @RequestParam("state") String state, HttpServletRequest request, HttpServletResponse response,
@RequestParam(value = "tenantId",required = false,defaultValue = "0") String tenantId) throws Exception {
String url;
//应用id为空，说明没有配置lowAppId
if(oConvertUtils.isEmpty(tenantId)){
return "租户编码未配置";
}
if (CommonConstant.WECHAT_ENTERPRISE.equalsIgnoreCase(source)) {
//换成第三方app配置表
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(Integer.valueOf(tenantId), MessageTypeEnum.QYWX.getType());
if(null == config){
return "还未配置企业微信应用，请配置企业微信应用";
}
StringBuilder builder = new StringBuilder();
// 构造企业微信OAuth2登录授权地址
builder.append("https://open.weixin.qq.com/connect/oauth2/authorize");
// 企业的CorpID
builder.append("?appid=").append(config.getClientId());
// 授权后重定向的回调链接地址，请使用urlencode对链接进行处理
String redirectUri = CommonUtils.getBaseUrl(request) + "/sys/thirdLogin/oauth2/wechat_enterprise/callback?tenantId="+tenantId;;
builder.append("&redirect_uri=").append(URLEncoder.encode(redirectUri, "UTF-8"));
// 返回类型，此时固定为：code
builder.append("&response_type=code");
// 应用授权作用域。
// snsapi_base：静默授权，可获取成员的的基础信息（UserId与DeviceId）；
builder.append("&scope=snsapi_base");
// 重定向后会带上state参数，长度不可超过128个字节
builder.append("&state=").append(state);
// 终端使用此参数判断是否需要带上身份信息
builder.append("#wechat_redirect");
url = builder.toString();
} else if (CommonConstant.DINGTALK.equalsIgnoreCase(source)) {
//换成第三方app配置表
SysThirdAppConfig appConfig = appConfigService.getThirdConfigByThirdType(Integer.valueOf(tenantId), MessageTypeEnum.DD.getType());
if(null == appConfig){
return "还未配置钉钉应用，请配置钉钉应用";
}
StringBuilder builder = new StringBuilder();
// 构造钉钉OAuth2登录授权地址
builder.append("https://login.dingtalk.com/oauth2/auth");
// 授权通过/拒绝后回调地址。
// 注意 需要与注册应用时登记的域名保持一致。
String redirectUri = CommonUtils.getBaseUrl(request) + "/sys/thirdLogin/oauth2/dingtalk/callback?tenantId="+tenantId;
builder.append("?redirect_uri=").append(URLEncoder.encode(redirectUri, "UTF-8"));
// 固定值为code。
// 授权通过后返回authCode。
builder.append("&response_type=code");
// 步骤一中创建的应用详情中获取。
// 企业内部应用：client_id为应用的AppKey。
builder.append("&client_id=").append(appConfig.getClientId());
// 授权范围，授权页面显示的授权信息以应用注册时配置的为准。
// openid：授权后可获得用户userid
builder.append("&scope=openid");
// 跟随authCode原样返回。
builder.append("&state=").append(state);
// 代码逻辑说明: [issues/I5BOUF]oauth2 钉钉无法登录------------
builder.append("&prompt=").append("consent");
url = builder.toString();
} else {
return "不支持的source";
}
log.info("oauth2 login url:" + url);
response.sendRedirect(url);
return "login…";
}
/**
* 企业微信/钉钉 OAuth2登录回调
*
* @param code
* @param state
* @param response
* @return
*/
@ResponseBody
@GetMapping("/oauth2/{source}/callback")
public String oauth2LoginCallback(
@PathVariable("source") String source,
// 企业微信返回的code
@RequestParam(value = "code", required = false) String code,
// 钉钉返回的code
@RequestParam(value = "authCode", required = false) String authCode,
@RequestParam("state") String state,
@RequestParam(name = "tenantId",defaultValue = "0") String tenantId,
HttpServletResponse response) {
SysUser loginUser;
if (CommonConstant.WECHAT_ENTERPRISE.equalsIgnoreCase(source)) {
log.info("【企业微信】OAuth2登录进入callback：code=" + code + ", state=" + state);
loginUser = thirdAppWechatEnterpriseService.oauth2Login(code,Integer.valueOf(tenantId));
if (loginUser == null) {
return "登录失败";
}
} else if (CommonConstant.DINGTALK.equalsIgnoreCase(source)) {
log.info("【钉钉】OAuth2登录进入callback：authCode=" + authCode + ", state=" + state);
loginUser = thirdAppDingtalkService.oauth2Login(authCode,Integer.valueOf(tenantId));
if (loginUser == null) {
return "登录失败";
}
} else {
return "不支持的source";
}
try {
// 代码逻辑说明: 工作流发送消息 点击消息链接跳转办理页面
String redirect = "";
if (state.indexOf("?") > 0) {
String[] arr = state.split("\\?");
state = arr[0];
if(arr.length>1){
redirect = arr[1];
}
}
String token = saveToken(loginUser);
state += "/oauth2-app/login?oauth2LoginToken=" + URLEncoder.encode(token, "UTF-8") + "&tenantId=" + URLEncoder.encode(tenantId, "UTF-8");
// 代码逻辑说明: [issues/I5BOUF]oauth2 钉钉无法登录------------
state += "&thirdType=" + source;
//state += "&thirdType=" + "wechat_enterprise";
if (redirect != null && redirect.length() > 0) {
state += "&" + redirect;
}
log.info("OAuth2登录重定向地址: " + state);
try {
response.sendRedirect(state);
return "ok";
} catch (IOException e) {
e.printStackTrace();
return "重定向失败";
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return "解码失败";
}
}
/**
* 注册账号并绑定第三方账号 【低代码应用专用接口】
* @param jsonObject
* @param user
* @return
*/
@ResponseBody
@PutMapping("/registerBindThirdAccount")
public Result<String> registerBindThirdAccount(@RequestBody JSONObject jsonObject, SysUser user) {
//手机号
String phone = jsonObject.getString("phone");
//验证码
String smscode = jsonObject.getString("smscode");
String redisKey = CommonConstant.PHONE_REDIS_KEY_PRE + phone;
Object code = redisUtil.get(redisKey);
//第三方uuid
String thirdUserUuid = jsonObject.getString("thirdUserUuid");
String username = jsonObject.getString("username");
//未设置用户名，则用手机号作为用户名
if (oConvertUtils.isEmpty(username)) {
username = phone;
}
//未设置密码，则随机生成一个密码
String password = jsonObject.getString("password");
if (oConvertUtils.isEmpty(password)) {
password = RandomUtil.randomString(8);
}
String email = jsonObject.getString("email");
SysUser sysUser1 = sysUserService.getUserByName(username);
if (sysUser1 != null) {
return Result.error("用户名已注册");
}
SysUser sysUser2 = sysUserService.getUserByPhone(phone);
if (sysUser2 != null) {
return Result.error("该手机号已注册");
}
if (oConvertUtils.isNotEmpty(email)) {
SysUser sysUser3 = sysUserService.getUserByEmail(email);
if (sysUser3 != null) {
return Result.error("邮箱已被注册");
}
}
if (null == code) {
return Result.error("手机验证码失效，请重新获取");
}
if (!smscode.equals(code.toString())) {
return Result.error("手机验证码错误");
}
String realname = jsonObject.getString("realname");
if (oConvertUtils.isEmpty(realname)) {
realname = username;
}
try {
//保存用户表
user.setCreateTime(new Date());
String salt = oConvertUtils.randomGen(8);
String passwordEncode = PasswordUtil.encrypt(username, password, salt);
user.setSalt(salt);
user.setUsername(username);
user.setRealname(realname);
user.setPassword(passwordEncode);
user.setEmail(email);
user.setPhone(phone);
user.setStatus(CommonConstant.USER_UNFREEZE);
user.setDelFlag(CommonConstant.DEL_FLAG_0);
user.setActivitiSync(CommonConstant.ACT_SYNC_1);
sysUserService.addUserWithRole(user, "");
//保存第三方用户表
sysThirdAccountService.updateThirdUserId(user, thirdUserUuid);
String token = saveToken(user);
return Result.ok(token);
} catch (Exception e) {
return Result.error("注册失败");
}
}
/**
* 设置用户租户和部门信息
*
* @param sysUser
* @param obj
* @param result
*/
private void setUserTenantAndDepart(SysUser sysUser, JSONObject obj, Result<JSONObject> result) {
//1.设置登录租户
sysUserService.setLoginTenant(sysUser, obj, sysUser.getUsername(), result);
//2.设置登录部门
String orgCode = sysUser.getOrgCode();
//部门不为空还是用原来的部门code
if(StringUtils.isEmpty(orgCode)){
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
//部门不为空取第一个作为当前登录部门
if(CollectionUtil.isNotEmpty(departs)){
orgCode = departs.get(0).getOrgCode();
sysUser.setOrgCode(orgCode);
this.sysUserService.updateUserDepart(sysUser.getUsername(), orgCode,null);
}
}
}
/**
* 新版钉钉登录
*
* @param authCode
* @param state
* @param tenantId
* @param response
* @return
*/
@ResponseBody
@GetMapping("/oauth2/dingding/login")
public String OauthDingDingLogin(@RequestParam(value = "authCode", required = false) String authCode,
@RequestParam("state") String state,
@RequestParam(name = "tenantId",defaultValue = "0") String tenantId,
HttpServletResponse response) {
SysUser loginUser = thirdAppDingtalkService.oauthDingDingLogin(authCode,Integer.valueOf(tenantId));
try {
String redirect = "";
if (state.indexOf("?") > 0) {
String[] arr = state.split("\\?");
state = arr[0];
if(arr.length>1){
redirect = arr[1];
}
}
String token = saveToken(loginUser);
state += "/oauth2-app/login?oauth2LoginToken=" + URLEncoder.encode(token, "UTF-8") + "&tenantId=" + URLEncoder.encode(tenantId, "UTF-8");
state += "&thirdType=DINGTALK";
if (redirect != null && redirect.length() > 0) {
state += "&" + redirect;
}
log.info("OAuth2登录重定向地址: " + state);
try {
response.sendRedirect(state);
return "ok";
} catch (IOException e) {
log.error(e.getMessage(),e);
return "重定向失败";
}
} catch (UnsupportedEncodingException e) {
log.error(e.getMessage(),e);
return "解码失败";
}
}
/**
* 获取企业id和应用id
* @param tenantId
* @return
*/
@ResponseBody
@GetMapping("/get/corpId/clientId")
public Result<SysThirdAppConfig> getCorpIdClientId(@RequestParam(value = "tenantId", defaultValue = "0") String tenantId){
Result<SysThirdAppConfig> result = new Result<>();
SysThirdAppConfig sysThirdAppConfig = thirdAppDingtalkService.getCorpIdClientId(Integer.valueOf(tenantId));
result.setSuccess(true);
result.setResult(sysThirdAppConfig);
return result;
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysRoleIndexController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysRoleIndexController.java | package org.jeecg.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 io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.constant.DefIndexConst;
import org.jeecg.modules.system.entity.SysRoleIndex;
import org.jeecg.modules.system.service.ISysRoleIndexService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import java.util.Arrays;
/**
* @Description: 角色首页配置
* @Author: jeecg-boot
* @Date: 2022-03-25
* @Version: V1.0
*/
@Slf4j
@Tag(name = "角色首页配置")
@RestController
@RequestMapping("/sys/sysRoleIndex")
public class SysRoleIndexController extends JeecgController<SysRoleIndex, ISysRoleIndexService> {
@Autowired
private ISysRoleIndexService sysRoleIndexService;
@Autowired
private ISysUserService sysUserService;
@Autowired
private RedisUtil redisUtil;
@Autowired
private BaseCommonService baseCommonService;
/**
* 分页列表查询
*
* @param sysRoleIndex
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "角色首页配置-分页列表查询")
@Operation(summary = "角色首页配置-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(SysRoleIndex sysRoleIndex,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<SysRoleIndex> queryWrapper = QueryGenerator.initQueryWrapper(sysRoleIndex, req.getParameterMap());
Page<SysRoleIndex> page = new Page<SysRoleIndex>(pageNo, pageSize);
IPage<SysRoleIndex> pageList = sysRoleIndexService.page(page, queryWrapper);
return Result.OK(pageList);
}
/**
* 添加
*
* @param sysRoleIndex
* @return
*/
@RequiresPermissions("system:roleindex:add")
@AutoLog(value = "角色首页配置-添加")
@Operation(summary = "角色首页配置-添加")
@PostMapping(value = "/add")
//@DynamicTable(value = DynamicTableConstant.SYS_ROLE_INDEX)
public Result<?> add(@RequestBody SysRoleIndex sysRoleIndex,HttpServletRequest request) {
String relationType = sysRoleIndex.getRelationType();
if(oConvertUtils.isEmpty(relationType)){
sysRoleIndex.setRelationType(CommonConstant.HOME_RELATION_ROLE);
}
sysRoleIndexService.save(sysRoleIndex);
//更新其他全局配置的状态
sysRoleIndexService.updateOtherDefaultStatus(sysRoleIndex.getRoleCode(),sysRoleIndex.getStatus(),sysRoleIndex.getId());
sysRoleIndexService.cleanDefaultIndexCache();
return Result.OK("添加成功！");
}
/**
* 编辑
*
* @param sysRoleIndex
* @return
*/
@RequiresPermissions("system:roleindex:edit")
@AutoLog(value = "角色首页配置-编辑")
@Operation(summary = "角色首页配置-编辑")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
//@DynamicTable(value = DynamicTableConstant.SYS_ROLE_INDEX)
public Result<?> edit(@RequestBody SysRoleIndex sysRoleIndex,HttpServletRequest request) {
String relationType = sysRoleIndex.getRelationType();
if(oConvertUtils.isEmpty(relationType)){
sysRoleIndex.setRelationType(CommonConstant.HOME_RELATION_ROLE);
}
sysRoleIndexService.updateById(sysRoleIndex);
//更新其他全局配置的状态
sysRoleIndexService.updateOtherDefaultStatus(sysRoleIndex.getRoleCode(),sysRoleIndex.getStatus(),sysRoleIndex.getId());
sysRoleIndexService.cleanDefaultIndexCache();
return Result.OK("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "角色首页配置-通过id删除")
@Operation(summary = "角色首页配置-通过id删除")
@RequiresPermissions("system:roleindex:delete")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
sysRoleIndexService.removeById(id);
return Result.OK("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "角色首页配置-批量删除")
@Operation(summary = "角色首页配置-批量删除")
@RequiresPermissions("system:roleindex:deleteBatch")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
baseCommonService.addLog("批量删除用户， ids： " +ids ,CommonConstant.LOG_TYPE_2, 3);
this.sysRoleIndexService.removeByIds(Arrays.asList(ids.split(",")));
return Result.OK("批量删除成功！");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "角色首页配置-通过id查询")
@Operation(summary = "角色首页配置-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
SysRoleIndex sysRoleIndex = sysRoleIndexService.getById(id);
return Result.OK(sysRoleIndex);
}
/**
* 导出excel
*
* @param request
* @param sysRoleIndex
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysRoleIndex sysRoleIndex) {
return super.exportXls(request, sysRoleIndex, SysRoleIndex.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, SysRoleIndex.class);
}
/**
* 通过code查询
*
* @param roleCode
* @return
*/
@AutoLog(value = "角色首页配置-通过code查询")
@Operation(summary = "角色首页配置-通过code查询")
@GetMapping(value = "/queryByCode")
//@DynamicTable(value = DynamicTableConstant.SYS_ROLE_INDEX)
public Result<?> queryByCode(@RequestParam(name = "roleCode", required = true) String roleCode,HttpServletRequest request) {
SysRoleIndex sysRoleIndex = sysRoleIndexService.getOne(new LambdaQueryWrapper<SysRoleIndex>().eq(SysRoleIndex::getRoleCode, roleCode));
return Result.OK(sysRoleIndex);
}
/**
* 查询默认首页配置
*/
@GetMapping("/queryDefIndex")
public Result<SysRoleIndex> queryDefIndex() {
SysRoleIndex defIndexCfg = sysRoleIndexService.queryDefaultIndex();
return Result.OK(defIndexCfg);
}
/**
* 更新默认首页配置
*/
@RequiresPermissions("system:permission:setDefIndex")
@PutMapping("/updateDefIndex")
public Result<?> updateDefIndex(
@RequestParam("url") String url,
@RequestParam("component") String component,
@RequestParam("isRoute") Boolean isRoute
) {
boolean success = sysRoleIndexService.updateDefaultIndex(url, component, isRoute);
if (success) {
return Result.OK("设置成功");
} else {
return Result.error("设置失败");
}
}
/**
* 切换默认门户
*
* @param sysRoleIndex
* @return
*/
@PostMapping(value = "/changeDefHome")
public Result<?> changeDefHome(@RequestBody SysRoleIndex sysRoleIndex,HttpServletRequest request) {
String username = JwtUtil.getUserNameByToken(request);
sysRoleIndex.setRoleCode(username);
sysRoleIndexService.changeDefHome(sysRoleIndex);
// 代码逻辑说明: 切换完成后的homePath获取
String version = request.getHeader(CommonConstant.VERSION);
String homePath = null;
SysRoleIndex defIndexCfg = sysUserService.getDynamicIndexByUserRole(username, version);
if (defIndexCfg == null) {
defIndexCfg = sysRoleIndexService.initDefaultIndex();
}
if (oConvertUtils.isNotEmpty(version) && defIndexCfg != null && oConvertUtils.isNotEmpty(defIndexCfg.getUrl())) {
homePath = defIndexCfg.getUrl();
if (!homePath.startsWith(SymbolConstant.SINGLE_SLASH)) {
homePath = SymbolConstant.SINGLE_SLASH + homePath;
}
}
return Result.OK(homePath);
}
/**
* 获取门户类型
*
* @return
*/
@GetMapping(value = "/getCurrentHome")
public Result<?> getCurrentHome(HttpServletRequest request) {
String username = JwtUtil.getUserNameByToken(request);
Object homeType = redisUtil.get(DefIndexConst.CACHE_TYPE + username);
return Result.OK(oConvertUtils.getString(homeType,DefIndexConst.HOME_TYPE_MENU));
}
/**
* 清除缓存
*
* @return
*/
@RequestMapping(value = "/cleanDefaultIndexCache")
public Result<?> cleanDefaultIndexCache(HttpServletRequest request) {
sysRoleIndexService.cleanDefaultIndexCache();
return Result.OK();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysLogController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysLogController.java | package org.jeecg.modules.system.controller;
import java.util.Arrays;
import java.util.List;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.modules.system.entity.SysLog;
import org.jeecg.modules.system.entity.SysRole;
import org.jeecg.modules.system.service.ISysLogService;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jeecgframework.poi.handler.inter.IExcelExportServerEnhanced;
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;
import org.springframework.web.servlet.ModelAndView;
/**
* <p>
* 系统日志表 前端控制器
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
@RestController
@RequestMapping("/sys/log")
@Slf4j
public class SysLogController extends JeecgController<SysLog, ISysLogService> {
@Autowired
private ISysLogService sysLogService;
/**
* for [issues/8699]AutoPoi在使用@ExcelEntity当设置show=true并且该项为null时报错
*/
@Resource
private JeecgBaseConfig jeecgBaseConfig;
/**
* 全部清除
*/
private static final String ALL_ClEAR = "allclear";
/**
* @功能：查询日志记录
* @param syslog
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
//@RequiresPermissions("system:log:list")
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)
//@RequiresPermissions("system:log: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)
//@RequiresPermissions("system:log:deleteBatch")
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(ALL_ClEAR.equals(ids)) {
this.sysLogService.removeAll();
result.success("清除成功!");
}
this.sysLogService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 导出excel
* for [QQYUN-13431]【jeecg】日志管理中添加大数据导出功能
* @param request
* @param syslog
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysLog syslog) {
// 复制参数，移除排序相关键（column/order 等）防止前端传入排序影响导出顺序
java.util.Map<String, String[]> rawMap = request.getParameterMap();
java.util.Map<String, String[]> paramMap = new java.util.HashMap<>(rawMap);
// 剔除自定义排序参数
paramMap.remove("column");
paramMap.remove("order");
// 组装查询条件（已剔除排序参数）
QueryWrapper<SysLog> queryWrapper = QueryGenerator.initQueryWrapper(syslog, paramMap);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
// 过滤选中数据
String selections = request.getParameter("selections");
if (oConvertUtils.isNotEmpty(selections)) {
List<String> selectionList = Arrays.asList(selections.split(","));
queryWrapper.in("id", selectionList);
}
// 定义IExcelExportServer
IExcelExportServerEnhanced<SysLog> excelExportServer = new IExcelExportServerEnhanced<>() {
@Override
public List<SysLog> selectListForExcelExport(Object queryParams, SysLog lastRecord, int pageSize) {
QueryWrapper<SysLog> originalWrapper = (QueryWrapper<SysLog>) queryParams;
// 克隆原始条件，避免多次迭代污染
QueryWrapper<SysLog> batchWrapper = null;
try {
batchWrapper = (QueryWrapper<SysLog>) originalWrapper.clone();
} catch (Exception e) {
batchWrapper = originalWrapper;
}
String lastId = null;
if (lastRecord != null) {
lastId = lastRecord.getId();
final String cursorLastId = lastId;
// 仅基于雪花ID（全局唯一，数值递增）作为游标，提升索引利用与性能
// 条件：id < 上一批最后一条的ID，实现“从大到小”倒序分页
batchWrapper.lt("id", cursorLastId);
}
// 排序：按 id DESC（雪花ID递增，倒序可获取最新数据）
batchWrapper.orderByDesc("id");
Page<SysLog> cursorPage = new Page<>(1, pageSize);
List<SysLog> list = service.page(cursorPage, batchWrapper).getRecords();
log.info("系统日志游标导出(ID游标) - lastId: {} batchSize: {} 返回: {}", lastId, pageSize, list.size());
if (!list.isEmpty()) {
SysLog endRecord = list.get(list.size() - 1);
log.debug("本批次最后一条记录游标ID -> id: {}", endRecord.getId());
}
return list;
}
@Override
public int getPageSize() {
return 10000;
}
};
String title = "系统日志";
// AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
//此处设置的filename无效 ,前端会重更新设置一下
mv.addObject(NormalExcelConstants.FILE_NAME, title);
mv.addObject(NormalExcelConstants.CLASS, SysLog.class);
ExportParams exportParams = new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title, jeecgBaseConfig.getPath().getUpload());
mv.addObject(NormalExcelConstants.PARAMS, exportParams);
mv.addObject(NormalExcelConstants.EXPORT_SERVER, excelExportServer);
mv.addObject(NormalExcelConstants.QUERY_PARAMS, queryWrapper);
return mv;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysPositionController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysPositionController.java | package org.jeecg.modules.system.controller;
import cn.hutool.core.util.RandomUtil;
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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.ImportExcelUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysPosition;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysPositionService;
import org.jeecg.modules.system.service.ISysUserPositionService;
import org.jeecg.modules.system.service.ISysUserService;
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.entity.enmus.ExcelType;
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 jakarta.servlet.http.HttpServletRequest;
import jakarta.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;
import java.util.stream.Collectors;
/**
* @Description: 职务表
* @Author: jeecg-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
@Slf4j
@Tag(name = "职务表")
@RestController
@RequestMapping("/sys/position")
public class SysPositionController {
@Autowired
private ISysPositionService sysPositionService;
@Autowired
private ISysUserPositionService userPositionService;
@Autowired
private ISysUserService userService;
/**
* 分页列表查询
*
* @param sysPosition
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "职务表-分页列表查询")
@Operation(summary = "职务表-分页列表查询")
@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>>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysPosition.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(),0));
}
//------------------------------------------------------------------------------------------------
QueryWrapper<SysPosition> queryWrapper = QueryGenerator.initQueryWrapper(sysPosition, req.getParameterMap());
queryWrapper.orderByAsc("post_level");
queryWrapper.orderByDesc("create_time");
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 = "职务表-添加")
@Operation(summary = "职务表-添加")
@PostMapping(value = "/add")
public Result<SysPosition> add(@RequestBody SysPosition sysPosition) {
Result<SysPosition> result = new Result<SysPosition>();
try {
//编号是空的，不需要判断多租户隔离了
if(oConvertUtils.isEmpty(sysPosition.getCode())){
//生成职位编码10位
sysPosition.setCode(RandomUtil.randomString(10));
}
sysPositionService.save(sysPosition);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
*
* @param sysPosition
* @return
*/
@AutoLog(value = "职务表-编辑")
@Operation(summary = "职务表-编辑")
@RequestMapping(value = "/edit", method ={RequestMethod.PUT, RequestMethod.POST})
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删除")
@Operation(summary = "职务表-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
try {
sysPositionService.removeById(id);
//删除用户职位关系表
userPositionService.removeByPositionId(id);
} catch (Exception e) {
log.error("删除失败", e.getMessage());
return Result.error("删除失败!");
}
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "职务表-批量删除")
@Operation(summary = "职务表-批量删除")
@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查询")
@Operation(summary = "职务表-通过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(SysPosition sysPosition,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 = JSON.parseObject(deString, SysPosition.class);
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysPosition.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(),0));
}
//------------------------------------------------------------------------------------------------
}
queryWrapper = QueryGenerator.initQueryWrapper(sysPosition, request.getParameterMap());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
// 代码逻辑说明: [03]职务导出，如果选择数据则只导出相关数据--------------------
String selections = request.getParameter("selections");
if(!oConvertUtils.isEmpty(selections)){
queryWrapper.in("id",selections.split(","));
}
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<SysPosition> pageList = sysPositionService.list(queryWrapper);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "职务表列表");
mv.addObject(NormalExcelConstants.CLASS, SysPosition.class);
//支持导出xlsx格式
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("职务表列表数据", "导出人:"+user.getRealname(),"导出信息", ExcelType.XSSF));
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
//职级导出支持导出字段
String exportFields = request.getParameter(NormalExcelConstants.EXPORT_FIELDS);
if(oConvertUtils.isNotEmpty(exportFields)){
mv.addObject(NormalExcelConstants.EXPORT_FIELDS, exportFields);
}
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查询")
@Operation(summary = "职务表-通过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;
}
/**
* 通过多个ID查询
*
* @param ids
* @return
*/
@AutoLog(value = "职务表-通过多个查询")
@Operation(summary = "职务表-通过多个id查询")
@GetMapping(value = "/queryByIds")
public Result<List<SysPosition>> queryByIds(@RequestParam(name = "ids") String ids) {
Result<List<SysPosition>> result = new Result<>();
QueryWrapper<SysPosition> queryWrapper = new QueryWrapper<>();
queryWrapper.in(true,"id",ids.split(","));
List<SysPosition> list = sysPositionService.list(queryWrapper);
if (list == null) {
result.error500("未找到对应实体");
} else {
result.setResult(list);
result.setSuccess(true);
}
return result;
}
/**
* 获取职位用户列表
*
* @param pageNo
* @param pageSize
* @param positionId
* @return
*/
@GetMapping("/getPositionUserList")
public Result<IPage<SysUser>> getPositionUserList(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
@RequestParam(name = "positionId") String positionId) {
Page<SysUser> page = new Page<>(pageNo, pageSize);
IPage<SysUser> pageList = userPositionService.getPositionUserList(page, positionId);
List<String> userIds = pageList.getRecords().stream().map(SysUser::getId).collect(Collectors.toList());
if (null != userIds && userIds.size() > 0) {
Map<String, String> useDepNames = userService.getDepNamesByUserIds(userIds);
pageList.getRecords().forEach(item -> {
item.setOrgCodeTxt(useDepNames.get(item.getId()));
});
}
return Result.ok(pageList);
}
/**
* 添加成员到用户职位关系表
*
* @param userIds
* @param positionId
* @return
*/
@PostMapping("/savePositionUser")
public Result<String> saveUserPosition(@RequestParam(name = "userIds") String userIds,
@RequestParam(name = "positionId") String positionId) {
userPositionService.saveUserPosition(userIds, positionId);
return Result.ok("添加成功");
}
/**
* 职位列表移除成员
*
* @param userIds
* @param positionId
* @return
*/
@DeleteMapping("/removePositionUser")
public Result<String> removeUserPosition(@RequestParam(name = "userIds") String userIds,
@RequestParam(name = "positionId") String positionId) {
userPositionService.removePositionUser(userIds, positionId);
return Result.OK("移除成员成功");
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/LoginController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/LoginController.java | package org.jeecg.modules.system.controller;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.exceptions.ClientException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.DySmsEnum;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.*;
import org.jeecg.common.util.encryption.AesEncryptUtil;
import org.jeecg.common.util.encryption.EncryptedString;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.shiro.IgnoreAuth;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysRoleIndex;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.model.SysLoginModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.service.impl.SysBaseApiImpl;
import org.jeecg.modules.system.util.RandImageUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
* @Author scott
* @since 2018-12-17
*/
@RestController
@RequestMapping("/sys")
@Tag(name="用户登录")
@Slf4j
public class LoginController {
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysPermissionService sysPermissionService;
@Autowired
private SysBaseApiImpl sysBaseApi;
@Autowired
private ISysLogService logService;
@Autowired
private RedisUtil redisUtil;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private ISysDictService sysDictService;
@Resource
private BaseCommonService baseCommonService;
@Autowired
private JeecgBaseConfig jeecgBaseConfig;
private final String BASE_CHECK_CODES = "qwertyuiplkjhgfdsazxcvbnmQWERTYUPLKJHGFDSAZXCVBNM1234567890";
/**
* 线程池用于异步发送纪要
*/
public static ExecutorService cachedThreadPool = new ShiroThreadPoolExecutor(0, 1024, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
@Operation(summary="登录接口")
@RequestMapping(value = "/login", method = RequestMethod.POST)
public Result<JSONObject> login(@RequestBody SysLoginModel sysLoginModel, HttpServletRequest request){
Result<JSONObject> result = new Result<>();
String username = sysLoginModel.getUsername();
// 密码加密传输(尝试 AES解密，失败视为明文)
String password = AesEncryptUtil.resolvePassword(sysLoginModel.getPassword());
log.debug("登录密码，原始密码:{}，解密密码:{}" , sysLoginModel.getPassword(), password);
//step.1 登录失败超出次数5次锁定用户10分钟
if(isLoginFailOvertimes(username)){
return result.error500("该用户登录失败次数过多，请于10分钟后再次登录！");
}
// step.2 验证码check
String realKey = validateCaptcha(sysLoginModel, result);
if (realKey == null) {
return result;
}
// step.3 校验用户是否存在且有效
LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysUser::getUsername,username);
SysUser sysUser = sysUserService.getOne(queryWrapper);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
// step.4 校验用户名或密码是否正确
String userpassword = PasswordUtil.encrypt(username, password, sysUser.getSalt());
String syspassword = sysUser.getPassword();
if (!syspassword.equals(userpassword)) {
addLoginFailOvertimes(username);
result.error500("用户名或密码错误");
return result;
}
// step.5 登录成功获取用户信息
String loginOrgCode = sysLoginModel.getLoginOrgCode();
sysUser.setLoginOrgCode(loginOrgCode);
userInfo(sysUser, result, request, CommonConstant.CLIENT_TYPE_PC);
// step.6 登录成功删除验证码
redisUtil.del(realKey);
redisUtil.del(CommonConstant.LOGIN_FAIL + username);
// step.7 记录用户登录日志
LoginUser loginUser = new LoginUser();
BeanUtils.copyProperties(sysUser, loginUser);
baseCommonService.addLog("用户名: " + username + ",登录成功！", CommonConstant.LOG_TYPE_1, null,loginUser);
return result;
}
/**
* 【vue3专用】获取用户信息
*/
@GetMapping("/user/getUserInfo")
public Result<JSONObject> getUserInfo(HttpServletRequest request){
long start = System.currentTimeMillis();
Result<JSONObject> result = new Result<JSONObject>();
String username = JwtUtil.getUserNameByToken(request);
if(oConvertUtils.isNotEmpty(username)) {
// 根据用户名查询用户信息
SysUser sysUser = sysUserService.getUserByName(username);
JSONObject obj=new JSONObject();
log.debug("1 获取用户信息耗时（用户基础信息）" + (System.currentTimeMillis() - start) + "毫秒");
// 代码逻辑说明: vue3前端，支持自定义首页-----------
String vue3Version = request.getHeader(CommonConstant.VERSION);
SysRoleIndex roleIndex = sysUserService.getDynamicIndexByUserRole(username, vue3Version);
if (oConvertUtils.isNotEmpty(vue3Version) && roleIndex != null && oConvertUtils.isNotEmpty(roleIndex.getUrl())) {
String homePath = roleIndex.getUrl();
if (!homePath.startsWith(SymbolConstant.SINGLE_SLASH)) {
homePath = SymbolConstant.SINGLE_SLASH + homePath;
}
sysUser.setHomePath(homePath);
}
log.debug("2 获取用户信息耗时 (首页面配置)" + (System.currentTimeMillis() - start) + "毫秒");
obj.put("userInfo",sysUser);
obj.put("sysAllDictItems", sysDictService.queryAllDictItems());
log.debug("3 获取用户信息耗时 (字典数据)" + (System.currentTimeMillis() - start) + "毫秒");
result.setResult(obj);
result.success("");
}
log.debug("end 获取用户信息耗时 " + (System.currentTimeMillis() - start) + "毫秒");
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) {
asyncClearLogoutCache(token, sysUser); // 异步清理
SecurityUtils.getSubject().logout();
return Result.ok("退出登录成功！");
}else {
return Result.error("Token无效!");
}
}
/**
* 清理用户缓存
*
* @param token
* @param sysUser
*/
private void asyncClearLogoutCache(String token, LoginUser sysUser) {
cachedThreadPool.execute(()->{
//清空用户登录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()));
//清空是否允许同一账号多地同时登录缓存（PC端和APP端）
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN_PC + sysUser.getUsername());
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN_APP + sysUser.getUsername());
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN_PHONE + sysUser.getUsername());
baseCommonService.addLog("用户名: "+sysUser.getRealname()+",退出成功！", CommonConstant.LOG_TYPE_1, null, sysUser);
log.debug("【退出成功操作】异步处理，退出后，清理用户缓存： "+sysUser.getRealname());
});
}
/**
* 获取访问量
* @return
*/
@GetMapping("loginfo")
public Result<JSONObject> loginfo() {
Result<JSONObject> result = new Result<JSONObject>();
JSONObject obj = new JSONObject();
// 获取一天的开始和结束时间
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);
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();
//获取登录租户
Integer tenantId = user.getLoginTenantId();
//设置用户登录部门和登录租户
this.sysUserService.updateUserDepart(username, orgCode,tenantId);
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,HttpServletRequest request) {
Result<String> result = new Result<String>();
String clientIp = IpUtils.getIpAddr(request);
String mobile = jsonObject.get("mobile").toString();
//手机号模式 登录模式: "2" 注册模式: "1"
String smsmode=jsonObject.get("smsmode").toString();
log.info("-------- IP:{}, 手机号：{}，获取绑定验证码", clientIp, mobile);
if(oConvertUtils.isEmpty(mobile)){
result.setMessage("手机号不允许为空！");
result.setSuccess(false);
return result;
}
// VUEN-2245【漏洞】发现新漏洞待处理20220906
String redisKey = CommonConstant.PHONE_REDIS_KEY_PRE+mobile;
Object object = redisUtil.get(redisKey);
if (object != null) {
result.setMessage("验证码10分钟内，仍然有效！");
result.setSuccess(false);
return result;
}
//-------------------------------------------------------------------------------------
//增加 check防止恶意刷短信接口
if(!DySmsLimit.canSendSms(clientIp)){
log.warn("--------[警告] IP地址:{}, 短信接口请求太多-------", clientIp);
result.setMessage("短信接口请求太多，请稍后再试！");
result.setCode(CommonConstant.PHONE_SMS_FAIL_CODE);
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();
String userNotExist="该用户不存在，请注册";
if(userNotExist.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);
// 代码逻辑说明: 【issues/8567】严重：修改密码存在水平越权问题。---
if(b){
String username = sysUser.getUsername();
obj.put("username",username);
redisUtil.set(redisKey, obj.toJSONString(), 600);
result.setSuccess(true);
return result;
}
}
}
if (b == false) {
result.setMessage("短信验证码发送失败,请稍后重试");
result.setSuccess(false);
return result;
}
//验证码10分钟内有效
redisUtil.set(redisKey, captcha, 600);
result.setSuccess(true);
} catch (ClientException e) {
e.printStackTrace();
result.error500(" 短信接口未配置，请联系管理员！");
return result;
}
return result;
}
/**
* 手机号登录接口
*
* @param jsonObject
* @return
*/
@Operation(summary="手机号登录接口")
@PostMapping("/phoneLogin")
public Result<JSONObject> phoneLogin(@RequestBody JSONObject jsonObject, HttpServletRequest request) {
Result<JSONObject> result = new Result<JSONObject>();
String phone = jsonObject.getString("mobile");
// 平台用户登录失败锁定用户
if(isLoginFailOvertimes(phone)){
return result.error500("该用户登录失败次数过多，请于10分钟后再次登录！");
}
//校验用户有效性
SysUser sysUser = sysUserService.getUserByPhone(phone);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
String smscode = jsonObject.getString("captcha");
// 代码逻辑说明: VUEN-2245 【漏洞】发现新漏洞待处理20220906
String redisKey = CommonConstant.PHONE_REDIS_KEY_PRE+phone;
Object code = redisUtil.get(redisKey);
if (!smscode.equals(code)) {
addLoginFailOvertimes(phone);
return Result.error("手机验证码错误");
}
//用户信息
String loginOrgCode = jsonObject.getString("loginOrgCode");
sysUser.setLoginOrgCode(loginOrgCode);
userInfo(sysUser, result, request, CommonConstant.CLIENT_TYPE_PHONE);
//添加日志
baseCommonService.addLog("用户名: " + sysUser.getUsername() + ",登录成功！", CommonConstant.LOG_TYPE_1, null);
redisUtil.removeAll(redisKey);
return result;
}
/**
* 用户信息
*
* @param sysUser
* @param result
* @return
*/
private Result<JSONObject> userInfo(SysUser sysUser, Result<JSONObject> result, HttpServletRequest request, String clientType) {
String username = sysUser.getUsername();
String syspassword = sysUser.getPassword();
JSONObject obj = new JSONObject(new LinkedHashMap<>());
//1.生成token，并设置超时时间
String token = JwtUtil.sign(username, syspassword, clientType);
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
// 根据客户端类型设置对应的过期时间
long expireTime = CommonConstant.CLIENT_TYPE_APP.equalsIgnoreCase(clientType)
? JwtUtil.APP_EXPIRE_TIME * 2 / 1000
: JwtUtil.EXPIRE_TIME * 2 / 1000;
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, expireTime);
obj.put("token", token);
// 是否允许同一账号多地同时登录，踢掉之前的登录
handleSingleSignOn(username, token, clientType);
//2.设置登录租户
Result<JSONObject> loginTenantError = sysUserService.setLoginTenant(sysUser, obj, username,result);
if (loginTenantError != null) {
return loginTenantError;
}
//3.设置登录用户信息
obj.put("userInfo", sysUser);
//4.设置登录部门
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
obj.put("departs", departs);
if (departs == null || departs.size() == 0) {
obj.put("multi_depart", 0);
sysUserService.updateUserDepart(username, null, null);
} else if (departs.size() == 1) {
sysUserService.updateUserDepart(username, departs.get(0).getOrgCode(),null);
obj.put("multi_depart", 1);
} else {
//查询当前是否有登录部门
SysUser sysUserById = sysUserService.getById(sysUser.getId());
//【部门切换】支持登录页面选择部门
String loginOrgCode = sysUser.getLoginOrgCode();
// 判断上次登录部门orgCode是否在departs中
boolean orgCodeInDeparts = departs.stream().anyMatch(d -> sysUserById.getOrgCode() != null && sysUserById.getOrgCode().equalsIgnoreCase(d.getOrgCode()));
if (!orgCodeInDeparts) {
sysUserById.setOrgCode(null);
}
// 如果未设置登录部门，则将登录部门设置为用户选择的 loginOrgCode（优先），否则设置为默认的第一个部门
if(oConvertUtils.isEmpty(sysUserById.getOrgCode())){
String orgCode = oConvertUtils.isNotEmpty(loginOrgCode) ? loginOrgCode : departs.get(0).getOrgCode();
sysUserService.updateUserDepart(username, orgCode, null);
} else {
// 已设置登录部门，若用户本次登录选择了不同的部门，则优先使用用户选择的 loginOrgCode 更新登录部门
String orgCode = sysUserById.getOrgCode();
if(oConvertUtils.isNotEmpty(loginOrgCode) && !orgCode.equalsIgnoreCase(loginOrgCode)){
sysUserService.updateUserDepart(username, loginOrgCode, null);
}
}
obj.put("multi_depart", 2);
}
// 5.vue3版本不加载字典数据，vue2下加载字典
String vue3Version = request.getHeader(CommonConstant.VERSION);
if(oConvertUtils.isEmpty(vue3Version)){
obj.put("sysAllDictItems", sysDictService.queryAllDictItems());
}
result.setResult(obj);
result.success("登录成功");
return result;
}
/**
* 同一账号在同一客户端类型只能登录一次
*
* @author scott
* @date 2025-10-31
* PC端、APP端、手机号登录分别独立，互不影响
*
* @param username 用户名
* @param newToken 新生成的token
* @param clientType 客户端类型（PC、APP、PHONE）
*/
private void handleSingleSignOn(String username, String newToken, String clientType) {
// 检查是否允许并发登录
if (jeecgBaseConfig.getFirewall() == null || jeecgBaseConfig.getFirewall().getIsConcurrent()==null || Boolean.TRUE.equals(jeecgBaseConfig.getFirewall().getIsConcurrent())) {
// 允许并发登录，只设置当前用户的token缓存，不踢掉之前的登录
log.debug("并发登录已启用：用户[{}]在{}端允许多地同时登录", username, clientType);
return;
}
log.info("【并发登录限制已开启】 用户[{}]在{}端不允许多地同时登录", username, clientType);
// 根据客户端类型选择对应的Redis key前缀
String redisKeyPrefix;
if (CommonConstant.CLIENT_TYPE_APP.equalsIgnoreCase(clientType)) {
redisKeyPrefix = CommonConstant.PREFIX_USER_TOKEN_APP;
} else if (CommonConstant.CLIENT_TYPE_PHONE.equalsIgnoreCase(clientType)) {
redisKeyPrefix = CommonConstant.PREFIX_USER_TOKEN_PHONE;
} else {
redisKeyPrefix = CommonConstant.PREFIX_USER_TOKEN_PC;
}
String userTokenKey = redisKeyPrefix + username;
// 获取该用户在当前客户端类型下之前的token
Object oldTokenObj = redisUtil.get(userTokenKey);
if (oldTokenObj != null && !oldTokenObj.equals(newToken)) {
String oldToken = oldTokenObj.toString();
// 清除旧登录token的缓存（设置 1 小时过期时间）
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN + oldToken);
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN_ERROR_MSG + oldToken, "不允许同一账号多地同时登录，当前登录被踢掉！", 60 * 1 * 60);
log.info("【并发登录限制已开启】用户[{}]在{}端的旧登录已被踢下线！", username, clientType);
log.info("【并发登录限制已开启】用户被踢下线，新token: {}，旧token：{}", newToken, oldToken);
}
// 保存新的token到单点登录缓存
redisUtil.set(userTokenKey, newToken);
redisUtil.expire(userTokenKey, JwtUtil.EXPIRE_TIME * 2 / 1000);
}
/**
* 获取加密字符串
* @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(5);
map.put("key", EncryptedString.key);
map.put("iv",EncryptedString.iv);
result.setResult(map);
return result;
}
/**
* 后台生成图形验证码 ：有效
* @param response
* @param key
*/
@Operation(summary="获取验证码")
@GetMapping(value = "/randomImage/{key}")
public Result<String> randomImage(HttpServletResponse response,@PathVariable("key") String key){
Result<String> res = new Result<String>();
try {
//生成验证码，存到redis中
String code = RandomUtil.randomString(BASE_CHECK_CODES,4);
String lowerCaseCode = code.toLowerCase();
String keyPrefix = Md5Util.md5Encode(key + jeecgBaseConfig.getSignatureSecret(), "utf-8");
String realKey = keyPrefix + lowerCaseCode;
redisUtil.removeAll(keyPrefix);
redisUtil.set(realKey, lowerCaseCode, 60);
log.debug("获取验证码，Redis key = {}，checkCode = {}", realKey, code);
String base64 = RandImageUtil.generate(code);
res.setSuccess(true);
res.setResult(base64);
} catch (Exception e) {
log.error(e.getMessage(), e);
res.error500("获取验证码失败,请检查redis配置!");
return res;
}
return res;
}
// /**
// * 切换菜单表为vue3的表
// */
// @RequiresRoles({"admin"})
// @GetMapping(value = "/switchVue3Menu")
// public Result<String> switchVue3Menu(HttpServletResponse response) {
// Result<String> res = new Result<String>();
// sysPermissionService.switchVue3Menu();
// return res;
// }
/**
* app登录
* @param sysLoginModel
* @return
* @throws Exception
*/
@RequestMapping(value = "/mLogin", method = RequestMethod.POST)
public Result<JSONObject> mLogin(@RequestBody SysLoginModel sysLoginModel, HttpServletRequest request) throws Exception {
Result<JSONObject> result = new Result<JSONObject>();
String username = sysLoginModel.getUsername();
// 密码加密传输(尝试 AES解密，失败视为明文)
String password = AesEncryptUtil.resolvePassword(sysLoginModel.getPassword());
log.debug("登录密码，原始密码:{}，解密密码:{}" , sysLoginModel.getPassword(), password);
JSONObject obj = new JSONObject();
// 1.平台用户登录失败锁定用户
if(isLoginFailOvertimes(username)){
return result.error500("该用户登录失败次数过多，请于10分钟后再次登录！");
}
// 2.校验用户是否有效
SysUser sysUser = sysUserService.getUserByName(username);
result = sysUserService.checkUserIsEffective(sysUser);
if(!result.isSuccess()) {
return result;
}
// 3.校验用户名或密码是否正确
String userpassword = PasswordUtil.encrypt(username, password, sysUser.getSalt());
String syspassword = sysUser.getPassword();
if (!syspassword.equals(userpassword)) {
addLoginFailOvertimes(username);
result.error500("用户名或密码错误");
return result;
}
//4.设置登录部门
String orgCode = sysUser.getOrgCode();
//登录设置的组织
String loginOrgCode = sysLoginModel.getLoginOrgCode();
if(oConvertUtils.isEmpty(orgCode)) {
//如果当前用户无选择部门 查看部门关联信息
if(oConvertUtils.isNotEmpty(loginOrgCode)){
sysUser.setOrgCode(loginOrgCode);
this.sysUserService.updateUserDepart(username, loginOrgCode,null);
}else{
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
if (departs != null && !departs.isEmpty()) {
orgCode = departs.get(0).getOrgCode();
sysUser.setOrgCode(orgCode);
this.sysUserService.updateUserDepart(username, orgCode,null);
}
}
}else{
if(oConvertUtils.isNotEmpty(loginOrgCode) && !orgCode.equalsIgnoreCase(loginOrgCode)){
sysUser.setOrgCode(loginOrgCode);
sysUserService.updateUserDepart(username, loginOrgCode,null);
}
}
//5. 设置登录租户
Result<JSONObject> loginTenantError = sysUserService.setLoginTenant(sysUser, obj, username, result);
if (loginTenantError != null) {
return loginTenantError;
}
// 设置登录用户信息
obj.put("userInfo", sysUser);
//6. 生成token，并设置超时时间
String token = JwtUtil.sign(username, syspassword, CommonConstant.CLIENT_TYPE_APP);
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.APP_EXPIRE_TIME*2 / 1000);
obj.put("token", token);
result.setResult(obj);
result.setSuccess(true);
result.setCode(200);
// 7.是否允许同一账号多地同时登录(APP端登录，踢掉之前的APP端登录)
handleSingleSignOn(username, token, CommonConstant.CLIENT_TYPE_APP);
// 8.登录成功记录日志
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();
}
/**
* 登录二维码
*/
@Operation(summary = "登录二维码")
@GetMapping("/getLoginQrcode")
public Result<?> getLoginQrcode() {
String qrcodeId = CommonConstant.LOGIN_QRCODE_PRE+IdWorker.getIdStr();
//定义二维码参数
Map params = new HashMap(5);
params.put("qrcodeId", qrcodeId);
//存放二维码唯一标识30秒有效
redisUtil.set(CommonConstant.LOGIN_QRCODE + qrcodeId, qrcodeId, 30);
return Result.OK(params);
}
/**
* 扫码二维码
*/
@Operation(summary = "扫码登录二维码")
@PostMapping("/scanLoginQrcode")
public Result<?> scanLoginQrcode(@RequestParam String qrcodeId, @RequestParam String token) {
Object check = redisUtil.get(CommonConstant.LOGIN_QRCODE + qrcodeId);
if (oConvertUtils.isNotEmpty(check)) {
//存放token给前台读取
redisUtil.set(CommonConstant.LOGIN_QRCODE_TOKEN+qrcodeId, token, 60);
} else {
return Result.error("二维码已过期,请刷新后重试");
}
return Result.OK("扫码成功");
}
/**
* 获取用户扫码后保存的token
*/
@Operation(summary = "获取用户扫码后保存的token")
@GetMapping("/getQrcodeToken")
public Result getQrcodeToken(@RequestParam String qrcodeId) {
Object token = redisUtil.get(CommonConstant.LOGIN_QRCODE_TOKEN + qrcodeId);
Map result = new HashMap(5);
Object qrcodeIdExpire = redisUtil.get(CommonConstant.LOGIN_QRCODE + qrcodeId);
if (oConvertUtils.isEmpty(qrcodeIdExpire)) {
//二维码过期通知前台刷新
result.put("token", "-2");
return Result.OK(result);
}
if (oConvertUtils.isNotEmpty(token)) {
result.put("success", true);
result.put("token", token);
} else {
result.put("token", "-1");
}
return Result.OK(result);
}
/**
* 登录失败超出次数5 返回true
* @param username
* @return
*/
private boolean isLoginFailOvertimes(String username){
String key = CommonConstant.LOGIN_FAIL + username;
Object failTime = redisUtil.get(key);
if(failTime!=null){
Integer val = Integer.parseInt(failTime.toString());
if(val>5){
return true;
}
}
return false;
}
/**
* 记录登录失败次数
* @param username
*/
private void addLoginFailOvertimes(String username){
String key = CommonConstant.LOGIN_FAIL + username;
Object failTime = redisUtil.get(key);
Integer val = 0;
if(failTime!=null){
val = Integer.parseInt(failTime.toString());
}
// 10分钟，一分钟为60s
redisUtil.set(key, ++val, 600);
}
/**
* 发送短信验证码接口(修改密码)
*
* @param jsonObject
* @return
*/
@PostMapping(value = "/sendChangePwdSms")
public Result<String> sendSms(@RequestBody JSONObject jsonObject) {
Result<String> result = new Result<>();
String mobile = jsonObject.get("mobile").toString();
if (oConvertUtils.isEmpty(mobile)) {
result.setMessage("手机号不允许为空！");
result.setSuccess(false);
return result;
}
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String username = sysUser.getUsername();
LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
query.eq(SysUser::getUsername, username).eq(SysUser::getPhone, mobile);
SysUser user = sysUserService.getOne(query);
if (null == user) {
return Result.error("当前登录用户和绑定的手机号不匹配，无法修改密码！");
}
String redisKey = CommonConstant.PHONE_REDIS_KEY_PRE + mobile;
Object object = redisUtil.get(redisKey);
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 = DySmsHelper.sendSms(mobile, obj, DySmsEnum.CHANGE_PASSWORD_TEMPLATE_CODE);
if (!b) {
result.setMessage("短信验证码发送失败,请稍后重试");
result.setSuccess(false);
return result;
}
//【issues/8567】严重：修改密码存在水平越权问题
obj.put("username",username);
redisUtil.set(redisKey, obj.toJSONString(), 300);
result.setSuccess(true);
} catch (ClientException e) {
e.printStackTrace();
result.error500(" 短信接口未配置，请联系管理员！");
return result;
}
return result;
}
/**
* 图形验证码
* @param sysLoginModel
* @return
*/
@RequestMapping(value = "/smsCheckCaptcha", method = RequestMethod.POST)
public Result<?> smsCheckCaptcha(@RequestBody SysLoginModel sysLoginModel, HttpServletRequest request){
String captcha = sysLoginModel.getCaptcha();
String checkKey = sysLoginModel.getCheckKey();
if(captcha==null){
return Result.error("验证码无效");
}
String lowerCaseCaptcha = captcha.toLowerCase();
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/DuplicateCheckController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/DuplicateCheckController.java | package org.jeecg.modules.system.controller;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.system.model.DuplicateCheckVo;
import org.jeecg.modules.system.service.ISysDictService;
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 jakarta.servlet.http.HttpServletRequest;
/**
* @Title: DuplicateCheckAction
* @Description: 重复校验工具
* @Author 张代浩
* @Date 2019-03-25
* @Version V1.0
*/
@Slf4j
@RestController
@RequestMapping("/sys/duplicate")
@Tag(name="重复校验")
public class DuplicateCheckController {
@Autowired
ISysDictService sysDictService;
/**
* 校验数据是否在系统中是否存在
*
* @return
*/
@RequestMapping(value = "/check", method = RequestMethod.GET)
@Operation(summary="重复校验接口")
public Result<String> doDuplicateCheck(DuplicateCheckVo duplicateCheckVo, HttpServletRequest request) {
log.debug("----duplicate check------："+ duplicateCheckVo.toString());
// 1.填值为空，直接返回
if(StringUtils.isEmpty(duplicateCheckVo.getFieldVal())){
Result rs = new Result();
rs.setCode(500);
rs.setSuccess(true);
rs.setMessage("数据为空,不作处理！");
return rs;
}
// 2.返回结果
if (sysDictService.duplicateCheckData(duplicateCheckVo)) {
// 该值可用
return Result.ok("该值可用！");
} else {
// 该值不可用
log.info("该值不可用，系统中已存在！");
return Result.error("该值不可用，系统中已存在！");
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysTenantController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysTenantController.java | package org.jeecg.modules.system.controller;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.RandomUtil;
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.RequiresPermissions;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.PermissionData;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.config.sign.annotation.SignatureCheck;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.service.ISysTenantPackService;
import org.jeecg.modules.system.service.ISysTenantService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.service.ISysUserTenantService;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.vo.SysUserTenantVo;
import org.jeecg.modules.system.vo.tenant.TenantDepartAuthInfo;
import org.jeecg.modules.system.vo.tenant.TenantPackModel;
import org.jeecg.modules.system.vo.tenant.TenantPackUser;
import org.jeecg.modules.system.vo.tenant.TenantPackUserCount;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletRequest;
import java.util.*;
/**
* 租户配置信息
* @author: jeecg-boot
*/
@Slf4j
@RestController
@RequestMapping("/sys/tenant")
public class SysTenantController {
@Autowired
private ISysTenantService sysTenantService;
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysUserTenantService relationService;
@Autowired
private ISysTenantPackService sysTenantPackService;
@Autowired
private BaseCommonService baseCommonService;
@Autowired
private ISysDepartService sysDepartService;
/**
* 获取列表数据
* @param sysTenant
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequiresPermissions("system:tenant:list")
@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>>();
//---author:zhangyafei---date:20210916-----for: 租户管理添加日期范围查询---
Date beginDate=null;
Date endDate=null;
if(oConvertUtils.isNotEmpty(sysTenant)) {
beginDate=sysTenant.getBeginDate();
endDate=sysTenant.getEndDate();
sysTenant.setBeginDate(null);
sysTenant.setEndDate(null);
}
//---author:zhangyafei---date:20210916-----for: 租户管理添加日期范围查询---
QueryWrapper<SysTenant> queryWrapper = QueryGenerator.initQueryWrapper(sysTenant, req.getParameterMap());
//---author:zhangyafei---date:20210916-----for: 租户管理添加日期范围查询---
if(oConvertUtils.isNotEmpty(sysTenant)){
queryWrapper.ge(oConvertUtils.isNotEmpty(beginDate),"begin_date",beginDate);
queryWrapper.le(oConvertUtils.isNotEmpty(endDate),"end_date",endDate);
}
//---author:zhangyafei---date:20210916-----for: 租户管理添加日期范围查询---
Page<SysTenant> page = new Page<SysTenant>(pageNo, pageSize);
IPage<SysTenant> pageList = sysTenantService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 获取租户删除的列表
* @param sysTenant
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping("/recycleBinPageList")
@RequiresPermissions("system:tenant:recycleBinPageList")
public Result<IPage<SysTenant>> recycleBinPageList(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>>();
Page<SysTenant> page = new Page<SysTenant>(pageNo, pageSize);
IPage<SysTenant> pageList = sysTenantService.getRecycleBinPageList(page, sysTenant);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param
* @return
*/
@RequiresPermissions("system:tenant:add")
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysTenant> add(@RequestBody SysTenant sysTenant) {
Result<SysTenant> result = new Result();
if(sysTenant!=null && oConvertUtils.isNotEmpty(sysTenant.getId()) && sysTenantService.getById(sysTenant.getId())!=null){
return result.error500("该编号已存在!");
}
try {
sysTenantService.saveTenant(sysTenant);
//添加默认产品包
sysTenantPackService.addTenantDefaultPack(sysTenant.getId());
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* [QQYUN-11032]【jeecg】租户套餐管理增加初始化套餐包按钮
* @param tenantId
* @return
* @author chenrui
* @date 2025/2/6 18:24
*/
@RequiresPermissions("system:tenant:syncDefaultPack")
@PostMapping(value = "/syncDefaultPack")
public Result<?> syncDefaultPack(@RequestParam(name="tenantId",required=true) Integer tenantId) {
//同步默认产品包
sysTenantPackService.syncDefaultPack(tenantId);
return Result.OK("操作成功");
}
/**
* 编辑
* @param
* @return
*/
@RequiresPermissions("system:tenant:edit")
@RequestMapping(value = "/edit", method ={RequestMethod.PUT, RequestMethod.POST})
public Result<SysTenant> edit(@RequestBody SysTenant tenant) {
Result<SysTenant> result = new Result();
SysTenant sysTenant = sysTenantService.getById(tenant.getId());
if(sysTenant==null) {
return result.error500("未找到对应实体");
}
if(oConvertUtils.isEmpty(sysTenant.getHouseNumber())){
tenant.setHouseNumber(RandomUtil.randomStringUpper(6));
}
boolean ok = sysTenantService.updateById(tenant);
if(ok) {
result.success("修改成功!");
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@RequiresPermissions("system:tenant:delete")
@RequestMapping(value = "/delete", method ={RequestMethod.DELETE, RequestMethod.POST})
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
//------------------------------------------------------------------
//如果是saas隔离的情况下，判断当前租户id是否是当前租户下的
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
//获取当前用户
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
SysTenant sysTenant = sysTenantService.getById(id);
String username = "admin";
String createdBy = sysUser.getUsername();
if (!sysTenant.getCreateBy().equals(createdBy) && !username.equals(createdBy)) {
baseCommonService.addLog("未经授权，不能删除非自己创建的租户，租户ID：" + id + "，操作人：" + sysUser.getUsername(), CommonConstant.LOG_TYPE_2, CommonConstant.OPERATE_TYPE_3);
return Result.error("删除租户失败,当前操作人不是租户的创建人！");
}
}
//------------------------------------------------------------------
sysTenantService.removeTenantById(id);
return Result.ok("删除成功");
}
/**
* 批量删除
* @param ids
* @return
*/
@RequiresPermissions("system:tenant:deleteBatch")
@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 {
String[] ls = ids.split(",");
// 过滤掉已被引用的租户
List<Integer> idList = new ArrayList<>();
for (String id : ls) {
//------------------------------------------------------------------
//如果是saas隔离的情况下，判断当前租户id是否是当前租户下的
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
//获取当前用户
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
SysTenant sysTenant = sysTenantService.getById(id);
String username = "admin";
String createdBy = sysUser.getUsername();
if (!sysTenant.getCreateBy().equals(createdBy) && !username.equals(createdBy)) {
baseCommonService.addLog("未经授权，不能删除非自己创建的租户，租户ID：" + id + "，操作人：" + sysUser.getUsername(), CommonConstant.LOG_TYPE_2, CommonConstant.OPERATE_TYPE_3);
return Result.error("删除租户失败,当前操作人不是租户的创建人！");
}
}
//------------------------------------------------------------------
idList.add(Integer.parseInt(id));
}
// 代码逻辑说明: 【QQYUN-5723】3、租户删除直接删除，不删除中间表------------
sysTenantService.removeByIds(idList);
result.success("删除成功！");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@SignatureCheck
@RequestMapping(value = "/queryById", method = RequestMethod.GET)
public Result<SysTenant> queryById(@RequestParam(name="id",required=true) String id) {
Result<SysTenant> result = new Result<SysTenant>();
if(oConvertUtils.isEmpty(id)){
result.error500("参数为空！");
}
//------------------------------------------------------------------------------------------------
//获取登录用户信息
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】, admin给特权可以管理所有租户
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL && !"admin".equals(sysUser.getUsername())){
Integer loginSessionTenant = oConvertUtils.getInt(TenantContext.getTenant());
if(loginSessionTenant!=null && !loginSessionTenant.equals(Integer.valueOf(id))){
result.error500("无权限访问他人租户！");
return result;
}
}
//------------------------------------------------------------------------------------------------
SysTenant sysTenant = sysTenantService.getById(id);
if(sysTenant==null) {
result.error500("未找到对应实体");
}else {
result.setResult(sysTenant);
result.setSuccess(true);
}
return result;
}
/**
* 查询有效的 租户数据
* @return
*/
@RequiresPermissions("system:tenant:queryList")
@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;
}
/**
* 产品包分页列表查询
*
* @param sysTenantPack
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/packList")
@RequiresPermissions("system:tenant:packList")
public Result<IPage<SysTenantPack>> queryPackPageList(SysTenantPack sysTenantPack,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<SysTenantPack> queryWrapper = QueryGenerator.initQueryWrapper(sysTenantPack, req.getParameterMap());
Page<SysTenantPack> page = new Page<SysTenantPack>(pageNo, pageSize);
IPage<SysTenantPack> pageList = sysTenantPackService.page(page, queryWrapper);
List<SysTenantPack> records = pageList.getRecords();
if (null != records && records.size() > 0) {
pageList.setRecords(sysTenantPackService.setPermissions(records));
}
return Result.OK(pageList);
}
/**
* 创建租户产品包
*
* @param sysTenantPack
* @return
*/
@PostMapping(value = "/addPackPermission")
@RequiresPermissions("system:tenant:add:pack")
public Result<String> addPackPermission(@RequestBody SysTenantPack sysTenantPack) {
sysTenantPackService.addPackPermission(sysTenantPack);
return Result.ok("创建租户产品包成功");
}
/**
* 创建租户产品包
*
* @param sysTenantPack
* @return
*/
@PutMapping(value = "/editPackPermission")
@RequiresPermissions("system:tenant:edit:pack")
public Result<String> editPackPermission(@RequestBody SysTenantPack sysTenantPack) {
sysTenantPackService.editPackPermission(sysTenantPack);
return Result.ok("修改租户产品包成功");
}
/**
* 批量删除用户菜单
*
* @param ids
* @return
*/
@DeleteMapping("/deleteTenantPack")
@RequiresPermissions("system:tenant:delete:pack")
public Result<String> deleteTenantPack(@RequestParam(value = "ids") String ids) {
sysTenantPackService.deleteTenantPack(ids);
return Result.ok("删除租户产品包成功");
}
//===========【低代码应用，前端专用接口 —— 加入限制只能维护和查看自己拥有的租户】==========================================================
/**
* 查询当前用户的所有有效租户【低代码应用专用接口】
* @return
*/
@RequestMapping(value = "/getCurrentUserTenant", method = RequestMethod.GET)
public Result<Map<String,Object>> getCurrentUserTenant() {
Result<Map<String,Object>> result = new Result<Map<String,Object>>();
try {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
// 代码逻辑说明: [QQYUN-3371]租户逻辑改造，改成关系表------------
List<Integer> tenantIdList = relationService.getTenantIdsByUserId(sysUser.getId());
Map<String,Object> map = new HashMap(5);
if (null!=tenantIdList && tenantIdList.size()>0) {
// 该方法仅查询有效的租户，如果返回0个就说明所有的租户均无效。
List<SysTenant> tenantList = sysTenantService.queryEffectiveTenant(tenantIdList);
map.put("list", tenantList);
}
result.setSuccess(true);
result.setResult(map);
}catch(Exception e) {
log.error(e.getMessage(), e);
result.error500("查询失败！");
}
return result;
}
/**
* 邀请用户【低代码应用专用接口】
* @param ids
* @param phone
* @return
*/
@PutMapping("/invitationUserJoin")
@RequiresPermissions("system:tenant:invitation:user")
public Result<String> invitationUserJoin(@RequestParam("ids") String ids,@RequestParam(value = "phone", required = false) String phone, @RequestParam(value = "username", required = false) String username){
if(oConvertUtils.isEmpty(phone) && oConvertUtils.isEmpty(username)){
return Result.error("手机号和用户账号不能同时为空！");
}
sysTenantService.invitationUserJoin(ids,phone,username);
return Result.ok("邀请用户成功");
}
/**
* 获取用户列表数据【低代码应用专用接口】
* @param user
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/getTenantUserList", method = RequestMethod.GET)
@RequiresPermissions("system:tenant:user:list")
public Result<IPage<SysUser>> getTenantUserList(SysUser user,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
@RequestParam(name="userTenantId") String userTenantId,
HttpServletRequest req) {
Result<IPage<SysUser>> result = new Result<>();
Page<SysUser> page = new Page<>(pageNo, pageSize);
Page<SysUser> pageList = relationService.getPageUserList(page,Integer.valueOf(userTenantId),user);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 请离用户租户【低代码应用专用接口】
* @param userIds
* @param tenantId
* @return
*/
@PutMapping("/leaveTenant")
@RequiresPermissions("system:tenant:leave")
public Result<String> leaveTenant(@RequestParam("userIds") String userIds,
@RequestParam("tenantId") String tenantId){
Result<String> result = new Result<>();
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL && !"admin".equals(sysUser.getUsername())){
Integer loginSessionTenant = oConvertUtils.getInt(TenantContext.getTenant());
if(loginSessionTenant!=null && !loginSessionTenant.equals(Integer.valueOf(tenantId))){
result.error500("无权限访问他人租户！");
return result;
}
}
sysTenantService.leaveTenant(userIds,tenantId);
return Result.ok("请离成功");
}
/**
* 编辑（只允许修改自己拥有的租户）【低代码应用专用接口】
* @param
* @return
*/
@RequestMapping(value = "/editOwnTenant", method ={RequestMethod.PUT, RequestMethod.POST})
public Result<SysTenant> editOwnTenant(@RequestBody SysTenant tenant,HttpServletRequest req) {
Result<SysTenant> result = new Result();
String tenantId = TokenUtils.getTenantIdByRequest(req);
if(!tenantId.equals(tenant.getId().toString())){
return result.error500("无权修改他人租户！");
}
SysTenant sysTenant = sysTenantService.getById(tenant.getId());
if(sysTenant==null) {
return result.error500("未找到对应实体");
}
if(oConvertUtils.isEmpty(sysTenant.getHouseNumber())){
tenant.setHouseNumber(RandomUtil.randomStringUpper(6));
}
boolean ok = sysTenantService.updateById(tenant);
if(ok) {
result.success("修改成功!");
}
return result;
}
/**
* 创建租户并且将用户保存到中间表【低代码应用专用接口】
* @param sysTenant
*/
@PostMapping("/saveTenantJoinUser")
public Result<Integer> saveTenantJoinUser(@RequestBody SysTenant sysTenant){
Result<Integer> result = new Result<>();
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
Integer tenantId = sysTenantService.saveTenantJoinUser(sysTenant, sysUser.getId());
result.setSuccess(true);
result.setMessage("创建成功");
result.setResult(tenantId);
return result;
}
// /**
// * 加入租户通过门牌号【低代码应用专用接口】
// * @param sysTenant
// */
// @PostMapping("/joinTenantByHouseNumber")
// public Result<Integer> joinTenantByHouseNumber(@RequestBody SysTenant sysTenant){
// LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
// Integer tenantId = sysTenantService.joinTenantByHouseNumber(sysTenant, sysUser.getId());
// Result<Integer> result = new Result<>();
// if(tenantId != 0){
// result.setMessage("申请加入组织成功");
// result.setSuccess(true);
// result.setResult(tenantId);
// return result;
// }else{
// result.setMessage("该门牌号不存在");
// result.setSuccess(false);
// return result;
// }
// }
/**
* 分页获取租户用户数据(vue3用户租户页面)【低代码应用专用接口】
*
* @param pageNo
* @param pageSize
* @param userTenantStatus
* @param type
* @param req
* @return
*/
@GetMapping("/getUserTenantPageList")
//@RequiresPermissions("system:tenant:tenantPageList")
public Result<IPage<SysUserTenantVo>> getUserTenantPageList(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
@RequestParam(name = "userTenantStatus") String userTenantStatus,
@RequestParam(name = "type", required = false) String type,
SysUser user,
HttpServletRequest req) {
Page<SysUserTenantVo> page = new Page<SysUserTenantVo>(pageNo, pageSize);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String tenantId = oConvertUtils.getString(TenantContext.getTenant(), "0");
IPage<SysUserTenantVo> list = relationService.getUserTenantPageList(page, Arrays.asList(userTenantStatus.split(SymbolConstant.COMMA)), user, Integer.valueOf(tenantId));
return Result.ok(list);
}
/**
* 通过用户id获取租户列表【低代码应用专用接口】
*
* @param userTenantStatus 关系表的状态
* @return
*/
@GetMapping("/getTenantListByUserId")
//@RequiresPermissions("system:tenant:getTenantListByUserId")
public Result<List<SysUserTenantVo>> getTenantListByUserId(@RequestParam(name = "userTenantStatus", required = false) String userTenantStatus) {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
List<String> list = null;
if (oConvertUtils.isNotEmpty(userTenantStatus)) {
list = Arrays.asList(userTenantStatus.split(SymbolConstant.COMMA));
}
//租户状态，用户id,租户用户关系状态
List<SysUserTenantVo> sysTenant = relationService.getTenantListByUserId(sysUser.getId(), list);
return Result.ok(sysTenant);
}
/**
* 更新用户租户关系状态【低代码应用专用接口】
*/
@PutMapping("/updateUserTenantStatus")
//@RequiresPermissions("system:tenant:updateUserTenantStatus")
public Result<String> updateUserTenantStatus(@RequestBody SysUserTenant userTenant) {
String tenantId = TenantContext.getTenant();
if (oConvertUtils.isEmpty(tenantId)) {
return Result.error("未找到当前租户信息");
}
relationService.updateUserTenantStatus(userTenant.getUserId(), tenantId, userTenant.getStatus());
return Result.ok("更新用户租户状态成功");
}
/**
* 注销租户【低代码应用专用接口】
*
* @param sysTenant
* @return
*/
@PutMapping("/cancelTenant")
//@RequiresPermissions("system:tenant:cancelTenant")
public Result<String> cancelTenant(@RequestBody SysTenant sysTenant,HttpServletRequest request) {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
SysTenant tenant = sysTenantService.getById(sysTenant.getId());
if (null == tenant) {
return Result.error("未找到当前租户信息");
}
if (!sysUser.getUsername().equals(tenant.getCreateBy())) {
return Result.error("无权限，只能注销自己创建的租户！");
}
SysUser userById = sysUserService.getById(sysUser.getId());
String loginPassword = request.getParameter("loginPassword");
String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(),loginPassword, userById.getSalt());
if (!passwordEncode.equals(userById.getPassword())) {
return Result.error("密码不正确");
}
sysTenantService.removeById(sysTenant.getId());
return Result.ok("注销成功");
}
/**
* 获取租户用户不同状态下的数量【低代码应用专用接口】
* @return
*/
@GetMapping("/getTenantStatusCount")
public Result<Long> getTenantStatusCount(@RequestParam(value = "status",defaultValue = "1") String status, HttpServletRequest req){
String tenantId = TokenUtils.getTenantIdByRequest(req);
if (null == tenantId) {
return Result.error("未找到当前租户信息");
}
LambdaQueryWrapper<SysUserTenant> query = new LambdaQueryWrapper<>();
query.eq(SysUserTenant::getTenantId,tenantId);
query.eq(SysUserTenant::getStatus,status);
long count = relationService.count(query);
return Result.ok(count);
}
/**
* 用户取消租户申请【低代码应用专用接口】
* @param tenantId
* @return
*/
@PutMapping("/cancelApplyTenant")
public Result<String> cancelApplyTenant(@RequestParam("tenantId") String tenantId){
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
sysTenantService.leaveTenant(sysUser.getId(),tenantId);
return Result.ok("取消申请成功");
}
//===========【低代码应用，前端专用接口 —— 加入限制只能维护和查看自己拥有的租户】==========================================================
/**
* 彻底删除租户
* @param ids
* @return
*/
@DeleteMapping("/deleteLogicDeleted")
@RequiresPermissions("system:tenant:deleteTenantLogic")
public Result<String> deleteTenantLogic(@RequestParam("ids") String ids){
sysTenantService.deleteTenantLogic(ids);
return Result.ok("彻底删除成功");
}
/**
* 还原删除的租户
* @param ids
* @return
*/
@PutMapping("/revertTenantLogic")
@RequiresPermissions("system:tenant:revertTenantLogic")
public Result<String> revertTenantLogic(@RequestParam("ids") String ids){
sysTenantService.revertTenantLogic(ids);
return Result.ok("还原成功");
}
/**
* 退出租户【低代码应用专用接口】
* @param sysTenant
* @param request
* @return
*/
@DeleteMapping("/exitUserTenant")
public Result<String> exitUserTenant(@RequestBody SysTenant sysTenant,HttpServletRequest request){
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//验证用户是否已存在
Integer count = relationService.userTenantIzExist(sysUser.getId(),sysTenant.getId());
if (count == 0) {
return Result.error("此租户下没有当前用户");
}
//验证密码
String loginPassword = request.getParameter("loginPassword");
SysUser userById = sysUserService.getById(sysUser.getId());
String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(),loginPassword, userById.getSalt());
if (!passwordEncode.equals(userById.getPassword())) {
return Result.error("密码不正确");
}
//退出登录
sysTenantService.exitUserTenant(sysUser.getId(),sysUser.getUsername(),String.valueOf(sysTenant.getId()));
return Result.ok("退出租户成功");
}
/**
* 变更租户拥有者【低代码应用专用接口】
* @param userId
* @return
*/
@PostMapping("/changeOwenUserTenant")
public Result<String> changeOwenUserTenant(@RequestParam("userId") String userId,
@RequestParam("tenantId") String tenantId){
sysTenantService.changeOwenUserTenant(userId,tenantId);
return Result.ok("退出租户成功");
}
/**
* 邀请用户到租户,通过手机号匹配 【低代码应用专用接口】
* @param phone
* @param departId
* @return
*/
@PostMapping("/invitationUser")
@RequiresPermissions("system:tenant:invitation:user")
public Result<String> invitationUser(@RequestParam(name="phone") String phone,
@RequestParam(name="departId",defaultValue = "") String departId){
return sysTenantService.invitationUser(phone,departId);
}
/**
* 获取 租户产品包-3个默认admin的人员数量
* @param tenantId
* @return
*/
@GetMapping("/loadAdminPackCount")
public Result<List<TenantPackUserCount>> loadAdminPackCount(@RequestParam("tenantId") Integer tenantId){
List<TenantPackUserCount> list = sysTenantService.queryTenantPackUserCount(tenantId);
return Result.ok(list);
}
/**
* 查询租户产品包信息
* @param packModel
* @return
*/
@GetMapping("/getTenantPackInfo")
public Result<TenantPackModel> getTenantPackInfo(TenantPackModel packModel){
TenantPackModel tenantPackModel = sysTenantService.queryTenantPack(packModel);
return Result.ok(tenantPackModel);
}
/**
* 添加用户和产品包的关系数据
* @param sysTenantPackUser
* @return
*/
@PostMapping("/addTenantPackUser")
public Result<?> addTenantPackUser(@RequestBody SysTenantPackUser sysTenantPackUser){
sysTenantService.addBatchTenantPackUser(sysTenantPackUser);
return Result.ok("操作成功！");
}
/**
* 从产品包移除用户
* @param sysTenantPackUser
* @return
*/
@PutMapping("/deleteTenantPackUser")
public Result<?> deleteTenantPackUser(@RequestBody SysTenantPackUser sysTenantPackUser){
sysTenantService.deleteTenantPackUser(sysTenantPackUser);
return Result.ok("操作成功！");
}
/**
* 修改申请状态
* @param sysTenant
* @return
*/
@PutMapping("/updateApplyStatus")
public Result<?> updateApplyStatus(@RequestBody SysTenant sysTenant){
SysTenant entity = this.sysTenantService.getById(sysTenant.getId());
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysAnnouncementController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysAnnouncementController.java | package org.jeecg.modules.system.controller;
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 com.jeecg.dingtalk.api.core.response.Response;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.dto.PushMessageDTO;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.CommonSendStatus;
import org.jeecg.common.constant.WebsocketConst;
import org.jeecg.common.constant.enums.NoticeTypeEnum;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.*;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.message.enums.RangeDateEnum;
import org.jeecg.modules.message.websocket.WebSocket;
import org.jeecg.modules.system.entity.SysAnnouncement;
import org.jeecg.modules.system.entity.SysAnnouncementSend;
import org.jeecg.modules.system.service.ISysAnnouncementSendService;
import org.jeecg.modules.system.service.ISysAnnouncementService;
import org.jeecg.modules.system.service.impl.SysBaseApiImpl;
import org.jeecg.modules.system.service.impl.ThirdAppDingtalkServiceImpl;
import org.jeecg.modules.system.service.impl.ThirdAppWechatEnterpriseServiceImpl;
import org.jeecg.modules.system.util.XssUtils;
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.context.annotation.Lazy;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
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 jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static org.jeecg.common.constant.CommonConstant.ANNOUNCEMENT_SEND_STATUS_1;
/**
* @Title: Controller
* @Description: 系统通告表
* @Author: jeecg-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;
@Autowired
ThirdAppWechatEnterpriseServiceImpl wechatEnterpriseService;
@Autowired
ThirdAppDingtalkServiceImpl dingtalkService;
@Autowired
private SysBaseApiImpl sysBaseApi;
@Autowired
@Lazy
private RedisUtil redisUtil;
@Autowired
public RedisTemplate redisTemplate;
//常规报错定义
private static final String SPECIAL_CHAR_ERROR = "保存失败:消息内容包含数据库不支持的特殊字符，请检查并修改内容!";
private static final String CONTENT_TOO_LONG_ERROR = "保存失败:消息内容超过最大长度限制，请缩减内容长度!";
private static final String DEFAULT_ERROR = "操作失败，请稍后重试或联系管理员!";
/**
* 通告缓存
*/
String ANNO_CACHE_KEY = "sys:cache:announcement";
/**
* QQYUN-5072【性能优化】线上通知消息打开有点慢
*/
public static ExecutorService cachedThreadPool = new ShiroThreadPoolExecutor(0, 1024,60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
public static ExecutorService completeNoteThreadPool = new ShiroThreadPoolExecutor(0, 1024,60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
/**
* 分页列表查询
* @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) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysAnnouncement.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
Result<IPage<SysAnnouncement>> result = new Result<IPage<SysAnnouncement>>();
sysAnnouncement.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
QueryWrapper<SysAnnouncement> queryWrapper = QueryGenerator.initQueryWrapper(sysAnnouncement, req.getParameterMap());
Page<SysAnnouncement> page = new Page<SysAnnouncement>(pageNo,pageSize);
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 {
// 代码逻辑说明: 标题处理xss攻击的问题
String title = XssUtils.scriptXss(sysAnnouncement.getTitile());
sysAnnouncement.setTitile(title);
sysAnnouncement.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
//未发布
sysAnnouncement.setSendStatus(CommonSendStatus.UNPUBLISHED_STATUS_0);
//流程状态
sysAnnouncement.setBpmStatus("1");
sysAnnouncement.setNoticeType(NoticeTypeEnum.NOTICE_TYPE_SYSTEM.getValue());
sysAnnouncementService.saveAnnouncement(sysAnnouncement);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500(determineErrorMessage(e));
}
return result;
}
/**
* 编辑
* @param sysAnnouncement
* @return
*/
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
public Result<SysAnnouncement> eidt(@RequestBody SysAnnouncement sysAnnouncement) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncementEntity = sysAnnouncementService.getById(sysAnnouncement.getId());
try{
if(sysAnnouncementEntity==null) {
result.error500("未找到对应实体");
}else {
// 代码逻辑说明: 标题处理xss攻击的问题
String title = XssUtils.scriptXss(sysAnnouncement.getTitile());
sysAnnouncement.setTitile(title);
sysAnnouncement.setNoticeType(NoticeTypeEnum.NOTICE_TYPE_SYSTEM.getValue());
boolean ok = sysAnnouncementService.upDateAnnouncement(sysAnnouncement);
//TODO 返回false说明什么？
if(ok) {
result.success("修改成功!");
}
}
} catch (Exception e) {
result.error500(determineErrorMessage(e));
}
return result;
}
/**
* 简单编辑
* @param sysAnnouncement
* @return
*/
@RequestMapping(value = "/editIzTop", method = {RequestMethod.PUT,RequestMethod.POST})
public Result<SysAnnouncement> editIzTop(@RequestBody SysAnnouncement sysAnnouncement) {
Result<SysAnnouncement> result = new Result<SysAnnouncement>();
SysAnnouncement sysAnnouncementEntity = sysAnnouncementService.getById(sysAnnouncement.getId());
if(sysAnnouncementEntity==null) {
result.error500("未找到对应实体");
}else {
Integer izTop = sysAnnouncement.getIzTop();
sysAnnouncementEntity.setIzTop(oConvertUtils.getInt(izTop,CommonConstant.IZ_TOP_0));
sysAnnouncementService.updateById(sysAnnouncementEntity);
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(oConvertUtils.isEmpty(sysAnnouncement.getNoticeType())){
sysAnnouncement.setNoticeType(NoticeTypeEnum.NOTICE_TYPE_SYSTEM.getValue());
}
if(ok) {
result.success("系统通知推送成功");
if(sysAnnouncement.getMsgType().equals(CommonConstant.MSG_TYPE_ALL)) {
// 补全公告和用户之前的关系
sysAnnouncementService.batchInsertSysAnnouncementSend(sysAnnouncement.getId(), sysAnnouncement.getTenantId());
// 推送websocket通知
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());
obj.put(CommonConstant.NOTICE_TYPE, sysAnnouncement.getNoticeType());
webSocket.sendMessage(obj.toJSONString());
//update-begin-author:liusq---date:2025-11-13--for: JHHB-827 【审批消息】移动端需要有推送 -全推送
PushMessageDTO pushMessageDTO = new PushMessageDTO();
pushMessageDTO.setTitle(sysAnnouncement.getTitile());
pushMessageDTO.setPushType(CommonConstant.MSG_TYPE_ALL);
pushMessageDTO.setContent(sysAnnouncement.getMsgAbstract());
sysBaseApi.uniPushMsgToUser(pushMessageDTO);
//update-begin-author:liusq---date:2025-11-13--for: JHHB-827 【审批消息】移动端需要有推送 -全推送
}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());
obj.put(CommonConstant.NOTICE_TYPE, sysAnnouncement.getNoticeType());
webSocket.sendMessage(userIds, obj.toJSONString());
//update-begin-author:liusq---date:2025-11-13--for: JHHB-827 【审批消息】移动端需要有推送
PushMessageDTO pushMessageDTO = new PushMessageDTO();
pushMessageDTO.setTitle(sysAnnouncement.getTitile());
pushMessageDTO.setUserIds(Arrays.asList(userIds));
pushMessageDTO.setContent(sysAnnouncement.getMsgAbstract());
sysBaseApi.uniPushMsgToUser(pushMessageDTO);
//update-begin-author:liusq---date:2025-11-13--for: JHHB-827 【审批消息】移动端需要有推送
}
try {
// 同步企业微信、钉钉的消息通知
Response<String> dtResponse = dingtalkService.sendActionCardMessage(sysAnnouncement, null, true);
wechatEnterpriseService.sendTextCardMessage(sysAnnouncement, null,true);
if (dtResponse != null && dtResponse.isSuccess()) {
String taskId = dtResponse.getResult();
sysAnnouncement.setDtTaskId(taskId);
sysAnnouncementService.updateById(sysAnnouncement);
}
} catch (Exception e) {
log.error("同步发送第三方APP消息失败：", e);
}
}
}
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("该系统通知撤销成功");
if (oConvertUtils.isNotEmpty(sysAnnouncement.getDtTaskId())) {
try {
dingtalkService.recallMessage(sysAnnouncement.getDtTaskId());
} catch (Exception e) {
log.error("第三方APP撤回消息失败：", e);
}
}
}
}
return result;
}
/**
* @功能：补充用户数据，并返回系统消息
* @return
*/
@RequestMapping(value = "/listByUser", method = RequestMethod.GET)
public Result<Map<String, Object>> listByUser(@RequestParam(required = false, defaultValue = "5") Integer pageSize, HttpServletRequest request) {
long start = System.currentTimeMillis();
Result<Map<String,Object>> result = new Result<Map<String,Object>>();
Map<String,Object> sysMsgMap = new HashMap(5);
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
// 获取上个月的第一天（只查近两个月的通知）
Date lastMonthStartDay = DateRangeUtils.getLastMonthStartDay();
log.info("-----查询近两个月收到的未读通知-----，近2月的第一天：{}", lastMonthStartDay);
// //补推送数据（用户和通知的关系表）
// completeNoteThreadPool.execute(()->{
// sysAnnouncementService.completeAnnouncementSendInfo();
// });
// 2.查询用户未读的系统消息
Page<SysAnnouncement> anntMsgList = new Page<SysAnnouncement>(0, pageSize);
//通知公告消息
anntMsgList = sysAnnouncementService.querySysCementPageByUserId(anntMsgList,userId,"1",null, lastMonthStartDay);
sysMsgMap.put("anntMsgList", anntMsgList.getRecords());
sysMsgMap.put("anntMsgTotal", anntMsgList.getTotal());
log.info("begin 获取用户近2个月的系统公告 (通知)" + (System.currentTimeMillis() - start) + "毫秒");
//系统消息
Page<SysAnnouncement> sysMsgList = new Page<SysAnnouncement>(0, pageSize);
sysMsgList = sysAnnouncementService.querySysCementPageByUserId(sysMsgList,userId,"2",null, lastMonthStartDay);
sysMsgMap.put("sysMsgList", sysMsgList.getRecords());
sysMsgMap.put("sysMsgTotal", sysMsgList.getTotal());
log.info("end 获取用户2个月的系统公告 (系统消息)" + (System.currentTimeMillis() - start) + "毫秒");
result.setSuccess(true);
result.setResult(sysMsgMap);
return result;
}
/**
* 获取未读消息通知数量
*
* @return
*/
@RequestMapping(value = "/getUnreadMessageCount", method = RequestMethod.GET)
public Result<Map<String, Integer>> getUnreadMessageCount(@RequestParam(required = false, defaultValue = "5") Integer pageSize, HttpServletRequest request) {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
// 获取上个月的第一天（只查近两个月的通知）
Date lastMonthStartDay = DateRangeUtils.getLastMonthStartDay();
log.debug(" ------查询近两个月收到的未读通知消息数量------，近2月的第一天：{}", lastMonthStartDay);
// 代码逻辑说明: 【QQYUN-12162】OA项目改造，系统重消息拆分，目前消息都在一起 需按分类进行拆分---
Map<String,Integer> unreadMessageCount = new HashMap<>();
//系统消息数量
Integer systemCount = sysAnnouncementService.getUnreadMessageCountByUserId(userId, lastMonthStartDay, NoticeTypeEnum.NOTICE_TYPE_SYSTEM.getValue());
unreadMessageCount.put("systemCount",systemCount);
//流程数量
Integer flowCount = sysAnnouncementService.getUnreadMessageCountByUserId(userId, lastMonthStartDay, NoticeTypeEnum.NOTICE_TYPE_FLOW.getValue());
unreadMessageCount.put("flowCount",flowCount);
//文件数量
Integer fileCount = sysAnnouncementService.getUnreadMessageCountByUserId(userId, lastMonthStartDay, NoticeTypeEnum.NOTICE_TYPE_FILE.getValue());
unreadMessageCount.put("fileCount",fileCount);
//日程计划数量
Integer planCount = sysAnnouncementService.getUnreadMessageCountByUserId(userId, lastMonthStartDay, NoticeTypeEnum.NOTICE_TYPE_PLAN.getValue());
unreadMessageCount.put("planCount",planCount);
Integer count = systemCount + flowCount + fileCount + planCount;
unreadMessageCount.put("count",count);
return Result.ok(unreadMessageCount);
}
/**
* 导出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.toString());
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());
}
if(oConvertUtils.isEmpty(sysAnnouncementExcel.getIzTop())){
sysAnnouncementExcel.setIzTop(CommonConstant.IZ_TOP_0);
}
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;
}
/**
* 通告查看详情页面（用于第三方APP）
* @param modelAndView
* @param id
* @return
*/
@GetMapping("/show/{id}")
public ModelAndView showContent(ModelAndView modelAndView, @PathVariable("id") String id, HttpServletRequest request) {
SysAnnouncement announcement = sysAnnouncementService.getById(id);
if (announcement != null) {
boolean tokenOk = false;
try {
// 验证Token有效性
tokenOk = TokenUtils.verifyToken(request, sysBaseApi, redisUtil);
} catch (Exception ignored) {
}
// 判断是否传递了Token，并且Token有效，如果传了就不做查看限制，直接返回
// 如果Token无效，就做查看限制：只能查看已发布的
if (tokenOk || ANNOUNCEMENT_SEND_STATUS_1.equals(announcement.getSendStatus())) {
modelAndView.addObject("data", announcement);
modelAndView.setViewName("announcement/showContent");
return modelAndView;
}
}
modelAndView.setStatus(HttpStatus.NOT_FOUND);
return modelAndView;
}
/**
* 【vue3用】 消息列表查询
* @param fromUser
* @param busType
* @param starFlag
* @param msgCategory
* @param beginDate
* @param endDate
* @param pageNo
* @param pageSize
* @return
*/
@RequestMapping(value = "/vue3List", method = RequestMethod.GET)
public Result<List<SysAnnouncement>> vue3List(@RequestParam(name="fromUser", required = false) String fromUser,
@RequestParam(name="busType", required = false) String busType,
@RequestParam(name="starFlag", required = false) String starFlag,
@RequestParam(name="msgCategory", required = false) String msgCategory,
@RequestParam(name="rangeDateKey", required = false) String rangeDateKey,
@RequestParam(name="beginDate", required = false) String beginDate,
@RequestParam(name="endDate", required = false) String endDate,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
@RequestParam(name= "noticeType", required = false) String noticeType) {
long calStartTime = System.currentTimeMillis(); // 记录开始时间
// 1、获取日期查询条件，开始时间和结束时间
Date beginTime = null, endTime = null;
if (RangeDateEnum.ZDY.getKey().equals(rangeDateKey)) {
// 自定义日期范围查询
if (oConvertUtils.isNotEmpty(beginDate)) {
beginTime = DateUtils.parseDatetime(beginDate);
}
if (oConvertUtils.isNotEmpty(endDate)) {
endTime = DateUtils.parseDatetime(endDate);
}
} else {
// 日期段落查询
Date[] arr = RangeDateEnum.getRangeArray(rangeDateKey);
if (arr != null) {
beginTime = arr[0];
endTime = arr[1];
}
}
// 2、根据条件查询用户的通知消息
List<SysAnnouncement> ls = this.sysAnnouncementService.querySysMessageList(pageSize, pageNo, fromUser, starFlag,busType, msgCategory, beginTime, endTime, noticeType);
// 3、设置当前页的消息为已读
if (!CollectionUtils.isEmpty(ls)) {
// 设置已读
String readed = "1";
List<String> annoceIdList = ls.stream().filter(item -> !readed.equals(item.getReadFlag())).map(item -> item.getId()).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(annoceIdList)) {
cachedThreadPool.execute(() -> {
sysAnnouncementService.updateReaded(annoceIdList);
});
}
}
JSONObject obj = new JSONObject();
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
webSocket.sendMessage(sysUser.getId(), obj.toJSONString());
// 4、性能统计耗时
long calEndTime = System.currentTimeMillis(); // 记录结束时间
long duration = calEndTime - calStartTime; // 计算耗时
//System.out.println("耗时：" + duration + " 毫秒");
return Result.ok(ls);
}
/**
* 根据用户id获取最新一条消息发送时间(创建时间)
* @param userId
* @return
*/
@GetMapping("/getLastAnnountTime")
public Result<Page<SysAnnouncementSend>> getLastAnnountTime(@RequestParam(name = "userId") String userId,@RequestParam(name="noticeType",required = false) String noticeType){
Result<Page<SysAnnouncementSend>> result = new Result<>();
//----------------------------------------------------------------------------------------
// step.1 此接口过慢，可以采用缓存一小时方案
String keyString = String.format(CommonConstant.CACHE_KEY_USER_LAST_ANNOUNT_TIME_1HOUR + "_" + noticeType, userId);
if (redisTemplate.hasKey(keyString)) {
log.debug("[SysAnnouncementSend Redis] 通过Redis缓存查询用户最后一次收到系统通知时间，userId={}", userId);
Page<SysAnnouncementSend> pageList = (Page<SysAnnouncementSend>) redisTemplate.opsForValue().get(keyString);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
//----------------------------------------------------------------------------------------
Page<SysAnnouncementSend> page = new Page<>(1,1);
LambdaQueryWrapper<SysAnnouncementSend> query = new LambdaQueryWrapper<>();
query.eq(SysAnnouncementSend::getUserId,userId);
//只查询上个月和本月，的通知的数据
query.ne(SysAnnouncementSend::getCreateTime, DateRangeUtils.getLastMonthStartDay());
query.select(SysAnnouncementSend::getCreateTime); // 提高查询效率
query.orderByDesc(SysAnnouncementSend::getCreateTime);
Page<SysAnnouncementSend> pageList = sysAnnouncementSendService.page(page, query);
//----------------------------------------------------------------------------------------
if (pageList != null && pageList.getSize() > 0) {
// step.3 保留1小时redis缓存
redisTemplate.opsForValue().set(keyString, pageList, 3600, TimeUnit.SECONDS);
}
//----------------------------------------------------------------------------------------
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 清除当前用户所有未读消息
* @return
*/
@PostMapping("/clearAllUnReadMessage")
public Result<String> clearAllUnReadMessage(){
sysAnnouncementService.clearAllUnReadMessage();
return Result.ok("清除未读消息成功");
}
/**
* 添加访问次数
* @param id
* @return
*/
@RequestMapping(value = "/addVisitsNumber", method = RequestMethod.GET)
public Result<?> addVisitsNumber(@RequestParam(name="id",required=true) String id) {
int count = oConvertUtils.getInt(redisUtil.get(ANNO_CACHE_KEY+id),0) + 1;
redisUtil.set(ANNO_CACHE_KEY+id, count);
if (count % 5 == 0) {
cachedThreadPool.execute(() -> {
sysAnnouncementService.updateVisitsNum(id, count);
});
// 重置访问次数
redisUtil.del(ANNO_CACHE_KEY+id);
}
return Result.ok("公告消息访问次数+1次");
}
/**
* 批量下载文件
* @param id
* @param request
* @param response
*/
@GetMapping("/downLoadFiles")
public void downLoadFiles(@RequestParam(name="id") String id,
HttpServletRequest request,
HttpServletResponse response){
sysAnnouncementService.downLoadFiles(id,request,response);
}
/**
* 根据异常信息确定友好的错误提示
*/
private String determineErrorMessage(Exception e) {
String errorMsg = e.getMessage();
if (isSpecialCharacterError(errorMsg)) {
return SPECIAL_CHAR_ERROR;
} else if (isContentTooLongError(errorMsg)) {
return CONTENT_TOO_LONG_ERROR;
} else {
return DEFAULT_ERROR;
}
}
/**
* 判断是否为特殊字符错误
*/
private boolean isSpecialCharacterError(String errorMsg) {
return errorMsg != null
&& errorMsg.contains("Incorrect string value")
&& errorMsg.contains("column 'msg_content'");
}
/**
* 判断是否为内容过长错误
*/
private boolean isContentTooLongError(String errorMsg) {
return errorMsg != null
&& errorMsg.contains("Data too long for column 'msg_content'");
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDictItemController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDictItemController.java | package org.jeecg.modules.system.controller;
import java.util.Arrays;
import java.util.Date;
import jakarta.servlet.http.HttpServletRequest;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysDictItem;
import org.jeecg.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
*/
@Tag(name = "数据字典")
@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
*/
@RequiresPermissions("system:dict:item:add")
@RequestMapping(value = "/add", method = RequestMethod.POST)
@CacheEvict(value= {CacheConstant.SYS_DICT_CACHE, CacheConstant.SYS_ENABLE_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
*/
@RequiresPermissions("system:dict:item:edit")
@RequestMapping(value = "/edit", method = { RequestMethod.PUT,RequestMethod.POST })
@CacheEvict(value={CacheConstant.SYS_DICT_CACHE, CacheConstant.SYS_ENABLE_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
*/
@RequiresPermissions("system:dict:item:delete")
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value={CacheConstant.SYS_DICT_CACHE, CacheConstant.SYS_ENABLE_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
*/
@RequiresPermissions("system:dict:item:deleteBatch")
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value={CacheConstant.SYS_DICT_CACHE, CacheConstant.SYS_ENABLE_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)
@Operation(summary="字典重复校验接口")
public Result<Object> doDictItemCheck(SysDictItem sysDictItem, HttpServletRequest request) {
Long num = Long.valueOf(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("该值不可用，系统中已存在！");
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDepartRoleController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDepartRoleController.java | package org.jeecg.modules.system.controller;
import java.util.*;
import java.util.stream.Collectors;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.*;
import org.jeecg.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.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
/**
* @Description: 部门角色
* @Author: jeecg-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Slf4j
@Tag(name="部门角色")
@RestController
@RequestMapping("/sys/sysDepartRole")
public class SysDepartRoleController extends JeecgController<SysDepartRole, ISysDepartRoleService> {
@Autowired
private ISysDepartRoleService sysDepartRoleService;
@Autowired
private ISysDepartRoleUserService departRoleUserService;
@Autowired
private ISysDepartPermissionService sysDepartPermissionService;
@Autowired
private ISysDepartRolePermissionService sysDepartRolePermissionService;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private BaseCommonService baseCommonService;
/**
* 分页列表查询
*
* @param sysDepartRole
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@Operation(summary="部门角色-分页列表查询")
@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);
//我的部门，选中部门只能看当前部门下的角色
// 代码逻辑说明: [QQYUN-10775]验证码可以复用 #7674------------
if(oConvertUtils.isNotEmpty(deptId)){
queryWrapper.eq("depart_id",deptId);
IPage<SysDepartRole> pageList = sysDepartRoleService.page(page, queryWrapper);
return Result.ok(pageList);
}else{
return Result.ok(null);
}
}
/**
* 添加
*
* @param sysDepartRole
* @return
*/
@RequiresPermissions("system:depart:role:add")
@Operation(summary="部门角色-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDepartRole sysDepartRole) {
sysDepartRoleService.save(sysDepartRole);
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param sysDepartRole
* @return
*/
@Operation(summary="部门角色-编辑")
@RequiresPermissions("system:depart:role:edit")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
public Result<?> edit(@RequestBody SysDepartRole sysDepartRole) {
sysDepartRoleService.updateById(sysDepartRole);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "部门角色-通过id删除")
@Operation(summary="部门角色-通过id删除")
@RequiresPermissions("system:depart:role:delete")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysDepartRoleService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "部门角色-批量删除")
@Operation(summary="部门角色-批量删除")
@RequiresPermissions("system:depart:role:deleteBatch")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
this.sysDepartRoleService.deleteDepartRole(Arrays.asList(ids.split(",")));
//this.sysDepartRoleService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功！");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@Operation(summary="部门角色-通过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
*/
@RequiresPermissions("system:depart:role:userAdd")
@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);
// 代码逻辑说明: [VUEN-234]部门角色分配添加敏感日志------------
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
baseCommonService.addLog("给部门用户ID："+userId+"分配角色，操作人： " +loginUser.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
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 = null;
if(roleIds!=null && roleIds.size()>0){
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(5);
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);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysGatewayRouteController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysGatewayRouteController.java | package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysGatewayRoute;
import org.jeecg.modules.system.service.ISysGatewayRouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.List;
/**
* @Description: gateway路由管理
* @Author: jeecg-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
@Tag(name = "gateway路由管理")
@RestController
@RequestMapping("/sys/gatewayRoute")
@Slf4j
public class SysGatewayRouteController extends JeecgController<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
*/
@RequiresPermissions("system:getway:delete")
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
sysGatewayRouteService.deleteById(id);
return Result.ok("删除路由成功");
}
/**
* 查询被删除的列表
* @return
*/
@RequestMapping(value = "/deleteList", method = RequestMethod.GET)
public Result<List<SysGatewayRoute>> deleteList(HttpServletRequest request) {
Result<List<SysGatewayRoute>> result = new Result<>();
List<SysGatewayRoute> list = sysGatewayRouteService.getDeletelist();
result.setSuccess(true);
result.setResult(list);
return result;
}
/**
* 还原被逻辑删除的路由
*
* @param jsonObject
* @return
*/
@RequiresPermissions("system:gateway:putRecycleBin")
@RequestMapping(value = "/putRecycleBin", method = RequestMethod.PUT)
public Result putRecycleBin(@RequestBody JSONObject jsonObject, HttpServletRequest request) {
try {
String ids = jsonObject.getString("ids");
if (StringUtils.isNotBlank(ids)) {
sysGatewayRouteService.revertLogicDeleted(Arrays.asList(ids.split(",")));
return Result.ok("操作成功!");
}
} catch (Exception e) {
e.printStackTrace();
return Result.error("操作失败!");
}
return Result.ok("还原成功");
}
/**
* 彻底删除路由
*
* @param ids 被删除的路由ID，多个id用半角逗号分割
* @return
*/
@RequiresPermissions("system:gateway:deleteRecycleBin")
@RequestMapping(value = "/deleteRecycleBin", method = RequestMethod.DELETE)
public Result deleteRecycleBin(@RequestParam("ids") String ids) {
try {
if (StringUtils.isNotBlank(ids)) {
sysGatewayRouteService.deleteLogicDeleted(Arrays.asList(ids.split(",")));
}
return Result.ok("删除成功!");
} catch (Exception e) {
e.printStackTrace();
return Result.error("删除失败!");
}
}
/**
* 复制路由
*
* @param id 路由id
* @return
*/
@RequiresPermissions("system:gateway:copyRoute")
@RequestMapping(value = "/copyRoute", method = RequestMethod.GET)
public Result<SysGatewayRoute> copyRoute(@RequestParam(name = "id", required = true) String id, HttpServletRequest req) {
Result<SysGatewayRoute> result = new Result<>();
SysGatewayRoute sysGatewayRoute= sysGatewayRouteService.copyRoute(id);
result.setResult(sysGatewayRoute);
result.setSuccess(true);
return result;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysAppVersionController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysAppVersionController.java | package org.jeecg.modules.system.controller;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysAppVersion;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* @Description: app系统配置
* @Author: jeecg-boot
* @Date: 2025-07-05
* @Version: V1.0
*/
@Tag(name="app系统配置")
@RestController
@RequestMapping("/sys/version")
@Slf4j
public class SysAppVersionController{
@Autowired
private RedisUtil redisUtil;
/**
* APP缓存前缀
*/
private String APP3_VERSION = "app3:version";
/**
* app3版本信息
* @return
*/
@Operation(summary="app版本")
@GetMapping(value = "/app3version")
public Result<SysAppVersion> app3Version(@RequestParam(name="key", required = false)String appKey) throws Exception {
Object appConfig = redisUtil.get(APP3_VERSION + appKey);
if (oConvertUtils.isNotEmpty(appConfig)) {
try {
SysAppVersion sysAppVersion = (SysAppVersion)appConfig;
return Result.OK(sysAppVersion);
} catch (Exception e) {
log.error(e.toString(),e);
return Result.error("app版本信息获取失败：" + e.getMessage());
}
}
return Result.OK();
}
/**
* 保存APP3
*
* @param sysAppVersion
* @return
*/
@RequiresRoles({"admin"})
@Operation(summary="app系统配置-保存")
@PostMapping(value = "/saveVersion")
public Result<?> saveVersion(@RequestBody SysAppVersion sysAppVersion) {
String id = sysAppVersion.getId();
redisUtil.set(APP3_VERSION + id,sysAppVersion);
return Result.OK();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDataLogController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDataLogController.java | package org.jeecg.modules.system.controller;
import java.util.ArrayList;
import java.util.List;
import jakarta.servlet.http.HttpServletRequest;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysDataLog;
import org.jeecg.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;
/**
* @Description: 系统数据日志
* @author: jeecg-boot
*/
@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>>();
dataLog.setType(CommonConstant.DATA_LOG_TYPE_JSON);
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);
// 代码逻辑说明: 新增查询条件-type
String type = req.getParameter("type");
if (oConvertUtils.isNotEmpty(type)) {
queryWrapper.eq("type", type);
}
// 按时间倒序排
queryWrapper.orderByDesc("create_time");
List<SysDataLog> list = service.list(queryWrapper);
if(list==null||list.size()<=0) {
result.error500("未找到版本信息");
}else {
result.setResult(list);
result.setSuccess(true);
}
return result;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysPermissionController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysPermissionController.java | package org.jeecg.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.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.Md5Util;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.shiro.ShiroRealm;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.constant.DefIndexConst;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.model.SysPermissionTree;
import org.jeecg.modules.system.model.TreeModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.util.PermissionDataUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletRequest;
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;
@Autowired
private ISysUserService sysUserService;
@Autowired
private JeecgBaseConfig jeecgBaseConfig;
@Autowired
private BaseCommonService baseCommonService;
@Autowired
private ISysRoleIndexService sysRoleIndexService;
@Autowired
private ShiroRealm shiroRealm;
/**
* 子菜单
*/
private static final String CHILDREN = "children";
/**
* 加载数据节点
*
* @return
*/
//@RequiresPermissions("system:permission:list")
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<List<SysPermissionTree>> list(SysPermission sysPermission, HttpServletRequest req) {
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);
//支持通过菜单名字，模糊查询
if(oConvertUtils.isNotEmpty(sysPermission.getName())){
query.like(SysPermission::getName, sysPermission.getName());
}
List<SysPermission> list = sysPermissionService.list(query);
List<SysPermissionTree> treeList = new ArrayList<>();
//如果有菜单名查询条件，则平铺数据 不做上下级
if(oConvertUtils.isNotEmpty(sysPermission.getName())){
if(list!=null && list.size()>0){
treeList = list.stream().map(e -> {
e.setLeaf(true);
return new SysPermissionTree(e);
}).collect(Collectors.toList());
}
}else{
getTreeList(treeList, list, null);
}
result.setResult(treeList);
result.setSuccess(true);
log.debug("======获取全部菜单数据=====耗时:" + (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:先查询一级菜单，当用户点击展开菜单时加载子菜单 */
/**
* 查询子菜单
*
* @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(5);
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());
}
}
// /**
// * 查询用户拥有的菜单权限和按钮权限（根据用户账号）
// *
// * @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)
//@DynamicTable(value = DynamicTableConstant.SYS_ROLE_INDEX)
public Result<?> getUserPermissionByToken(HttpServletRequest request) {
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.getId());
//添加首页路由
// 代码逻辑说明: 自定义首页地址 LOWCOD-1578
String version = request.getHeader(CommonConstant.VERSION);
SysRoleIndex defIndexCfg = sysUserService.getDynamicIndexByUserRole(loginUser.getUsername(), version);
if (defIndexCfg == null) {
defIndexCfg = sysRoleIndexService.initDefaultIndex();
}
// 如果没有授权角色首页，则自动添加首页路由
if (!PermissionDataUtil.hasIndexPage(metaList, defIndexCfg)) {
LambdaQueryWrapper<SysPermission> indexQueryWrapper = new LambdaQueryWrapper<>();
indexQueryWrapper.eq(SysPermission::getUrl, defIndexCfg.getUrl());
SysPermission indexMenu = sysPermissionService.getOne(indexQueryWrapper);
if (indexMenu == null) {
indexMenu = new SysPermission();
indexMenu.setUrl(defIndexCfg.getUrl());
indexMenu.setComponent(defIndexCfg.getComponent());
indexMenu.setRoute(defIndexCfg.getRoute());
indexMenu.setName(DefIndexConst.DEF_INDEX_NAME);
indexMenu.setMenuType(0);
}
// 如果没有授权一级菜单，则自身变为一级菜单
if (indexMenu.getParentId() != null && !PermissionDataUtil.hasMenuById(metaList, indexMenu.getParentId())) {
indexMenu.setMenuType(0);
indexMenu.setParentId(null);
}
if (oConvertUtils.isEmpty(indexMenu.getIcon())) {
indexMenu.setIcon("ant-design:home");
}
metaList.add(0, indexMenu);
}
/* TODO 注： 这段代码的主要作用是：把首页菜单的组件替换成角色菜单的组件，由于现在的逻辑如果角色菜单不存在则自动插入一条，所以这段代码暂时不需要
List<SysPermission> menus = metaList.stream().filter(sysPermission -> {
if (defIndexCfg.getUrl().equals(sysPermission.getUrl())) {
return true;
}
return defIndexCfg.getUrl().equals(sysPermission.getUrl());
}).collect(Collectors.toList());
// 代码逻辑说明: 设置自定义首页地址和组件----------
if (menus.size() == 1) {
String component = defIndexCfg.getComponent();
String routeUrl = defIndexCfg.getUrl();
boolean route = defIndexCfg.isRoute();
if (oConvertUtils.isNotEmpty(routeUrl)) {
menus.get(0).setComponent(component);
menus.get(0).setRoute(route);
menus.get(0).setUrl(routeUrl);
} else {
menus.get(0).setComponent(component);
}
}
*/
JSONObject json = new JSONObject();
JSONArray menujsonArray = new JSONArray();
this.getPermissionJsonArray(menujsonArray, metaList, null);
//一级菜单下的子菜单全部是隐藏路由，则一级菜单不显示
this.handleFirstLevelMenuHidden(menujsonArray);
JSONArray authjsonArray = new JSONArray();
this.getAuthJsonArray(authjsonArray, metaList);
//查询所有的权限
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>().select( SysPermission::getName, SysPermission::getPermsType, SysPermission::getPerms, SysPermission::getStatus);
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);
// 按钮权限（用户拥有的权限集合）
List<String> codeList = metaList.stream()
.filter((permission) -> CommonConstant.MENU_TYPE_2.equals(permission.getMenuType()) && CommonConstant.STATUS_1.equals(permission.getStatus()))
.collect(ArrayList::new, (list, permission) -> list.add(permission.getPerms()), ArrayList::addAll);
// 所拥有的权限编码(vue3专用)
json.put("codeList", codeList);
//全部权限配置集合（按钮权限，访问权限）
json.put("allAuth", allauthjsonArray);
//数据源安全模式
json.put("sysSafeMode", jeecgBaseConfig.getFirewall()!=null? jeecgBaseConfig.getFirewall().getDataSourceSafe(): false);
result.setResult(json);
} catch (Exception e) {
result.error500("查询失败:" + e.getMessage());
log.error(e.getMessage(), e);
}
return result;
}
/**
* 【vue3专用】获取
* 1、查询用户拥有的按钮/表单访问权限
* 2、所有权限 (菜单权限配置)
* 3、系统安全模式 (开启则online报表的数据源必填)
*/
@RequestMapping(value = "/getPermCode", method = RequestMethod.GET)
public Result<?> getPermCode() {
try {
// 直接获取当前用户
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
if (oConvertUtils.isEmpty(loginUser)) {
return Result.error("请登录系统！");
}
// 获取当前用户的权限集合
List<SysPermission> metaList = sysPermissionService.queryByUser(loginUser.getId());
// 按钮权限（用户拥有的权限集合）
List<String> codeList = metaList.stream()
.filter((permission) -> CommonConstant.MENU_TYPE_2.equals(permission.getMenuType()) && CommonConstant.STATUS_1.equals(permission.getStatus()))
.collect(ArrayList::new, (list, permission) -> list.add(permission.getPerms()), ArrayList::addAll);
//
JSONArray authArray = new JSONArray();
this.getAuthJsonArray(authArray, metaList);
// 查询所有的权限
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>().select( SysPermission::getName, SysPermission::getPermsType, SysPermission::getPerms, SysPermission::getStatus);
query.eq(SysPermission::getDelFlag, CommonConstant.DEL_FLAG_0);
query.eq(SysPermission::getMenuType, CommonConstant.MENU_TYPE_2);
List<SysPermission> allAuthList = sysPermissionService.list(query);
JSONArray allAuthArray = new JSONArray();
this.getAllAuthJsonArray(allAuthArray, allAuthList);
JSONObject result = new JSONObject();
// 所拥有的权限编码
result.put("codeList", codeList);
//按钮权限（用户拥有的权限集合）
result.put("auth", authArray);
//全部权限配置集合（按钮权限，访问权限）
result.put("allAuth", allAuthArray);
//数据源安全模式
result.put("sysSafeMode", jeecgBaseConfig.getFirewall()!=null? jeecgBaseConfig.getFirewall().getDataSourceSafe(): null);
return Result.OK(result);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("查询失败:" + e.getMessage());
}
}
/**
* 添加菜单
* @param permission
* @return
*/
@RequiresPermissions("system:permission:add")
@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
*/
@RequiresPermissions("system:permission:edit")
@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
* @param url
* @return
*/
@RequestMapping(value = "/checkPermDuplication", method = RequestMethod.GET)
public Result<String> checkPermDuplication(@RequestParam(name = "id", required = false) String id,@RequestParam(name = "url") String url,@RequestParam(name = "alwaysShow") Boolean alwaysShow) {
Result<String> result = new Result<>();
try {
boolean check=sysPermissionService.checkPermDuplication(id,url,alwaysShow);
if(check){
return Result.ok("该值可用！");
}
return Result.error("访问路径不允许重复，请重定义！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 删除菜单
* @param id
* @return
*/
@RequiresPermissions("system:permission:delete")
@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
*/
@RequiresPermissions("system:permission:deleteBatch")
@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)) {
try {
sysPermissionService.deletePermission(id);
} catch (JeecgBootException e) {
if(e.getMessage()!=null && e.getMessage().contains("未找到菜单信息")){
log.warn(e.getMessage());
}else{
throw e;
}
}
}
}
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>(5);
// 全部树节点数据
resMap.put("treeList", treeList);
// 全部树ids
resMap.put("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)
@RequiresPermissions("system:permission:saveRole")
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);
// 代码逻辑说明: [VUEN-234]用户管理角色授权添加敏感日志------------
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
baseCommonService.addLog("修改角色ID: "+roleId+" 的权限配置，操作人： " +loginUser.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
result.success("保存成功！");
log.info("======角色授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
// 清除当前用户的授权缓存信息
Subject currentUser = SecurityUtils.getSubject();
if (currentUser.isAuthenticated()) {
shiroRealm.clearCache(currentUser.getPrincipals());
}
} 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);
}
}
}
}
/**
* 一级菜单的子菜单全部是隐藏路由，则一级菜单不显示
* @param jsonArray
*/
private void handleFirstLevelMenuHidden(JSONArray jsonArray) {
jsonArray = jsonArray.stream().map(obj -> {
JSONObject returnObj = new JSONObject();
JSONObject jsonObj = (JSONObject)obj;
if(jsonObj.containsKey(CHILDREN)){
JSONArray childrens = jsonObj.getJSONArray(CHILDREN);
childrens = childrens.stream().filter(arrObj -> !"true".equals(((JSONObject) arrObj).getString("hidden"))).collect(Collectors.toCollection(JSONArray::new));
if(childrens==null || childrens.size()==0){
jsonObj.put("hidden",true);
//vue3版本兼容代码
JSONObject meta = new JSONObject();
meta.put("hideMenu",true);
jsonObj.put("meta", meta);
}
}
return returnObj;
}).collect(Collectors.toCollection(JSONArray::new));
}
/**
* 获取权限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()));
}
JSONObject meta = new JSONObject();
// 是否隐藏路由，默认都是显示的
if (permission.isHidden()) {
json.put("hidden", true);
//vue3版本兼容代码
meta.put("hideMenu",true);
}
// 聚合路由
if (permission.isAlwaysShow()) {
json.put("alwaysShow", true);
}
json.put("component", permission.getComponent());
// 由用户设置是否缓存页面 用布尔值
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());
// 代码逻辑说明: 路由缓存问题，关闭了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)));
}
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());
}
// 代码逻辑说明: 新增适配vue3项目的隐藏tab功能
if (permission.isHideTab()) {
meta.put("hideTab", true);
}
json.put("meta", meta);
}
return json;
}
/**
* 判断是否外网URL 例如： http://localhost:8080/jeecg-boot/swagger-ui.html#/ 支持特殊格式： {{
* window._CONFIG['domianURL'] }}/druid/ {{ JS代码片段 }}，前台解析会自动执行JS代码片段
*
* @return
*/
private boolean isWwwHttpUrl(String url) {
boolean flag = url != null && (url.startsWith(CommonConstant.HTTP_PROTOCOL) || url.startsWith(CommonConstant.HTTPS_PROTOCOL) || url.startsWith(SymbolConstant.DOUBLE_LEFT_CURLY_BRACKET));
if (flag) {
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(SymbolConstant.SINGLE_SLASH)) {
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());
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/CommonController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/CommonController.java | package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.FileTypeEnum;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.filter.SsrfFileTypeFilter;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.util.HttpFileToMultipartFileUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
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 jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.*;
/**
* <p>
* 用户表 前端控制器
* </p>
*
* @Author scott
* @since 2018-12-20
*/
@Slf4j
@RestController
@RequestMapping("/sys/common")
public class CommonController {
@Value(value = "${jeecg.path.upload}")
private String uploadpath;
/**
* 本地：local minio：minio 阿里：alioss
*/
@Value(value="${jeecg.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) throws Exception {
Result<?> result = new Result<>();
String savePath = "";
String bizPath = request.getParameter("biz");
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("file");
// 文件安全校验，防止上传漏洞文件
SsrfFileTypeFilter.checkUploadFileType(file, bizPath);
if (oConvertUtils.isEmpty(bizPath)) {
bizPath = CommonConstant.UPLOAD_TYPE_OSS.equals(uploadType) ? "upload" : "";
}
if(CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)){
savePath = this.uploadLocal(file,bizPath);
}else{
savePath = CommonUtils.upload(file, bizPath, uploadType);
}
if(oConvertUtils.isNotEmpty(savePath)){
//添加到文件表
String orgName = file.getOriginalFilename();
// 获取文件名
orgName = CommonUtils.getFileName(orgName);
String type = orgName.substring(orgName.lastIndexOf(SymbolConstant.SPOT));
FileTypeEnum fileType = FileTypeEnum.getByType(type);
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(SymbolConstant.SPOT)!=-1){
fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."));
}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(SymbolConstant.DOUBLE_BACKSLASH)) {
dbpath = dbpath.replace(SymbolConstant.DOUBLE_BACKSLASH, SymbolConstant.SINGLE_SLASH);
}
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) || CommonConstant.STRING_NULL.equals(imgPath)){
return;
}
try {
imgPath = imgPath.replace("..", "").replace("../","");
if (imgPath.endsWith(SymbolConstant.COMMA)) {
imgPath = imgPath.substring(0, imgPath.length() - 1);
}
// 代码逻辑说明: 检查下载文件类型--------------
SsrfFileTypeFilter.checkDownloadFileType(imgPath);
String filePath = uploadpath + File.separator + imgPath;
File file = new File(filePath);
if(!file.exists()){
response.setStatus(404);
log.warn("文件["+imgPath+"]不存在..");
return;
//throw new RuntimeException();
}
// 设置强制下载不打开
response.setContentType("application/force-download");
response.addHeader("Content-Disposition", "attachment;fileName=" + new String(file.getName().getBytes("UTF-8"),"iso-8859-1"));
// 结合 StreamingResponseBody 的流式写法
try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file));
OutputStream outputStream = response.getOutputStream()) {
byte[] buf = new byte[8192];
int len;
while ((len = inputStream.read(buf)) != -1) {
outputStream.write(buf, 0, len);
}
outputStream.flush();
}
} catch (IOException e) {
log.error("预览文件失败" + e.getMessage());
response.setStatus(404);
e.printStackTrace();
}
}
// /**
// * 下载文件
// * 请求地址：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);
}
/**
* 根据网路图片地址上传到服务器
* @param jsonObject
* @param request
* @return
*/
@PostMapping("/uploadImgByHttp")
public Result<String> uploadImgByHttp(@RequestBody JSONObject jsonObject, HttpServletRequest request){
String fileUrl = oConvertUtils.getString(jsonObject.get("fileUrl"));
String filename = oConvertUtils.getString(jsonObject.get("filename"));
String bizPath = oConvertUtils.getString(jsonObject.get("bizPath"));
try {
String savePath = "";
MultipartFile file = HttpFileToMultipartFileUtil.httpFileToMultipartFile(fileUrl, filename);
// 文件安全校验，防止上传漏洞文件
SsrfFileTypeFilter.checkUploadFileType(file, bizPath);
if (oConvertUtils.isEmpty(bizPath)) {
bizPath = CommonConstant.UPLOAD_TYPE_OSS.equals(uploadType) ? "upload" : "";
}
if(CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)){
savePath = this.uploadLocal(file,bizPath);
}else{
savePath = CommonUtils.upload(file, bizPath, uploadType);
}
return Result.OK(savePath);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error(e.getMessage());
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDepartPermissionController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDepartPermissionController.java | package org.jeecg.modules.system.controller;
import java.util.*;
import java.util.stream.Collectors;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.SysDepartPermission;
import org.jeecg.modules.system.entity.SysDepartRolePermission;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import org.jeecg.modules.system.model.TreeModel;
import org.jeecg.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 org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.modules.system.service.ISysDepartRolePermissionService;
import org.jeecg.modules.system.service.ISysPermissionDataRuleService;
import org.jeecg.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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
/**
* @Description: 部门权限表
* @Author: jeecg-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
@Slf4j
@Tag(name="部门权限表")
@RestController
@RequestMapping("/sys/sysDepartPermission")
public class SysDepartPermissionController extends JeecgController<SysDepartPermission, ISysDepartPermissionService> {
@Autowired
private ISysDepartPermissionService sysDepartPermissionService;
@Autowired
private ISysPermissionDataRuleService sysPermissionDataRuleService;
@Autowired
private ISysPermissionService sysPermissionService;
@Autowired
private ISysDepartRolePermissionService sysDepartRolePermissionService;
@Autowired
private BaseCommonService baseCommonService;
/**
* 分页列表查询
*
* @param sysDepartPermission
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@Operation(summary="部门权限表-分页列表查询")
@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
*/
@Operation(summary="部门权限表-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDepartPermission sysDepartPermission) {
sysDepartPermissionService.save(sysDepartPermission);
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param sysDepartPermission
* @return
*/
@Operation(summary="部门权限表-编辑")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
public Result<?> edit(@RequestBody SysDepartPermission sysDepartPermission) {
sysDepartPermissionService.updateById(sysDepartPermission);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@Operation(summary="部门权限表-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysDepartPermissionService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@Operation(summary="部门权限表-批量删除")
@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
*/
@Operation(summary="部门权限表-通过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(5);
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("保存成功！");
// 代码逻辑说明: [VUEN-234]部门角色授权添加敏感日志------------
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
baseCommonService.addLog("修改部门角色ID:"+roleId+"的权限配置，操作人： " +loginUser.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
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 {
List<SysPermission> list = sysPermissionService.queryDepartPermissionList(departId);
for(SysPermission sysPer : list) {
ids.add(sysPer.getId());
}
List<TreeModel> treeList = new ArrayList<>();
getTreeModelList(treeList, list, null);
Map<String,Object> resMap = new HashMap(5);
//全部树节点数据
resMap.put("treeList", treeList);
//全部树ids
resMap.put("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);
}
}
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysAnnouncementSendController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysAnnouncementSendController.java | package org.jeecg.modules.system.controller;
import java.util.Arrays;
import java.util.Date;
import jakarta.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.DataBaseConstant;
import org.jeecg.common.constant.WebsocketConst;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.SqlInjectionUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.message.websocket.WebSocket;
import org.jeecg.modules.system.entity.SysAnnouncementSend;
import org.jeecg.modules.system.model.AnnouncementSendModel;
import org.jeecg.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: jeecg-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/sysAnnouncementSend")
@Slf4j
public class SysAnnouncementSendController {
@Autowired
private ISysAnnouncementSendService sysAnnouncementSendService;
@Autowired
private WebSocket webSocket;
/**
* 分页列表查询
* @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(DataBaseConstant.SQL_ASC.equals(order)) {
queryWrapper.orderByAsc(SqlInjectionUtil.getSqlInjectSortField(column));
}else {
queryWrapper.orderByDesc(SqlInjectionUtil.getSqlInjectSortField(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>();
//根据用户id和通告阅读表的id获取当前用户已阅读的数量
long count = sysAnnouncementSendService.getReadCountByUserId(id);
if(0 == count) {
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.deleteBatchByIds(ids);
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());
// 代码逻辑说明: 系统模块存在的sql漏洞写法
updateWrapper.eq(SysAnnouncementSend::getAnntId,anntId);
updateWrapper.eq(SysAnnouncementSend::getUserId,userId);
//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);
// 代码逻辑说明: 【TV360X-545】我的消息列表不能通过时间范围查询---
if(StringUtils.isNotEmpty(announcementSendModel.getSendTimeBegin())){
announcementSendModel.setSendTimeBegin(announcementSendModel.getSendTimeBegin() + " 00:00:00");
}
if(StringUtils.isNotEmpty(announcementSendModel.getSendTimeBegin())){
announcementSendModel.setSendTimeEnd(announcementSendModel.getSendTimeEnd() + " 23:59:59");
}
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.eq(SysAnnouncementSend::getUserId,userId);
//updateWrapper.last("where user_id ='"+userId+"'");
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
sysAnnouncementSendService.update(announcementSend, updateWrapper);
JSONObject socketParams = new JSONObject();
socketParams.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_TOPIC);
webSocket.sendMessage(socketParams.toJSONString());
result.setSuccess(true);
result.setMessage("全部已读");
return result;
}
/**
* 根据消息发送记录ID获取消息内容
* @param sendId
* @return
*/
@GetMapping(value = "/getOne")
public Result<AnnouncementSendModel> getOne(@RequestParam(name="sendId",required=true) String sendId) {
AnnouncementSendModel model = sysAnnouncementSendService.getOne(sendId);
return Result.ok(model);
}
/**
* 根据业务类型和ID修改阅读状态
* @param busType
* @return
*/
@GetMapping(value = "/updateSysAnnounReadFlag")
public Result<AnnouncementSendModel> updateSysAnnounReadFlag(
@RequestParam(name="busId",required=true) String busId,
@RequestParam(name="busType",required=false) String busType) {
//更新阅读状态
sysAnnouncementSendService.updateReadFlagByBusId(busId,busType);
//刷新未读数量
JSONObject obj = new JSONObject();
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
webSocket.sendMessage(sysUser.getId(), obj.toJSONString());
return Result.ok();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysTableWhiteListController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysTableWhiteListController.java | package org.jeecg.modules.system.controller;
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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.system.entity.SysTableWhiteList;
import org.jeecg.modules.system.service.ISysTableWhiteListService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletRequest;
/**
* @Description: 系统表白名单
* @Author: jeecg-boot
* @Date: 2023-09-12
* @Version: V1.0
*/
@Slf4j
@Tag(name = "系统表白名单")
@RestController
@RequestMapping("/sys/tableWhiteList")
public class SysTableWhiteListController extends JeecgController<SysTableWhiteList, ISysTableWhiteListService> {
@Autowired
private ISysTableWhiteListService sysTableWhiteListService;
/**
* 分页列表查询
*
* @param sysTableWhiteList
* @param pageNo
* @param pageSize
* @param req
* @return
*/
//@RequiresRoles("admin")
@RequiresPermissions("system:tableWhite:list")
@GetMapping(value = "/list")
public Result<?> queryPageList(
SysTableWhiteList sysTableWhiteList,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req
) {
QueryWrapper<SysTableWhiteList> queryWrapper = QueryGenerator.initQueryWrapper(sysTableWhiteList, req.getParameterMap());
Page<SysTableWhiteList> page = new Page<>(pageNo, pageSize);
IPage<SysTableWhiteList> pageList = sysTableWhiteListService.page(page, queryWrapper);
return Result.OK(pageList);
}
/**
* 添加
*
* @param sysTableWhiteList
* @return
*/
@AutoLog(value = "系统表白名单-添加")
@Operation(summary = "系统表白名单-添加")
//@RequiresRoles("admin")
@RequiresPermissions("system:tableWhite:add")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysTableWhiteList sysTableWhiteList) {
if (sysTableWhiteListService.add(sysTableWhiteList)) {
return Result.OK("添加成功！");
} else {
return Result.error("添加失败！");
}
}
/**
* 编辑
*
* @param sysTableWhiteList
* @return
*/
@AutoLog(value = "系统表白名单-编辑")
@Operation(summary = "系统表白名单-编辑")
//@RequiresRoles("admin")
@RequiresPermissions("system:tableWhite:edit")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
public Result<?> edit(@RequestBody SysTableWhiteList sysTableWhiteList) {
if (sysTableWhiteListService.edit(sysTableWhiteList)) {
return Result.OK("编辑成功！");
} else {
return Result.error("编辑失败！");
}
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "系统表白名单-通过id删除")
@Operation(summary = "系统表白名单-通过id删除")
// @RequiresRoles("admin")
@RequiresPermissions("system:tableWhite:delete")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id") String id) {
if (sysTableWhiteListService.deleteByIds(id)) {
return Result.OK("删除成功！");
} else {
return Result.error("删除失败！");
}
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "系统表白名单-批量删除")
@Operation(summary = "系统表白名单-批量删除")
// @RequiresRoles("admin")
@RequiresPermissions("system:tableWhite:deleteBatch")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids") String ids) {
if (sysTableWhiteListService.deleteByIds(ids)) {
return Result.OK("批量删除成功！");
} else {
return Result.error("批量删除失败！");
}
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "系统表白名单-通过id查询")
@Operation(summary = "系统表白名单-通过id查询")
// @RequiresRoles("admin")
@RequiresPermissions("system:tableWhite:queryById")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
SysTableWhiteList sysTableWhiteList = sysTableWhiteListService.getById(id);
return Result.OK(sysTableWhiteList);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysRoleController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysRoleController.java | package org.jeecg.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 jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.PageDTO;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.base.BaseMap;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.modules.redis.client.JeecgRedisClient;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.model.TreeModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.vo.SysUserRoleCountVo;
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.entity.enmus.ExcelType;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
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 org.jeecg.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;
@Autowired
private ISysUserRoleService sysUserRoleService;
@Autowired
private BaseCommonService baseCommonService;
@Autowired
private JeecgRedisClient jeecgRedisClient;
/**
* 分页列表查询 【系统角色，不做租户隔离】
* @param role
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequiresPermissions("system:role:list")
@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,
@RequestParam(name="isMultiTranslate", required = false) Boolean isMultiTranslate,
HttpServletRequest req) {
// 代码逻辑说明: 【issues/7948】角色解决根据id查询回显不对---
if(null != isMultiTranslate && isMultiTranslate){
pageSize = 100;
}
Result<IPage<SysRole>> result = new Result<IPage<SysRole>>();
//QueryWrapper<SysRole> queryWrapper = QueryGenerator.initQueryWrapper(role, req.getParameterMap());
//IPage<SysRole> pageList = sysRoleService.page(page, queryWrapper);
Page<SysRole> page = new Page<SysRole>(pageNo, pageSize);
//换成不做租户隔离的方法，实际上还是存在缺陷（缺陷：如果开启租户隔离，虽然能看到其他租户下的角色，编辑会提示报错）
IPage<SysRole> pageList = sysRoleService.listAllSysRole(page, role);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 分页列表查询【租户角色，做租户隔离】
* @param role
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequestMapping(value = "/listByTenant", method = RequestMethod.GET)
public Result<IPage<SysRole>> listByTenant(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>>();
//此接口必须通过租户来隔离查询
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
role.setTenantId(oConvertUtils.getInt(!"0".equals(TenantContext.getTenant()) ? TenantContext.getTenant() : "", -1));
}
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)
@RequiresPermissions("system:role:add")
public Result<SysRole> add(@RequestBody SysRole role) {
Result<SysRole> result = new Result<SysRole>();
try {
//开启多租户隔离,角色id自动生成10位
// 代码逻辑说明: 【TV360X-42】角色新增时设置的编码，保存后不一致---
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL && oConvertUtils.isEmpty(role.getRoleCode())){
role.setRoleCode(RandomUtil.randomString(10));
}
role.setCreateTime(new Date());
sysRoleService.save(role);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param role
* @return
*/
@RequiresPermissions("system:role:edit")
@RequestMapping(value = "/edit",method = {RequestMethod.PUT,RequestMethod.POST})
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());
//------------------------------------------------------------------
//如果是saas隔离的情况下，判断当前租户id是否是当前租户下的
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
//获取当前用户
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
String username = "admin";
if (!tenantId.equals(sysrole.getTenantId()) && !username.equals(sysUser.getUsername())) {
baseCommonService.addLog("未经授权，修改非本租户下的角色ID：" + role.getId() + "，操作人：" + sysUser.getUsername(), CommonConstant.LOG_TYPE_2, CommonConstant.OPERATE_TYPE_3);
return Result.error("修改角色失败,当前角色不在此租户中。");
}
}
//------------------------------------------------------------------
boolean ok = sysRoleService.updateById(role);
if(ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@RequiresPermissions("system:role:delete")
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
//如果是saas隔离的情况下，判断当前租户id是否是当前租户下的
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
//获取当前用户
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
Long getRoleCount = sysRoleService.getRoleCountByTenantId(id, tenantId);
String username = "admin";
if(getRoleCount == 0 && !username.equals(sysUser.getUsername())){
baseCommonService.addLog("未经授权，删除非本租户下的角色ID：" + id + "，操作人：" + sysUser.getUsername(), CommonConstant.LOG_TYPE_2, CommonConstant.OPERATE_TYPE_4);
return Result.error("删除角色失败,当前角色不在此租户中。");
}
}
//是否存在admin角色
sysRoleService.checkAdminRoleRejectDel(id);
sysRoleService.deleteRole(id);
return Result.ok("删除角色成功");
}
/**
* 批量删除
* @param ids
* @return
*/
@RequiresPermissions("system:role:deleteBatch")
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysRole> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
baseCommonService.addLog("删除角色操作，角色ids：" + ids, CommonConstant.LOG_TYPE_2, CommonConstant.OPERATE_TYPE_4);
Result<SysRole> result = new Result<SysRole>();
if(oConvertUtils.isEmpty(ids)) {
result.error500("未选中角色！");
}else {
//如果是saas隔离的情况下，判断当前租户id是否是当前租户下的
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
String[] roleIds = ids.split(SymbolConstant.COMMA);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String username = "admin";
for (String id:roleIds) {
Long getRoleCount = sysRoleService.getRoleCountByTenantId(id, tenantId);
//如果存在角色id为0，即不存在，则删除角色
if(getRoleCount == 0 && !username.equals(sysUser.getUsername()) ){
baseCommonService.addLog("未经授权，删除非本租户下的角色ID：" + id + "，操作人：" + sysUser.getUsername(), CommonConstant.LOG_TYPE_2, CommonConstant.OPERATE_TYPE_4);
return Result.error("批量删除角色失败,存在角色不在此租户中，禁止批量删除");
}
}
}
//验证是否为admin角色
sysRoleService.checkAdminRoleRejectDel(ids);
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;
}
/**
* 查询全部角色（参与租户隔离）
*
* @return
*/
@RequestMapping(value = "/queryall", method = RequestMethod.GET)
public Result<List<SysRole>> queryall() {
Result<List<SysRole>> result = new Result<>();
LambdaQueryWrapper<SysRole> query = new LambdaQueryWrapper<SysRole>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysRole::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
List<SysRole> list = sysRoleService.list(query);
if(list==null||list.size()<=0) {
result.error500("未找到角色信息");
}else {
result.setResult(list);
result.setSuccess(true);
}
return result;
}
/**
* 查询全部系统角色（不做租户隔离）
*
* @return
*/
@RequiresPermissions("system:role:queryallNoByTenant")
@RequestMapping(value = "/queryallNoByTenant", method = RequestMethod.GET)
public Result<List<SysRole>> queryallNoByTenant() {
Result<List<SysRole>> result = new Result<>();
LambdaQueryWrapper<SysRole> query = new LambdaQueryWrapper<SysRole>();
List<SysRole> list = sysRoleService.list(query);
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<>();
//如果此参数为false则程序发生异常
result.setResult(true);
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));
SysRole newRole = sysRoleService.getRoleNoTenant(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) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysRole.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
// 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();
//导出支持xlsx
mv.addObject(NormalExcelConstants.PARAMS,new ExportParams("角色列表数据","导出人:"+user.getRealname(),"导出信息", ExcelType.XSSF));
mv.addObject(NormalExcelConstants.DATA_LIST,pageList);
//角色支持指定字段导出
String exportFields = request.getParameter(NormalExcelConstants.EXPORT_FIELDS);
if(oConvertUtils.isNotEmpty(exportFields)){
mv.addObject(NormalExcelConstants.EXPORT_FIELDS, exportFields);
}
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(5);
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(5);
//全部树节点数据
resMap.put("treeList", treeList);
//全部树ids
resMap.put("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);
}
}
}
}
/**
* 分页获取全部角色列表（包含每个角色的数量）
* @return
*/
@RequestMapping(value = "/queryPageRoleCount", method = RequestMethod.GET)
public Result<IPage<SysUserRoleCountVo>> queryPageRoleCount(@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize) {
Result<IPage<SysUserRoleCountVo>> result = new Result<>();
LambdaQueryWrapper<SysRole> query = new LambdaQueryWrapper<SysRole>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysRole::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
Page<SysRole> page = new Page<>(pageNo, pageSize);
IPage<SysRole> pageList = sysRoleService.page(page, query);
List<SysRole> records = pageList.getRecords();
IPage<SysUserRoleCountVo> sysRoleCountPage = new PageDTO<>();
List<SysUserRoleCountVo> sysCountVoList = new ArrayList<>();
//循环角色数据获取每个角色下面对应的角色数量
for (SysRole role:records) {
LambdaQueryWrapper<SysUserRole> countQuery = new LambdaQueryWrapper<>();
countQuery.eq(SysUserRole::getRoleId,role.getId());
long count = sysUserRoleService.count(countQuery);
SysUserRoleCountVo countVo = new SysUserRoleCountVo();
BeanUtils.copyProperties(role,countVo);
countVo.setCount(count);
sysCountVoList.add(countVo);
}
sysRoleCountPage.setRecords(sysCountVoList);
sysRoleCountPage.setTotal(pageList.getTotal());
sysRoleCountPage.setSize(pageList.getSize());
result.setSuccess(true);
result.setResult(sysRoleCountPage);
return result;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysUserController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysUserController.java | package org.jeecg.modules.system.controller;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSON;
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 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 org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.PermissionData;
import org.jeecg.common.base.BaseMap;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.PasswordConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.modules.redis.client.JeecgRedisClient;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.*;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.excelstyle.ExcelExportSysUserStyle;
import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.model.SysUserSysDepPostModel;
import org.jeecg.modules.system.model.SysUserSysDepartModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.util.ImportSysUserCache;
import org.jeecg.modules.system.vo.SysDepartUsersVO;
import org.jeecg.modules.system.vo.SysUserExportVo;
import org.jeecg.modules.system.vo.SysUserRoleVO;
import org.jeecg.modules.system.vo.lowapp.DepartAndUserInfo;
import org.jeecg.modules.system.vo.lowapp.UpdateDepartInfo;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.enmus.ExcelType;
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.*;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 用户表 前端控制器
* </p>
*
* @Author scott
* @since 2018-12-20
*/
@Slf4j
@RestController
@RequestMapping("/sys/user")
public class SysUserController {
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private ISysUserRoleService sysUserRoleService;
@Autowired
private ISysUserDepartService sysUserDepartService;
@Autowired
private ISysDepartRoleUserService departRoleUserService;
@Autowired
private ISysDepartRoleService departRoleService;
@Autowired
private RedisUtil redisUtil;
@Value("${jeecg.path.upload}")
private String upLoadPath;
@Autowired
private BaseCommonService baseCommonService;
@Autowired
private ISysPositionService sysPositionService;
@Autowired
private ISysUserTenantService userTenantService;
@Autowired
private JeecgRedisClient jeecgRedisClient;
@Autowired
private JeecgBaseConfig jeecgBaseConfig;
/**
* 获取租户下用户数据（支持租户隔离）
* @param user
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@PermissionData(pageComponent = "system/UserList")
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<IPage<SysUser>> queryPageList(SysUser user,@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,HttpServletRequest req) {
QueryWrapper<SysUser> queryWrapper = QueryGenerator.initQueryWrapper(user, req.getParameterMap());
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
String tenantId = oConvertUtils.getString(TenantContext.getTenant(), "-1");
List<String> userIds = userTenantService.getUserIdsByTenantId(Integer.valueOf(tenantId));
if (oConvertUtils.listIsNotEmpty(userIds)) {
queryWrapper.in("id", userIds);
}else{
queryWrapper.eq("id", "通过租户查询不到任何用户");
}
}
//------------------------------------------------------------------------------------------------
return sysUserService.queryPageList(req, queryWrapper, pageSize, pageNo);
}
/**
* 获取系统用户数据（查询全部用户，不做租户隔离）
*
* @param user
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@RequiresPermissions("system:user:listAll")
@RequestMapping(value = "/listAll", method = RequestMethod.GET)
public Result<IPage<SysUser>> queryAllPageList(SysUser user, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) {
QueryWrapper<SysUser> queryWrapper = QueryGenerator.initQueryWrapper(user, req.getParameterMap());
return sysUserService.queryPageList(req, queryWrapper, pageSize, pageNo);
}
@RequiresPermissions("system:user:add")
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysUser> add(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
String selectedRoles = jsonObject.getString("selectedroles");
String selectedDeparts = jsonObject.getString("selecteddeparts");
try {
SysUser user = JSON.parseObject(jsonObject.toJSONString(), SysUser.class);
user.setCreateTime(new Date());//设置创建时间
String salt = oConvertUtils.randomGen(8);
user.setSalt(salt);
String passwordEncode = PasswordUtil.encrypt(user.getUsername(), user.getPassword(), salt);
user.setPassword(passwordEncode);
user.setStatus(1);
user.setDelFlag(CommonConstant.DEL_FLAG_0);
//用户表字段org_code不能在这里设置他的值
user.setOrgCode(null);
user.setLastPwdUpdateTime(new Date());
// 保存用户走一个service 保证事务
//获取租户ids
String relTenantIds = jsonObject.getString("relTenantIds");
sysUserService.saveUser(user, selectedRoles, selectedDeparts, relTenantIds, false);
baseCommonService.addLog("添加用户，username： " +user.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
@RequiresPermissions("system:user:edit")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
public Result<SysUser> edit(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
try {
SysUser sysUser = sysUserService.getById(jsonObject.getString("id"));
baseCommonService.addLog("编辑用户，username： " +sysUser.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
if(sysUser==null) {
result.error500("未找到对应实体");
}else {
SysUser user = JSON.parseObject(jsonObject.toJSONString(), SysUser.class);
user.setUpdateTime(new Date());
//String passwordEncode = PasswordUtil.encrypt(user.getUsername(), user.getPassword(), sysUser.getSalt());
user.setPassword(sysUser.getPassword());
String roles = jsonObject.getString("selectedroles");
String departs = jsonObject.getString("selecteddeparts");
if(oConvertUtils.isEmpty(departs)){
//vue3.0前端只传递了departIds
departs=user.getDepartIds();
}
//用户表字段org_code不能在这里设置他的值
user.setOrgCode(null);
// 修改用户走一个service 保证事务
//获取租户ids
String relTenantIds = jsonObject.getString("relTenantIds");
String updateFromPage = jsonObject.getString("updateFromPage");
//update-begin---author:wangshuai---date:2025-11-12---for:【JHHB-776】用户编辑，应该从数据库查出老数据，页面传递什么字段，把这些字段覆盖数据库查询结果，再更新---
oConvertUtils.copyNonNullFields(user, sysUser);
sysUserService.editUser(sysUser, roles, departs, relTenantIds, updateFromPage);
//update-end---author:wangshuai---date:2025-11-12---for:【JHHB-776】用户编辑，应该从数据库查出老数据，页面传递什么字段，把这些字段覆盖数据库查询结果，再更新---
result.success("修改成功!");
}
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 添加用户【后台租户模式专用，敲敲云不要用这个】
*
* @param jsonObject
* @return
*/
@RequiresPermissions("system:user:addTenantUser")
@RequestMapping(value = "/addTenantUser", method = RequestMethod.POST)
public Result<SysUser> addTenantUser(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
String selectedRoles = jsonObject.getString("selectedroles");
String selectedDeparts = jsonObject.getString("selecteddeparts");
try {
SysUser user = JSON.parseObject(jsonObject.toJSONString(), SysUser.class);
user.setCreateTime(new Date());//设置创建时间
String salt = oConvertUtils.randomGen(8);
user.setSalt(salt);
String passwordEncode = PasswordUtil.encrypt(user.getUsername(), user.getPassword(), salt);
user.setPassword(passwordEncode);
user.setStatus(1);
user.setDelFlag(CommonConstant.DEL_FLAG_0);
//用户表字段org_code不能在这里设置他的值
user.setOrgCode(null);
// 保存用户走一个service 保证事务
//获取租户ids
String relTenantIds = jsonObject.getString("relTenantIds");
sysUserService.saveUser(user, selectedRoles, selectedDeparts, relTenantIds, true);
baseCommonService.addLog("添加用户，username： " + user.getUsername(), CommonConstant.LOG_TYPE_2, 2);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 删除用户
*/
@RequiresPermissions("system:user:delete")
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
baseCommonService.addLog("删除用户，id： " +id ,CommonConstant.LOG_TYPE_2, 3);
List<String> userNameList = sysUserService.userIdToUsername(Arrays.asList(id));
this.sysUserService.deleteUser(id);
if (!userNameList.isEmpty()) {
String joinedString = String.join(",", userNameList);
}
return Result.ok("删除用户成功");
}
/**
* 批量删除用户
*/
@RequiresPermissions("system:user:deleteBatch")
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
baseCommonService.addLog("批量删除用户， ids： " +ids ,CommonConstant.LOG_TYPE_2, 3);
List<String> userNameList = sysUserService.userIdToUsername(Arrays.asList(ids.split(",")));
this.sysUserService.deleteBatchUsers(ids);
// 用户变更，触发同步工作流
if (!userNameList.isEmpty()) {
String joinedString = String.join(",", userNameList);
}
return Result.ok("批量删除用户成功");
}
/**
* 冻结&解冻用户
* @param jsonObject
* @return
*/
@RequiresPermissions("system:user:frozenBatch")
@RequestMapping(value = "/frozenBatch", method = RequestMethod.PUT)
public Result<SysUser> frozenBatch(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
try {
String ids = jsonObject.getString("ids");
sysUserService.checkUserAdminRejectDel(ids);
String status = jsonObject.getString("status");
String[] arr = ids.split(",");
for (String id : arr) {
if(oConvertUtils.isNotEmpty(id)) {
// 代码逻辑说明: [QQYUN-5577]用户列表-冻结用户，再解冻之后，用户还是无法登陆，有缓存问题 #5066------------
sysUserService.updateStatus(id,status);
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败"+e.getMessage());
}
result.success("操作成功!");
return result;
}
/**
* 重置为系统密码接口
* @param usernames
* @return
*/
@RequiresRoles({"admin"})
@RequiresPermissions("system:user:resetPassword")
@RequestMapping(value = "/resetPassword", method = RequestMethod.PUT)
public Result<SysUser> resetPassword(@RequestParam(name = "usernames") String usernames) {
Result<SysUser> result = new Result<SysUser>();
try {
sysUserService.resetToSysPassword(usernames);
result.success("操作成功!");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500(e.getMessage());
}
return result;
}
@RequiresPermissions("system:user:queryById")
@RequestMapping(value = "/queryById", method = RequestMethod.GET)
public Result<SysUser> queryById(@RequestParam(name = "id", required = true) String id) {
Result<SysUser> result = new Result<SysUser>();
SysUser sysUser = sysUserService.getById(id);
if (sysUser == null) {
result.error500("未找到对应实体");
} else {
result.setResult(sysUser);
result.setSuccess(true);
}
return result;
}
@RequiresPermissions("system:user:queryUserRole")
@RequestMapping(value = "/queryUserRole", method = RequestMethod.GET)
public Result<List<String>> queryUserRole(@RequestParam(name = "userid", required = true) String userid) {
Result<List<String>> result = new Result<>();
List<String> list = new ArrayList<String>();
List<SysUserRole> userRole = sysUserRoleService.list(new QueryWrapper<SysUserRole>().lambda().eq(SysUserRole::getUserId, userid));
if (userRole == null || userRole.size() <= 0) {
result.error500("未找到用户相关角色信息");
} else {
for (SysUserRole sysUserRole : userRole) {
list.add(sysUserRole.getRoleId());
}
result.setSuccess(true);
result.setResult(list);
}
return result;
}
/**
* 校验用户账号是否唯一<br>
* 可以校验其他 需要检验什么就传什么。。。
*
* @param sysUser
* @return
*/
@RequestMapping(value = "/checkOnlyUser", method = RequestMethod.GET)
public Result<Boolean> checkOnlyUser(SysUser sysUser) {
Result<Boolean> result = new Result<>();
//如果此参数为false则程序发生异常
result.setResult(true);
try {
//通过传入信息查询新的用户信息
sysUser.setPassword(null);
SysUser user = sysUserService.getOne(new QueryWrapper<SysUser>(sysUser));
if (user != null) {
result.setSuccess(false);
result.setMessage("用户账号已存在");
return result;
}
} catch (Exception e) {
result.setSuccess(false);
result.setMessage(e.getMessage());
return result;
}
result.setSuccess(true);
return result;
}
/**
* 修改密码
*/
@RequiresPermissions("system:user:changepwd")
@RequestMapping(value = "/changePassword", method = RequestMethod.PUT)
public Result<?> changePassword(@RequestBody SysUser sysUser, HttpServletRequest request) {
//-------------------------------------------------------------------------------------
//增加 check防止恶意刷短信接口
String clientIp = IpUtils.getIpAddr(request);
if(!DySmsLimit.canSendSms(clientIp)){
log.warn("-------- IP地址:{}, 短信接口请求太多，有攻击风险！", clientIp);
return Result.error("短信接口请求太多，请稍后再试！");
}
//-------------------------------------------------------------------------------------
SysUser u = this.sysUserService.getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUsername, sysUser.getUsername()));
if (u == null) {
return Result.error("用户不存在！");
}
sysUser.setId(u.getId());
// 代码逻辑说明: [VUEN-234]修改密码添加敏感日志------------
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
baseCommonService.addLog("修改用户 "+sysUser.getUsername()+" 的密码，操作人： " +loginUser.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
return sysUserService.changePassword(sysUser);
}
/**
* 查询指定用户和部门关联的数据
*
* @param userId
* @return
*/
@RequestMapping(value = "/userDepartList", method = RequestMethod.GET)
public Result<List<DepartIdModel>> getUserDepartsList(@RequestParam(name = "userId", required = true) String userId) {
Result<List<DepartIdModel>> result = new Result<>();
try {
List<DepartIdModel> depIdModelList = this.sysUserDepartService.queryDepartIdsOfUser(userId);
if (depIdModelList != null && depIdModelList.size() > 0) {
result.setSuccess(true);
result.setMessage("查找成功");
result.setResult(depIdModelList);
} else {
result.setSuccess(false);
result.setMessage("查找失败");
}
return result;
} catch (Exception e) {
log.error(e.getMessage(), e);
result.setSuccess(false);
result.setMessage("查找过程中出现了异常: " + e.getMessage());
return result;
}
}
/**
* 生成在添加用户情况下没有主键的问题,返回给前端,根据该id绑定部门数据
*
* @return
*/
@RequestMapping(value = "/generateUserId", method = RequestMethod.GET)
public Result<String> generateUserId() {
Result<String> result = new Result<>();
//System.out.println("我执行了,生成用户ID==============================");
String userId = UUID.randomUUID().toString().replace("-", "");
result.setSuccess(true);
result.setResult(userId);
return result;
}
/**
* 根据部门id查询用户信息
*
* @param id
* @return
*/
@RequestMapping(value = "/queryUserByDepId", method = RequestMethod.GET)
public Result<List<SysUser>> queryUserByDepId(@RequestParam(name = "id", required = true) String id,@RequestParam(name="realname",required=false) String realname) {
Result<List<SysUser>> result = new Result<>();
//List<SysUser> userList = sysUserDepartService.queryUserByDepId(id);
SysDepart sysDepart = sysDepartService.getById(id);
List<SysUser> userList = sysUserDepartService.queryUserByDepCode(sysDepart.getOrgCode(),realname);
//批量查询用户的所属部门
//step.1 先拿到全部的 useids
//step.2 通过 useids，一次性查询用户的所属部门名字
List<String> userIds = userList.stream().map(SysUser::getId).collect(Collectors.toList());
if(userIds!=null && userIds.size()>0){
Map<String,String> useDepNames = sysUserService.getDepNamesByUserIds(userIds);
userList.forEach(item->{
//TODO 临时借用这个字段用于页面展示
item.setOrgCodeTxt(useDepNames.get(item.getId()));
});
}
try {
result.setSuccess(true);
result.setResult(userList);
return result;
} catch (Exception e) {
log.error(e.getMessage(), e);
result.setSuccess(false);
return result;
}
}
/**
* 用户选择组件 专用 根据用户账号或部门分页查询
* @param departId
* @param username
* @return
*/
@RequestMapping(value = "/queryUserComponentData", method = RequestMethod.GET)
public Result<IPage<SysUser>> queryUserComponentData(
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
@RequestParam(name = "departId", required = false) String departId,
@RequestParam(name="realname",required=false) String realname,
@RequestParam(name="username",required=false) String username,
@RequestParam(name="isMultiTranslate",required=false) String isMultiTranslate,
@RequestParam(name="id",required = false) String id) {
// 代码逻辑说明: VUEN-1702【禁止问题】sql注入漏洞
String[] arr = new String[]{departId, realname, username, id};
SqlInjectionUtil.filterContent(arr, SymbolConstant.SINGLE_QUOTATION_MARK);
IPage<SysUser> pageList = sysUserDepartService.queryDepartUserPageList(departId, username, realname, pageSize, pageNo,id,isMultiTranslate);
return Result.OK(pageList);
}
/**
* 导出excel
*
* @param request
* @param sysUser
*/
@RequiresPermissions("system:user:export")
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysUser sysUser,HttpServletRequest request) {
// Step.1 组装查询条件
QueryWrapper<SysUser> queryWrapper = QueryGenerator.initQueryWrapper(sysUser, request.getParameterMap());
queryWrapper.ne("username", "_reserve_user_external");
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
// 代码逻辑说明: [03]用户导出，如果选择数据则只导出相关数据--------------------
String selections = request.getParameter("selections");
if(!oConvertUtils.isEmpty(selections)){
queryWrapper.in("id",selections.split(","));
}
//是否存在部门id
boolean izDepartId = true;
String departId = request.getParameter("departId");
if (oConvertUtils.isNotEmpty(departId)) {
LambdaQueryWrapper<SysUserDepart> query = new LambdaQueryWrapper<>();
query.in(SysUserDepart::getDepId, Arrays.asList(departId.split(",")));
List<SysUserDepart> list = sysUserDepartService.list(query);
List<String> userIds = list.stream().map(SysUserDepart::getUserId).collect(Collectors.toList());
if (oConvertUtils.listIsNotEmpty(userIds)) {
queryWrapper.in("id", userIds);
}else{
izDepartId = false;
}
}
List<SysUserExportVo> list = new ArrayList<>();
// 代码逻辑说明: 【JHHB-762】【用户管理】需要支持按组织架构查询用户---
if(izDepartId){
List<SysUser> pageList = sysUserService.list(queryWrapper);
list = sysUserService.getDepartAndRoleExportMsg(pageList);
}
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "用户列表");
mv.addObject(NormalExcelConstants.CLASS, SysUserExportVo.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
ExportParams exportParams = new ExportParams("导入规则：\n" +
"1. 用户名为必填项，仅支持新增数据导入；\n" +
"2. 多个部门、角色或负责部门请用英文分号 ; 分隔，如：财务部;研发部；\n" +
"3. 部门层级请用英文斜杠 / 分隔，如：北京公司/财务部/财务一部；\n" +
"4. 部门类型需与部门层级一致，也用 / 分隔，如：公司/部门/部门 或 1/3/3，多个类型用 ; 分隔。机构类型编码：公司(1)，子公司(4)，部门(3)；\n" +
"5. 部门根据用户名匹配，若存在多个则关联最新创建的部门，不存在时自动新增；\n" +
"6. 负责部门与所属部门导入规则一致，若所属部门不包含负责部门，则不关联负责部门；\n" +
"7. 用户主岗位导入时会在部门下自动创建新岗位，职级为空时默认不与岗位建立关联。", "导出人：" + user.getRealname(), "导出信息");
exportParams.setTitleHeight((short)70);
exportParams.setStyle(ExcelExportSysUserStyle.class);
exportParams.setImageBasePath(upLoadPath);
//导出为xlsx
exportParams.setType(ExcelType.XSSF);
mv.addObject(NormalExcelConstants.PARAMS, exportParams);
mv.addObject(NormalExcelConstants.DATA_LIST, list);
//用户导出支持导出字段
String exportFields = request.getParameter(NormalExcelConstants.EXPORT_FIELDS);
if(oConvertUtils.isNotEmpty(exportFields)){
mv.addObject(NormalExcelConstants.EXPORT_FIELDS, exportFields);
}
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequiresPermissions("system:user:import")
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response)throws IOException {
//return ImportOldUserUtil.importOldSysUser(request);
return sysUserService.importSysUser(request);
}
/**
* @功能：根据id 批量查询
* @param userIds
* @return
*/
@RequestMapping(value = "/queryByIds", method = RequestMethod.GET)
public Result<Collection<SysUser>> queryByIds(@RequestParam(name = "userIds") String userIds) {
Result<Collection<SysUser>> result = new Result<>();
String[] userId = userIds.split(",");
Collection<String> idList = Arrays.asList(userId);
Collection<SysUser> userRole = sysUserService.listByIds(idList);
result.setSuccess(true);
result.setResult(userRole);
return result;
}
/**
* @功能：根据id 批量查询
* @param userNames
* @return
*/
@RequestMapping(value = "/queryByNames", method = RequestMethod.GET)
public Result<Collection<SysUser>> queryByNames(@RequestParam(name = "userNames") String userNames) {
Result<Collection<SysUser>> result = new Result<>();
String[] names = userNames.split(",");
QueryWrapper<SysUser> queryWrapper=new QueryWrapper();
queryWrapper.lambda().in(true,SysUser::getUsername,names);
Collection<SysUser> userRole = sysUserService.list(queryWrapper);
result.setSuccess(true);
result.setResult(userRole);
return result;
}
/**
* @功能：根据userName查询用户以及部门信息
* @param userName
* @return
*/
@RequestMapping(value = "/queryUserAndDeptByName", method = RequestMethod.GET)
public Result<Map<String,String>> queryUserAndDeptByName(@RequestParam(name = "userName") String userName) {
Map<String,String> userInfo= sysUserService.queryUserAndDeptByName(userName);
return Result.ok(userInfo);
}
/**
* 首页用户重置密码
*/
@RequiresPermissions("system:user:updatepwd")
@RequestMapping(value = "/updatePassword", method = RequestMethod.PUT)
public Result<?> updatePassword(@RequestBody JSONObject json) {
String username = json.getString("username");
String oldpassword = json.getString("oldpassword");
String password = json.getString("password");
String confirmpassword = json.getString("confirmpassword");
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
if(!sysUser.getUsername().equals(username)){
return Result.error("只允许修改自己的密码！");
}
SysUser user = this.sysUserService.getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUsername, username));
if(user==null) {
return Result.error("用户不存在！");
}
// 代码逻辑说明: [VUEN-234]修改密码添加敏感日志------------
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
baseCommonService.addLog("修改密码，username： " +loginUser.getUsername() ,CommonConstant.LOG_TYPE_2, 2);
return sysUserService.resetPassword(username,oldpassword,password,confirmpassword);
}
@RequestMapping(value = "/userRoleList", method = RequestMethod.GET)
public Result<IPage<SysUser>> userRoleList(@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize, HttpServletRequest req) {
Result<IPage<SysUser>> result = new Result<IPage<SysUser>>();
Page<SysUser> page = new Page<SysUser>(pageNo, pageSize);
String roleId = req.getParameter("roleId");
String username = req.getParameter("username");
String realname = req.getParameter("realname");
IPage<SysUser> pageList = sysUserService.getUserByRoleId(page,roleId,username,realname);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 给指定角色添加用户
*
* @param
* @return
*/
@RequiresPermissions("system:user:addUserRole")
@RequestMapping(value = "/addSysUserRole", method = RequestMethod.POST)
public Result<String> addSysUserRole(@RequestBody SysUserRoleVO sysUserRoleVO) {
Result<String> result = new Result<String>();
//TODO 判断当前操作的角色是当前登录租户下的
try {
String sysRoleId = sysUserRoleVO.getRoleId();
for(String sysUserId:sysUserRoleVO.getUserIdList()) {
SysUserRole sysUserRole = new SysUserRole(sysUserId,sysRoleId);
QueryWrapper<SysUserRole> queryWrapper = new QueryWrapper<SysUserRole>();
queryWrapper.eq("role_id", sysRoleId).eq("user_id",sysUserId);
SysUserRole one = sysUserRoleService.getOne(queryWrapper);
if(one==null){
sysUserRoleService.save(sysUserRole);
}
}
result.setMessage("添加成功!");
result.setSuccess(true);
return result;
}catch(Exception e) {
log.error(e.getMessage(), e);
result.setSuccess(false);
result.setMessage("出错了: " + e.getMessage());
return result;
}
}
/**
* 删除指定角色的用户关系
* @param
* @return
*/
@RequiresPermissions("system:user:deleteRole")
@RequestMapping(value = "/deleteUserRole", method = RequestMethod.DELETE)
public Result<SysUserRole> deleteUserRole(@RequestParam(name="roleId") String roleId,
@RequestParam(name="userId",required=true) String userId
) {
Result<SysUserRole> result = new Result<SysUserRole>();
try {
QueryWrapper<SysUserRole> queryWrapper = new QueryWrapper<SysUserRole>();
queryWrapper.eq("role_id", roleId).eq("user_id",userId);
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDictController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDictController.java | package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSON;
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;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.DictQuery;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.*;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.config.shiro.ShiroRealm;
import org.jeecg.modules.system.constant.DefIndexConst;
import org.jeecg.modules.system.entity.SysDict;
import org.jeecg.modules.system.entity.SysDictItem;
import org.jeecg.modules.system.model.SysDictTree;
import org.jeecg.modules.system.model.TreeSelectModel;
import org.jeecg.modules.system.service.ISysDictItemService;
import org.jeecg.modules.system.service.ISysDictService;
import org.jeecg.modules.system.vo.SysDictPage;
import org.jeecg.modules.system.vo.lowapp.SysDictVo;
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.entity.enmus.ExcelType;
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 jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
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;
@Autowired
private RedisUtil redisUtil;
@Autowired
private ShiroRealm shiroRealm;
@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,
// 查询关键字，模糊筛选code和name
@RequestParam(name = "keywords", required = false) String keywords,
HttpServletRequest req
) {
Result<IPage<SysDict>> result = new Result<IPage<SysDict>>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysDict.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(),0));
}
//------------------------------------------------------------------------------------------------
QueryWrapper<SysDict> queryWrapper = QueryGenerator.initQueryWrapper(sysDict, req.getParameterMap());
// 查询关键字，模糊筛选code和name
if (oConvertUtils.isNotEmpty(keywords)) {
queryWrapper.and(i -> i.like("dict_code", keywords).or().like("dict_name", keywords));
}
Page<SysDict> page = new Page<>(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;
}
/**
* 获取全部字典数据
*
* @return
*/
@RequestMapping(value = "/queryAllDictItems", method = RequestMethod.GET)
public Result<?> queryAllDictItems(HttpServletRequest request) {
Map<String, List<DictModel>> res = new HashMap(5);
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 字典code
* @param dictCode 表名,文本字段,code字段 | 举例：sys_user,realname,id
* @return
*/
@RequestMapping(value = "/getDictItems/{dictCode}", method = RequestMethod.GET)
public Result<List<DictModel>> getDictItems(@PathVariable("dictCode") String dictCode, @RequestParam(value = "sign",required = false) String sign,HttpServletRequest request) {
log.debug(" dictCode : "+ dictCode);
Result<List<DictModel>> result = new Result<List<DictModel>>();
try {
List<DictModel> ls = sysDictService.getDictItems(dictCode);
if (ls == null) {
result.error500("字典Code格式不正确！");
return result;
}
result.setSuccess(true);
result.setResult(ls);
log.debug(result.toString());
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
return result;
}
return result;
}
/**
* 【接口签名验证】
* 【JSearchSelectTag下拉搜索组件专用接口】
* 大数据量的字典表 走异步加载 即前端输入内容过滤数据
* @param dictCode 字典code格式：table,text,code
* @return
*/
@RequestMapping(value = "/loadDict/{dictCode}", method = RequestMethod.GET)
public Result<List<DictModel>> loadDict(@PathVariable("dictCode") String dictCode,
@RequestParam(name="keyword",required = false) String keyword,
@RequestParam(value = "sign",required = false) String sign,
@RequestParam(name = "pageNo", defaultValue = "1", required = false) Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10", required = false) Integer pageSize) {
// 代码逻辑说明: /issues/4905 因为中括号(%5)的问题导致的 表单生成器字段配置时，选择关联字段，在进行高级配置时，无法加载数据库列表，提示 Sgin签名校验错误！ #4905 RouteToRequestUrlFilter
if(keyword!=null && keyword.indexOf("%5")>=0){
try {
keyword = URLDecoder.decode(keyword, "UTF-8");
} catch (UnsupportedEncodingException e) {
log.error("下拉搜索关键字解码失败", e);
}
}
log.info(" 加载字典表数据,加载关键字: "+ keyword);
Result<List<DictModel>> result = new Result<List<DictModel>>();
try {
List<DictModel> ls = sysDictService.loadDict(dictCode, keyword, pageNo,pageSize);
if (ls == null) {
result.error500("字典Code格式不正确！");
return result;
}
result.setSuccess(true);
result.setResult(ls);
log.info(result.toString());
return result;
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败：" + e.getMessage());
return result;
}
}
/**
* 【接口签名验证】
* 【给表单设计器的表字典使用】下拉搜索模式，有值时动态拼接数据
* @param dictCode
* @param keyword 当前控件的值，可以逗号分割
* @param sign
* @param pageSize
* @return
*/
@RequestMapping(value = "/loadDictOrderByValue/{dictCode}", method = RequestMethod.GET)
public Result<List<DictModel>> loadDictOrderByValue(
@PathVariable("dictCode") String dictCode,
@RequestParam(name = "keyword") String keyword,
@RequestParam(value = "sign", required = false) String sign,
@RequestParam(value = "pageSize", required = false) Integer pageSize) {
// 首次查询查出来用户选中的值，并且不分页
Result<List<DictModel>> firstRes = this.loadDict(dictCode, keyword, sign,null, null);
if (!firstRes.isSuccess()) {
return firstRes;
}
// 然后再查询出第一页的数据
Result<List<DictModel>> result = this.loadDict(dictCode, "", sign,1, pageSize);
if (!result.isSuccess()) {
return result;
}
// 合并两次查询的数据
List<DictModel> firstList = firstRes.getResult();
List<DictModel> list = result.getResult();
for (DictModel firstItem : firstList) {
// anyMatch 表示：判断的条件里，任意一个元素匹配成功，返回true
// allMatch 表示：判断条件里的元素，所有的都匹配成功，返回true
// noneMatch 跟 allMatch 相反，表示：判断条件里的元素，所有的都匹配失败，返回true
boolean none = list.stream().noneMatch(item -> item.getValue().equals(firstItem.getValue()));
// 当元素不存在时，再添加到集合里
if (none) {
list.add(0, firstItem);
}
}
return result;
}
/**
* 【接口签名验证】
* 根据字典code加载字典text 返回
* @param dictCode 顺序：tableName,text,code
* @param keys 要查询的key
* @param sign
* @param delNotExist 是否移除不存在的项，默认为true，设为false如果某个key不存在数据库中，则直接返回key本身
* @param request
* @return
*/
@RequestMapping(value = "/loadDictItem/{dictCode}", method = RequestMethod.GET)
public Result<List<String>> loadDictItem(@PathVariable("dictCode") String dictCode,@RequestParam(name="key") String keys, @RequestParam(value = "sign",required = false) String sign,@RequestParam(value = "delNotExist",required = false,defaultValue = "true") boolean delNotExist,HttpServletRequest request) {
Result<List<String>> result = new Result<>();
try {
if(dictCode.indexOf(SymbolConstant.COMMA)!=-1) {
String[] params = dictCode.split(SymbolConstant.COMMA);
if(params.length!=3) {
result.error500("字典Code格式不正确！");
return result;
}
List<String> texts = sysDictService.queryTableDictByKeys(params[0], params[1], params[2], keys, delNotExist);
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 加载树形数据
* @param hasChildField 是否叶子节点字段
* @param converIsLeafVal 是否需要系统转换 是否叶子节点的值 (0标识不转换、1标准系统自动转换)
* @param tableName 表名
* @param text label字段
* @param code value 字段
* @param condition 查询条件 ？
*
*/
@SuppressWarnings("unchecked")
@RequestMapping(value = "/loadTreeData", method = RequestMethod.GET)
public Result<List<TreeSelectModel>> loadTreeData(@RequestParam(name="pid",required = false) String pid,@RequestParam(name="pidField") String pidField,
@RequestParam(name="tableName") String tableName,
@RequestParam(name="text") String text,
@RequestParam(name="code") String code,
@RequestParam(name="hasChildField") String hasChildField,
@RequestParam(name="converIsLeafVal",defaultValue ="1") int converIsLeafVal,
@RequestParam(name="condition") String condition,
@RequestParam(value = "sign",required = false) String sign,HttpServletRequest request) {
Result<List<TreeSelectModel>> result = new Result<List<TreeSelectModel>>();
// 【QQYUN-9207】防止参数为空导致报错
if (oConvertUtils.isEmpty(tableName) || oConvertUtils.isEmpty(text) || oConvertUtils.isEmpty(code)) {
result.error500("字典Code格式不正确！");
return result;
}
// 1.获取查询条件参数
Map<String, String> query = null;
if(oConvertUtils.isNotEmpty(condition)) {
query = JSON.parseObject(condition, Map.class);
}
// 2.返回查询结果
List<TreeSelectModel> ls = sysDictService.queryTreeList(query,tableName, text, code, pidField, pid,hasChildField,converIsLeafVal);
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>>();
List<DictModel> ls = this.sysDictService.queryDictTablePageList(query,pageSize,pageNo);
res.setResult(ls);
res.setSuccess(true);
return res;
}
/**
* @功能：新增
* @param sysDict
* @return
*/
@RequiresPermissions("system:dict:add")
@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
*/
@RequiresPermissions("system:dict:edit")
@RequestMapping(value = "/edit", method = { RequestMethod.PUT,RequestMethod.POST })
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
*/
@RequiresPermissions("system:dict:delete")
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value={CacheConstant.SYS_DICT_CACHE, CacheConstant.SYS_ENABLE_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
*/
@RequiresPermissions("system:dict:deleteBatch")
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value= {CacheConstant.SYS_DICT_CACHE, CacheConstant.SYS_ENABLE_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 keys7 = redisTemplate.keys(CacheConstant.SYS_ENABLE_DICT_CACHE + "*");
// Set keys2 = redisTemplate.keys(CacheConstant.SYS_DICT_TABLE_CACHE + "*");
// Set keys21 = redisTemplate.keys(CacheConstant.SYS_DICT_TABLE_BY_KEYS_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(keys21);
// redisTemplate.delete(keys3);
// redisTemplate.delete(keys4);
// redisTemplate.delete(keys5);
// redisTemplate.delete(keys6);
// redisTemplate.delete(keys7);
// 代码逻辑说明: [issue/4358]springCache中的清除缓存的操作使用了“keys”
redisUtil.removeAll(CacheConstant.SYS_DICT_CACHE);
redisUtil.removeAll(CacheConstant.SYS_ENABLE_DICT_CACHE);
redisUtil.removeAll(CacheConstant.SYS_DICT_TABLE_CACHE);
redisUtil.removeAll(CacheConstant.SYS_DICT_TABLE_BY_KEYS_CACHE);
redisUtil.removeAll(CacheConstant.SYS_DEPARTS_CACHE);
redisUtil.removeAll(CacheConstant.SYS_DEPART_IDS_CACHE);
redisUtil.removeAll("jmreport:cache:dict");
redisUtil.removeAll("jmreport:cache:dictTable");
// 清除当前用户的授权缓存信息
Subject currentUser = SecurityUtils.getSubject();
if (currentUser.isAuthenticated()) {
shiroRealm.clearCache(currentUser.getPrincipals());
}
// 清空默认首页缓存（开源版和商业版会串）
redisUtil.del(DefIndexConst.CACHE_KEY + "::" + DefIndexConst.DEF_INDEX_ALL);
return result;
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(SysDict sysDict,HttpServletRequest request) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysDict.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
// Step.1 组装查询条件
QueryWrapper<SysDict> queryWrapper = QueryGenerator.initQueryWrapper(sysDict, request.getParameterMap());
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
String selections = request.getParameter("selections");
if(!oConvertUtils.isEmpty(selections)){
queryWrapper.in("id",selections.split(","));
}
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(), "数据字典", ExcelType.XSSF));
// 导出数据列表
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param
* @return
*/
@RequiresPermissions("system:dict:importExcel")
@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!=null && !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++;
// 代码逻辑说明: [JTC-1168]如果字典项值为空，则字典项忽略导入------------
}else if(integer == -1){
errorLines++;
errorMessage.add("字典名称：" + po.getDictName() + "，对应字典列表的字典项值不能为空，忽略导入。");
}else{
errorLines++;
int lineNumber = i + 1;
// 代码逻辑说明: [JTC-1168]字典编号不能为空------------
if(oConvertUtils.isEmpty(po.getDictCode())){
errorMessage.add("第 " + lineNumber + " 行：字典编码不能为空，忽略导入。");
}else{
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(HttpServletRequest request) {
Result<List<SysDict>> result = new Result<List<SysDict>>();
String tenantId = TokenUtils.getTenantIdByRequest(request);
List<SysDict> list = this.sysDictService.queryDeleteList(tenantId);
result.setSuccess(true);
result.setResult(list);
return result;
}
/**
* 物理删除
* @param id
* @return
*/
@RequestMapping(value = "/deletePhysic/{id}", method = RequestMethod.DELETE)
public Result<?> deletePhysic(@PathVariable("id") 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("id") String id) {
try {
sysDictService.updateDictDelFlag(0,id);
return Result.ok("操作成功!");
} catch (Exception e) {
e.printStackTrace();
return Result.error("操作失败!");
}
}
/**
* 还原被逻辑删除的用户
*
* @param jsonObject
* @return
*/
@RequestMapping(value = "/putRecycleBin", method = RequestMethod.PUT)
public Result putRecycleBin(@RequestBody JSONObject jsonObject, HttpServletRequest request) {
try {
String ids = jsonObject.getString("ids");
if (StringUtils.isNotBlank(ids)) {
sysDictService.revertLogicDeleted(Arrays.asList(ids.split(",")));
return Result.ok("操作成功!");
}
} catch (Exception e) {
e.printStackTrace();
return Result.error("操作失败!");
}
return Result.ok("还原成功");
}
/**
* 彻底删除字典
*
* @param ids 被删除的字典ID，多个id用半角逗号分割
* @return
*/
@RequiresPermissions("system:dict:deleteRecycleBin")
@RequestMapping(value = "/deleteRecycleBin", method = RequestMethod.DELETE)
public Result deleteRecycleBin(@RequestParam("ids") String ids) {
try {
if (StringUtils.isNotBlank(ids)) {
sysDictService.removeLogicDeleted(Arrays.asList(ids.split(",")));
}
return Result.ok("删除成功!");
} catch (Exception e) {
e.printStackTrace();
return Result.error("删除失败!");
}
}
/**
* VUEN-2584【issue】平台sql注入漏洞几个问题
* 部分特殊函数 可以将查询结果混夹在错误信息中，导致数据库的信息暴露
* @param e
* @return
*/
@ExceptionHandler(java.sql.SQLException.class)
public Result<?> handleSQLException(Exception e){
String msg = e.getMessage();
String extractvalue = "extractvalue";
String updatexml = "updatexml";
if(msg!=null && (msg.toLowerCase().indexOf(extractvalue)>=0 || msg.toLowerCase().indexOf(updatexml)>=0)){
return Result.error("校验失败，sql解析异常！");
}
return Result.error("校验失败，sql解析异常！" + msg);
}
/**
* 根据应用id获取字典列表和详情
* @param request
*/
@GetMapping("/getDictListByLowAppId")
public Result<List<SysDictVo>> getDictListByLowAppId(HttpServletRequest request){
String lowAppId = oConvertUtils.getString(TokenUtils.getLowAppIdByRequest(request));
List<SysDictVo> list = sysDictService.getDictListByLowAppId(lowAppId);
return Result.ok(list);
}
/**
* 添加字典
* @param sysDictVo
* @param request
* @return
*/
@PostMapping("/addDictByLowAppId")
public Result<String> addDictByLowAppId(@RequestBody SysDictVo sysDictVo,HttpServletRequest request){
String lowAppId = oConvertUtils.getString(TokenUtils.getLowAppIdByRequest(request));
String tenantId = oConvertUtils.getString(TokenUtils.getTenantIdByRequest(request));
sysDictVo.setLowAppId(lowAppId);
sysDictVo.setTenantId(oConvertUtils.getInteger(tenantId, null));
sysDictService.addDictByLowAppId(sysDictVo);
return Result.ok("添加成功");
}
@PutMapping("/editDictByLowAppId")
public Result<String> editDictByLowAppId(@RequestBody SysDictVo sysDictVo,HttpServletRequest request){
String lowAppId = oConvertUtils.getString(TokenUtils.getLowAppIdByRequest(request));
sysDictVo.setLowAppId(lowAppId);
sysDictService.editDictByLowAppId(sysDictVo);
return Result.ok("编辑成功");
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysCommentController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysCommentController.java | package org.jeecg.modules.system.controller;
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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.dto.DataLogDTO;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.system.entity.SysComment;
import org.jeecg.modules.system.service.ISysCommentService;
import org.jeecg.modules.system.vo.SysCommentFileVo;
import org.jeecg.modules.system.vo.SysCommentVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.List;
/**
* @Description: 系统评论回复表
* @Author: jeecg-boot
* @Date: 2022-07-19
* @Version: V1.0
*/
@Tag(name = "系统评论回复表")
@RestController
@RequestMapping("/sys/comment")
@Slf4j
public class SysCommentController extends JeecgController<SysComment, ISysCommentService> {
@Autowired
private ISysCommentService sysCommentService;
@Autowired
private ISysBaseAPI sysBaseAPI;
/**
* 在线预览文件地址
*/
@Value("${jeecg.file-view-domain}/onlinePreview")
private String onlinePreviewDomain;
/**
* 查询评论+文件
*
* @param sysComment
* @return
*/
@Operation(summary = "系统评论回复表-列表查询")
@GetMapping(value = "/listByForm")
public Result<IPage<SysCommentVO>> queryListByForm(SysComment sysComment) {
List<SysCommentVO> list = sysCommentService.queryFormCommentInfo(sysComment);
IPage<SysCommentVO> pageList = new Page();
pageList.setRecords(list);
return Result.OK(pageList);
}
/**
* 查询文件
*
* @param sysComment
* @return
*/
@Operation(summary = "系统评论回复表-列表查询")
@GetMapping(value = "/fileList")
public Result<IPage<SysCommentFileVo>> queryFileList(SysComment sysComment) {
List<SysCommentFileVo> list = sysCommentService.queryFormFileList(sysComment.getTableName(), sysComment.getTableDataId());
IPage<SysCommentFileVo> pageList = new Page();
pageList.setRecords(list);
return Result.OK(pageList);
}
@Operation(summary = "系统评论表-添加文本")
@PostMapping(value = "/addText")
public Result<String> addText(@RequestBody SysComment sysComment) {
String commentId = sysCommentService.saveOne(sysComment);
return Result.OK(commentId);
}
@Operation(summary = "系统评论表-添加文件")
@PostMapping(value = "/addFile")
public Result<String> addFile(HttpServletRequest request) {
try {
sysCommentService.saveOneFileComment(request);
return Result.OK("success");
} catch (Exception e) {
log.error("评论文件上传失败：{}", e.getMessage());
return Result.error("操作失败," + e.getMessage());
}
}
/**
* app端添加评论表
* @param request
* @return
*/
@Operation(summary = "系统评论表-添加文件")
@PostMapping(value = "/appAddFile")
public Result<String> appAddFile(HttpServletRequest request) {
try {
sysCommentService.appSaveOneFileComment(request);
return Result.OK("success");
} catch (Exception e) {
log.error("评论文件上传失败：{}", e.getMessage());
return Result.error("操作失败," + e.getMessage());
}
}
@Operation(summary = "系统评论回复表-通过id删除")
@DeleteMapping(value = "/deleteOne")
public Result<String> deleteOne(@RequestParam(name = "id", required = true) String id) {
SysComment comment = sysCommentService.getById(id);
if(comment==null){
return Result.error("该评论已被删除！");
}
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String username = sysUser.getUsername();
String admin = "admin";
//除了admin外 其他人只能删除自己的评论
if((!admin.equals(username)) && !username.equals(comment.getCreateBy())){
return Result.error("只能删除自己的评论！");
}
sysCommentService.deleteOne(id);
//删除评论添加日志
String logContent = "删除了评论， "+ comment.getCommentContent();
DataLogDTO dataLog = new DataLogDTO(comment.getTableName(), comment.getTableDataId(), logContent, CommonConstant.DATA_LOG_TYPE_COMMENT);
sysBaseAPI.saveDataLog(dataLog);
return Result.OK("删除成功!");
}
/**
* 获取文件预览的地址
* @return
*/
@GetMapping(value = "/getFileViewDomain")
public Result<String> getFileViewDomain() {
return Result.OK(onlinePreviewDomain);
}
/**
* 分页列表查询
*
* @param sysComment
* @param pageNo
* @param pageSize
* @param req
* @return
*/
//@AutoLog(value = "系统评论回复表-分页列表查询")
@Operation(summary = "系统评论回复表-分页列表查询")
@GetMapping(value = "/list")
public Result<IPage<SysComment>> queryPageList(SysComment sysComment,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<SysComment> queryWrapper = QueryGenerator.initQueryWrapper(sysComment, req.getParameterMap());
Page<SysComment> page = new Page<SysComment>(pageNo, pageSize);
IPage<SysComment> pageList = sysCommentService.page(page, queryWrapper);
return Result.OK(pageList);
}
/**
* 添加
*
* @param sysComment
* @return
*/
@Operation(summary = "系统评论回复表-添加")
//@RequiresPermissions("org.jeecg.modules.demo:sys_comment:add")
@PostMapping(value = "/add")
public Result<String> add(@RequestBody SysComment sysComment) {
sysCommentService.save(sysComment);
return Result.OK("添加成功！");
}
/**
* 编辑
*
* @param sysComment
* @return
*/
//@AutoLog(value = "系统评论回复表-编辑")
@Operation(summary = "系统评论回复表-编辑")
//@RequiresPermissions("org.jeecg.modules.demo:sys_comment:edit")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
public Result<String> edit(@RequestBody SysComment sysComment) {
sysCommentService.updateById(sysComment);
return Result.OK("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
//@AutoLog(value = "系统评论回复表-通过id删除")
@Operation(summary = "系统评论回复表-通过id删除")
//@RequiresPermissions("org.jeecg.modules.demo:sys_comment:delete")
@DeleteMapping(value = "/delete")
public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
sysCommentService.removeById(id);
return Result.OK("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
//@AutoLog(value = "系统评论回复表-批量删除")
@Operation(summary = "系统评论回复表-批量删除")
//@RequiresPermissions("org.jeecg.modules.demo:sys_comment:deleteBatch")
@DeleteMapping(value = "/deleteBatch")
public Result<String> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.sysCommentService.removeByIds(Arrays.asList(ids.split(",")));
return Result.OK("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
//@AutoLog(value = "系统评论回复表-通过id查询")
@Operation(summary = "系统评论回复表-通过id查询")
@GetMapping(value = "/queryById")
public Result<SysComment> queryById(@RequestParam(name = "id", required = true) String id) {
SysComment sysComment = sysCommentService.getById(id);
if (sysComment == null) {
return Result.error("未找到对应数据");
}
return Result.OK(sysComment);
}
/**
* 导出excel
*
* @param request
* @param sysComment
*/
//@RequiresPermissions("org.jeecg.modules.demo:sys_comment:exportXls")
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysComment sysComment) {
return super.exportXls(request, sysComment, SysComment.class, "系统评论回复表");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
//@RequiresPermissions("sys_comment:importExcel")
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, SysComment.class);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysUploadController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysUploadController.java | package org.jeecg.modules.system.controller;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.MinioUtil;
import org.jeecg.common.util.filter.SsrfFileTypeFilter;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.oss.entity.OssFile;
import org.jeecg.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 jakarta.servlet.http.HttpServletRequest;
/**
* minio文件上传示例
* @author: jeecg-boot
*/
@Slf4j
@RestController
@RequestMapping("/sys/upload")
public class SysUploadController {
@Autowired
private IOssFileService ossFileService;
/**
* 上传
* @param request
*/
@PostMapping(value = "/uploadMinio")
public Result<?> uploadMinio(HttpServletRequest request) throws Exception {
Result<?> result = new Result<>();
// 获取业务路径
String bizPath = request.getParameter("biz");
// 获取上传文件对象
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("file");
// 文件安全校验，防止上传漏洞文件
SsrfFileTypeFilter.checkUploadFileType(file, bizPath);
if(oConvertUtils.isEmpty(bizPath)){
bizPath = "";
}
// 获取文件名
String orgName = file.getOriginalFilename();
orgName = CommonUtils.getFileName(orgName);
String fileUrl = MinioUtil.upload(file,bizPath);
if(oConvertUtils.isEmpty(fileUrl)){
return Result.error("上传失败,请检查配置信息是否正确!");
}
//保存文件信息
OssFile minioFile = new OssFile();
minioFile.setFileName(orgName);
minioFile.setUrl(fileUrl);
ossFileService.save(minioFile);
result.setMessage(fileUrl);
result.setSuccess(true);
return result;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysFormFileController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysFormFileController.java | package org.jeecg.modules.system.controller;
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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.system.entity.SysFormFile;
import org.jeecg.modules.system.service.ISysFormFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.util.Arrays;
/**
* @Description: 表单评论文件
* @Author: jeecg-boot
* @Date: 2022-07-21
* @Version: V1.0
*/
@Slf4j
@Tag(name = "表单评论文件")
@RestController
@RequestMapping("/sys/formFile")
public class SysFormFileController extends JeecgController<SysFormFile, ISysFormFileService> {
@Autowired
private ISysFormFileService sysFormFileService;
/**
* 分页列表查询
*
* @param sysFormFile
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "表单评论文件-分页列表查询")
@Operation(summary = "表单评论文件-分页列表查询")
@GetMapping(value = "/list")
public Result<?> queryPageList(SysFormFile sysFormFile,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<SysFormFile> queryWrapper = QueryGenerator.initQueryWrapper(sysFormFile, req.getParameterMap());
Page<SysFormFile> page = new Page<SysFormFile>(pageNo, pageSize);
IPage<SysFormFile> pageList = sysFormFileService.page(page, queryWrapper);
return Result.OK(pageList);
}
/**
* 添加
*
* @param sysFormFile
* @return
*/
@AutoLog(value = "表单评论文件-添加")
@Operation(summary = "表单评论文件-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysFormFile sysFormFile) {
sysFormFileService.save(sysFormFile);
return Result.OK("添加成功！");
}
/**
* 编辑
*
* @param sysFormFile
* @return
*/
@AutoLog(value = "表单评论文件-编辑")
@Operation(summary = "表单评论文件-编辑")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
public Result<?> edit(@RequestBody SysFormFile sysFormFile) {
sysFormFileService.updateById(sysFormFile);
return Result.OK("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "表单评论文件-通过id删除")
@Operation(summary = "表单评论文件-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
sysFormFileService.removeById(id);
return Result.OK("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "表单评论文件-批量删除")
@Operation(summary = "表单评论文件-批量删除")
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.sysFormFileService.removeByIds(Arrays.asList(ids.split(",")));
return Result.OK("批量删除成功！");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@AutoLog(value = "表单评论文件-通过id查询")
@Operation(summary = "表单评论文件-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
SysFormFile sysFormFile = sysFormFileService.getById(id);
return Result.OK(sysFormFile);
}
/**
* 导出excel
*
* @param request
* @param sysFormFile
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysFormFile sysFormFile) {
return super.exportXls(request, sysFormFile, SysFormFile.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, SysFormFile.class);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysFillRuleController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysFillRuleController.java | package org.jeecg.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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.FillRuleUtil;
import org.jeecg.modules.system.entity.SysFillRule;
import org.jeecg.modules.system.service.ISysFillRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.util.Arrays;
/**
* @Description: 填值规则
* @Author: jeecg-boot
* @Date: 2019-11-07
* @Version: V1.0
*/
@Slf4j
@Tag(name = "填值规则")
@RestController
@RequestMapping("/sys/fillRule")
public class SysFillRuleController extends JeecgController<SysFillRule, ISysFillRuleService> {
@Autowired
private ISysFillRuleService sysFillRuleService;
/**
* 分页列表查询
*
* @param sysFillRule
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "填值规则-分页列表查询")
@Operation(summary = "填值规则-分页列表查询")
@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 = "填值规则-添加")
@Operation(summary = "填值规则-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysFillRule sysFillRule) {
sysFillRuleService.save(sysFillRule);
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param sysFillRule
* @return
*/
@AutoLog(value = "填值规则-编辑")
@Operation(summary = "填值规则-编辑")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
public Result<?> edit(@RequestBody SysFillRule sysFillRule) {
sysFillRuleService.updateById(sysFillRule);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "填值规则-通过id删除")
@Operation(summary = "填值规则-通过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 = "填值规则-批量删除")
@Operation(summary = "填值规则-批量删除")
@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查询")
@Operation(summary = "填值规则-通过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);
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDepartController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDepartController.java | package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.ImportExcelUtil;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.excelstyle.ExcelExportSysUserStyle;
import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysUserDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.vo.SysChangeDepartVo;
import org.jeecg.modules.system.vo.SysDepartExportVo;
import org.jeecg.modules.system.vo.SysPositionSelectTreeVo;
import org.jeecg.modules.system.vo.lowapp.ExportDepartVo;
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.entity.enmus.ExcelType;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
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 jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
/**
* <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;
@Autowired
private RedisUtil redisUtil;
/**
* 查询数据 查出我的部门,并以树结构数据格式响应给前端
*
* @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 )){
// 代码逻辑说明: 部门查询ids为空后的前端显示问题 issues/I3UD06
String departIds = user.getDepartIds();
if(StringUtils.isNotBlank(departIds)){
List<SysDepartTreeModel> list = sysDepartService.queryMyDeptTreeList(departIds);
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(@RequestParam(name = "ids", required = false) String ids) {
Result<List<SysDepartTreeModel>> result = new Result<>();
try {
// 从内存中读取
// List<SysDepartTreeModel> list =FindsDepartsChildrenUtil.getSysDepartTreeList();
// if (CollectionUtils.isEmpty(list)) {
// list = sysDepartService.queryTreeList();
// }
if(oConvertUtils.isNotEmpty(ids)){
List<SysDepartTreeModel> departList = sysDepartService.queryTreeList(ids);
result.setResult(departList);
}else{
List<SysDepartTreeModel> list = sysDepartService.queryTreeList();
result.setResult(list);
}
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* 异步查询部门list
* @param parentId 父节点 异步加载时传递
* @param ids 前端回显是传递
* @param primaryKey 主键字段（id或者orgCode）
* @return
*/
@RequestMapping(value = "/queryDepartTreeSync", method = RequestMethod.GET)
public Result<List<SysDepartTreeModel>> queryDepartTreeSync(@RequestParam(name = "pid", required = false) String parentId,@RequestParam(name = "ids", required = false) String ids, @RequestParam(name = "primaryKey", required = false) String primaryKey) {
Result<List<SysDepartTreeModel>> result = new Result<>();
try {
List<SysDepartTreeModel> list = sysDepartService.queryTreeListByPid(parentId,ids, primaryKey);
result.setResult(list);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
result.setSuccess(false);
result.setMessage("查询失败");
}
return result;
}
/**
* 异步查询部门和岗位list
* @param parentId 父节点 异步加载时传递
* @param ids 前端回显是传递
* @param primaryKey 主键字段（id或者orgCode）
* @return
*/
@RequestMapping(value = "/queryDepartAndPostTreeSync", method = RequestMethod.GET)
public Result<List<SysDepartTreeModel>> queryDepartAndPostTreeSync(@RequestParam(name = "pid", required = false) String parentId,
@RequestParam(name = "ids", required = false) String ids,
@RequestParam(name = "primaryKey", required = false) String primaryKey,
@RequestParam(name = "departIds", required = false) String departIds,
@RequestParam(name = "name", required = false) String orgName) {
Result<List<SysDepartTreeModel>> result = new Result<>();
try {
List<SysDepartTreeModel> list = sysDepartService.queryDepartAndPostTreeSync(parentId,ids, primaryKey, departIds, orgName);
result.setResult(list);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
result.setSuccess(false);
result.setMessage("查询失败");
}
return result;
}
/**
* 获取某个部门的所有父级部门的ID
*
* @param departId 根据departId查
* @param orgCode 根据orgCode查，departId和orgCode必须有一个不为空
*/
@GetMapping("/queryAllParentId")
public Result queryParentIds(
@RequestParam(name = "departId", required = false) String departId,
@RequestParam(name = "orgCode", required = false) String orgCode) {
try {
JSONObject data;
if (oConvertUtils.isNotEmpty(departId)) {
data = sysDepartService.queryAllParentIdByDepartId(departId);
} else if (oConvertUtils.isNotEmpty(orgCode)) {
data = sysDepartService.queryAllParentIdByOrgCode(orgCode);
} else {
return Result.error("departId 和 orgCode 不能都为空！");
}
return Result.OK(data);
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error(e.getMessage());
}
}
/**
* 添加新数据 添加用户新建的部门对象数据,并保存到数据库
*
* @param sysDepart
* @return
*/
@RequiresPermissions("system:depart:add")
@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
*/
@RequiresPermissions("system:depart:edit")
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
@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
*/
@RequiresPermissions("system:depart:delete")
@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 {
sysDepartService.deleteDepart(id);
//清除部门树内存
//FindsDepartsChildrenUtil.clearSysDepartTreeList();
// FindsDepartsChildrenUtil.clearDepartIdModel();
result.success("删除成功!");
}
return result;
}
/**
* 批量删除 根据前端请求的多个ID,对数据库执行删除相关部门数据的操作
*
* @param ids
* @return
*/
@RequiresPermissions("system:depart:deleteBatch")
@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,
@RequestParam(name = "orgCategory", required = false) String orgCategory,
@RequestParam(name = "departIds", required = false) String depIds) {
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.searchByKeyWord(keyWord,myDeptSearch,departIds,orgCategory,depIds);
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) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysDepart.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
//// Step.1 组装查询条件
//QueryWrapper<SysDepart> queryWrapper = QueryGenerator.initQueryWrapper(sysDepart, request.getParameterMap());
//Step.1 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());
//}
//});
// 过滤选中数据
String selections = request.getParameter("selections");
List<String> idList = new ArrayList<>();
if (oConvertUtils.isNotEmpty(selections)) {
idList = Arrays.asList(selections.split(","));
}
//step.2 组装导出数据
Integer tenantId = sysDepart == null ? null : sysDepart.getTenantId();
// 代码逻辑说明: 【TV360X-1671】部门管理不支持选中的记录导出---
List<SysDepartExportVo> sysDepartExportVos = sysDepartService.getExportDepart(tenantId,idList);
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "部门列表");
mv.addObject(NormalExcelConstants.CLASS, SysDepartExportVo.class);
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
ExportParams exportParams = new ExportParams("导入规则：\n" +
"1、标题为第三行，部门路径和部门名称的标题不允许修改，否则会匹配失败；第四行为数据填写范围;\n" +
"2、部门路径用英文字符/分割，部门名称为部门路径的最后一位;\n" +
"3、部门从一级名称开始创建，如果有同级就需要多添加一行，如研发部/研发一部;研发部/研发二部;\n" +
"4、自定义的部门编码需要满足规则才能导入。如一级部门编码为A01,那么子部门为A01A01,同级子部门为A01A02,编码固定为三位，首字母为A-Z,后两位为数字0-99，依次递增;", "导出人:" + user.getRealname(), "导出信息", ExcelType.XSSF);
exportParams.setTitleHeight((short)70);
exportParams.setStyle(ExcelExportSysUserStyle.class);
mv.addObject(NormalExcelConstants.PARAMS, exportParams);
mv.addObject(NormalExcelConstants.DATA_LIST, sysDepartExportVos);
return mv;
}
/**
* 通过excel导入数据
* 部门导入方案1: 通过机构编码来计算出部门的父级ID,维护上下级关系;
* 部门导入方案2: 你也可以改造下程序,机构编码直接导入,先不设置父ID;全部导入后,写一个sql,补下父ID;
*
* @param request
* @param response
* @return
*/
@RequiresPermissions("system:depart:importExcel")
@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;
List<SysDepartExportVo> 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.ZHANWEI_LENGTH;
// 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());
// //更新父级部门不是叶子结点
// sysDepartService.updateIzLeaf(parentDept.getId(),CommonConstant.NOT_LEAF);
// } else {
// sysDepart.setParentId("");
// }
// }catch (Exception e) {
// //没有查找到parentDept
// }
// }else{
// sysDepart.setParentId("");
// }
// sysDepart.setOrgType(sysDepart.getOrgCode().length()/codeLength+"");
// sysDepart.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
// if(oConvertUtils.isEmpty(sysDepart.getOrgCategory())){
// sysDepart.setOrgCategory("1");
// }
// ImportExcelUtil.importDateSaveOne(sysDepart, ISysDepartService.class, errorMessageList, num, CommonConstant.SQL_INDEX_UNIQ_DEPART_ORG_CODE);
// num++;
// }
// 代码逻辑说明: 【QQYUN-5482】系统的部门导入导出也可以改成敲敲云模式的部门路径---
listSysDeparts = ExcelImportUtil.importExcel(file.getInputStream(), SysDepartExportVo.class, params);
sysDepartService.importSysDepart(listSysDeparts,errorMessageList);
//清空部门缓存
List<String> keys3 = redisUtil.scan(CacheConstant.SYS_DEPARTS_CACHE + "*");
List<String> keys4 = redisUtil.scan(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(5);
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;
}
/**
* @功能：根据id 批量查询
* @param deptIds
* @return
*/
@RequestMapping(value = "/queryByIds", method = RequestMethod.GET)
public Result<Collection<SysDepart>> queryByIds(@RequestParam(name = "deptIds") String deptIds) {
Result<Collection<SysDepart>> result = new Result<>();
String[] ids = deptIds.split(",");
Collection<String> idList = Arrays.asList(ids);
Collection<SysDepart> deptList = sysDepartService.listByIds(idList);
// 设置部门路径名称
for (SysDepart depart : deptList) {
String departPathName = sysDepartService.getDepartPathNameByOrgCode(depart.getOrgCode(),null);
depart.setDepartPathName(departPathName);
}
result.setSuccess(true);
result.setResult(deptList);
return result;
}
@GetMapping("/getMyDepartList")
public Result<List<SysDepart>> getMyDepartList(){
List<SysDepart> list = sysDepartService.getMyDepartList();
return Result.ok(list);
}
/**
* 异步查询部门list
* @param parentId 父节点 异步加载时传递
* @return
*/
@RequestMapping(value = "/queryBookDepTreeSync", method = RequestMethod.GET)
public Result<List<SysDepartTreeModel>> queryBookDepTreeSync(@RequestParam(name = "pid", required = false) String parentId,
@RequestParam(name = "tenantId") Integer tenantId,
@RequestParam(name = "departName",required = false) String departName) {
Result<List<SysDepartTreeModel>> result = new Result<>();
try {
List<SysDepartTreeModel> list = sysDepartService.queryBookDepTreeSync(parentId, tenantId, departName);
result.setResult(list);
result.setSuccess(true);
} catch (Exception e) {
log.error(e.getMessage(),e);
}
return result;
}
/**
* 通过部门id和租户id获取用户 【低代码应用: 用于选择部门负责人】
* @param departId
* @return
*/
@GetMapping("/getUsersByDepartTenantId")
public Result<List<SysUser>> getUsersByDepartTenantId(@RequestParam("departId") String departId){
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
List<SysUser> sysUserList = sysUserDepartService.getUsersByDepartTenantId(departId,tenantId);
return Result.ok(sysUserList);
}
/**
* 导出excel【低代码应用: 用于导出部门】
*
* @param request
*/
@RequestMapping(value = "/appExportXls")
public ModelAndView appExportXls(SysDepart sysDepart,HttpServletRequest request) {
// Step.1 组装查询条件
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<ExportDepartVo> pageList = sysDepartService.getExcelDepart(tenantId);
//Step.2 AutoPoi 导出Excel
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "部门列表");
mv.addObject(NormalExcelConstants.CLASS, ExportDepartVo.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
*/
@RequestMapping(value = "/appImportExcel", method = RequestMethod.POST)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<?> appImportExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
List<String> errorMessageList = new ArrayList<>();
List<ExportDepartVo> 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 {
listSysDeparts = ExcelImportUtil.importExcel(file.getInputStream(), ExportDepartVo.class, params);
sysDepartService.importExcel(listSysDeparts,errorMessageList);
//清空部门缓存
List<String> keys3 = redisUtil.scan(CacheConstant.SYS_DEPARTS_CACHE + "*");
List<String> keys4 = redisUtil.scan(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("文件导入失败！");
}
/**
* 根据部门id和职级id获取岗位信息
*/
@GetMapping("/getPositionByDepartId")
public Result<List<SysPositionSelectTreeVo>> getPositionByDepartId(@RequestParam(name = "parentId") String parentId,
@RequestParam(name = "departId",required = false) String departId,
@RequestParam(name = "positionId") String positionId){
List<SysPositionSelectTreeVo> positionByDepartId = sysDepartService.getPositionByDepartId(parentId, departId, positionId);
return Result.OK(positionByDepartId);
}
/**
* 获取职级关系
* @param departId
* @return
*/
@GetMapping("/getRankRelation")
public Result<List<SysPositionSelectTreeVo>> getRankRelation(@RequestParam(name = "departId") String departId){
List<SysPositionSelectTreeVo> list = sysDepartService.getRankRelation(departId);
return Result.ok(list);
}
/**
* 根据部门code获取当前和上级部门名称
*
* @param orgCode
* @param depId
* @return String 部门名称
*/
@GetMapping("/getDepartPathNameByOrgCode")
public Result<String> getDepartPathNameByOrgCode(@RequestParam(name = "orgCode", required = false) String orgCode,
@RequestParam(name = "depId", required = false) String depId) {
String departName = sysDepartService.getDepartPathNameByOrgCode(orgCode, depId);
return Result.OK(departName);
}
/**
* 根据部门id获取部门下的岗位id
*
* @param depIds 当前选择的公司、子公司、部门id
* @return
*/
@GetMapping("/getDepPostIdByDepId")
public Result<Map<String, String>> getDepPostIdByDepId(@RequestParam(name = "depIds") String depIds) {
String departIds = sysDepartService.getDepPostIdByDepId(depIds);
return Result.OK(departIds);
}
/**
* 更新改变后的部门数据
*
* @param changeDepartVo
* @return
*/
@PutMapping("/updateChangeDepart")
@RequiresPermissions("system:depart:updateChange")
@RequiresRoles({"admin"})
public Result<String> updateChangeDepart(@RequestBody SysChangeDepartVo changeDepartVo) {
sysDepartService.updateChangeDepart(changeDepartVo);
return Result.ok("调整部门位置成功！");
}
/**
* 获取部门负责人
*
* @param departId
* @return
*/
@GetMapping("/getDepartmentHead")
public Result<IPage<SysUser>> getDepartmentHead(@RequestParam(name = "departId") String departId,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize){
Page<SysUser> page = new Page<>(pageNo, pageSize);
IPage<SysUser> pageList = sysDepartService.getDepartmentHead(departId,page);
return Result.OK(pageList);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysCategoryController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysCategoryController.java | package org.jeecg.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 org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.ImportExcelUtil;
import org.jeecg.common.util.ReflectHelper;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysCategory;
import org.jeecg.modules.system.model.TreeSelectModel;
import org.jeecg.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.entity.enmus.ExcelType;
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 jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 分类字典
* @Author: jeecg-boot
* @Date: 2019-05-29
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/category")
@Slf4j
public class SysCategoryController {
@Autowired
private ISysCategoryService sysCategoryService;
/**
* 分类编码0
*/
private static final String CATEGORY_ROOT_CODE = "0";
/**
* 分页列表查询
* @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>>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysCategory.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(),0));
}
//------------------------------------------------------------------------------------------------
//--author:os_chengtgen---date:20190804 -----for: 分类字典页面显示错误,issues:377--------start
//--author:liusq---date:20211119 -----for: 【vue3】分类字典页面查询条件配置--------start
QueryWrapper<SysCategory> queryWrapper = QueryGenerator.initQueryWrapper(sysCategory, req.getParameterMap());
String name = sysCategory.getName();
String code = sysCategory.getCode();
//QueryWrapper<SysCategory> queryWrapper = new QueryWrapper<SysCategory>();
if(StringUtils.isBlank(name)&&StringUtils.isBlank(code)){
queryWrapper.eq("pid", sysCategory.getPid());
}
//--author:liusq---date:20211119 -----for: 分类字典页面查询条件配置--------end
//--author:os_chengtgen---date:20190804 -----for:【vue3】 分类字典页面显示错误,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) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysCategory.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
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
*/
@RequestMapping(value = "/edit", method = { RequestMethod.PUT,RequestMethod.POST })
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) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysCategory.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
// 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();
//导出支持xlsx
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("分类字典列表数据", "导出人:"+user.getRealname(), "导出信息", ExcelType.XSSF));
//分类字典导出支持导出字段
String exportFields = request.getParameter(NormalExcelConstants.EXPORT_FIELDS);
if(oConvertUtils.isNotEmpty(exportFields)){
mv.addObject(NormalExcelConstants.EXPORT_FIELDS, exportFields);
}
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<SysCategory> listSysCategorys = ExcelImportUtil.importExcel(file.getInputStream(), SysCategory.class, params);
// 代码逻辑说明: [issues/8612]分类字典导入bug #8612 ------------
Set<String> parentCategoryIds = new HashSet<>();
//按照编码长度排序
Collections.sort(listSysCategorys);
log.info("排序后的list====>",listSysCategorys);
for (int i = 0; i < listSysCategorys.size(); i++) {
SysCategory sysCategoryExcel = listSysCategorys.get(i);
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);
parentCategoryIds.add(pId);
}
}else{
sysCategoryExcel.setPid("0");
}
try {
sysCategoryService.save(sysCategoryExcel);
successLines++;
} catch (Exception e) {
errorLines++;
String message = e.getMessage().toLowerCase();
int lineNumber = i + 1;
// 通过索引名判断出错信息
if (message.contains(CommonConstant.SQL_INDEX_UNIQ_CATEGORY_CODE)) {
errorMessage.add("第 " + lineNumber + " 行：分类编码已经存在，忽略导入。");
} else {
errorMessage.add("第 " + lineNumber + " 行：未知错误，忽略导入");
log.error(e.getMessage(), e);
}
}
}
// 代码逻辑说明: [issues/8612]分类字典导入bug #8612 ------------
if(oConvertUtils.isObjectNotEmpty(parentCategoryIds)){
for (String parentCategoryId : parentCategoryIds) {
SysCategory parentCategory = sysCategoryService.getById(parentCategoryId);
if(oConvertUtils.isObjectNotEmpty(parentCategory)){
parentCategory.setHasChild(CommonConstant.STATUS_1);
sysCategoryService.updateById(parentCategory);
}
}
}
} catch (Exception e) {
errorMessage.add("发生异常：" + e.getMessage());
log.error(e.getMessage(), e);
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return ImportExcelUtil.imporReturnRes(errorLines,successLines,errorMessage);
}
/**
* 加载单个数据 用于回显
*/
@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 {
// 代码逻辑说明: issues/3663 sql注入问题
boolean isClassField = ReflectHelper.isClassField(field, SysCategory.class);
if (!isClassField) {
return Result.error("字段无效，请检查!");
}
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
* @param delNotExist 是否移除不存在的项，默认为true，设为false如果某个key不存在数据库中，则直接返回key本身
* @return
*/
@RequestMapping(value = "/loadDictItem", method = RequestMethod.GET)
public Result<List<String>> loadDictItem(@RequestParam(name = "ids") String ids, @RequestParam(name = "delNotExist", required = false, defaultValue = "true") boolean delNotExist) {
Result<List<String>> result = new Result<>();
// 非空判断
if (StringUtils.isBlank(ids)) {
result.setSuccess(false);
result.setMessage("ids 不能为空");
return result;
}
// 查询数据
List<String> textList = sysCategoryService.loadDictItem(ids, delNotExist);
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) && !CATEGORY_ROOT_CODE.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());
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysUserOnlineController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysUserOnlineController.java | package org.jeecg.modules.system.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.service.impl.SysBaseApiImpl;
import org.jeecg.modules.system.vo.SysUserOnlineVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* @Description: 在线用户
* @Author: chenli
* @Date: 2020-06-07
* @Version: V1.0
*/
@RestController
@RequestMapping("/sys/online")
@Slf4j
public class SysUserOnlineController {
@Autowired
private RedisUtil redisUtil;
@Autowired
public RedisTemplate redisTemplate;
@Autowired
public ISysUserService userService;
@Autowired
private SysBaseApiImpl sysBaseApi;
@Resource
private BaseCommonService baseCommonService;
@RequiresPermissions("system:online:list")
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Result<Page<SysUserOnlineVO>> list(@RequestParam(name="username", required=false) String username,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,@RequestParam(name="pageSize", defaultValue="10") Integer pageSize) {
Collection<String> keys = redisUtil.scan(CommonConstant.PREFIX_USER_TOKEN + "*");
List<SysUserOnlineVO> onlineList = new ArrayList<SysUserOnlineVO>();
for (String key : keys) {
String token = (String)redisUtil.get(key);
if (StringUtils.isNotEmpty(token)) {
SysUserOnlineVO online = new SysUserOnlineVO();
online.setToken(token);
//TODO 改成一次性查询
LoginUser loginUser = sysBaseApi.getUserByName(JwtUtil.getUsername(token));
if (loginUser != null && !"_reserve_user_external".equals(loginUser.getUsername())) {
//验证用户名是否与传过来的用户名相同
boolean isMatchUsername=true;
//判断用户名是否为空，并且当前循环的用户不包含传过来的用户名，那么就设成false
if(oConvertUtils.isNotEmpty(username) && !loginUser.getUsername().contains(username)){
isMatchUsername = false;
}
if(isMatchUsername){
BeanUtils.copyProperties(loginUser, online);
onlineList.add(online);
}
}
}
}
Collections.reverse(onlineList);
Page<SysUserOnlineVO> page = new Page<SysUserOnlineVO>(pageNo, pageSize);
int count = onlineList.size();
List<SysUserOnlineVO> pages = new ArrayList<>();
// 计算当前页第一条数据的下标
int currId = pageNo > 1 ? (pageNo - 1) * pageSize : 0;
for (int i = 0; i < pageSize && i < count - currId; i++) {
pages.add(onlineList.get(currId + i));
}
page.setSize(pageSize);
page.setCurrent(pageNo);
page.setTotal(count);
// 计算分页总页数
page.setPages(count % 10 == 0 ? count / 10 : count / 10 + 1);
page.setRecords(pages);
Result<Page<SysUserOnlineVO>> result = new Result<Page<SysUserOnlineVO>>();
result.setSuccess(true);
result.setResult(page);
return result;
}
/**
* 强退用户
*/
@RequiresPermissions("system:online:forceLogout")
@RequestMapping(value = "/forceLogout",method = RequestMethod.POST)
public Result<Object> forceLogout(@RequestBody SysUserOnlineVO online) {
//用户退出逻辑
if(oConvertUtils.isEmpty(online.getToken())) {
return Result.error("退出登录失败！");
}
String username = JwtUtil.getUsername(online.getToken());
LoginUser sysUser = sysBaseApi.getUserByName(username);
if(sysUser!=null) {
baseCommonService.addLog("强制: "+sysUser.getRealname()+"退出成功！", CommonConstant.LOG_TYPE_1, null,sysUser);
log.info(" 强制 "+sysUser.getRealname()+"退出成功！ ");
//清空用户登录Token缓存
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN + online.getToken());
//清空用户登录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无效!");
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/ThirdAppController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/ThirdAppController.java | package org.jeecg.modules.system.controller;
import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jeecg.dingtalk.api.core.response.Response;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.MessageTypeEnum;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysThirdAccount;
import org.jeecg.modules.system.entity.SysThirdAppConfig;
import org.jeecg.modules.system.service.ISysThirdAccountService;
import org.jeecg.modules.system.service.ISysThirdAppConfigService;
import org.jeecg.modules.system.service.impl.ThirdAppDingtalkServiceImpl;
import org.jeecg.modules.system.service.impl.ThirdAppWechatEnterpriseServiceImpl;
import org.jeecg.modules.system.vo.thirdapp.JwSysUserDepartVo;
import org.jeecg.modules.system.vo.thirdapp.JwUserDepartVo;
import org.jeecg.modules.system.vo.thirdapp.SyncInfoVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 第三方App对接
* @author: jeecg-boot
*/
@Slf4j
@RestController("thirdAppController")
@RequestMapping("/sys/thirdApp")
public class ThirdAppController {
@Autowired
ThirdAppWechatEnterpriseServiceImpl wechatEnterpriseService;
@Autowired
ThirdAppDingtalkServiceImpl dingtalkService;
@Autowired
private ISysThirdAppConfigService appConfigService;
@Autowired
private ISysThirdAccountService sysThirdAccountService;
/**
* 获取启用的系统
*/
@GetMapping("/getEnabledType")
public Result getEnabledType() {
Map<String, Boolean> enabledMap = new HashMap(5);
int tenantId;
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
tenantId = oConvertUtils.getInt(TenantContext.getTenant(), -1);
} else {
tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
}
//查询当前租户下的第三方配置
List<SysThirdAppConfig> list = appConfigService.getThirdConfigListByThirdType(tenantId);
//钉钉是否已配置
boolean dingConfig = false;
//企业微信是否已配置
boolean qywxConfig = false;
if(null != list && list.size()>0){
for (SysThirdAppConfig config:list) {
if(MessageTypeEnum.DD.getType().equals(config.getThirdType())){
dingConfig = true;
continue;
}
if(MessageTypeEnum.QYWX.getType().equals(config.getThirdType())){
qywxConfig = true;
continue;
}
}
}
enabledMap.put("wechatEnterprise", qywxConfig);
enabledMap.put("dingtalk", dingConfig);
return Result.OK(enabledMap);
}
/**
* 同步本地[用户]到【企业微信】
*
* @param ids
* @return
*/
@GetMapping("/sync/wechatEnterprise/user/toApp")
public Result syncWechatEnterpriseUserToApp(@RequestParam(value = "ids", required = false) String ids) {
//获取企业微信配置
Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.QYWX.getType());
if (null != config) {
// 代码逻辑说明: [QQYUN-3440]通过租户模式隔离 ------------
SyncInfoVo syncInfo = wechatEnterpriseService.syncLocalUserToThirdApp(ids);
if (syncInfo.getFailInfo().size() == 0) {
return Result.OK("同步成功", syncInfo);
} else {
return Result.error("同步失败", syncInfo);
}
}
return Result.error("企业微信尚未配置,请配置企业微信");
}
/**
* 同步【企业微信】[用户]到本地
*
* @param ids 作废
* @return
*/
@GetMapping("/sync/wechatEnterprise/user/toLocal")
public Result syncWechatEnterpriseUserToLocal(@RequestParam(value = "ids", required = false) String ids) {
return Result.error("由于企业微信接口调整，同步到本地功能已失效");
// if (thirdAppConfig.isWechatEnterpriseEnabled()) {
// SyncInfoVo syncInfo = wechatEnterpriseService.syncThirdAppUserToLocal();
// if (syncInfo.getFailInfo().size() == 0) {
// return Result.OK("同步成功", syncInfo);
// } else {
// return Result.error("同步失败", syncInfo);
// }
// }
// return Result.error("企业微信同步功能已禁用");
}
/**
* 同步本地[部门]到【企业微信】
*
* @param ids
* @return
*/
@GetMapping("/sync/wechatEnterprise/depart/toApp")
public Result syncWechatEnterpriseDepartToApp(@RequestParam(value = "ids", required = false) String ids) {
//获取企业微信配置
Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.QYWX.getType());
if (null != config) {
SyncInfoVo syncInfo = wechatEnterpriseService.syncLocalDepartmentToThirdApp(ids);
if (syncInfo.getFailInfo().size() == 0) {
return Result.OK("同步成功", null);
} else {
return Result.error("同步失败", syncInfo);
}
}
return Result.error("企业微信尚未配置,请配置企业微信");
}
/**
* 同步【企业微信】[部门]到本地
*
* @param ids
* @return
*/
@GetMapping("/sync/wechatEnterprise/depart/toLocal")
public Result syncWechatEnterpriseDepartToLocal(@RequestParam(value = "ids", required = false) String ids) {
return Result.error("由于企业微信接口调整，企业微信同步本地部门失效");
// //获取企业微信配置
// Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
// SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.QYWX.getType());
// if (null != config) {
// SyncInfoVo syncInfo = wechatEnterpriseService.syncThirdAppDepartmentToLocal(ids);
// if (syncInfo.getFailInfo().size() == 0) {
// return Result.OK("同步成功", syncInfo);
// } else {
// return Result.error("同步失败", syncInfo);
// }
// }
// return Result.error("企业微信尚未配置,请配置企业微信");
}
/**
* 同步本地[部门]到【钉钉】
*
* @param ids
* @return
*/
@GetMapping("/sync/dingtalk/depart/toApp")
public Result syncDingtalkDepartToApp(@RequestParam(value = "ids", required = false) String ids) {
//获取钉钉配置
Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.DD.getType());
if (null != config) {
SyncInfoVo syncInfo = dingtalkService.syncLocalDepartmentToThirdApp(ids);
if (syncInfo.getFailInfo().size() == 0) {
return Result.OK("同步成功", null);
} else {
return Result.error("同步失败", syncInfo);
}
}
return Result.error("钉钉尚未配置,请配置钉钉");
}
// /**
// * 同步【钉钉】[部门]到本地
// *
// * @param ids
// * @return
// */
// @GetMapping("/sync/dingtalk/depart/toLocal")
// public Result syncDingtalkDepartToLocal(@RequestParam(value = "ids", required = false) String ids) {
// //获取钉钉配置
// Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
// SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.DD.getType());
// if (null!= config) {
// SyncInfoVo syncInfo = dingtalkService.syncThirdAppDepartmentToLocal(ids);
// if (syncInfo.getFailInfo().size() == 0) {
// return Result.OK("同步成功", syncInfo);
// } else {
// return Result.error("同步失败", syncInfo);
// }
// }
// return Result.error("钉钉尚未配置,请配置钉钉");
// }
/**
* 同步本地[用户]到【钉钉】
*
* @param ids
* @return
*/
@GetMapping("/sync/dingtalk/user/toApp")
public Result syncDingtalkUserToApp(@RequestParam(value = "ids", required = false) String ids) {
//获取钉钉配置
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
//根据租户id和第三方类别获取租户数据
SysThirdAppConfig appConfig = appConfigService.getThirdConfigByThirdType(tenantId,MessageTypeEnum.DD.getType());
if(null != appConfig){
SyncInfoVo syncInfo = dingtalkService.syncLocalUserToThirdApp(ids);
if (syncInfo.getFailInfo().size() == 0) {
return Result.OK("同步成功", syncInfo);
} else {
return Result.error("同步失败", syncInfo);
}
}
return Result.error("钉钉尚未配置,请配置钉钉");
}
// /**
// * 同步【钉钉】[用户]到本地
// *
// * @param ids 作废
// * @return
// */
// @GetMapping("/sync/dingtalk/user/toLocal")
// public Result syncDingtalkUserToLocal(@RequestParam(value = "ids", required = false) String ids) {
// //获取钉钉配置
// Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
// SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.DD.getType());
// if (null != config) {
// SyncInfoVo syncInfo = dingtalkService.syncThirdAppUserToLocal();
// if (syncInfo.getFailInfo().size() == 0) {
// return Result.OK("同步成功", syncInfo);
// } else {
// return Result.error("同步失败", syncInfo);
// }
// }
// return Result.error("钉钉尚未配置,请配置钉钉");
// }
/**
* 发送消息测试
*
* @return
*/
@PostMapping("/sendMessageTest")
public Result sendMessageTest(@RequestBody JSONObject params, HttpServletRequest request) {
/* 获取前台传递的参数 */
// 第三方app的类型
String app = params.getString("app");
// 是否发送给全部人
boolean sendAll = params.getBooleanValue("sendAll");
// 消息接收者，传sys_user表的username字段，多个用逗号分割
String receiver = params.getString("receiver");
// 消息内容
String content = params.getString("content");
// 租户id
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
String fromUser = JwtUtil.getUserNameByToken(request);
String title = "第三方APP消息测试";
MessageDTO message = new MessageDTO(fromUser, receiver, title, content);
message.setToAll(sendAll);
// 代码逻辑说明: [QQYUN-3440]钉钉、企业微信通过租户模式隔离 ------------
String weChatType = MessageTypeEnum.QYWX.getType();
String dingType = MessageTypeEnum.DD.getType();
if (weChatType.toUpperCase().equals(app)) {
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, weChatType);
if (null != config) {
JSONObject response = wechatEnterpriseService.sendMessageResponse(message, false);
return Result.OK(response);
}
return Result.error("企业微信尚未配置,请配置企业微信");
} else if (dingType.toUpperCase().equals(app)) {
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, dingType);
if (null != config) {
Response<String> response = dingtalkService.sendMessageResponse(message, false);
return Result.OK(response);
}
return Result.error("钉钉尚未配置,请配置钉钉");
}
return Result.error("不识别的第三方APP");
}
/**
* 撤回消息测试
*
* @return
*/
@PostMapping("/recallMessageTest")
public Result recallMessageTest(@RequestBody JSONObject params) {
/* 获取前台传递的参数 */
// 第三方app的类型
String app = params.getString("app");
// 消息id
String msgTaskId = params.getString("msg_task_id");
//租户id
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(),0);
if (CommonConstant.WECHAT_ENTERPRISE.equals(app)) {
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.QYWX.getType());
if (null != config) {
return Result.error("企业微信不支持撤回消息");
}
return Result.error("企业微信尚未配置,请配置企业微信");
} else if (CommonConstant.DINGTALK.equals(app)) {
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.DD.getType());
if (null != config) {
Response<JSONObject> response = dingtalkService.recallMessageResponse(msgTaskId);
if (response.isSuccess()) {
return Result.OK("撤回成功", response);
} else {
return Result.error("撤回失败：" + response.getErrcode() + "——" + response.getErrmsg(), response);
}
}
return Result.error("钉钉尚未配置,请配置钉钉");
}
return Result.error("不识别的第三方APP");
}
//========================begin 应用低代码钉钉/企业微信同步用户部门专用 =============================
/**
* 添加第三方app配置
*
* @param appConfig
* @return
*/
@RequestMapping(value = "/addThirdAppConfig", method = RequestMethod.POST)
public Result<String> addThirdAppConfig(@RequestBody SysThirdAppConfig appConfig) {
Result<String> result = new Result<>();
//根据当前登录租户id和第三方类别判断是否已经创建
Integer tenantId = oConvertUtils.isNotEmpty(appConfig.getTenantId()) ? appConfig.getTenantId() : oConvertUtils.getInt(TenantContext.getTenant(), 0);
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, appConfig.getThirdType());
if (null != config) {
result.error500("操作失败,同一个租户下只允许绑定一个钉钉或者企业微信");
return result;
}
String clientId = appConfig.getClientId();
//通过应用key获取第三方配置
List<SysThirdAppConfig> thirdAppConfigByClientId = appConfigService.getThirdAppConfigByClientId(clientId);
if(CollectionUtil.isNotEmpty(thirdAppConfigByClientId)){
result.error500("AppKey已存在，请勿重复添加");
return result;
}
try {
appConfig.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(),0));
appConfigService.save(appConfig);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑第三方app配置
*
* @param appConfig
* @return
*/
@RequestMapping(value = "/editThirdAppConfig", method = {RequestMethod.PUT, RequestMethod.POST})
public Result<String> editThirdAppConfig(@RequestBody SysThirdAppConfig appConfig) {
Result<String> result = new Result<>();
SysThirdAppConfig config = appConfigService.getById(appConfig.getId());
if (null == config) {
result.error500("数据不存在");
return result;
}
String clientId = appConfig.getClientId();
//如果编辑的应用key,和数据库中的不一致，需要判断应用key是否已存在
if(!clientId.equals(config.getClientId())){
//通过应用key获取第三方配置
List<SysThirdAppConfig> thirdAppConfigByClientId = appConfigService.getThirdAppConfigByClientId(clientId);
if(CollectionUtil.isNotEmpty(thirdAppConfigByClientId)){
result.error500("AppKey已存在，请勿重复添加");
return result;
}
}
try {
appConfigService.updateById(appConfig);
result.success("修改成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 根据id删除第三方配置表
* @param id
* @return
*/
@DeleteMapping(value = "/deleteThirdAppConfig")
@RequiresPermissions("system:third:config:delete")
public Result<String> deleteThirdAppConfig(@RequestParam(name="id",required=true) String id) {
Result<String> result = new Result<>();
SysThirdAppConfig config = appConfigService.getById(id);
if (null == config) {
result.error500("数据不存在");
return result;
}
try {
appConfigService.removeById(id);
result.success("解绑成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败");
}
return result;
}
/**
* 根据租户id和第三方类型获取第三方app配置信息
*
* @param tenantId
* @param thirdType
* @return
*/
@GetMapping("/getThirdConfigByTenantId")
public Result<SysThirdAppConfig> getThirdAppByTenantId(@RequestParam(name = "tenantId", required = false) Integer tenantId,
@RequestParam(name = "thirdType") String thirdType) {
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
if (tenantId == null) {
return Result.error("开启多租户模式，租户ID参数不允许为空！");
}
} else {
//租户未传递，则采用平台的
if (tenantId == null) {
tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
}
}
Result<SysThirdAppConfig> result = new Result<>();
LambdaQueryWrapper<SysThirdAppConfig> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAppConfig::getThirdType,thirdType);
query.eq(SysThirdAppConfig::getTenantId,tenantId);
SysThirdAppConfig sysThirdAppConfig = appConfigService.getOne(query);
result.setSuccess(true);
result.setResult(sysThirdAppConfig);
return result;
}
/**
* 同步【钉钉】[部门和用户]到本地
*
* @param ids
* @return
*/
@GetMapping("/sync/dingtalk/departAndUser/toLocal")
public Result syncDingTalkDepartAndUserToLocal(@RequestParam(value = "ids", required = false) String ids) {
Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.DD.getType());
if (null != config) {
SyncInfoVo syncInfo = dingtalkService.syncThirdAppDepartmentUserToLocal();
if (syncInfo.getFailInfo().size() == 0) {
return Result.OK("同步成功", syncInfo);
} else {
return Result.error("同步失败", syncInfo);
}
}
return Result.error("钉钉尚未配置,请配置钉钉");
}
//========================end 应用低代码钉钉/企业微信同步用户部门专用 ========================
//========================begin 应用低代码账号设置第三方账号绑定 ================================
/**
* 获取第三方账号
* @param thirdType
* @return
*/
@GetMapping("/getThirdAccountByUserId")
public Result<List<SysThirdAccount>> getThirdAccountByUserId(@RequestParam(name="thirdType") String thirdType){
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<>();
//根据id查询
query.eq(SysThirdAccount::getSysUserId,sysUser.getId());
//扫码登录只有租户为0
query.eq(SysThirdAccount::getTenantId,CommonConstant.TENANT_ID_DEFAULT_VALUE);
//根据第三方类别查询
if(oConvertUtils.isNotEmpty(thirdType)){
query.in(SysThirdAccount::getThirdType, Arrays.asList(thirdType.split(SymbolConstant.COMMA)));
}
List<SysThirdAccount> list = sysThirdAccountService.list(query);
return Result.ok(list);
}
/**
* 绑定第三方账号
* @return
*/
@PostMapping("/bindThirdAppAccount")
public Result<SysThirdAccount> bindThirdAppAccount(@RequestBody SysThirdAccount sysThirdAccount){
SysThirdAccount thirdAccount = sysThirdAccountService.bindThirdAppAccountByUserId(sysThirdAccount);
return Result.ok(thirdAccount);
}
/**
* 删除第三方用户信息
* @param sysThirdAccount
* @return
*/
@DeleteMapping("/deleteThirdAccount")
public Result<String> deleteThirdAccountById(@RequestBody SysThirdAccount sysThirdAccount){
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
if(!sysUser.getId().equals(sysThirdAccount.getSysUserId())){
return Result.error("无权修改他人信息");
}
SysThirdAccount thirdAccount = sysThirdAccountService.getById(sysThirdAccount.getId());
if(null == thirdAccount){
return Result.error("未找到改第三方账户信息");
}
sysThirdAccountService.removeById(thirdAccount.getId());
return Result.ok("解绑成功");
}
//========================end 应用低代码账号设置第三方账号绑定 ================================
/**
* 获取企业微信绑定的用户信息
* @param request
* @return
*/
@GetMapping("/getThirdUserByWechat")
public Result<JwSysUserDepartVo> getThirdUserByWechat(HttpServletRequest request){
//获取企业微信配置
Integer tenantId = oConvertUtils.getInt(TokenUtils.getTenantIdByRequest(request),0);
SysThirdAppConfig config = appConfigService.getThirdConfigByThirdType(tenantId, MessageTypeEnum.QYWX.getType());
if (null != config) {
JwSysUserDepartVo list = wechatEnterpriseService.getThirdUserByWechat(tenantId);
return Result.ok(list);
}
return Result.error("企业微信尚未配置,请配置企业微信");
}
/**
* 同步企业微信部门和用户到本地
* @param jwUserDepartJson
* @param request
* @return
*/
@GetMapping("/sync/wechatEnterprise/departAndUser/toLocal")
public Result<SyncInfoVo> syncWechatEnterpriseDepartAndUserToLocal(@RequestParam(name = "jwUserDepartJson") String jwUserDepartJson,HttpServletRequest request){
int tenantId = oConvertUtils.getInt(TokenUtils.getTenantIdByRequest(request), 0);
SyncInfoVo syncInfoVo = wechatEnterpriseService.syncWechatEnterpriseDepartAndUserToLocal(jwUserDepartJson,tenantId);
return Result.ok(syncInfoVo);
}
/**
* 查询被绑定的企业微信用户
* @param request
* @return
*/
@GetMapping("/getThirdUserBindByWechat")
public Result<List<JwUserDepartVo>> getThirdUserBindByWechat(HttpServletRequest request){
int tenantId = oConvertUtils.getInt(TokenUtils.getTenantIdByRequest(request), 0);
List<JwUserDepartVo> jwSysUserDepartVos = wechatEnterpriseService.getThirdUserBindByWechat(tenantId);
return Result.ok(jwSysUserDepartVos);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/WechatVerifyController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/WechatVerifyController.java | package org.jeecg.modules.system.controller;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.modules.system.util.XssUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import jakarta.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
/**
* @Description: 企业微信证书验证
* @author: wangshuai
* @date: 2023/12/6 10:42
*/
@RestController
@Slf4j
public class WechatVerifyController {
/**
* 企业微信验证
*/
@RequestMapping(value = "/WW_verify_{code}.txt")
public void mpVerify(@PathVariable("code") String code, HttpServletResponse response) {
if(StringUtils.isEmpty(code)){
log.error("企业微信证书验证失败！(code为空)");
return;
}
try {
PrintWriter writer = response.getWriter();
code = XssUtils.scriptXss(code);
writer.write(code);
writer.close();
} catch (Exception e) {
log.error("企业微信证书验证失败！");
log.error(e.getMessage(), e);
e.printStackTrace();
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDataSourceController.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/controller/SysDataSourceController.java | package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
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.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.dynamic.db.DataSourceCachePool;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.common.util.security.JdbcSecurityUtil;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysDataSource;
import org.jeecg.modules.system.service.ISysDataSourceService;
import org.jeecg.modules.system.util.SecurityUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import javax.sql.DataSource;
import java.util.Arrays;
import java.util.List;
/**
* @Description: 多数据源管理
* @Author: jeecg-boot
* @Date: 2019-12-25
* @Version: V1.0
*/
@Slf4j
@Tag(name = "多数据源管理")
@RestController
@RequestMapping("/sys/dataSource")
public class SysDataSourceController extends JeecgController<SysDataSource, ISysDataSourceService> {
@Autowired
private ISysDataSourceService sysDataSourceService;
/**
* 分页列表查询
*
* @param sysDataSource
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "多数据源管理-分页列表查询")
@Operation(summary = "多数据源管理-分页列表查询")
@RequiresPermissions("system:datasource:list")
@GetMapping(value = "/list")
public Result<?> queryPageList(
SysDataSource sysDataSource,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysDataSource.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
QueryWrapper<SysDataSource> queryWrapper = QueryGenerator.initQueryWrapper(sysDataSource, req.getParameterMap());
Page<SysDataSource> page = new Page<>(pageNo, pageSize);
IPage<SysDataSource> pageList = sysDataSourceService.page(page, queryWrapper);
return Result.ok(pageList);
}
@GetMapping(value = "/options")
public Result<?> queryOptions(SysDataSource sysDataSource, HttpServletRequest req) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysDataSource.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
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 = "多数据源管理-添加")
@Operation(summary = "多数据源管理-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDataSource sysDataSource) {
// 代码逻辑说明: jdbc连接地址漏洞问题
try {
JdbcSecurityUtil.validate(sysDataSource.getDbUrl());
}catch (JeecgBootException e){
log.error(e.toString());
return Result.error("操作失败：" + e.getMessage());
}
return sysDataSourceService.saveDataSource(sysDataSource);
}
/**
* 编辑
*
* @param sysDataSource
* @return
*/
@AutoLog(value = "多数据源管理-编辑")
@Operation(summary = "多数据源管理-编辑")
@RequestMapping(value = "/edit", method ={RequestMethod.PUT, RequestMethod.POST})
public Result<?> edit(@RequestBody SysDataSource sysDataSource) {
// 代码逻辑说明: jdbc连接地址漏洞问题
try {
JdbcSecurityUtil.validate(sysDataSource.getDbUrl());
} catch (JeecgBootException e) {
log.error(e.toString());
return Result.error("操作失败：" + e.getMessage());
}
return sysDataSourceService.editDataSource(sysDataSource);
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "多数据源管理-通过id删除")
@Operation(summary = "多数据源管理-通过id删除")
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id") String id) {
return sysDataSourceService.deleteDataSource(id);
}
/**
* 批量删除
*
* @param ids
* @return
*/
@AutoLog(value = "多数据源管理-批量删除")
@Operation(summary = "多数据源管理-批量删除")
@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查询")
@Operation(summary = "多数据源管理-通过id查询")
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id") String id) throws InterruptedException {
SysDataSource sysDataSource = sysDataSourceService.getById(id);
//密码解密
String dbPassword = sysDataSource.getDbPassword();
if(StringUtils.isNotBlank(dbPassword)){
String decodedStr = SecurityUtil.jiemi(dbPassword);
sysDataSource.setDbPassword(decodedStr);
}
return Result.ok(sysDataSource);
}
/**
* 导出excel
*
* @param request
* @param sysDataSource
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, SysDataSource sysDataSource) {
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
sysDataSource.setTenantId(oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
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);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/ImportOldUserUtil.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/ImportOldUserUtil.java | package org.jeecg.modules.system.util;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.ImportExcelUtil;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserDepart;
import org.jeecg.modules.system.service.ISysUserDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.service.impl.SysUserDepartServiceImpl;
import org.jeecg.modules.system.service.impl.SysUserServiceImpl;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* @Description: 旧版导入
* @author: wangshuai
* @date: 2025/4/2 10:19
*/
@Slf4j
public class ImportOldUserUtil {
public static Result<?> importOldSysUser(HttpServletRequest request) 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<SysUser> listSysUsers = ExcelImportUtil.importExcel(file.getInputStream(), SysUser.class, params);
for (int i = 0; i < listSysUsers.size(); i++) {
SysUser sysUserExcel = listSysUsers.get(i);
if (StringUtils.isBlank(sysUserExcel.getPassword())) {
// 密码默认为 “123456”
sysUserExcel.setPassword("123456");
}
// 密码加密加盐
String salt = oConvertUtils.randomGen(8);
sysUserExcel.setSalt(salt);
String passwordEncode = PasswordUtil.encrypt(sysUserExcel.getUsername(), sysUserExcel.getPassword(), salt);
sysUserExcel.setPassword(passwordEncode);
try {
ISysUserService service = SpringContextUtils.getBean(SysUserServiceImpl.class);
service.save(sysUserExcel);
successLines++;
} catch (Exception e) {
errorLines++;
String message = e.getMessage().toLowerCase();
int lineNumber = i + 1;
// 通过索引名判断出错信息
if (message.contains(CommonConstant.SQL_INDEX_UNIQ_SYS_USER_USERNAME)) {
errorMessage.add("第 " + lineNumber + " 行：用户名已经存在，忽略导入。");
} else if (message.contains(CommonConstant.SQL_INDEX_UNIQ_SYS_USER_WORK_NO)) {
errorMessage.add("第 " + lineNumber + " 行：工号已经存在，忽略导入。");
} else if (message.contains(CommonConstant.SQL_INDEX_UNIQ_SYS_USER_PHONE)) {
errorMessage.add("第 " + lineNumber + " 行：手机号已经存在，忽略导入。");
} else if (message.contains(CommonConstant.SQL_INDEX_UNIQ_SYS_USER_EMAIL)) {
errorMessage.add("第 " + lineNumber + " 行：电子邮件已经存在，忽略导入。");
} else if (message.contains(CommonConstant.SQL_INDEX_UNIQ_SYS_USER)) {
errorMessage.add("第 " + lineNumber + " 行：违反表唯一性约束。");
} else {
errorMessage.add("第 " + lineNumber + " 行：未知错误，忽略导入");
log.error(e.getMessage(), e);
}
}
// 批量将部门和用户信息建立关联关系
String departIds = sysUserExcel.getDepartIds();
if (StringUtils.isNotBlank(departIds)) {
String userId = sysUserExcel.getId();
String[] departIdArray = departIds.split(",");
List<SysUserDepart> userDepartList = new ArrayList<>(departIdArray.length);
for (String departId : departIdArray) {
userDepartList.add(new SysUserDepart(userId, departId));
}
ISysUserDepartService service = SpringContextUtils.getBean(SysUserDepartServiceImpl.class);
service.saveBatch(userDepartList);
}
}
} catch (Exception e) {
errorMessage.add("发生异常：" + e.getMessage());
log.error(e.getMessage(), e);
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
}
return ImportExcelUtil.imporReturnRes(errorLines, successLines, errorMessage);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/FindsDepartsChildrenUtil.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/FindsDepartsChildrenUtil.java | package org.jeecg.modules.system.util;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.List;
/**
* <P>
* 对应部门的表,处理并查找树级数据
* <P>
*
* @Author: Steve
* @Date: 2019-01-22
*/
public class FindsDepartsChildrenUtil {
//部门树信息-树结构
//private static List<SysDepartTreeModel> sysDepartTreeList = new ArrayList<SysDepartTreeModel>();
//部门树id-树结构
//private static List<DepartIdModel> idList = new ArrayList<>();
/**
* queryTreeList的子方法 ====1=====
* 该方法是s将SysDepart类型的list集合转换成SysDepartTreeModel类型的集合
*/
public static List<SysDepartTreeModel> wrapTreeDataToTreeList(List<SysDepart> recordList) {
// 在该方法每请求一次,都要对全局list集合进行一次清理
//idList.clear();
List<DepartIdModel> idList = new ArrayList<DepartIdModel>();
List<SysDepartTreeModel> records = new ArrayList<>();
for (int i = 0; i < recordList.size(); i++) {
SysDepart depart = recordList.get(i);
records.add(new SysDepartTreeModel(depart));
}
List<SysDepartTreeModel> tree = findChildren(records, idList);
setEmptyChildrenAsNull(tree);
return tree;
}
/**
* 获取 DepartIdModel
* @param recordList
* @return
*/
public static List<DepartIdModel> wrapTreeDataToDepartIdTreeList(List<SysDepart> recordList) {
// 在该方法每请求一次,都要对全局list集合进行一次清理
//idList.clear();
List<DepartIdModel> idList = new ArrayList<DepartIdModel>();
List<SysDepartTreeModel> records = new ArrayList<>();
for (int i = 0; i < recordList.size(); i++) {
SysDepart depart = recordList.get(i);
records.add(new SysDepartTreeModel(depart));
}
findChildren(records, idList);
return idList;
}
/**
* queryTreeList的子方法 ====2=====
* 该方法是找到并封装顶级父类的节点到TreeList集合
*/
private static List<SysDepartTreeModel> findChildren(List<SysDepartTreeModel> recordList,
List<DepartIdModel> departIdList) {
List<SysDepartTreeModel> treeList = new ArrayList<>();
for (int i = 0; i < recordList.size(); i++) {
SysDepartTreeModel branch = recordList.get(i);
if (oConvertUtils.isEmpty(branch.getParentId())) {
treeList.add(branch);
DepartIdModel departIdModel = new DepartIdModel().convert(branch);
departIdList.add(departIdModel);
}
}
getGrandChildren(treeList,recordList,departIdList);
//idList = departIdList;
return treeList;
}
/**
* queryTreeList的子方法====3====
*该方法是找到顶级父类下的所有子节点集合并封装到TreeList集合
*/
private static void getGrandChildren(List<SysDepartTreeModel> treeList,List<SysDepartTreeModel> recordList,List<DepartIdModel> idList) {
for (int i = 0; i < treeList.size(); i++) {
SysDepartTreeModel model = treeList.get(i);
DepartIdModel idModel = idList.get(i);
for (int i1 = 0; i1 < recordList.size(); i1++) {
SysDepartTreeModel m = recordList.get(i1);
if (m.getParentId()!=null && m.getParentId().equals(model.getId())) {
model.getChildren().add(m);
DepartIdModel dim = new DepartIdModel().convert(m);
idModel.getChildren().add(dim);
}
}
getGrandChildren(treeList.get(i).getChildren(), recordList, idList.get(i).getChildren());
}
}
/**
* queryTreeList的子方法 ====4====
* 该方法是将子节点为空的List集合设置为Null值
*/
private static void setEmptyChildrenAsNull(List<SysDepartTreeModel> treeList) {
for (int i = 0; i < treeList.size(); i++) {
SysDepartTreeModel model = treeList.get(i);
if (model.getChildren().size() == 0) {
model.setChildren(null);
model.setIsLeaf(true);
}else{
setEmptyChildrenAsNull(model.getChildren());
model.setIsLeaf(false);
}
}
// sysDepartTreeList = treeList;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/RandImageUtil.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/RandImageUtil.java | package org.jeecg.modules.system.util;
import javax.imageio.ImageIO;
import jakarta.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.Random;
/**
* 登录验证码工具类
* @date 2025-09-11
* @author AI优化
*/
public class RandImageUtil {
// 静态初始化块，解决无头环境字体配置问题
static {
System.setProperty("java.awt.headless", "true");
}
public static final String KEY = "JEECG_LOGIN_KEY";
/** 验证码图片宽度 */
private static final int WIDTH = 105;
/** 验证码图片高度 */
private static final int HEIGHT = 35;
/** 干扰线数量 */
private static final int INTERFERENCE_LINE_COUNT = 200;
/** 干扰线宽度 */
private static final int LINE_WIDTH = 2;
/** 图片格式 */
private static final String IMG_FORMAT = "JPEG";
/** base64 图片前缀 */
private static final String BASE64_PREFIX = "data:image/jpg;base64,";
/** 字符间距 */
private static final int CHAR_SPACING = 23;
/** 字体大小 */
private static final int FONT_SIZE = 24;
/** 字符Y轴偏移 */
private static final int CHAR_Y_OFFSET = 26;
/** 字符X轴起始偏移 */
private static final int CHAR_X_OFFSET = 8;
/**
* 直接通过response输出验证码图片
*
* @param response HTTP响应对象
* @param verifyCode 验证码字符串
* @throws IOException 输出异常
*/
public static void generate(HttpServletResponse response, String verifyCode) throws IOException {
if (response == null || verifyCode == null || verifyCode.trim().isEmpty()) {
throw new IllegalArgumentException("参数不能为空");
}
try {
BufferedImage image = createVerifyCodeImage(verifyCode);
ImageIO.write(image, IMG_FORMAT, response.getOutputStream());
} catch (Exception e) {
throw new IOException("生成验证码图片失败", e);
}
}
/**
* 生成验证码的base64字符串
*
* @param verifyCode 验证码字符串
* @return base64编码的图片字符串
* @throws IOException 生成异常
*/
public static String generate(String verifyCode) throws IOException {
if (verifyCode == null || verifyCode.trim().isEmpty()) {
throw new IllegalArgumentException("验证码不能为空");
}
try {
BufferedImage image = createVerifyCodeImage(verifyCode);
try (ByteArrayOutputStream byteStream = new ByteArrayOutputStream()) {
ImageIO.write(image, IMG_FORMAT, byteStream);
byte[] bytes = byteStream.toByteArray();
String base64 = Base64.getEncoder().encodeToString(bytes).trim();
// 清理换行符
base64 = base64.replaceAll("[\r\n]", "");
return BASE64_PREFIX + base64;
}
} catch (Exception e) {
throw new IOException("生成验证码base64失败", e);
}
}
/**
* 创建验证码图像
*
* @param verifyCode 验证码字符串
* @return 验证码图像
*/
private static BufferedImage createVerifyCodeImage(String verifyCode) {
BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
Graphics2D graphics = null;
try {
graphics = (Graphics2D) image.getGraphics();
// 设置图形渲染质量
setupRenderingHints(graphics);
// 绘制背景
drawBackground(graphics);
// 绘制边框
drawBorder(graphics);
// 获取安全的随机数生成器
SecureRandom random = createSecureRandom();
// 绘制干扰线
drawInterferenceLines(graphics, random);
// 绘制验证码字符
drawVerifyCodeText(graphics, verifyCode);
} catch (Exception e) {
// 如果绘制失败，创建简单的错误图像
return createErrorImage(verifyCode);
} finally {
if (graphics != null) {
graphics.dispose();
}
}
return image;
}
/**
* 设置图形渲染质量
*/
private static void setupRenderingHints(Graphics2D graphics) {
graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
}
/**
* 绘制白色背景
*/
private static void drawBackground(Graphics2D graphics) {
graphics.setColor(Color.WHITE);
graphics.fillRect(0, 0, WIDTH, HEIGHT);
}
/**
* 绘制边框
*/
private static void drawBorder(Graphics2D graphics) {
graphics.setColor(Color.GRAY);
graphics.drawRect(0, 0, WIDTH - 1, HEIGHT - 1);
}
/**
* 创建安全的随机数生成器
*/
private static SecureRandom createSecureRandom() {
try {
return SecureRandom.getInstance("SHA1PRNG");
} catch (NoSuchAlgorithmException e) {
return new SecureRandom();
}
}
/**
* 绘制干扰线
*/
private static void drawInterferenceLines(Graphics2D graphics, SecureRandom random) {
for (int i = 0; i < INTERFERENCE_LINE_COUNT; i++) {
graphics.setColor(getRandomColor(150, 200, random));
// 确保干扰线在边框内
int x1 = random.nextInt(WIDTH - LINE_WIDTH - 1) + 1;
int y1 = random.nextInt(HEIGHT - LINE_WIDTH - 1) + 1;
int x2 = x1 + random.nextInt(LINE_WIDTH);
int y2 = y1 + random.nextInt(LINE_WIDTH);
graphics.drawLine(x1, y1, x2, y2);
}
}
/**
* 绘制验证码文本
*/
private static void drawVerifyCodeText(Graphics2D graphics, String verifyCode) {
graphics.setColor(Color.BLACK);
Font font = createSafeFont();
graphics.setFont(font);
for (int i = 0; i < verifyCode.length(); i++) {
char character = verifyCode.charAt(i);
int x = i * CHAR_SPACING + CHAR_X_OFFSET;
graphics.drawString(String.valueOf(character), x, CHAR_Y_OFFSET);
}
}
/**
* 创建安全的字体，避免字体配置问题
*/
private static Font createSafeFont() {
// 使用逻辑字体名称，在所有平台都可用
String[] safeFontNames = {Font.SERIF, Font.SANS_SERIF, Font.MONOSPACED, "Dialog"};
for (String fontName : safeFontNames) {
try {
Font font = new Font(fontName, Font.BOLD, FONT_SIZE);
if (font.getFamily() != null) {
return font;
}
} catch (Exception e) {
// 继续尝试下一个字体
}
}
// 最后的回退方案
return new Font(Font.MONOSPACED, Font.BOLD, FONT_SIZE);
}
/**
* 创建错误图像（当正常绘制失败时使用）
*/
private static BufferedImage createErrorImage(String verifyCode) {
BufferedImage errorImage = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
Graphics2D graphics = null;
try {
graphics = (Graphics2D) errorImage.getGraphics();
// 白色背景
graphics.setColor(Color.WHITE);
graphics.fillRect(0, 0, WIDTH, HEIGHT);
// 黑色边框
graphics.setColor(Color.BLACK);
graphics.drawRect(0, 0, WIDTH - 1, HEIGHT - 1);
// 尝试绘制验证码
try {
graphics.setFont(new Font(Font.MONOSPACED, Font.BOLD, 20));
graphics.setColor(Color.BLUE);
for (int i = 0; i < verifyCode.length(); i++) {
graphics.drawString(String.valueOf(verifyCode.charAt(i)),
i * CHAR_SPACING + CHAR_X_OFFSET, CHAR_Y_OFFSET);
}
} catch (Exception fontException) {
// 如果连基本字体都失败，显示ERROR
graphics.setColor(Color.RED);
graphics.drawString("ERROR", 10, 20);
}
} finally {
if (graphics != null) {
graphics.dispose();
}
}
return errorImage;
}
/**
* 获取指定范围内的随机颜色
*
* @param minColorValue 最小颜色值
* @param maxColorValue 最大颜色值
* @param random 随机数生成器
* @return 随机颜色
*/
private static Color getRandomColor(int minColorValue, int maxColorValue, Random random) {
// 确保颜色值在有效范围内
int min = Math.max(0, Math.min(minColorValue, 255));
int max = Math.max(min, Math.min(maxColorValue, 255));
int range = max - min;
if (range == 0) {
return new Color(min, min, min);
}
int red = min + random.nextInt(range);
int green = min + random.nextInt(range);
int blue = min + random.nextInt(range);
return new Color(red, green, blue);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/HttpFileToMultipartFileUtil.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/HttpFileToMultipartFileUtil.java | package org.jeecg.modules.system.util;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.jeecg.common.util.MyCommonsMultipartFile;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* @Description: http文件转MultipartFile
* @author: wangshuai
* @date: 2025/11/5 17:55
*/
public class HttpFileToMultipartFileUtil {
/**
* 获取
*
* @param fileUrl
* @param filename
* @return
* @throws Exception
*/
public static MultipartFile httpFileToMultipartFile(String fileUrl, String filename) throws Exception {
byte[] bytes = downloadImageData(fileUrl);
return convertByteToMultipartFile(bytes, filename);
}
/**
* 下载图片数据
*/
private static byte[] downloadImageData(String fileUrl) throws IOException {
URL url = new URL(fileUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setConnectTimeout(5000);
connection.setReadTimeout(10000);
connection.setRequestProperty("User-Agent",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
connection.setRequestProperty("Accept", "image/*");
int responseCode = connection.getResponseCode();
if (responseCode != HttpURLConnection.HTTP_OK) {
throw new IOException("HTTP请求失败，响应码: " + responseCode);
}
try (InputStream inputStream = connection.getInputStream();
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
return outputStream.toByteArray();
} finally {
connection.disconnect();
}
}
/**
* byte转 MultipartFile
*
* @param data
* @param fileName
* @return
*/
private static MultipartFile convertByteToMultipartFile(byte[] data, String fileName) {
FileItemFactory factory = new DiskFileItemFactory();
FileItem item = factory.createItem(fileName, "application/octet-stream", true, fileName);
try (OutputStream os = item.getOutputStream();
ByteArrayInputStream bis = new ByteArrayInputStream(data)) {
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = bis.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
} catch (IOException e) {
throw new RuntimeException("字节数组转换失败", e);
}
try {
return new MyCommonsMultipartFile(item);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/SecurityUtil.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/SecurityUtil.java | package org.jeecg.modules.system.util;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
/**
* @Description: 密码加密解密
* @author: lsq
* @date: 2020年09月07日 14:26
*/
public class SecurityUtil {
/**加密key*/
private static String key = "JEECGBOOT1423670";
//---AES加密---------begin---------
/**加密
* @param content
* @return
*/
public static String jiami(String content) {
SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());
String encryptResultStr = aes.encryptHex(content);
return encryptResultStr;
}
/**解密
* @param encryptResultStr
* @return
*/
public static String jiemi(String encryptResultStr){
SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());
//解密为字符串
String decryptResult = aes.decryptStr(encryptResultStr, CharsetUtil.CHARSET_UTF_8);
return decryptResult;
}
//---AES加密---------end---------
/**
* 主函数
*/
public static void main(String[] args) {
String content="test1111";
String encrypt = jiami(content);
System.out.println(encrypt);
//构建
String decrypt = jiemi(encrypt);
//解密为字符串
System.out.println(decrypt);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/PermissionDataUtil.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/PermissionDataUtil.java | package org.jeecg.modules.system.util;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.entity.SysRoleIndex;
import org.jeecg.modules.system.service.ISysRoleIndexService;
import java.util.List;
/**
* @Author: scott
* @Date: 2019-04-03
*/
public class PermissionDataUtil {
/**
* 路径：views/
*/
private static final String PATH_VIEWS = "views/";
/**
* 路径：src/views/
*/
private static final String PATH_SRC_VIEWS = "src/views/";
/**
* .vue后缀
*/
private static final String VUE_SUFFIX = ".vue";
/**
* 智能处理错误数据，简化用户失误操作
*
* @param permission
*/
public static SysPermission intelligentProcessData(SysPermission permission) {
if (permission == null) {
return null;
}
// 组件
if (oConvertUtils.isNotEmpty(permission.getComponent())) {
String component = permission.getComponent();
if (component.startsWith(SymbolConstant.SINGLE_SLASH)) {
component = component.substring(1);
}
if (component.startsWith(PATH_VIEWS)) {
component = component.replaceFirst(PATH_VIEWS, "");
}
if (component.startsWith(PATH_SRC_VIEWS)) {
component = component.replaceFirst(PATH_SRC_VIEWS, "");
}
if (component.endsWith(VUE_SUFFIX)) {
component = component.replace(VUE_SUFFIX, "");
}
permission.setComponent(component);
}
// 请求URL
if (oConvertUtils.isNotEmpty(permission.getUrl())) {
String url = permission.getUrl();
if (url.endsWith(VUE_SUFFIX)) {
url = url.replace(VUE_SUFFIX, "");
}
if (!url.startsWith(CommonConstant.STR_HTTP) && !url.startsWith(SymbolConstant.SINGLE_SLASH)&&!url.trim().startsWith(SymbolConstant.DOUBLE_LEFT_CURLY_BRACKET)) {
url = SymbolConstant.SINGLE_SLASH + url;
}
permission.setUrl(url);
}
// 一级菜单默认组件
if (0 == permission.getMenuType() && oConvertUtils.isEmpty(permission.getComponent())) {
// 一级菜单默认组件
permission.setComponent("layouts/RouteView");
}
return permission;
}
/**
* 如果没有index页面 需要new 一个放到list中
* @param metaList
*/
public static void addIndexPage(List<SysPermission> metaList) {
boolean hasIndexMenu = false;
SysRoleIndex defIndexCfg = PermissionDataUtil.getDefIndexConfig();
for (SysPermission sysPermission : metaList) {
if(defIndexCfg.getUrl().equals(sysPermission.getUrl())) {
hasIndexMenu = true;
break;
}
}
if(!hasIndexMenu) {
metaList.add(0,new SysPermission(true));
}
}
/**
* 判断是否授权首页
* @param metaList
* @return
*/
public static boolean hasIndexPage(List<SysPermission> metaList, SysRoleIndex defIndexCfg){
boolean hasIndexMenu = false;
for (SysPermission sysPermission : metaList) {
if(defIndexCfg.getUrl().equals(sysPermission.getUrl())) {
hasIndexMenu = true;
break;
}
}
return hasIndexMenu;
}
/**
* 通过id判断是否授权某个页面
*
* @param metaList
* @return
*/
public static boolean hasMenuById(List<SysPermission> metaList, String id) {
for (SysPermission sysPermission : metaList) {
if (id.equals(sysPermission.getId())) {
return true;
}
}
return false;
}
/**
* 获取默认首页配置
*/
public static SysRoleIndex getDefIndexConfig() {
ISysRoleIndexService sysRoleIndexService = SpringContextUtils.getBean(ISysRoleIndexService.class);
return sysRoleIndexService.queryDefaultIndex();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/ImportSysUserCache.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/ImportSysUserCache.java | package org.jeecg.modules.system.util;
import java.util.HashMap;
import java.util.Map;
/**
* @Description: 导入缓存类，为了前台显示进度
* @author: wangshuai
* @date: 2025/9/6 14:09
*/
public class ImportSysUserCache {
private static final Map<String, Double> importSysUserMap = new HashMap<>();
/**
* 获取导入的列
*
* @param key
* @param type user 用户 可扩展
* @return
*/
public static Double getImportSysUserMap(String key, String type) {
if (importSysUserMap.containsKey(key + "__" + type)) {
return importSysUserMap.get(key + "__" + type);
}
return 0.0;
}
/**
* 设置导入缓存
*
* @param key 前村传过来的随机key
* @param num 导入行数
* @param length 总长度
* @param type 导入类型 user 用户列表
*/
public static void setImportSysUserMap(String key, int num, int length, String type) {
double percent = (num * 100.0) / length;
if(num == length){
percent = 100;
}
importSysUserMap.put(key + "__" + type, percent);
}
/**
* 移除导入缓存
*
* @param key
*/
public static void removeImportLowAppMap(String key) {
importSysUserMap.remove(key);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/XssUtils.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/util/XssUtils.java | package org.jeecg.modules.system.util;
import org.springframework.web.util.HtmlUtils;
import java.util.regex.Pattern;
/**
* @Description: 工具类XSSUtils，现在的做法是替换成空字符，CSDN的是进行转义，比如文字开头的"<"转成<
* @author: lsq
* @date: 2021年07月26日 19:13
*/
public class XssUtils {
private static Pattern[] patterns = new Pattern[]{
//Script fragments
Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE),
//src='...'
Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
//script tags
Pattern.compile("</script>", Pattern.CASE_INSENSITIVE),
Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
//eval(...)
Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
//expression(...)
Pattern.compile("expression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
//javascript:...
Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE),
//vbscript:...
Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE),
//onload(...)=...
Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
};
public static String scriptXss(String value) {
if (value != null) {
value = value.replaceAll(" ", "");
for(Pattern scriptPattern: patterns){
value = scriptPattern.matcher(value).replaceAll("");
}
}
return HtmlUtils.htmlEscape(value);
}
public static void main(String[] args) {
String s = scriptXss("<img src=x onload=alert(111).*?><script></script>javascript:eval()\\\\.");
System.err.println("s======>" + s);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/constant/DefIndexConst.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/constant/DefIndexConst.java | package org.jeecg.modules.system.constant;
/**
* 默认首页常量
*/
public interface DefIndexConst {
/**
* 默认首页的roleCode
*/
String DEF_INDEX_ALL = "DEF_INDEX_ALL";
/**
* 默认首页的缓存key
*/
String CACHE_KEY = "sys:cache:def_index";
/**
* 缓存默认首页的类型前缀
*/
String CACHE_TYPE = "sys:cache:home_type::";
/**
* 默认首页类型
*/
String HOME_TYPE_SYSTEM = "system";
String HOME_TYPE_PERSONAL = "personal";
String HOME_TYPE_MENU = "menuHome";
/**
* 默认首页的初始值
*/
String DEF_INDEX_NAME = "首页";
String DEF_INDEX_URL = "/dashboard/analysis";
String DEF_INDEX_COMPONENT = "dashboard/Analysis";
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartRoleUserService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartRoleUserService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysDepartRoleUser;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* @Description: 部门角色人员信息
* @Author: jeecg-boot
* @Date: 2020-02-13
* @Version: V1.0
*/
public interface ISysDepartRoleUserService extends IService<SysDepartRoleUser> {
/**
* 添加用户与部门关联
* @param userId 用户id
* @param newRoleId 新的角色id
* @param oldRoleId 旧的角色id
*/
void deptRoleUserAdd(String userId,String newRoleId,String oldRoleId);
/**
* 取消用户与部门关联，删除关联关系
* @param userIds
* @param depId
*/
void removeDeptRoleUser(List<String> userIds,String depId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysCommentService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysCommentService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysComment;
import org.jeecg.modules.system.vo.SysCommentFileVo;
import org.jeecg.modules.system.vo.SysCommentVO;
import jakarta.servlet.http.HttpServletRequest;
import java.util.List;
/**
* @Description: 系统评论回复表
* @Author: jeecg-boot
* @Date: 2022-07-19
* @Version: V1.0
*/
public interface ISysCommentService extends IService<SysComment> {
/**
* 保存评论 返回评论ID
*
* @param sysComment
*/
String saveOne(SysComment sysComment);
/**
* 删除
*
* @param id
*/
void deleteOne(String id);
/**
* 根据表名和数据id查询表单评论及文件信息
*
* @param sysComment
* @return
*/
List<SysCommentVO> queryFormCommentInfo(SysComment sysComment);
/**
* 保存文件+评论
*
* @param req
*/
void saveOneFileComment(HttpServletRequest req);
/**
* 查询当前表单的文件列表
*
* @param tableName
* @param formDataId
* @return
*/
List<SysCommentFileVo> queryFormFileList(String tableName, String formDataId);
/**
* app端 保存文件+评论
*
* @param request
*/
void appSaveOneFileComment(HttpServletRequest request);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartService.java | package org.jeecg.modules.system.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.jeecg.modules.system.vo.SysChangeDepartVo;
import org.jeecg.modules.system.vo.SysDepartExportVo;
import org.jeecg.modules.system.vo.SysPositionSelectTreeVo;
import org.jeecg.modules.system.vo.lowapp.ExportDepartVo;
import java.util.List;
/**
* <p>
* 部门表 服务实现类
* <p>
*
* @Author:Steve
* @Since： 2019-01-22
*/
public interface ISysDepartService extends IService<SysDepart>{
/**
* 查询我的部门信息,并分节点进行显示
* @param departIds 部门id
* @return
*/
List<SysDepartTreeModel> queryMyDeptTreeList(String departIds);
/**
* 查询所有部门信息,并分节点进行显示
* @return
*/
List<SysDepartTreeModel> queryTreeList();
/**
* 查询所有部门信息,并分节点进行显示
* @param ids 多个部门id
* @return
*/
List<SysDepartTreeModel> queryTreeList(String ids);
/**
* 查询所有部门DepartId信息,并分节点进行显示
* @return
*/
public List<DepartIdModel> queryDepartIdTreeList();
/**
* 保存部门数据
* @param sysDepart
* @param username 用户名
*/
void saveDepartData(SysDepart sysDepart,String username);
/**
* 更新depart数据
* @param sysDepart
* @param username 用户名
* @return
*/
Boolean updateDepartDataById(SysDepart sysDepart,String username);
/**
* 删除depart数据
* @param id
* @return
*/
/* boolean removeDepartDataById(String id); */
/**
* 根据关键字搜索相关的部门数据
*
* @param keyWord
* @param myDeptSearch
* @param departIds 多个部门id
* @param orgCategory
* @param depIds
* @return
*/
List<SysDepartTreeModel> searchByKeyWord(String keyWord, String myDeptSearch, String departIds, String orgCategory, String depIds);
/**
* 根据部门id删除并删除其可能存在的子级部门
* @param id
* @return
*/
boolean delete(String id);
/**
* 查询SysDepart集合
* @param userId
* @return
*/
public List<SysDepart> queryUserDeparts(String userId);
/**
* 根据用户名查询部门
*
* @param username
* @return
*/
List<SysDepart> queryDepartsByUsername(String username);
/**
* 根据用户ID查询部门
*
* @param userId
* @return
*/
List<String> queryDepartsByUserId(String userId);
/**
* 根据部门id批量删除并删除其可能存在的子级部门
* @param ids 多个部门id
* @return
*/
void deleteBatchWithChildren(List<String> ids);
/**
* 根据部门Id查询,当前和下级所有部门IDS
* @param departId
* @return
*/
List<String> getSubDepIdsByDepId(String departId);
/**
* 获取我的部门下级所有部门IDS
* @param departIds 多个部门id
* @return
*/
List<String> getMySubDepIdsByDepId(String departIds);
/**
* 根据关键字获取部门信息（通讯录）
* @param keyWord 搜索词
* @return
*/
List<SysDepartTreeModel> queryTreeByKeyWord(String keyWord);
/**
* 获取我的部门下级所有部门
* @param parentId 父id
* @param ids 多个部门id
* @param primaryKey 主键字段（id或者orgCode）
* @return
*/
List<SysDepartTreeModel> queryTreeListByPid(String parentId,String ids, String primaryKey);
/**
* 获取某个部门的所有父级部门的ID
*
* @param departId 根据departId查
* @return JSONObject
*/
JSONObject queryAllParentIdByDepartId(String departId);
/**
* 获取某个部门的所有父级部门的ID
*
* @param orgCode 根据orgCode查
* @return JSONObject
*/
JSONObject queryAllParentIdByOrgCode(String orgCode);
/**
* 获取公司信息
* @param orgCode 部门编码
* @return
*/
SysDepart queryCompByOrgCode(String orgCode);
/**
* 获取下级部门
* @param pid
* @return
*/
List<SysDepart> queryDeptByPid(String pid);
/**
* 获取我的部门已加入的公司
* @return
*/
List<SysDepart> getMyDepartList();
/**
* 删除部门
* @param id
*/
void deleteDepart(String id);
/**
* 通讯录通过租户id查询部门数据
* @param parentId
* @param tenantId
* @param departName
* @return
*/
List<SysDepartTreeModel> queryBookDepTreeSync(String parentId, Integer tenantId, String departName);
/**
* 根据id查询部门信息
* @param parentId
* @return
*/
SysDepart getDepartById(String parentId);
/**
* 根据id查询部门信息
* @param parentId
* @return
*/
IPage<SysDepart> getMaxCodeDepart(Page<SysDepart> page, String parentId);
/**
* 更新叶子节点
* @param id
* @param izLeaf
*/
void updateIzLeaf(String id, Integer izLeaf);
/**
* 获取导出部门的数据
* @param tenantId
* @return
*/
List<ExportDepartVo> getExcelDepart(int tenantId);
void importExcel(List<ExportDepartVo> listSysDeparts, List<String> errorMessageList);
/**
* 根据租户id导出部门
* @param tenantId
* @param idList
* @return
*/
List<SysDepartExportVo> getExportDepart(Integer tenantId, List<String> idList);
/**
* 导出系统部门excel
* @param listSysDeparts
* @param errorMessageList
*/
void importSysDepart(List<SysDepartExportVo> listSysDeparts, List<String> errorMessageList);
/**
* 根据部门id和职级id获取岗位信息
*
* @param parentId
* @param departId
* @param positionId
*/
List<SysPositionSelectTreeVo> getPositionByDepartId(String parentId, String departId, String positionId);
/**
* 获取职级关系
* @param departId
* @return
*/
List<SysPositionSelectTreeVo> getRankRelation(String departId);
/**
* 异步查询部门和岗位接口
*
* @param parentId
* @param ids
* @param primaryKey
* @param departIds
* @return
*/
List<SysDepartTreeModel> queryDepartAndPostTreeSync(String parentId, String ids, String primaryKey, String departIds,String orgName);
/**
* 根据部门code获取当前和上级部门名称
*
* @param orgCode
* @param depId
* @return
*/
String getDepartPathNameByOrgCode(String orgCode, String depId);
/**
* 根据部门id获取部门下的岗位id
*
* @param depIds 当前选择的公司、子公司、部门id
* @return
*/
String getDepPostIdByDepId(String depIds);
/**
* 调整部门位置
*
* @param changeDepartVo
* @return
*/
void updateChangeDepart(SysChangeDepartVo changeDepartVo);
/**
* 获取部门负责人
*
* @param departId
* @param page
* @return
*/
IPage<SysUser> getDepartmentHead(String departId, Page<SysUser> page);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysLogService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysLogService.java | package org.jeecg.modules.system.service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.jeecg.modules.system.entity.SysLog;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 系统日志表 服务类
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
public interface ISysLogService extends IService<SysLog> {
/**
* 清空所有日志记录
*/
public void removeAll();
/**
* 获取系统总访问次数
*
* @return Long
*/
Long findTotalVisitCount();
/**
* 获取系统今日访问次数
* @param dayStart
* @param dayEnd
* @return Long
*/
Long findTodayVisitCount(Date dayStart, Date dayEnd);
/**
* 获取系统今日访问 IP数
* @param dayStart 开始时间
* @param dayEnd 结束时间
* @return Long
*/
Long findTodayIp(Date dayStart, Date dayEnd);
/**
* 首页：根据时间统计访问数量/ip数量
* @param dayStart
* @param dayEnd
* @return
*/
List<Map<String,Object>> findVisitCount(Date dayStart, Date dayEnd);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserTenantService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserTenantService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.modules.system.entity.SysTenant;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserTenant;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.vo.SysUserTenantVo;
import java.util.List;
/**
* @Description: sys_user_tenant_relation
* @Author: jeecg-boot
* @Date: 2022-12-23
* @Version: V1.0
*/
public interface ISysUserTenantService extends IService<SysUserTenant> {
/**
* 通过租户id获取数据
* @param page
* @param userTenantId
* @param user
* @return
*/
Page<SysUser> getPageUserList(Page<SysUser> page, Integer userTenantId, SysUser user);
/**
* 设置租户id
* @param records
* @return
*/
List<SysUser> setUserTenantIds(List<SysUser> records);
/**
* 获取租户id获取用户ids
* @param tenantId
* @return
*/
List<String> getUserIdsByTenantId(Integer tenantId);
/**
* 通过用户id获取租户ids
* @param userId
* @return
*/
List<Integer> getTenantIdsByUserId(String userId);
/**
* 通过用户id获取租户列表
* @param userId
* @param userTenantStatus
* @return
*/
List<SysUserTenantVo> getTenantListByUserId(String userId, List<String> userTenantStatus);
/**
* 更新用户租户状态
* @param id
* @param tenantId
* @param userTenantStatus
*/
void updateUserTenantStatus(String id, String tenantId, String userTenantStatus);
/**
* 联查用户和租户审核状态
* @param page
* @param status 租户用户状态，默认为1正常
* @param user
* @return
*/
IPage<SysUserTenantVo> getUserTenantPageList(Page<SysUserTenantVo> page, List<String> status, SysUser user, Integer tenantId);
/**
* 取消离职
* @param userIds
* @param tenantId
*/
void putCancelQuit(List<String> userIds, Integer tenantId);
/**
* 验证用户是否已存在
* @param userId
* @param tenantId
* @return
*/
Integer userTenantIzExist(String userId, Integer tenantId);
/**
* 根据用户id获取我的租户
*
* @param page
* @param userId
* @param userTenantStatus
* @param sysUserTenantVo
* @return
*/
IPage<SysTenant> getTenantPageListByUserId(Page<SysTenant> page, String userId, List<String> userTenantStatus,SysUserTenantVo sysUserTenantVo);
/**
* 同意加入租户
* @param userId
* @param tenantId
*/
void agreeJoinTenant(String userId, Integer tenantId);
/**
* 拒绝加入租户
* @param userId
* @param tenantId
*/
void refuseJoinTenant(String userId, Integer tenantId);
/**
* 根据用户id和租户id获取用户租户中间表信息
* @param userId
* @param tenantId
* @return
*/
SysUserTenant getUserTenantByTenantId(String userId, Integer tenantId);
/**
* 获取租户下的成员数量
* @param tenantId
* @param tenantStatus
* @return
*/
Long getUserCount(Integer tenantId, String tenantStatus);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPermissionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPermissionService.java | package org.jeecg.modules.system.service;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.model.TreeModel;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 菜单权限表 服务类
* </p>
*
* @Author scott
* @since 2018-12-21
*/
public interface ISysPermissionService extends IService<SysPermission> {
/**
* 切换vue3菜单
*/
public void switchVue3Menu();
/**
* 通过父id查询菜单
* @param parentId 父id
* @return
*/
public List<TreeModel> queryListByParentId(String parentId);
/**
* 真实删除
* @param id 菜单id
* @throws JeecgBootException
*/
public void deletePermission(String id) throws JeecgBootException;
/**
* 逻辑删除
* @param id 菜单id
* @throws JeecgBootException
*/
public void deletePermissionLogical(String id) throws JeecgBootException;
/**
* 添加菜单
* @param sysPermission SysPermission对象
* @throws JeecgBootException
*/
public void addPermission(SysPermission sysPermission) throws JeecgBootException;
/**
* 编辑菜单
* @param sysPermission SysPermission对象
* @throws JeecgBootException
*/
public void editPermission(SysPermission sysPermission) throws JeecgBootException;
/**
* 获取登录用户拥有的权限
* @param username 用户名
* @return
*/
public List<SysPermission> queryByUser(String username);
/**
* 根据permissionId删除其关联的SysPermissionDataRule表中的数据
*
* @param id
* @return
*/
public void deletePermRuleByPermId(String id);
/**
* 查询出带有特殊符号的菜单地址的集合
* @return
*/
public List<String> queryPermissionUrlWithStar();
/**
* 判断用户否拥有权限
* @param username
* @param sysPermission
* @return
*/
public boolean hasPermission(String username, SysPermission sysPermission);
/**
* 根据用户和请求地址判断是否有此权限
* @param username
* @param url
* @return
*/
public boolean hasPermission(String username, String url);
/**
* 查询部门权限数据
* @param departId
* @return
*/
List<SysPermission> queryDepartPermissionList(String departId);
/**
* 检测地址是否存在(聚合路由的情况下允许使用子菜单路径作为父菜单的路由地址)
* @param id
* @param url
* @param alwaysShow 是否是聚合路由
* @return
*/
boolean checkPermDuplication(String id, String url,Boolean alwaysShow);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDictItemService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDictItemService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysDictItem;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 服务类
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
public interface ISysDictItemService extends IService<SysDictItem> {
/**
* 通过字典id查询字典项
* @param mainId 字典id
* @return
*/
public List<SysDictItem> selectItemsByMainId(String mainId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserDepartService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserDepartService.java | package org.jeecg.modules.system.service;
import java.util.List;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserDepart;
import org.jeecg.modules.system.model.DepartIdModel;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* SysUserDpeart用户组织机构service
* </p>
* @Author ZhiLin
*
*/
public interface ISysUserDepartService extends IService<SysUserDepart> {
/**
* 根据指定用户id查询部门信息
* @param userId
* @return
*/
List<DepartIdModel> queryDepartIdsOfUser(String userId);
/**
* 根据部门id查询用户信息
* @param depId
* @return
*/
List<SysUser> queryUserByDepId(String depId);
/**
* 根据部门code，查询当前部门和下级部门的用户信息
* @param depCode 部门code
* @param realname 真实姓名
* @return List<SysUser>
*/
List<SysUser> queryUserByDepCode(String depCode,String realname);
/**
* 用户组件数据查询
* @param departId
* @param username
* @param pageSize
* @param pageNo
* @param realname
* @param id
* @param isMultiTranslate 是否多字段翻译
* @return
*/
IPage<SysUser> queryDepartUserPageList(String departId, String username, String realname, int pageSize, int pageNo,String id,String isMultiTranslate);
/**
* 获取用户信息
* @param tenantId
* @param departId
* @param keyword
* @param pageSize
* @param pageNo
* @return
*/
IPage<SysUser> getUserInformation(Integer tenantId, String departId, String keyword, Integer pageSize, Integer pageNo);
/**
* 获取用户信息
* @param tenantId
* @param departId
* @param roleId
* @param keyword
* @param pageSize
* @param pageNo
* @return
*/
IPage<SysUser> getUserInformation(Integer tenantId,String departId,String roleId, String keyword, Integer pageSize, Integer pageNo, String excludeUserIdList, String includeUsernameList);
/**
* 通过部门id和租户id获取多个用户
* @param departId
* @param tenantId
* @return
*/
List<SysUser> getUsersByDepartTenantId(String departId,Integer tenantId);
/**
* 查询部门岗位下的用户
*
* @param departId
* @param username
* @param realname
* @param pageSize
* @param pageNo
* @param id
* @param isMultiTranslate
* @return
*/
IPage<SysUser> queryDepartPostUserPageList(String departId, String username, String realname, Integer pageSize, Integer pageNo, String id, String isMultiTranslate);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysThirdAppConfigService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysThirdAppConfigService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysThirdAppConfig;
import java.util.List;
/**
* @Description: 第三方配置表
* @Author: jeecg-boot
* @Date: 2023-02-03
* @Version: V1.0
*/
public interface ISysThirdAppConfigService extends IService<SysThirdAppConfig>{
/**
* 根据租户id获取钉钉/企业微信配置
* @param tenantId
* @return
*/
List<SysThirdAppConfig> getThirdConfigListByThirdType(int tenantId);
/**
* 根据租户id和第三方类别获取第三方配置
* @param tenantId
* @param thirdType
* @return
*/
SysThirdAppConfig getThirdConfigByThirdType(Integer tenantId, String thirdType);
/**
* 根据应用key获取第三方表配置
* @param clientId
*/
List<SysThirdAppConfig> getThirdAppConfigByClientId(String clientId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysAnnouncementService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysAnnouncementService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysAnnouncement;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.util.Date;
import java.util.List;
/**
* @Description: 系统通告表
* @Author: jeecg-boot
* @Date: 2019-01-02
* @Version: V1.0
*/
public interface ISysAnnouncementService extends IService<SysAnnouncement> {
/**
* 保存系统通告
* @param sysAnnouncement
*/
public void saveAnnouncement(SysAnnouncement sysAnnouncement);
/**
* 修改系统通告
* @param sysAnnouncement
* @return
*/
public boolean upDateAnnouncement(SysAnnouncement sysAnnouncement);
/**
* 保存系统通告
* @param title 标题
* @param msgContent 信息内容
*/
public void saveSysAnnouncement(String title, String msgContent);
/**
* 分页查询系统通告
* @param page 当前页数
* @param userId 用户id
* @param msgCategory 消息类型
* @return Page<SysAnnouncement>
*/
public Page<SysAnnouncement> querySysCementPageByUserId(Page<SysAnnouncement> page, String userId, String msgCategory, Integer tenantId, Date beginDate);
/**
* 获取用户未读消息数量
*
* @param userId 用户id
* @param noticeType 通知类型
* @return
*/
public Integer getUnreadMessageCountByUserId(String userId, Date beginDate, String noticeType);
/**
* 补全当前登录用户的消息阅读记录
* @作废无用 2023-09-19
*/
@Deprecated
void completeAnnouncementSendInfo();
/**
* 补全所有用户的推送公告关系数据
*
* @param commentId
* @param tenantId
*/
void batchInsertSysAnnouncementSend(String commentId, Integer tenantId);
/**
* 分页查询当前登录用户的消息， 并且标记哪些是未读消息
*/
List<SysAnnouncement> querySysMessageList(int pageSize, int pageNo, String fromUser, String starFlag, String busType, String msgCategory, Date beginDate, Date endDate, String noticeType);
/**
* 修改为已读消息
*/
void updateReaded(List<String> annoceIdList);
/**
* 清除所有未读消息
*/
void clearAllUnReadMessage();
/**
* 查询用户未阅读的通知公告
* @param userId
* @return
*/
public List<String> getNotSendedAnnouncementlist(String userId);
/**
* 添加访问次数
* @param id
* @param count
*/
void updateVisitsNum(String id, int count);
/**
* 批量下载文件
* @param id
* @param request
* @param response
*/
void downLoadFiles(String id, HttpServletRequest request, HttpServletResponse response);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysRoleIndexService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysRoleIndexService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysRoleIndex;
/**
* @Description: 角色首页配置
* @Author: jeecg-boot
* @Date: 2022-03-25
* @Version: V1.0
*/
public interface ISysRoleIndexService extends IService<SysRoleIndex> {
/**
* 查询默认首页
*
* @return
*/
SysRoleIndex queryDefaultIndex();
/**
* 更新默认首页
*
* @param url
* @param component
* @param isRoute 是否是路由页面
* @return
*/
boolean updateDefaultIndex(String url, String component, boolean isRoute);
/**
* 创建最原始的默认首页配置
*
* @return
*/
SysRoleIndex initDefaultIndex();
/**
* 清理默认首页的redis缓存
*/
void cleanDefaultIndexCache();
/**
* 切换默认门户
* @param sysRoleIndex
*/
void changeDefHome(SysRoleIndex sysRoleIndex);
/**
* 更新其他全局默认的状态值
*
* @param roleCode
* @param status
* @param id
*/
void updateOtherDefaultStatus(String roleCode, String status, String id);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPackPermissionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPackPermissionService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysPackPermission;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 产品包菜单关系表
* @Author: jeecg-boot
* @Date: 2022-12-31
* @Version: V1.0
*/
public interface ISysPackPermissionService extends IService<SysPackPermission> {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysRolePermissionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysRolePermissionService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysRolePermission;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 角色权限表 服务类
* </p>
*
* @Author scott
* @since 2018-12-21
*/
public interface ISysRolePermissionService extends IService<SysRolePermission> {
/**
* 保存授权/先删后增
* @param roleId
* @param permissionIds
*/
public void saveRolePermission(String roleId,String permissionIds);
/**
* 保存授权 将上次的权限和这次作比较 差异处理提高效率
* @param roleId
* @param permissionIds
* @param lastPermissionIds
*/
public void saveRolePermission(String roleId,String permissionIds,String lastPermissionIds);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTenantService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTenantService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.system.entity.SysTenant;
import org.jeecg.modules.system.entity.SysTenantPackUser;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.vo.tenant.TenantDepartAuthInfo;
import org.jeecg.modules.system.vo.tenant.TenantPackModel;
import org.jeecg.modules.system.vo.tenant.TenantPackUser;
import org.jeecg.modules.system.vo.tenant.TenantPackUserCount;
import java.util.Collection;
import java.util.List;
/**
* @Description: 租户service接口
* @author: jeecg-boot
*/
public interface ISysTenantService extends IService<SysTenant> {
/**
* 查询有效的租户
*
* @param idList
* @return
*/
List<SysTenant> queryEffectiveTenant(Collection<Integer> idList);
/**
* 返回某个租户被多少个用户引用了
*
* @param id
* @return
*/
Long countUserLinkTenant(String id);
/**
* 根据ID删除租户，会判断是否已被引用
*
* @param id
* @return
*/
boolean removeTenantById(String id);
/**
* 邀请用户加入租户,通过手机号
* @param ids
* @param phone
* @param username
*/
void invitationUserJoin(String ids, String phone,String username);
/**
* 请离用户（租户）
* @param userIds
* @param tenantId
*/
void leaveTenant(String userIds, String tenantId);
/**
* 添加租户，并将创建的用户加入关系表
* @param sysTenant
* @param userId
*/
Integer saveTenantJoinUser(SysTenant sysTenant, String userId);
/**
* 保存租户
* @param sysTenant
*/
void saveTenant(SysTenant sysTenant);
/**
* 通过门牌号加入租户
* @param sysTenant
* @param userId
*/
Integer joinTenantByHouseNumber(SysTenant sysTenant, String userId);
/**
* 统计一个人创建了多少个租户
*
* @param userId
* @return
*/
Integer countCreateTenantNum(String userId);
/**
* 获取租户回收站的数据
* @param page
* @param sysTenant
* @return
*/
IPage<SysTenant> getRecycleBinPageList(Page<SysTenant> page, SysTenant sysTenant);
/**
* 彻底删除租户
* @param ids
*/
void deleteTenantLogic(String ids);
/**
* 还原租户
* @param ids
*/
void revertTenantLogic(String ids);
/**
* 退出租户
* @param userId
* @param userId
* @param username
*/
void exitUserTenant(String userId, String username, String tenantId);
/**
* 变更租户拥有者
* @param userId
* @param tenantId
*/
void changeOwenUserTenant(String userId, String tenantId);
/**
* 邀请用户到租户。通过手机号匹配
* @param phone
* @param departId
* @return
*/
Result<String> invitationUser(String phone, String departId);
/**
* 进入应用组织页面 查询用户是否有 超级管理员的权限
* @param tenantId
* @return
*/
TenantDepartAuthInfo getTenantDepartAuthInfo(Integer tenantId);
/**
* 获取 租户产品包-3个默认admin的人员数量
* @param tenantId
* @return
*/
List<TenantPackUserCount> queryTenantPackUserCount(Integer tenantId);
/**
* 查询租户产品包信息
* @param model
* @return
*/
TenantPackModel queryTenantPack(TenantPackModel model);
/**
* 添加多个用户和产品包的关系数据
* @param sysTenantPackUser
*/
void addBatchTenantPackUser(SysTenantPackUser sysTenantPackUser);
/**
* 添加用户和产品包的关系数据 带日志记录的
* @param sysTenantPackUser
*/
void addTenantPackUser(SysTenantPackUser sysTenantPackUser);
/**
* 移除用户和产品包的关系数据 带日志记录的
* @param sysTenantPackUser
*/
void deleteTenantPackUser(SysTenantPackUser sysTenantPackUser);
/**
* 查询申请的用户列表
*/
List<TenantPackUser> getTenantPackApplyUsers(Integer tenantId);
/**
* 个人 申请成为管理员
* @param sysTenantPackUser
*/
void doApplyTenantPackUser(SysTenantPackUser sysTenantPackUser);
/**
* 申请通过 成为管理员
* @param sysTenantPackUser
*/
void passApply(SysTenantPackUser sysTenantPackUser);
/**
* 拒绝申请 成为管理员
* @param sysTenantPackUser
*/
void deleteApply(SysTenantPackUser sysTenantPackUser);
/**
* 产品包用户列表
* @param tenantId
* @param packId
* @param status
* @param page
* @return
*/
IPage<TenantPackUser> queryTenantPackUserList(String tenantId, String packId, Integer status, Page<TenantPackUser> page);
/**
* 查看是否已经申请过了管理员
* @return
*/
Long getApplySuperAdminCount();
/**
* 发送同意或者拒绝消息
*
* @param user
* @param content
*/
void sendMsgForAgreeAndRefuseJoin(SysUser user, String content);
/**
* 根据密码删除当前用户
*
* @param sysUser
* @param tenantId
*/
void deleteUserByPassword(SysUser sysUser, Integer tenantId);
/**
* 根据用户id获取租户信息
* @param userId
* @return
*/
List<SysTenant> getTenantListByUserId(String userId);
/**
* 删除用户
* @param sysUser
* @param tenantId
*/
void deleteUser(SysUser sysUser, Integer tenantId);
/**
* 为用户添加租户下所有套餐
* @param userId
* @param tenantId
*/
void addPackUser(String userId, String tenantId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserDepPostService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserDepPostService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysUserDepPost;
/**
* @Description: 部门岗位用户表
* @author: wangshuai
* @date: 2025/9/5 11:45
*/
public interface ISysUserDepPostService extends IService<SysUserDepPost> {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.