code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package com.jcm.common.security.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 角色认证：必须具有指定角色标识才能进入该方法
*
* @author junchenmo
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD, ElementType.TYPE })
public @interface RequiresRoles
{
/**
* 需要校验的角色标识
*/
String[] value() default {};
/**
* 验证逻辑：AND | OR，默认AND
*/
Logical logical() default Logical.AND;
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/annotation/RequiresRoles.java
|
Java
|
unknown
| 619
|
package com.jcm.common.security.aspect;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.exception.InnerAuthException;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.security.annotation.InnerAuth;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
/**
* 内部服务调用验证处理
*
* @author junchenmo
*/
@Aspect
@Component
public class InnerAuthAspect implements Ordered
{
@Around("@annotation(innerAuth)")
public Object innerAround(ProceedingJoinPoint point, InnerAuth innerAuth) throws Throwable
{
String source = ServletUtils.getRequest().getHeader(SecurityConstants.FROM_SOURCE);
// 内部请求验证
if (!StringUtils.equals(SecurityConstants.INNER, source))
{
throw new InnerAuthException("没有内部访问权限，不允许访问");
}
String userid = ServletUtils.getRequest().getHeader(SecurityConstants.DETAILS_USER_ID);
String username = ServletUtils.getRequest().getHeader(SecurityConstants.DETAILS_USERNAME);
// 用户信息验证
if (innerAuth.isUser() && (StringUtils.isEmpty(userid) || StringUtils.isEmpty(username)))
{
throw new InnerAuthException("没有设置用户信息，不允许访问 ");
}
return point.proceed();
}
/**
* 确保在权限认证aop执行前执行
*/
@Override
public int getOrder()
{
return Ordered.HIGHEST_PRECEDENCE + 1;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/aspect/InnerAuthAspect.java
|
Java
|
unknown
| 1,728
|
package com.jcm.common.security.aspect;
import com.jcm.common.security.annotation.RequiresLogin;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.security.annotation.RequiresRoles;
import com.jcm.common.security.auth.AuthUtil;
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.springframework.stereotype.Component;
import java.lang.reflect.Method;
/**
* 基于 Spring Aop 的注解鉴权
*
* @author kong
*/
@Aspect
@Component
public class PreAuthorizeAspect
{
/**
* 构建
*/
public PreAuthorizeAspect()
{
}
/**
* 定义AOP签名 (切入所有使用鉴权注解的方法)
*/
public static final String POINTCUT_SIGN = " @annotation(com.jcm.common.security.annotation.RequiresLogin) || "
+ "@annotation(com.jcm.common.security.annotation.RequiresPermissions) || "
+ "@annotation(com.jcm.common.security.annotation.RequiresRoles)";
/**
* 声明AOP签名
*/
@Pointcut(POINTCUT_SIGN)
public void pointcut(){
}
/**
* 环绕切入
*
* @param joinPoint 切面对象
* @return 底层方法执行后的返回值
* @throws Throwable 底层方法抛出的异常
*/
@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable
{
// 注解鉴权
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
checkMethodAnnotation(signature.getMethod());
try
{
// 执行原有逻辑
Object obj = joinPoint.proceed();
return obj;
}
catch (Throwable e)
{
throw e;
}
}
/**
* 对一个Method对象进行注解检查
*/
public void checkMethodAnnotation(Method method)
{
// 校验 @RequiresLogin 注解
RequiresLogin requiresLogin = method.getAnnotation(RequiresLogin.class);
if (requiresLogin != null)
{
AuthUtil.checkLogin();
}
// 校验 @RequiresRoles 注解
RequiresRoles requiresRoles = method.getAnnotation(RequiresRoles.class);
if (requiresRoles != null)
{
AuthUtil.checkRole(requiresRoles);
}
// 校验 @RequiresPermissions 注解
RequiresPermissions requiresPermissions = method.getAnnotation(RequiresPermissions.class);
if (requiresPermissions != null)
{
AuthUtil.checkPermi(requiresPermissions);
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/aspect/PreAuthorizeAspect.java
|
Java
|
unknown
| 2,718
|
package com.jcm.common.security.aspect;
import com.alibaba.fastjson2.JSONObject;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import com.jcm.common.security.annotation.PrintParams;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* @description:
* @author:
* @create: 2023/9/26 15:31
* restful接口请求参数打印切面
* 说明：在方法上添加@PrintParams注解即可
* 方式1（默认同时打印入参和返回结果）：@PrintParams
* 方式2（可选打印入参或返回结果），如打印入参但不打印返回结果：@PrintParams(requestParam = true,responseParam = false)
*/
@Aspect
@Component
public class PrintParamsAspect {
private static final Logger logger = LoggerFactory.getLogger(PrintParamsAspect.class);
@Around("@annotation(com.jcm.common.security.annotation.PrintParams)")
public Object printParams(ProceedingJoinPoint joinPoint) throws Throwable {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
String methodName = method.getName();
Object[] args = joinPoint.getArgs();
String declaringTypeName = signature.getDeclaringTypeName();
String methodFullPath = declaringTypeName+"."+method.getName();
String[] paramNames = signature.getParameterNames();
PrintParams printParams = method.getAnnotation(PrintParams.class);
try {
if(printParams.requestParam()){
logger.info("调用接口{}，请求入参：参数名{}，参数值{}", methodFullPath, Arrays.toString(paramNames), Arrays.toString(args));
}
}catch (Exception e){
logger.error("打印请求参数失败");
}
// 在调用方法之前记录开始时间
long startTime = System.currentTimeMillis();
Object result = joinPoint.proceed();
// 在目标方法返回后记录结束时间
long endTime = System.currentTimeMillis();
// 计算已过去的时间（单位：毫秒）
long duration = endTime - startTime;
logger.info("调用接口{}，耗时：{} 毫秒", methodFullPath,duration);
try {
if(printParams.responseParam()){
logger.info("调用接口{}，返回结果：{}", methodFullPath, JSONObject.toJSONString(result));
}
}catch (Exception e){
logger.error("打印返回结果参数失败");
}
return result;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/aspect/PrintParamsAspect.java
|
Java
|
unknown
| 2,746
|
package com.jcm.common.security.auth;
import com.jcm.common.core.context.SecurityContextHolder;
import com.jcm.common.core.exception.auth.NotLoginException;
import com.jcm.common.core.exception.auth.NotPermissionException;
import com.jcm.common.core.exception.auth.NotRoleException;
import com.jcm.common.core.utils.SpringUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.security.annotation.Logical;
import com.jcm.common.security.annotation.RequiresLogin;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.security.annotation.RequiresRoles;
import com.jcm.common.security.service.TokenService;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.model.LoginUser;
import org.springframework.util.PatternMatchUtils;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
/**
* Token 权限验证，逻辑实现类
*
* @author junchenmo
*/
public class AuthLogic
{
/** 所有权限标识 */
private static final String ALL_PERMISSION = "*:*:*";
/** 管理员角色权限标识 */
private static final String SUPER_ADMIN = "admin";
public TokenService tokenService = SpringUtils.getBean(TokenService.class);
/**
* 会话注销
*/
public void logout()
{
String token = SecurityUtils.getToken();
if (token == null)
{
return;
}
logoutByToken(token);
}
/**
* 会话注销，根据指定Token
*/
public void logoutByToken(String token)
{
tokenService.delLoginUser(token);
}
/**
* 检验用户是否已经登录，如未登录，则抛出异常
*/
public void checkLogin()
{
getLoginUser();
}
/**
* 获取当前用户缓存信息, 如果未登录，则抛出异常
*
* @return 用户缓存信息
*/
public LoginUser getLoginUser()
{
String token = SecurityUtils.getToken();
if (token == null)
{
throw new NotLoginException("未提供token");
}
LoginUser loginUser = SecurityUtils.getLoginUser();
if (loginUser == null)
{
throw new NotLoginException("无效的token");
}
return loginUser;
}
/**
* 获取当前用户缓存信息, 如果未登录，则抛出异常
*
* @param token 前端传递的认证信息
* @return 用户缓存信息
*/
public LoginUser getLoginUser(String token)
{
return tokenService.getLoginUser(token);
}
/**
* 验证当前用户有效期, 如果相差不足120分钟，自动刷新缓存
*
* @param loginUser 当前用户信息
*/
public void verifyLoginUserExpire(LoginUser loginUser)
{
tokenService.verifyToken(loginUser);
}
/**
* 验证用户是否具备某权限
*
* @param permission 权限字符串
* @return 用户是否具备某权限
*/
public boolean hasPermi(String permission)
{
return hasPermi(getPermiList(), permission);
}
/**
* 验证用户是否具备某权限, 如果验证未通过，则抛出异常: NotPermissionException
*
* @param permission 权限字符串
* @return 用户是否具备某权限
*/
public void checkPermi(String permission)
{
if (!hasPermi(getPermiList(), permission))
{
throw new NotPermissionException(permission);
}
}
/**
* 根据注解(@RequiresPermissions)鉴权, 如果验证未通过，则抛出异常: NotPermissionException
*
* @param requiresPermissions 注解对象
*/
public void checkPermi(RequiresPermissions requiresPermissions)
{
SecurityContextHolder.setPermission(StringUtils.join(requiresPermissions.value(), ","));
if (requiresPermissions.logical() == Logical.AND)
{
checkPermiAnd(requiresPermissions.value());
}
else
{
checkPermiOr(requiresPermissions.value());
}
}
/**
* 验证用户是否含有指定权限，必须全部拥有
*
* @param permissions 权限列表
*/
public void checkPermiAnd(String... permissions)
{
Set<String> permissionList = getPermiList();
for (String permission : permissions)
{
if (!hasPermi(permissionList, permission))
{
throw new NotPermissionException(permission);
}
}
}
/**
* 验证用户是否含有指定权限，只需包含其中一个
*
* @param permissions 权限码数组
*/
public void checkPermiOr(String... permissions)
{
System.out.println(permissions);
Set<String> permissionList = getPermiList();
for (String permission : permissions)
{
if (hasPermi(permissionList, permission))
{
return;
}
}
if (permissions.length > 0)
{
throw new NotPermissionException(permissions);
}
}
/**
* 判断用户是否拥有某个角色
*
* @param role 角色标识
* @return 用户是否具备某角色
*/
public boolean hasRole(String role)
{
return hasRole(getRoleList(), role);
}
/**
* 判断用户是否拥有某个角色, 如果验证未通过，则抛出异常: NotRoleException
*
* @param role 角色标识
*/
public void checkRole(String role)
{
if (!hasRole(role))
{
throw new NotRoleException(role);
}
}
/**
* 根据注解(@RequiresRoles)鉴权
*
* @param requiresRoles 注解对象
*/
public void checkRole(RequiresRoles requiresRoles)
{
if (requiresRoles.logical() == Logical.AND)
{
checkRoleAnd(requiresRoles.value());
}
else
{
checkRoleOr(requiresRoles.value());
}
}
/**
* 验证用户是否含有指定角色，必须全部拥有
*
* @param roles 角色标识数组
*/
public void checkRoleAnd(String... roles)
{
Set<String> roleList = getRoleList();
for (String role : roles)
{
if (!hasRole(roleList, role))
{
throw new NotRoleException(role);
}
}
}
/**
* 验证用户是否含有指定角色，只需包含其中一个
*
* @param roles 角色标识数组
*/
public void checkRoleOr(String... roles)
{
Set<String> roleList = getRoleList();
for (String role : roles)
{
if (hasRole(roleList, role))
{
return;
}
}
if (roles.length > 0)
{
throw new NotRoleException(roles);
}
}
/**
* 根据注解(@RequiresLogin)鉴权
*
* @param at 注解对象
*/
public void checkByAnnotation(RequiresLogin at)
{
this.checkLogin();
}
/**
* 根据注解(@RequiresRoles)鉴权
*
* @param at 注解对象
*/
public void checkByAnnotation(RequiresRoles at)
{
String[] roleArray = at.value();
if (at.logical() == Logical.AND)
{
this.checkRoleAnd(roleArray);
}
else
{
this.checkRoleOr(roleArray);
}
}
/**
* 根据注解(@RequiresPermissions)鉴权
*
* @param at 注解对象
*/
public void checkByAnnotation(RequiresPermissions at)
{
String[] permissionArray = at.value();
if (at.logical() == Logical.AND)
{
this.checkPermiAnd(permissionArray);
}
else
{
this.checkPermiOr(permissionArray);
}
}
/**
* 获取当前账号的角色列表
*
* @return 角色列表
*/
public Set<String> getRoleList()
{
try
{
LoginUser loginUser = getLoginUser();
return loginUser.getRoles();
}
catch (Exception e)
{
return new HashSet<>();
}
}
/**
* 获取当前账号的权限列表
*
* @return 权限列表
*/
public Set<String> getPermiList()
{
try
{
LoginUser loginUser = getLoginUser();
return loginUser.getPermissions();
}
catch (Exception e)
{
return new HashSet<>();
}
}
/**
* 判断是否包含权限
*
* @param authorities 权限列表
* @param permission 权限字符串
* @return 用户是否具备某权限
*/
public boolean hasPermi(Collection<String> authorities, String permission)
{
return authorities.stream().filter(StringUtils::hasText)
.anyMatch(x -> ALL_PERMISSION.equals(x) || PatternMatchUtils.simpleMatch(x, permission));
}
/**
* 判断是否包含角色
*
* @param roles 角色列表
* @param role 角色
* @return 用户是否具备某角色权限
*/
public boolean hasRole(Collection<String> roles, String role)
{
return roles.stream().filter(StringUtils::hasText)
.anyMatch(x -> SUPER_ADMIN.equals(x) || PatternMatchUtils.simpleMatch(x, role));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/auth/AuthLogic.java
|
Java
|
unknown
| 9,494
|
package com.jcm.common.security.auth;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.security.annotation.RequiresRoles;
import com.jcm.system.api.model.LoginUser;
/**
* Token 权限验证工具类
*
* @author junchenmo
*/
public class AuthUtil
{
/**
* 底层的 AuthLogic 对象
*/
public static AuthLogic authLogic = new AuthLogic();
/**
* 会话注销
*/
public static void logout()
{
authLogic.logout();
}
/**
* 会话注销，根据指定Token
*
* @param token 指定token
*/
public static void logoutByToken(String token)
{
authLogic.logoutByToken(token);
}
/**
* 检验当前会话是否已经登录，如未登录，则抛出异常
*/
public static void checkLogin()
{
authLogic.checkLogin();
}
/**
* 获取当前登录用户信息
*
* @param token 指定token
* @return 用户信息
*/
public static LoginUser getLoginUser(String token)
{
return authLogic.getLoginUser(token);
}
/**
* 验证当前用户有效期
*
* @param loginUser 用户信息
*/
public static void verifyLoginUserExpire(LoginUser loginUser)
{
authLogic.verifyLoginUserExpire(loginUser);
}
/**
* 当前账号是否含有指定角色标识, 返回true或false
*
* @param role 角色标识
* @return 是否含有指定角色标识
*/
public static boolean hasRole(String role)
{
return authLogic.hasRole(role);
}
/**
* 当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
*
* @param role 角色标识
*/
public static void checkRole(String role)
{
authLogic.checkRole(role);
}
/**
* 根据注解传入参数鉴权, 如果验证未通过，则抛出异常: NotRoleException
*
* @param requiresRoles 角色权限注解
*/
public static void checkRole(RequiresRoles requiresRoles)
{
authLogic.checkRole(requiresRoles);
}
/**
* 当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
*
* @param roles 角色标识数组
*/
public static void checkRoleAnd(String... roles)
{
authLogic.checkRoleAnd(roles);
}
/**
* 当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
*
* @param roles 角色标识数组
*/
public static void checkRoleOr(String... roles)
{
authLogic.checkRoleOr(roles);
}
/**
* 当前账号是否含有指定权限, 返回true或false
*
* @param permission 权限码
* @return 是否含有指定权限
*/
public static boolean hasPermi(String permission)
{
return authLogic.hasPermi(permission);
}
/**
* 当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException
*
* @param permission 权限码
*/
public static void checkPermi(String permission)
{
authLogic.checkPermi(permission);
}
/**
* 根据注解传入参数鉴权, 如果验证未通过，则抛出异常: NotPermissionException
*
* @param requiresPermissions 权限注解
*/
public static void checkPermi(RequiresPermissions requiresPermissions)
{
authLogic.checkPermi(requiresPermissions);
}
/**
* 当前账号是否含有指定权限 [指定多个，必须全部验证通过]
*
* @param permissions 权限码数组
*/
public static void checkPermiAnd(String... permissions)
{
authLogic.checkPermiAnd(permissions);
}
/**
* 当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
*
* @param permissions 权限码数组
*/
public static void checkPermiOr(String... permissions)
{
authLogic.checkPermiOr(permissions);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/auth/AuthUtil.java
|
Java
|
unknown
| 4,101
|
package com.jcm.common.security.config;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import java.util.TimeZone;
/**
* 系统配置
*
* @author junchenmo
*/
public class ApplicationConfig
{
/**
* 时区配置
*/
@Bean
public Jackson2ObjectMapperBuilderCustomizer jacksonObjectMapperCustomization()
{
return jacksonObjectMapperBuilder -> jacksonObjectMapperBuilder.timeZone(TimeZone.getDefault());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/config/ApplicationConfig.java
|
Java
|
unknown
| 545
|
package com.jcm.common.security.config;
import com.jcm.common.security.interceptor.HeaderInterceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* 拦截器配置
*
* @author junchenmo
*/
@Component
public class WebMvcConfig implements WebMvcConfigurer
{
/** 不需要拦截地址 */
public static final String[] excludeUrls = { "/login", "/logout", "/refresh" };
@Override
public void addInterceptors(InterceptorRegistry registry)
{
registry.addInterceptor(getHeaderInterceptor())
.addPathPatterns("/**")
.excludePathPatterns(excludeUrls)
.order(-10);
}
/**
* 自定义请求头拦截器
*/
public HeaderInterceptor getHeaderInterceptor()
{
return new HeaderInterceptor();
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/config/WebMvcConfig.java
|
Java
|
unknown
| 964
|
package com.jcm.common.security.feign;
import feign.RequestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Feign 配置注册
*
* @author junchenmo
**/
@Configuration
public class FeignAutoConfiguration
{
@Bean
public RequestInterceptor requestInterceptor()
{
return new FeignRequestInterceptor();
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/feign/FeignAutoConfiguration.java
|
Java
|
unknown
| 416
|
package com.jcm.common.security.feign;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.utils.ip.IpUtils;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
/**
* feign 请求拦截器
*
* @author junchenmo
*/
@Component
public class FeignRequestInterceptor implements RequestInterceptor
{
@Override
public void apply(RequestTemplate requestTemplate)
{
HttpServletRequest httpServletRequest = ServletUtils.getRequest();
if (StringUtils.isNotNull(httpServletRequest))
{
Map<String, String> headers = ServletUtils.getHeaders(httpServletRequest);
// 传递用户信息请求头，防止丢失
String userId = headers.get(SecurityConstants.DETAILS_USER_ID);
if (StringUtils.isNotEmpty(userId))
{
requestTemplate.header(SecurityConstants.DETAILS_USER_ID, userId);
}
String userKey = headers.get(SecurityConstants.USER_KEY);
if (StringUtils.isNotEmpty(userKey))
{
requestTemplate.header(SecurityConstants.USER_KEY, userKey);
}
String userName = headers.get(SecurityConstants.DETAILS_USERNAME);
if (StringUtils.isNotEmpty(userName))
{
requestTemplate.header(SecurityConstants.DETAILS_USERNAME, userName);
}
String authentication = headers.get(SecurityConstants.AUTHORIZATION_HEADER);
if (StringUtils.isNotEmpty(authentication))
{
requestTemplate.header(SecurityConstants.AUTHORIZATION_HEADER, authentication);
}
// 配置客户端IP
requestTemplate.header("X-Forwarded-For", IpUtils.getIpAddr());
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/feign/FeignRequestInterceptor.java
|
Java
|
unknown
| 2,011
|
package com.jcm.common.security.handler;
import com.jcm.common.core.constant.HttpStatus;
import com.jcm.common.core.exception.DemoModeException;
import com.jcm.common.core.exception.InnerAuthException;
import com.jcm.common.core.exception.ServiceException;
import com.jcm.common.core.exception.auth.NotPermissionException;
import com.jcm.common.core.exception.auth.NotRoleException;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.web.domain.AjaxResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.BindException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import javax.servlet.http.HttpServletRequest;
/**
* 全局异常处理器
*
* @author junchenmo
*/
@RestControllerAdvice
public class GlobalExceptionHandler
{
private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
/**
* 权限码异常
*/
@ExceptionHandler(NotPermissionException.class)
public AjaxResult handleNotPermissionException(NotPermissionException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',权限码校验失败'{}'", requestURI, e.getMessage());
return AjaxResult.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权");
}
/**
* 角色权限异常
*/
@ExceptionHandler(NotRoleException.class)
public AjaxResult handleNotRoleException(NotRoleException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',角色权限校验失败'{}'", requestURI, e.getMessage());
return AjaxResult.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权");
}
/**
* 请求方式不支持
*/
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public AjaxResult handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod());
return AjaxResult.error(e.getMessage());
}
/**
* 业务异常
*/
@ExceptionHandler(ServiceException.class)
public AjaxResult handleServiceException(ServiceException e, HttpServletRequest request)
{
log.error(e.getMessage(), e);
Integer code = e.getCode();
return StringUtils.isNotNull(code) ? AjaxResult.error(code, e.getMessage()) : AjaxResult.error(e.getMessage());
}
/**
* 请求路径中缺少必需的路径变量
*/
@ExceptionHandler(MissingPathVariableException.class)
public AjaxResult handleMissingPathVariableException(MissingPathVariableException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求路径中缺少必需的路径变量'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(String.format("请求路径中缺少必需的路径变量[%s]", e.getVariableName()));
}
/**
* 请求参数类型不匹配
*/
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
public AjaxResult handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求参数类型不匹配'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(String.format("请求参数类型不匹配，参数[%s]要求类型为：'%s'，但输入值为：'%s'", e.getName(), e.getRequiredType().getName(), e.getValue()));
}
/**
* 拦截未知的运行时异常
*/
@ExceptionHandler(RuntimeException.class)
public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生未知异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
/**
* 系统异常
*/
@ExceptionHandler(Exception.class)
public AjaxResult handleException(Exception e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
/**
* 自定义验证异常
*/
@ExceptionHandler(BindException.class)
public AjaxResult handleBindException(BindException e)
{
log.error(e.getMessage(), e);
String message = e.getAllErrors().get(0).getDefaultMessage();
return AjaxResult.error(message);
}
/**
* 自定义验证异常
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
public Object handleMethodArgumentNotValidException(MethodArgumentNotValidException e)
{
log.error(e.getMessage(), e);
String message = e.getBindingResult().getFieldError().getDefaultMessage();
return AjaxResult.error(message);
}
/**
* 内部认证异常
*/
@ExceptionHandler(InnerAuthException.class)
public AjaxResult handleInnerAuthException(InnerAuthException e)
{
return AjaxResult.error(e.getMessage());
}
/**
* 演示模式异常
*/
@ExceptionHandler(DemoModeException.class)
public AjaxResult handleDemoModeException(DemoModeException e)
{
return AjaxResult.error("演示模式，不允许操作");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/handler/GlobalExceptionHandler.java
|
Java
|
unknown
| 6,000
|
package com.jcm.common.security.interceptor;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.context.SecurityContextHolder;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.security.auth.AuthUtil;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.model.LoginUser;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.AsyncHandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 自定义请求头拦截器，将Header数据封装到线程变量中方便获取
* 注意：此拦截器会同时验证当前用户有效期自动刷新有效期
*
* @author junchenmo
*/
public class HeaderInterceptor implements AsyncHandlerInterceptor
{
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (!(handler instanceof HandlerMethod)){
return true;
}
SecurityContextHolder.setUserId(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USER_ID));
SecurityContextHolder.setUserName(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USERNAME));
SecurityContextHolder.setUserKey(ServletUtils.getHeader(request, SecurityConstants.USER_KEY));
String token = SecurityUtils.getToken();
if (StringUtils.isNotEmpty(token)){
LoginUser loginUser = AuthUtil.getLoginUser(token);
if (StringUtils.isNotNull(loginUser)) {
AuthUtil.verifyLoginUserExpire(loginUser);
SecurityContextHolder.set(SecurityConstants.LOGIN_USER, loginUser);
}
}
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception
{
SecurityContextHolder.remove();
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/interceptor/HeaderInterceptor.java
|
Java
|
unknown
| 2,040
|
package com.jcm.common.security.service;
import com.jcm.common.core.constant.CacheConstants;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.utils.JwtUtils;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.utils.ip.IpUtils;
import com.jcm.common.core.utils.uuid.IdUtils;
import com.jcm.common.redis.service.RedisService;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.model.LoginUser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* token验证处理
*
* @author junchenmo
*/
@Component
public class TokenService
{
private static final Logger log = LoggerFactory.getLogger(TokenService.class);
@Autowired
private RedisService redisService;
protected static final long MILLIS_SECOND = 1000;
protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;
private final static long expireTime = CacheConstants.EXPIRATION;
private final static String ACCESS_TOKEN = CacheConstants.LOGIN_TOKEN_KEY;
private final static Long MILLIS_MINUTE_TEN = CacheConstants.REFRESH_TIME * MILLIS_MINUTE;
/**
* 创建令牌
*/
public Map<String, Object> createToken(LoginUser loginUser)
{
String token = IdUtils.fastUUID();
Long userId = loginUser.getSysUser().getUserId();
String userName = loginUser.getSysUser().getUsername();
loginUser.setToken(token);
loginUser.setUserid(userId);
loginUser.setUsername(userName);
loginUser.setIpaddr(IpUtils.getIpAddr());
refreshToken(loginUser);
// Jwt存储信息
Map<String, Object> claimsMap = new HashMap<String, Object>();
claimsMap.put(SecurityConstants.USER_KEY, token);
claimsMap.put(SecurityConstants.DETAILS_USER_ID, userId);
claimsMap.put(SecurityConstants.DETAILS_USERNAME, userName);
// 接口返回信息
Map<String, Object> rspMap = new HashMap<String, Object>();
rspMap.put("access_token", JwtUtils.createToken(claimsMap));
rspMap.put("expires_in", expireTime);
return rspMap;
}
/**
* 获取用户身份信息
*
* @return 用户信息
*/
public LoginUser getLoginUser()
{
return getLoginUser(ServletUtils.getRequest());
}
/**
* 获取用户身份信息
*
* @return 用户信息
*/
public LoginUser getLoginUser(HttpServletRequest request)
{
// 获取请求携带的令牌
String token = SecurityUtils.getToken(request);
return getLoginUser(token);
}
/**
* 获取用户身份信息
*
* @return 用户信息
*/
public LoginUser getLoginUser(String token)
{
LoginUser user = null;
try
{
if (StringUtils.isNotEmpty(token))
{
String userkey = JwtUtils.getUserKey(token);
user = redisService.getCacheObject(getTokenKey(userkey));
return user;
}
}
catch (Exception e)
{
log.error("获取用户信息异常'{}'", e.getMessage());
}
return user;
}
/**
* 设置用户身份信息
*/
public void setLoginUser(LoginUser loginUser)
{
if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken()))
{
refreshToken(loginUser);
}
}
/**
* 删除用户缓存信息
*/
public void delLoginUser(String token)
{
if (StringUtils.isNotEmpty(token))
{
String userkey = JwtUtils.getUserKey(token);
redisService.deleteObject(getTokenKey(userkey));
}
}
/**
* 验证令牌有效期，相差不足120分钟，自动刷新缓存
*
* @param loginUser
*/
public void verifyToken(LoginUser loginUser)
{
long expireTime = loginUser.getExpireTime();
long currentTime = System.currentTimeMillis();
if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
{
refreshToken(loginUser);
}
}
/**
* 刷新令牌有效期
*
* @param loginUser 登录信息
*/
public void refreshToken(LoginUser loginUser)
{
loginUser.setLoginTime(System.currentTimeMillis());
loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
// 根据uuid将loginUser缓存
String userKey = getTokenKey(loginUser.getToken());
redisService.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
}
private String getTokenKey(String token)
{
return ACCESS_TOKEN + token;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/service/TokenService.java
|
Java
|
unknown
| 5,030
|
package com.jcm.common.security.utils;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.constant.TokenConstants;
import com.jcm.common.core.context.SecurityContextHolder;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.system.api.model.LoginUser;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import javax.servlet.http.HttpServletRequest;
/**
* 权限获取工具类
*
* @author junchenmo
*/
public class SecurityUtils
{
/**
* 获取用户ID
*/
public static Long getUserId()
{
return SecurityContextHolder.getUserId();
}
/**
* 获取用户名称
*/
public static String getUsername()
{
return SecurityContextHolder.getUserName();
}
/**
* 获取用户key
*/
public static String getUserKey()
{
return SecurityContextHolder.getUserKey();
}
/**
* 获取登录用户信息
*/
public static LoginUser getLoginUser()
{
return SecurityContextHolder.get(SecurityConstants.LOGIN_USER, LoginUser.class);
}
/**
* 获取请求token
*/
public static String getToken()
{
return getToken(ServletUtils.getRequest());
}
/**
* 根据request获取请求token
*/
public static String getToken(HttpServletRequest request)
{
// 从header获取token标识
String token = request.getHeader(TokenConstants.AUTHENTICATION);
return replaceTokenPrefix(token);
}
/**
* 裁剪token前缀
*/
public static String replaceTokenPrefix(String token)
{
// 如果前端设置了令牌前缀，则裁剪掉前缀
if (StringUtils.isNotEmpty(token) && token.startsWith(TokenConstants.PREFIX))
{
token = token.replaceFirst(TokenConstants.PREFIX, "");
}
return token;
}
/**
* 是否为管理员
*
* @param userId 用户ID
* @return 结果
*/
public static boolean isAdmin(Long userId)
{
return userId != null && 1L == userId;
}
/**
* 生成BCryptPasswordEncoder密码
*
* @param password 密码
* @return 加密字符串
*/
public static String encryptPassword(String password)
{
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
return passwordEncoder.encode(password);
}
/**
* 判断密码是否相同
*
* @param rawPassword 真实密码
* @param encodedPassword 加密后字符
* @return 结果
*/
public static boolean matchesPassword(String rawPassword, String encodedPassword)
{
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
return passwordEncoder.matches(rawPassword, encodedPassword);
}
public static void main(String[] args) {
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
System.out.println(passwordEncoder.encode("lvshihao"));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-security/src/main/java/com/jcm/common/security/utils/SecurityUtils.java
|
Java
|
unknown
| 3,095
|
package com.jcm.framework.swagger.conf;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.spring.web.plugins.WebMvcRequestHandlerProvider;
import java.lang.reflect.Field;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author lvshihao
*/
@ConditionalOnClass({Docket.class})
@Configuration
@EnableConfigurationProperties(SwaggerProperties.class)
@AutoConfiguration
public class SwaggerConfiguration {
@Bean(value = "api")
public Docket groupRestApi(SwaggerProperties swaggerProperties) {
return new Docket(DocumentationType.SWAGGER_2)
.enable(swaggerProperties.getEnable())
.apiInfo(groupApiInfo(swaggerProperties))
.select()
.apis(RequestHandlerSelectors.basePackage(swaggerProperties.getBasePackage()))
.paths(PathSelectors.any())
.build();
}
private ApiInfo groupApiInfo(SwaggerProperties swaggerProperties){
return new ApiInfoBuilder()
.title(swaggerProperties.getTitle())
.description(swaggerProperties.getDescription())
.licenseUrl(swaggerProperties.getLicenseUrl())
.license(swaggerProperties.getLicense())
.termsOfServiceUrl(swaggerProperties.getUrl())
.contact(new Contact(swaggerProperties.getContact().getName(),swaggerProperties.getContact().getUrl(),swaggerProperties.getContact().getEmail()))
.version(swaggerProperties.getVersion())
.build();
}
/**
* 解决springboot高版本 swagger启动报错
* @return
*/
@Bean
public static BeanPostProcessor springfoxHandlerProviderBeanPostProcessor() {
return new BeanPostProcessor() {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof WebMvcRequestHandlerProvider) {
customizeSpringfoxHandlerMappings(getHandlerMappings(bean));
}
return bean;
}
private <T extends RequestMappingInfoHandlerMapping> void customizeSpringfoxHandlerMappings(List<T> mappings) {
List<T> copy = mappings.stream()
.filter(mapping -> mapping.getPatternParser() == null)
.collect(Collectors.toList());
mappings.clear();
mappings.addAll(copy);
}
@SuppressWarnings("unchecked")
private List<RequestMappingInfoHandlerMapping> getHandlerMappings(Object bean) {
try {
Field field = ReflectionUtils.findField(bean.getClass(), "handlerMappings");
field.setAccessible(true);
return (List<RequestMappingInfoHandlerMapping>) field.get(bean);
} catch (IllegalArgumentException | IllegalAccessException e) {
throw new IllegalStateException(e);
}
}
};
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-swagger/src/main/java/com/jcm/framework/swagger/conf/SwaggerConfiguration.java
|
Java
|
unknown
| 4,032
|
package com.jcm.framework.swagger.conf;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "jcm.swagger.contact")
public class SwaggerContactProperties {
private String name;
private String url;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-swagger/src/main/java/com/jcm/framework/swagger/conf/SwaggerContactProperties.java
|
Java
|
unknown
| 743
|
package com.jcm.framework.swagger.conf;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @author lvshihao
*/
@Component
@ConfigurationProperties(prefix = "jcm.swagger")
@AutoConfiguration
public class SwaggerProperties {
/**
* 标题
*/
private String title;
/**
* 文档描述
*/
private String description;
/**
* url
*/
private String url;
/**
* license
*/
private String license;
/**
* licenseUrl
*/
private String licenseUrl;
/**
* 扫描包的路径
*/
private String basePackage;
/**
* 文档版本
*/
private String version;
/**
* 文档版本
*/
private Boolean enable;
/**
* 联系人信息
*/
private SwaggerContactProperties contact;
public SwaggerContactProperties getContact() {
return contact;
}
public void setContact(SwaggerContactProperties contact) {
this.contact = contact;
}
public Boolean getEnable() {
return enable;
}
public void setEnable(Boolean enable) {
this.enable = enable;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getBasePackage() {
return basePackage;
}
public void setBasePackage(String basePackage) {
this.basePackage = basePackage;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getLicense() {
return license;
}
public void setLicense(String license) {
this.license = license;
}
public String getLicenseUrl() {
return licenseUrl;
}
public void setLicenseUrl(String licenseUrl) {
this.licenseUrl = licenseUrl;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-framework/jcm-spring-boot-starter-swagger/src/main/java/com/jcm/framework/swagger/conf/SwaggerProperties.java
|
Java
|
unknown
| 2,366
|
package com.jcm.gateway;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
/**
* 网关启动程序
*
* @author junchenmo
*/
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class })
public class JcmGatewayApplication
{
public static void main(String[] args)
{
SpringApplication.run(JcmGatewayApplication.class, args);
System.out.println(" (♥◠‿◠)ﾉﾞ 网关启动成功 ლ(´ڡ`ლ)ﾞ ");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/JcmGatewayApplication.java
|
Java
|
unknown
| 608
|
package com.jcm.gateway.config;
import com.google.code.kaptcha.impl.DefaultKaptcha;
import com.google.code.kaptcha.util.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Properties;
import static com.google.code.kaptcha.Constants.*;
/**
* 验证码配置
*
* @author 君尘陌
*/
@Configuration
public class CaptchaConfig
{
@Bean(name = "captchaProducer")
public DefaultKaptcha getKaptchaBean()
{
DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
Properties properties = new Properties();
// 是否有边框 默认为true 我们可以自己设置yes，no
properties.setProperty(KAPTCHA_BORDER, "yes");
// 验证码文本字符颜色 默认为Color.BLACK
properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_COLOR, "black");
// 验证码图片宽度 默认为200
properties.setProperty(KAPTCHA_IMAGE_WIDTH, "160");
// 验证码图片高度 默认为50
properties.setProperty(KAPTCHA_IMAGE_HEIGHT, "60");
// 验证码文本字符大小 默认为40
properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_SIZE, "38");
// KAPTCHA_SESSION_KEY
properties.setProperty(KAPTCHA_SESSION_CONFIG_KEY, "kaptchaCode");
// 验证码文本字符长度 默认为5
properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "4");
// 验证码文本字体样式 默认为new Font("Arial", 1, fontSize), new Font("Courier", 1, fontSize)
properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_NAMES, "Arial,Courier");
// 图片样式 水纹com.google.code.kaptcha.impl.WaterRipple 鱼眼com.google.code.kaptcha.impl.FishEyeGimpy 阴影com.google.code.kaptcha.impl.ShadowGimpy
properties.setProperty(KAPTCHA_OBSCURIFICATOR_IMPL, "com.google.code.kaptcha.impl.ShadowGimpy");
Config config = new Config(properties);
defaultKaptcha.setConfig(config);
return defaultKaptcha;
}
@Bean(name = "captchaProducerMath")
public DefaultKaptcha getKaptchaBeanMath()
{
DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
Properties properties = new Properties();
// 是否有边框 默认为true 我们可以自己设置yes，no
properties.setProperty(KAPTCHA_BORDER, "no");
// 边框颜色 默认为Color.BLACK
properties.setProperty(KAPTCHA_BORDER_COLOR, "105,179,90");
// 验证码文本字符颜色 默认为Color.BLACK
properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_COLOR, "black");
// 验证码图片宽度 默认为200
properties.setProperty(KAPTCHA_IMAGE_WIDTH, "120");
// 验证码图片高度 默认为50
properties.setProperty(KAPTCHA_IMAGE_HEIGHT, "30");
// 验证码文本字符大小 默认为40
properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_SIZE, "25");
// KAPTCHA_SESSION_KEY
properties.setProperty(KAPTCHA_SESSION_CONFIG_KEY, "kaptchaCodeMath");
// 验证码文本生成器
properties.setProperty(KAPTCHA_TEXTPRODUCER_IMPL, "com.jcm.gateway.config.KaptchaTextCreator");
// 验证码文本字符间距 默认为2
properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_SPACE, "3");
// 验证码文本字符长度 默认为5
properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "6");
// 验证码文本字体样式 默认为new Font("Arial", 1, fontSize), new Font("Courier", 1, fontSize)
properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_NAMES, "宋体,楷体,微软雅黑");
// 验证码噪点颜色 默认为Color.BLACK
properties.setProperty(KAPTCHA_NOISE_COLOR, "255,96,0");
// 干扰实现类
properties.setProperty(KAPTCHA_NOISE_IMPL, "com.google.code.kaptcha.impl.NoNoise");
// 图片样式 水纹com.google.code.kaptcha.impl.WaterRipple 鱼眼com.google.code.kaptcha.impl.FishEyeGimpy 阴影com.google.code.kaptcha.impl.ShadowGimpy
properties.setProperty(KAPTCHA_OBSCURIFICATOR_IMPL, "com.jcm.gateway.config.NoWaterRipple");
Config config = new Config(properties);
defaultKaptcha.setConfig(config);
return defaultKaptcha;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/config/CaptchaConfig.java
|
Java
|
unknown
| 4,282
|
package com.jcm.gateway.config;
import com.google.code.kaptcha.text.impl.DefaultTextCreator;
import java.util.Random;
/**
* 验证码文本生成器
*
* @author 君尘陌
*/
public class KaptchaTextCreator extends DefaultTextCreator
{
private static final String[] CNUMBERS = "0,1,2,3,4,5,6,7,8,9,10".split(",");
@Override
public String getText()
{
Integer result = 0;
Random random = new Random();
int x = random.nextInt(10);
int y = random.nextInt(10);
StringBuilder suChinese = new StringBuilder();
int randomoperands = random.nextInt(3);
if (randomoperands == 0)
{
result = x * y;
suChinese.append(CNUMBERS[x]);
suChinese.append("*");
suChinese.append(CNUMBERS[y]);
}
else if (randomoperands == 1)
{
if ((x != 0) && y % x == 0)
{
result = y / x;
suChinese.append(CNUMBERS[y]);
suChinese.append("/");
suChinese.append(CNUMBERS[x]);
}
else
{
result = x + y;
suChinese.append(CNUMBERS[x]);
suChinese.append("+");
suChinese.append(CNUMBERS[y]);
}
}
else if (randomoperands == 2)
{
if (x >= y)
{
result = x - y;
suChinese.append(CNUMBERS[x]);
suChinese.append("-");
suChinese.append(CNUMBERS[y]);
}
else
{
result = y - x;
suChinese.append(CNUMBERS[y]);
suChinese.append("-");
suChinese.append(CNUMBERS[x]);
}
}
else
{
result = x + y;
suChinese.append(CNUMBERS[x]);
suChinese.append("+");
suChinese.append(CNUMBERS[y]);
}
suChinese.append("=?@" + result);
return suChinese.toString();
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/config/KaptchaTextCreator.java
|
Java
|
unknown
| 2,071
|
package com.jcm.gateway.config;
import com.google.code.kaptcha.GimpyEngine;
import com.google.code.kaptcha.util.Configurable;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
public class NoWaterRipple extends Configurable implements GimpyEngine {
public NoWaterRipple(){}
@Override
public BufferedImage getDistortedImage(BufferedImage baseImage) {
BufferedImage distortedImage = new BufferedImage(baseImage.getWidth(), baseImage.getHeight(), 2);
Graphics2D graphics = (Graphics2D)distortedImage.getGraphics();
graphics.drawImage(baseImage, 0, 0, (Color)null, (ImageObserver)null);
graphics.dispose();
return distortedImage;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/config/NoWaterRipple.java
|
Java
|
unknown
| 733
|
package com.jcm.gateway.config;
import com.jcm.gateway.handler.ValidateCodeHandler;
import lombok.AllArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
/**
* 路由配置信息
*
* @author 君尘陌
*/
@Configuration
@AllArgsConstructor
public class RouterFunctionConfiguration
{
/**
* 获取验证码的请求处理类
*/
private final ValidateCodeHandler validateCodeHandler;
/**
* Spring 5的RouterFunction函数式编程模式
* 这里配置
* /code = 获取验证码
*/
@SuppressWarnings("rawtypes")
@Bean
public RouterFunction routerFunction()
{
return RouterFunctions.route(
RequestPredicates.GET("/code").and(RequestPredicates.accept(MediaType.TEXT_PLAIN)),
validateCodeHandler);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/config/RouterFunctionConfiguration.java
|
Java
|
unknown
| 1,144
|
package com.jcm.gateway.config.properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
/**
* 验证码配置
*
* @author 君尘陌
*/
@Configuration
@RefreshScope
@ConfigurationProperties(prefix = "security.captcha")
public class CaptchaProperties
{
/**
* 验证码开关
*/
private Boolean enabled;
/**
* 验证码类型（math 数组计算 char 字符）
*/
private String type;
public Boolean getEnabled()
{
return enabled;
}
public void setEnabled(Boolean enabled)
{
this.enabled = enabled;
}
public String getType()
{
return type;
}
public void setType(String type)
{
this.type = type;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/config/properties/CaptchaProperties.java
|
Java
|
unknown
| 889
|
package com.jcm.gateway.config.properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
/**
* 放行白名单配置
*
* @author 君尘陌
*/
@Configuration
@RefreshScope
@ConfigurationProperties(prefix = "security.ignore")
public class IgnoreWhiteProperties
{
/**
* 放行白名单配置，网关不校验此处的白名单
*/
private List<String> whites = new ArrayList<>();
public List<String> getWhites()
{
return whites;
}
public void setWhites(List<String> whites)
{
this.whites = whites;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/config/properties/IgnoreWhiteProperties.java
|
Java
|
unknown
| 781
|
package com.jcm.gateway.filter;
import com.jcm.common.core.constant.CacheConstants;
import com.jcm.common.core.constant.HttpStatus;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.constant.TokenConstants;
import com.jcm.common.core.utils.JwtUtils;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.redis.service.RedisService;
import com.jcm.gateway.config.properties.IgnoreWhiteProperties;
import io.jsonwebtoken.Claims;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
/**
* 网关鉴权
*
* @author junchenmo
*/
@Component
public class AuthFilter implements GlobalFilter, Ordered
{
private static final Logger log = LoggerFactory.getLogger(AuthFilter.class);
// 排除过滤的 uri 地址，nacos自行添加
@Autowired
private IgnoreWhiteProperties ignoreWhite;
@Autowired
private RedisService redisService;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain)
{
ServerHttpRequest request = exchange.getRequest();
ServerHttpRequest.Builder mutate = request.mutate();
String url = request.getURI().getPath();
// 跳过不需要验证的路径
if (StringUtils.matches(url, ignoreWhite.getWhites()))
{
return chain.filter(exchange);
}
String token = getToken(request);
if (StringUtils.isEmpty(token))
{
return unauthorizedResponse(exchange, "令牌不能为空");
}
Claims claims = JwtUtils.parseToken(token);
if (claims == null)
{
return unauthorizedResponse(exchange, "令牌已过期或验证不正确！");
}
String userkey = JwtUtils.getUserKey(claims);
boolean islogin = redisService.hasKey(getTokenKey(userkey));
if (!islogin)
{
return unauthorizedResponse(exchange, "登录状态已过期");
}
String userid = JwtUtils.getUserId(claims);
String username = JwtUtils.getUserName(claims);
if (StringUtils.isEmpty(userid) || StringUtils.isEmpty(username))
{
return unauthorizedResponse(exchange, "令牌验证失败");
}
// 设置用户信息到请求
addHeader(mutate, SecurityConstants.USER_KEY, userkey);
addHeader(mutate, SecurityConstants.DETAILS_USER_ID, userid);
addHeader(mutate, SecurityConstants.DETAILS_USERNAME, username);
// 内部请求来源参数清除
removeHeader(mutate, SecurityConstants.FROM_SOURCE);
return chain.filter(exchange.mutate().request(mutate.build()).build());
}
private void addHeader(ServerHttpRequest.Builder mutate, String name, Object value)
{
if (value == null)
{
return;
}
String valueStr = value.toString();
String valueEncode = ServletUtils.urlEncode(valueStr);
mutate.header(name, valueEncode);
}
private void removeHeader(ServerHttpRequest.Builder mutate, String name)
{
mutate.headers(httpHeaders -> httpHeaders.remove(name)).build();
}
private Mono<Void> unauthorizedResponse(ServerWebExchange exchange, String msg)
{
log.error("[鉴权异常处理]请求路径:{}", exchange.getRequest().getPath());
return ServletUtils.webFluxResponseWriter(exchange.getResponse(), msg, HttpStatus.UNAUTHORIZED);
}
/**
* 获取缓存key
*/
private String getTokenKey(String token)
{
return CacheConstants.LOGIN_TOKEN_KEY + token;
}
/**
* 获取请求token
*/
private String getToken(ServerHttpRequest request)
{
String token = request.getHeaders().getFirst(TokenConstants.AUTHENTICATION);
// 如果前端设置了令牌前缀，则裁剪掉前缀
if (StringUtils.isNotEmpty(token) && token.startsWith(TokenConstants.PREFIX))
{
token = token.replaceFirst(TokenConstants.PREFIX, StringUtils.EMPTY);
}
return token;
}
@Override
public int getOrder()
{
return -200;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/filter/AuthFilter.java
|
Java
|
unknown
| 4,625
|
package com.jcm.gateway.filter;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpMethod;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.net.URI;
import java.nio.CharBuffer;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/***
* @ClassName: MyGlobalFilter
* @Description: 自定义gateway全局过滤器, 全局过滤器无需配置, 对所有的路由都生效
* @Author: TKQ
* @Create_time: 14:30 2021-03-02
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class CacheRequestFilter implements GlobalFilter, Ordered {
/**
* 请求频率限制时间
*/
private static final Integer OFFSET = 3;
@SneakyThrows
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
//获取当前请求的url
String requestUrl = exchange.getRequest().getURI().toString();
if (requestUrl.contains("chat-record/timCallBack")) {
log.debug("{} 请求进入 {}", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")), requestUrl);
}
//TODO 校验token合法性等等,自定义逻辑
ServerHttpRequest serverHttpRequest = exchange.getRequest();
String methodName = serverHttpRequest.getMethodValue();
String contentType = serverHttpRequest.getHeaders().getFirst("Content-Type");
URI uri = serverHttpRequest.getURI();
//post请求拦截判断重复调用
if (HttpMethod.POST.name().equals(methodName) && contentType != null && !contentType.startsWith("multipart/form-data")) {
AtomicReference<String> bodyRef = new AtomicReference<>();
return DataBufferUtils.join(exchange.getRequest().getBody())
.flatMap(dataBuffer -> {
CharBuffer charBuffer = StandardCharsets.UTF_8.decode(dataBuffer.asByteBuffer());
DataBufferUtils.retain(dataBuffer);
bodyRef.set(charBuffer.toString());
String bodyStr = formatStr(bodyRef.get());
Flux<DataBuffer> cachedFlux = Flux
.defer(() -> Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
log.info("请求拦截器; url={}", uri.toString());
// 封装 request，传给下一级
ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(
exchange.getRequest()) {
@Override
public Flux<DataBuffer> getBody() {
return cachedFlux;
}
};
return chain.filter(exchange.mutate().request(mutatedRequest).build());
});
}
// 放行请求
return chain.filter(exchange);
}
/**
* 去掉空格,换行和制表符
* @param str
* @return
*/
private static String formatStr(String str) {
if (str != null && str.length() > 0) {
Pattern p = Pattern.compile("\\s*|\t|\r|\n");
Matcher m = p.matcher(str);
return m.replaceAll("");
}
return str;
}
@Override
public int getOrder() {
// 设置最高级别, 优先执行该过滤器, 防止gateway读取body后后续的过滤器不能正常获取body
return Ordered.HIGHEST_PRECEDENCE;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/filter/CacheRequestFilter.java
|
Java
|
unknown
| 4,326
|
package com.jcm.gateway.filter;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.gateway.config.properties.CaptchaProperties;
import com.jcm.gateway.service.ValidateCodeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import java.nio.charset.StandardCharsets;
/**
* 验证码过滤器
*
* @author 君尘陌
*/
@Component
public class ValidateCodeFilter extends AbstractGatewayFilterFactory<Object>
{
private final static String[] VALIDATE_URL = new String[] { "/auth/login", "/auth/register" };
@Autowired
private ValidateCodeService validateCodeService;
@Autowired
private CaptchaProperties captchaProperties;
private static final String CODE = "code";
private static final String UUID = "uuid";
@Override
public GatewayFilter apply(Object config)
{
return (exchange, chain) -> {
ServerHttpRequest request = exchange.getRequest();
// 非登录/注册请求或验证码关闭，不处理
if (!StringUtils.equalsAnyIgnoreCase(request.getURI().getPath(), VALIDATE_URL) || !captchaProperties.getEnabled())
{
return chain.filter(exchange);
}
try
{
String rspStr = resolveBodyFromRequest(request);
JSONObject obj = JSON.parseObject(rspStr);
validateCodeService.checkCaptcha(obj.getString(CODE), obj.getString(UUID));
}
catch (Exception e)
{
return ServletUtils.webFluxResponseWriter(exchange.getResponse(), e.getMessage());
}
return chain.filter(exchange);
};
}
private String resolveBodyFromRequest(ServerHttpRequest serverHttpRequest)
{
//获取请求体
Flux<DataBuffer> body = serverHttpRequest.getBody();
StringBuilder sb = new StringBuilder();
body.subscribe(buffer -> {
byte[] bytes = new byte[buffer.readableByteCount()];
buffer.read(bytes);
String bodyString = new String(bytes, StandardCharsets.UTF_8);
sb.append(bodyString);
});
return formatStr(sb.toString());
}
private String formatStr(String str) {
return str.trim().replaceAll("\\s+", "");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/filter/ValidateCodeFilter.java
|
Java
|
unknown
| 2,793
|
package com.jcm.gateway.handler;
import com.jcm.common.core.exception.CaptchaException;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.gateway.service.ValidateCodeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.HandlerFunction;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
import java.io.IOException;
/**
* 验证码获取处理类
*
* @author 君尘陌
*/
@Component
public class ValidateCodeHandler implements HandlerFunction<ServerResponse>
{
@Autowired
private ValidateCodeService validateCodeService;
@Override
public Mono<ServerResponse> handle(ServerRequest serverRequest)
{
AjaxResult ajax;
try
{
ajax = validateCodeService.createCaptcha();
}
catch (CaptchaException | IOException e)
{
return Mono.error(e);
}
return ServerResponse.status(HttpStatus.OK).body(BodyInserters.fromValue(ajax));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/handler/ValidateCodeHandler.java
|
Java
|
unknown
| 1,312
|
package com.jcm.gateway.service;
import com.jcm.common.core.exception.CaptchaException;
import com.jcm.common.core.web.domain.AjaxResult;
import java.io.IOException;
/**
* 验证码处理
*
* @author 君尘陌
*/
public interface ValidateCodeService
{
/**
* 生成验证码
*/
public AjaxResult createCaptcha() throws IOException, CaptchaException;
/**
* 校验验证码
*/
public void checkCaptcha(String key, String value) throws CaptchaException;
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/service/ValidateCodeService.java
|
Java
|
unknown
| 496
|
package com.jcm.gateway.service.impl;
import com.google.code.kaptcha.Producer;
import com.jcm.common.core.constant.CacheConstants;
import com.jcm.common.core.constant.Constants;
import com.jcm.common.core.exception.CaptchaException;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.utils.sign.Base64;
import com.jcm.common.core.utils.uuid.IdUtils;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.redis.service.RedisService;
import com.jcm.gateway.config.properties.CaptchaProperties;
import com.jcm.gateway.service.ValidateCodeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.FastByteArrayOutputStream;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
/**
* 验证码实现处理
*
* @author 君尘陌
*/
@Service
public class ValidateCodeServiceImpl implements ValidateCodeService
{
@Resource(name = "captchaProducer")
private Producer captchaProducer;
@Resource(name = "captchaProducerMath")
private Producer captchaProducerMath;
@Autowired
private RedisService redisService;
@Autowired
private CaptchaProperties captchaProperties;
/**
* 生成验证码
*/
@Override
public AjaxResult createCaptcha() throws IOException, CaptchaException
{
AjaxResult ajax = AjaxResult.success();
boolean captchaEnabled = captchaProperties.getEnabled();
ajax.put("captchaEnabled", captchaEnabled);
if (!captchaEnabled)
{
return ajax;
}
// 保存验证码信息
String uuid = IdUtils.simpleUUID();
String verifyKey = CacheConstants.CAPTCHA_CODE_KEY + uuid;
String capStr = null, code = null;
BufferedImage image = null;
String captchaType = captchaProperties.getType();
// 生成验证码
if ("math".equals(captchaType))
{
String capText = captchaProducerMath.createText();
capStr = capText.substring(0, capText.lastIndexOf("@"));
code = capText.substring(capText.lastIndexOf("@") + 1);
image = captchaProducerMath.createImage(capStr);
}
else if ("char".equals(captchaType))
{
capStr = code = captchaProducer.createText();
image = captchaProducer.createImage(capStr);
}
//设置验证码的超时时间是2分钟
redisService.setCacheObject(verifyKey, code, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);
// 转换流信息写出
FastByteArrayOutputStream os = new FastByteArrayOutputStream();
try
{
ImageIO.write(image, "jpg", os);
}
catch (IOException e)
{
return AjaxResult.error(e.getMessage());
}
ajax.put("uuid", uuid);
ajax.put("img", Base64.encode(os.toByteArray()));
return ajax;
}
/**
* 校验验证码
*/
@Override
public void checkCaptcha(String code, String uuid) throws CaptchaException
{
if (StringUtils.isEmpty(code))
{
throw new CaptchaException("验证码不能为空");
}
if (StringUtils.isEmpty(uuid))
{
throw new CaptchaException("验证码已失效");
}
String verifyKey = CacheConstants.CAPTCHA_CODE_KEY + uuid;
String captcha = redisService.getCacheObject(verifyKey);
redisService.deleteObject(verifyKey);
if (!code.equalsIgnoreCase(captcha))
{
throw new CaptchaException("验证码错误");
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-gateway/src/main/java/com/jcm/gateway/service/impl/ValidateCodeServiceImpl.java
|
Java
|
unknown
| 3,781
|
package com.jcm.auth;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @author lvshihao
*/
@EnableFeignClients("com.jcm.system.api")
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class })
public class JcmAuthApplication {
public static void main(String[] args)
{
SpringApplication.run(JcmAuthApplication.class, args);
System.out.println(" (♥◠‿◠)ﾉﾞ 认证授权中心启动成功 ლ(´ڡ`ლ)ﾞ ");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/JcmAuthApplication.java
|
Java
|
unknown
| 689
|
package com.jcm.auth.controller;
import com.jcm.auth.form.LoginBody;
import com.jcm.auth.service.SysLoginService;
import com.jcm.common.core.domain.R;
import com.jcm.common.core.utils.JwtUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.security.auth.AuthUtil;
import com.jcm.common.security.service.TokenService;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.model.LoginUser;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
@Api(tags="认证服务")
@RestController
@AllArgsConstructor
public class TokenController {
private final TokenService tokenService;
private final SysLoginService sysLoginService;
@ApiOperation(value = "用户登录", notes = "登录用户并创建JWT TOKEN返回")
@PostMapping("/login")
public R<?> login(@RequestBody LoginBody form) {
// 用户登录
LoginUser userInfo = sysLoginService.login(form.getUsername(), form.getPassword());
// 获取登录token
return R.ok(tokenService.createToken(userInfo));
}
@ApiOperation(value = "用户登出", notes = "退出登录，删除TOKEN")
@DeleteMapping("/logout")
public R<?> logout(HttpServletRequest request) {
String token = SecurityUtils.getToken(request);
if (StringUtils.isNotEmpty(token)) {
String username = JwtUtils.getUserName(token);
// 删除用户缓存记录
AuthUtil.logoutByToken(token);
}
return R.ok();
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/controller/TokenController.java
|
Java
|
unknown
| 1,858
|
package com.jcm.auth.form;
/**
* 用户登录对象
*
* @author junchenmo
*/
public class LoginBody
{
/**
* 用户名
*/
private String username;
/**
* 用户密码
*/
private String password;
public String getUsername()
{
return username;
}
public void setUsername(String username)
{
this.username = username;
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/form/LoginBody.java
|
Java
|
unknown
| 562
|
package com.jcm.auth.form;
/**
* 用户注册对象
*
* @author junchenmo
*/
public class RegisterBody extends LoginBody
{
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/form/RegisterBody.java
|
Java
|
unknown
| 132
|
package com.jcm.auth.service;
import com.jcm.common.core.constant.CacheConstants;
import com.jcm.common.core.constant.Constants;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.constant.UserConstants;
import com.jcm.common.core.domain.R;
import com.jcm.common.core.enums.UserStatus;
import com.jcm.common.core.exception.ServiceException;
import com.jcm.common.core.text.Convert;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.utils.ip.IpUtils;
import com.jcm.common.redis.service.RedisService;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.RemoteUserService;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.api.model.LoginUser;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* 登录校验方法
*
* @author junchenmo
*/
@Component
@AllArgsConstructor
public class SysLoginService
{
private final RemoteUserService remoteUserService;
private final SysRecordLogService recordLogService;
private final SysPasswordService passwordService;
private final RedisService redisService;
/**
* 登录
*/
public LoginUser login(String username, String password)
{
// 用户名或密码为空 错误
if (StringUtils.isAnyBlank(username, password))
{
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "用户/密码必须填写");
throw new ServiceException("用户/密码必须填写");
}
// 密码如果不在指定范围内 错误
if (password.length() < UserConstants.PASSWORD_MIN_LENGTH
|| password.length() > UserConstants.PASSWORD_MAX_LENGTH)
{
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "用户密码不在指定范围");
throw new ServiceException("用户密码不在指定范围");
}
// 用户名不在指定范围内 错误
if (username.length() < UserConstants.USERNAME_MIN_LENGTH
|| username.length() > UserConstants.USERNAME_MAX_LENGTH)
{
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "用户名不在指定范围");
throw new ServiceException("用户名不在指定范围");
}
// IP黑名单校验
String blackStr = Convert.toStr(redisService.getCacheObject(CacheConstants.SYS_LOGIN_BLACKIPLIST));
if (IpUtils.isMatchedIp(blackStr, IpUtils.getIpAddr()))
{
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "很遗憾，访问IP已被列入系统黑名单");
throw new ServiceException("很遗憾，访问IP已被列入系统黑名单");
}
// 查询用户信息
R<LoginUser> userResult = remoteUserService.getUserInfo(username, SecurityConstants.INNER);
if (StringUtils.isNull(userResult) || StringUtils.isNull(userResult.getData()))
{
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "登录用户不存在");
throw new ServiceException("登录用户：" + username + " 不存在");
}
if (R.FAIL == userResult.getCode())
{
throw new ServiceException(userResult.getMsg());
}
LoginUser userInfo = userResult.getData();
SysUser sysUser = userResult.getData().getSysUser();
if (UserStatus.DISABLE.getCode().equals(sysUser.getStatus().toString()))
{
recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, "用户已停用，请联系管理员");
throw new ServiceException("对不起，您的账号：" + username + " 已停用");
}
passwordService.validate(sysUser, password);
// 设置用户最后登录的时间和IP
sysUser.setLoginDate(LocalDateTime.now());
sysUser.setLoginIp(IpUtils.getHostIp());
remoteUserService.changeLoginInfo(sysUser, SecurityConstants.INNER);
recordLogService.recordLogininfor(username, Constants.LOGIN_SUCCESS, "登录成功");
return userInfo;
}
// public void logout(String loginName)
// {
// recordLogService.recordLogininfor(loginName, Constants.LOGOUT, "退出成功");
// }
/**
* 注册
*/
public void register(String username, String password)
{
// 用户名或密码为空 错误
if (StringUtils.isAnyBlank(username, password))
{
throw new ServiceException("用户/密码必须填写");
}
if (username.length() < UserConstants.USERNAME_MIN_LENGTH
|| username.length() > UserConstants.USERNAME_MAX_LENGTH)
{
throw new ServiceException("账户长度必须在2到20个字符之间");
}
if (password.length() < UserConstants.PASSWORD_MIN_LENGTH
|| password.length() > UserConstants.PASSWORD_MAX_LENGTH)
{
throw new ServiceException("密码长度必须在5到20个字符之间");
}
// 注册用户信息
SysUser sysUser = new SysUser();
sysUser.setUsername(username);
sysUser.setNickname(username);
sysUser.setPassword(SecurityUtils.encryptPassword(password));
R<?> registerResult = remoteUserService.registerUserInfo(sysUser, SecurityConstants.INNER);
if (R.FAIL == registerResult.getCode())
{
throw new ServiceException(registerResult.getMsg());
}
// recordLogService.recordLogininfor(username, Constants.REGISTER, "注册成功");
}
public void logout(String loginName)
{
// recordLogService.recordLogininfor(loginName, Constants.LOGOUT, "退出成功");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/service/SysLoginService.java
|
Java
|
unknown
| 5,819
|
package com.jcm.auth.service;
import com.jcm.common.core.constant.CacheConstants;
import com.jcm.common.core.exception.ServiceException;
import com.jcm.common.redis.service.RedisService;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.domain.SysUser;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* 登录密码方法
*
* @author junchenmo
*/
@Component
public class SysPasswordService
{
public SysPasswordService(RedisService redisService) {
this.redisService = redisService;
}
private final RedisService redisService;
private int maxRetryCount = CacheConstants.PASSWORD_MAX_RETRY_COUNT;
private Long lockTime = CacheConstants.PASSWORD_LOCK_TIME;
/**
* 登录账户密码错误次数缓存键名
*
* @param username 用户名
* @return 缓存键key
*/
private String getCacheKey(String username)
{
return CacheConstants.PWD_ERR_CNT_KEY + username;
}
public void validate(SysUser sysUser, String password)
{
String username = sysUser.getUsername();
Integer retryCount = redisService.getCacheObject(getCacheKey(username));
if (retryCount == null)
{
retryCount = 0;
}
if (retryCount >= Integer.valueOf(maxRetryCount).intValue())
{
String errMsg = String.format("密码输入错误%s次，帐户锁定%s分钟", maxRetryCount, lockTime);
// recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL,errMsg);
throw new ServiceException(errMsg);
}
if (!matches(sysUser, password))
{
retryCount = retryCount + 1;
// recordLogService.recordLogininfor(username, Constants.LOGIN_FAIL, String.format("密码输入错误%s次", retryCount));
redisService.setCacheObject(getCacheKey(username), retryCount, lockTime, TimeUnit.MINUTES);
throw new ServiceException("用户不存在/密码错误");
}
else
{
clearLoginRecordCache(username);
}
}
public boolean matches(SysUser sysUser, String rawPassword)
{
return SecurityUtils.matchesPassword(rawPassword, sysUser.getPassword());
}
public void clearLoginRecordCache(String loginName)
{
if (redisService.hasKey(getCacheKey(loginName)))
{
redisService.deleteObject(getCacheKey(loginName));
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/service/SysPasswordService.java
|
Java
|
unknown
| 2,507
|
package com.jcm.auth.service;
import com.jcm.common.core.constant.Constants;
import com.jcm.common.core.constant.SecurityConstants;
import com.jcm.common.core.utils.ServletUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.utils.ip.IpUtils;
import com.jcm.system.api.RemoteLogService;
import com.jcm.system.api.domain.SysLogininfor;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
/**
* 记录日志方法
*
* @author junchenmo
*/
@Component
@AllArgsConstructor
public class SysRecordLogService
{
private final RemoteLogService remoteLogService;
/**
* 记录登录信息
*
* @param username 用户名
* @param status 状态
* @param message 消息内容
* @return
*/
public void recordLogininfor(String username, String status, String message)
{
HttpServletRequest request = ServletUtils.getRequest();
SysLogininfor logininfor = new SysLogininfor();
logininfor.setUserName(username);
logininfor.setIpaddr(IpUtils.getIpAddr());
String cityInfo = IpUtils.getCityInfo(IpUtils.getIpAddr());
if(StringUtils.isNotEmpty(cityInfo)&&cityInfo.split("\\|").length==5){
String[] cityInfoArr = cityInfo.split("\\|");
StringBuffer stringBuffer=new StringBuffer();
stringBuffer.append(cityInfoArr[0] + "-")
.append(cityInfoArr[2] + "-")
.append(cityInfoArr[3] + "-")
.append("("+cityInfoArr[4]+")");
logininfor.setLoginLocation(stringBuffer.toString());
}
logininfor.setMsg(message);
// 获取当前时间作为请求时间
LocalDateTime requestTime = LocalDateTime.now();
logininfor.setLoginTime(requestTime);
// 从请求头中获取User-Agent信息来解析浏览器相关信息
String userAgent = request.getHeader("User-Agent");
String browserInfo = parseBrowserInfo(userAgent);
logininfor.setBrowser(browserInfo);
// 尝试获取操作系统相关信息（从User-Agent等信息中解析，简单示例，可能不准确）
String operatingSystem = parseOperatingSystemInfo(userAgent);
logininfor.setOs(operatingSystem);
// 日志状态
if (StringUtils.equalsAny(status, Constants.LOGIN_SUCCESS, Constants.LOGOUT, Constants.REGISTER))
{
logininfor.setStatus(Constants.LOGIN_SUCCESS_STATUS);
}
else if (Constants.LOGIN_FAIL.equals(status))
{
logininfor.setStatus(Constants.LOGIN_FAIL_STATUS);
}
remoteLogService.saveLogininfor(logininfor, SecurityConstants.INNER);
}
private String parseBrowserInfo(String userAgent) {
if (userAgent == null) {
return "未知浏览器";
}
// 简单示例，可根据实际需求使用更完善的解析库来准确判断浏览器类型和版本等信息
if (userAgent.contains("Chrome")) {
return "Chrome浏览器";
} else if (userAgent.contains("Firefox")) {
return "Firefox浏览器";
} else if (userAgent.contains("Safari")) {
return "Safari浏览器";
}
return "其他浏览器";
}
private String parseOperatingSystemInfo(String userAgent) {
if (userAgent == null) {
return "未知操作系统";
}
// 简单示例，可根据实际需求使用更完善的解析库来准确判断操作系统类型等信息
if (userAgent.contains("Windows")) {
return "Windows操作系统";
} else if (userAgent.contains("Mac OS")) {
return "Mac OS操作系统";
} else if (userAgent.contains("Linux")) {
return "Linux操作系统";
}
return "其他操作系统";
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-auth/src/main/java/com/jcm/auth/service/SysRecordLogService.java
|
Java
|
unknown
| 3,973
|
package com.jcm.doc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* doc启动程序
*
* @author junchenmo
*/
@SpringBootApplication
public class JcmDocApplication
{
public static void main(String[] args)
{
SpringApplication.run(JcmDocApplication.class, args);
System.out.println(" (♥◠‿◠)ﾉﾞ doc动成功 ლ(´ڡ`ლ)ﾞ ");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-doc/src/main/java/com/jcm/doc/JcmDocApplication.java
|
Java
|
unknown
| 458
|
package com.jcm.gen;
import com.jcm.common.security.annotation.EnableCustomConfig;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @author lvshihao
*/
@EnableFeignClients("com.jcm.system.api")
@MapperScan("com.jcm.gen.mapper")
@EnableCustomConfig
@SpringBootApplication
public class JcmGenApplication {
public static void main(String[] args)
{
SpringApplication.run(JcmGenApplication.class, args);
System.out.println(" (♥◠‿◠)ﾉﾞ 系统模块启动成功 ლ(´ڡ`ლ)ﾞ ");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/JcmGenApplication.java
|
Java
|
unknown
| 715
|
package com.jcm.gen.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 代码生成相关配置
*
* @author junchenmo
*/
@Component
@ConfigurationProperties(prefix = "jcm.gen")
public class GenConfig
{
/** 作者 */
public static String author;
/** 生成包路径 */
public static String packageName;
/** 自动去除表前缀，默认是false */
public static boolean autoRemovePre;
/** 表前缀(类名不会包含表前缀) */
public static String tablePrefix;
public static String getAuthor()
{
return author;
}
public void setAuthor(String author)
{
GenConfig.author = author;
}
public static String getPackageName()
{
return packageName;
}
public void setPackageName(String packageName)
{
GenConfig.packageName = packageName;
}
public static boolean getAutoRemovePre()
{
return autoRemovePre;
}
public void setAutoRemovePre(boolean autoRemovePre)
{
GenConfig.autoRemovePre = autoRemovePre;
}
public static String getTablePrefix()
{
return tablePrefix;
}
public void setTablePrefix(String tablePrefix)
{
GenConfig.tablePrefix = tablePrefix;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/config/GenConfig.java
|
Java
|
unknown
| 1,349
|
package com.jcm.gen.configuration;
import com.alibaba.dashscope.aigc.conversation.Conversation;
import com.alibaba.dashscope.aigc.conversation.ConversationParam;
import com.alibaba.dashscope.aigc.conversation.ConversationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.fastjson2.JSONObject;
import com.jcm.common.redis.service.RedisService;
import io.reactivex.Flowable;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author lvshihao
*/
@Component
@AllArgsConstructor
public class TableGeneratorConfig {
private final TableGeneratorProperties properties;
private final RedisService redisService;
/**
* 系统生成表的消息内容配置
*/
private static final String SYSTEM_TABLE_MESSAGE_CONTENT = "{" +
" id: number\n" +
" name: string | undefined\n" +
" type: string | undefined\n" +
" length: number | undefined\n" +
" point: number | undefined\n" +
" notNull: boolean\n" +
" primaryKey: boolean\n" +
" comment: string\n" +
"}你是一个专业的mysql数据库管理员，你可以生成所有描述场景的表结构而且非常详细，结构是Json数组类型，name是列的名称，" +
"type是列的类型(类型名称小写),length是列数据的长度,point是列的小数点位数,notNull代表这个字段不能为空,primaryKey代表这是主键,comment是列的注释。最后要求只需要给我json数组的数据，要求是纯文本json字符串,除此以外不要返回任何数据。";
/**
* 系统生成Sql的消息内容配置
*/
private static final String SYSTEM_TABLE_SQL_MESSAGE_CONTENT = "" +
"你是一个专业的mysql数据库管理员，按照我给你数据表的JSON数组数据生成创建表的Sql语句，每一个json都是一行列的信息，name是列的名称，" +
"type是列的类型(类型名称小写),length是列数据的长度,point是列的小数点位数,notNull代表这个字段不能为空,primaryKey代表这是主键,comment是列的注释。最后要求只需要给我创建表的sql语句，要求是纯文本sql字符串,除此以外不要返回任何数据。";
/**
* 根据给定的表名称生成相应的MySQL表结构的JSON数组数据
*
* @param prompts 要生成表结构的prompts
* @return 生成的表结构对应的JSON数组数据，如果出现异常则返回null
*/
public HashMap<String,String> generateTableStructure(String prompts) throws ApiException{
try {
HashMap<String,String> data = new HashMap<>();
String[] split = prompts.split("\\|jcm\\|");
//第二次请求
if(split.length==2 && redisService.hasKey("aiTable:"+split[0])){
String requestId = split[0];
return handleQuestionPrompts(requestId, prompts, data, true);
}else{
return handleQuestionPrompts(null, prompts, data, false);
}
} catch (ApiException | NoApiKeyException | InputRequiredException e) {
System.err.println("错误信息：" + e.getMessage());
System.out.println("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code");
return null;
}
}
private HashMap<String,String> handleQuestionPrompts(String requestId, String prompts, HashMap<String,String> data, boolean isAfterward) throws NoApiKeyException, InputRequiredException {
List<JSONObject> messageList = new ArrayList<>();
if (isAfterward) {
// 获取上一次的消息集合
messageList = redisService.getCacheList("aiTable:"+requestId);
} else {
// 添加系统消息
JSONObject system = new JSONObject();
system.put("role", Role.SYSTEM.getValue());
system.put("content", SYSTEM_TABLE_MESSAGE_CONTENT);
messageList.add(system);
}
// 添加用户消息
JSONObject user = new JSONObject();
user.put("role", Role.USER.getValue());
user.put("content", prompts);
messageList.add(user);
// 将jsonObj转换成Message
List<Message> messages = new ArrayList<>();
messageList.stream().forEach(jsonObject -> {
Message message = new Message();
message.setRole(String.valueOf(jsonObject.get("role")));
message.setContent(String.valueOf(jsonObject.get("content")));
messages.add(message);
});
ConversationParam param = ConversationParam.builder()
.apiKey(properties.getApiKey())
.model(properties.getModel())
.messages(messages)
.build();
Conversation gen = new Conversation();
Flowable<ConversationResult> result = gen.streamCall(param);
List<String> tests = new ArrayList<>();
AtomicReference<String> requestIdRef = new AtomicReference<>(requestId);
result.blockingForEach(msg -> {
if (!isAfterward) {
requestIdRef.set(msg.getRequestId());
}
String text = msg.getOutput().getText();
tests.add(text);
});
// 获取更新后的requestId
requestId = requestIdRef.get();
// 添加助手消息
JSONObject assistant = new JSONObject();
assistant.put("role", Role.ASSISTANT.getValue());
assistant.put("content", tests.get(tests.size() - 1));
messageList.add(assistant);
// 保存消息列表到Redis
redisService.setCacheList("aiTable:"+requestId, messageList);
data.put("context", tests.get(tests.size() - 1));
data.put("requestId", requestId);
return data;
}
public String generateSqlStructure(String prompts) {
try {
// 添加系统消息
Message system = new Message();
system.setRole(Role.SYSTEM.getValue());
system.setContent(SYSTEM_TABLE_SQL_MESSAGE_CONTENT);
// 添加用户消息
Message user = new Message();
user.setRole(Role.USER.getValue());
user.setContent(prompts);
ConversationParam param = ConversationParam.builder()
.apiKey(properties.getApiKey())
.model(properties.getModel())
.messages(Arrays.asList(system, user))
.build();
Conversation gen = new Conversation();
Flowable<ConversationResult> result = gen.streamCall(param);
List<String> tests = new ArrayList<>();
result.blockingForEach(msg -> {
String text = msg.getOutput().getText();
tests.add(text);
});
System.out.println("返回数据:\n"+tests.get(tests.size()-1));
return tests.get(tests.size() - 1);
} catch (ApiException | NoApiKeyException | InputRequiredException e) {
System.err.println("错误信息：" + e.getMessage());
System.out.println("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code");
return null;
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/configuration/TableGeneratorConfig.java
|
Java
|
unknown
| 7,756
|
package com.jcm.gen.configuration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @author lvshihao
*/
@Component
@ConfigurationProperties(prefix = "jcm.ai")
public class TableGeneratorProperties {
private String apiKey;
private String model;
public String getApiKey() {
return apiKey;
}
public void setApiKey(String apiKey) {
this.apiKey = apiKey;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/configuration/TableGeneratorProperties.java
|
Java
|
unknown
| 617
|
package com.jcm.gen.controller;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.text.Convert;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.gen.domain.GenTable;
import com.jcm.gen.domain.GenTableColumn;
import com.jcm.gen.service.IGenTableColumnService;
import com.jcm.gen.service.IGenTableService;
import lombok.AllArgsConstructor;
import org.apache.commons.io.IOUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 代码生成 操作处理
*
* @author Junchenmo
*/
@RequestMapping("/genCode")
@AllArgsConstructor
@BusinessName(title = OperationNameConstants.GEN_CODE)
@RestController
public class GenController extends PageBaseController {
private final IGenTableService genTableService;
private final IGenTableColumnService genTableColumnService;
/**
* 查询代码生成列表
*/
@RequiresPermissions("tool:gen:list")
@GetMapping("/list")
public TableDataInfo genList(GenTable genTable)
{
startPage();
List<GenTable> list = genTableService.selectGenTableList(genTable);
return getDataTable(list);
}
/**
* 预览代码
*/
@RequiresPermissions("tool:gen:preview")
@GetMapping("/preview/{tableId}")
public AjaxResult preview(@PathVariable("tableId") Long tableId) throws IOException
{
Map<String, String> dataMap = genTableService.previewCode(tableId);
return success(dataMap);
}
/**
* 删除代码生成
*/
@RequiresPermissions("tool:gen:remove")
@Log(functionName = "删除导入的表", businessType = BusinessType.DELETE)
@DeleteMapping("/")
public AjaxResult remove(@RequestBody Long[] tableIds)
{
genTableService.deleteGenTableByIds(tableIds);
return success();
}
/**
* 查询数据库列表
*/
@RequiresPermissions("tool:gen:list")
@GetMapping("/db/list")
public TableDataInfo dataList(GenTable genTable)
{
System.out.println(genTable);
startPage();
List<GenTable> list = genTableService.selectDbTableList(genTable);
return getDataTable(list);
}
/**
* 导入表结构（保存）
*/
@RequiresPermissions("tool:gen:import")
@Log(functionName = "导入表结构", businessType = BusinessType.IMPORT)
@PostMapping("/importTable")
public AjaxResult importTableSave(String tables)
{
String[] tableNames = Convert.toStrArray(tables);
// 查询表信息
List<GenTable> tableList = genTableService.selectDbTableListByNames(tableNames);
genTableService.importGenTable(tableList);
return success();
}
/**
* 修改代码生成业务
*/
@RequiresPermissions("tool:gen:query")
@GetMapping(value = "/{tableId}")
public AjaxResult getInfo(@PathVariable Long tableId)
{
GenTable table = genTableService.selectGenTableById(tableId);
List<GenTableColumn> list = genTableColumnService.selectGenTableColumnListByTableId(tableId);
Map<String, Object> map = new HashMap<String, Object>();
map.put("info", table);
map.put("rows", list);
return success(map);
}
/**
* 修改保存代码生成业务
*/
@RequiresPermissions("tool:gen:edit")
@Log(functionName = "修改业务信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult editSave(@Validated @RequestBody GenTable genTable)
{
genTableService.validateEdit(genTable);
genTableService.updateGenTable(genTable);
return success();
}
/**
* 同步数据库
*/
@RequiresPermissions("tool:gen:edit")
@Log(functionName = "同步数据库", businessType = BusinessType.UPDATE)
@GetMapping("/synchDb/{tableName}")
public AjaxResult synchDb(@PathVariable("tableName") String tableName)
{
genTableService.synchDb(tableName);
return success();
}
/**
* 生成代码（自定义路径）
*/
@RequiresPermissions("tool:gen:code")
@Log(functionName = "生成代码", businessType = BusinessType.GENCODE)
@GetMapping("/genCode/{tableName}")
public AjaxResult genCode(@PathVariable("tableName") String tableName)
{
genTableService.generatorCode(tableName);
return success();
}
/**
* 批量生成代码
*/
@RequiresPermissions("tool:gen:code")
@Log(functionName = "生成代码", businessType = BusinessType.GENCODE)
@GetMapping("/batchGenCode")
public void batchGenCode(HttpServletResponse response, String tables) throws IOException
{
String[] tableNames = Convert.toStrArray(tables);
byte[] data = genTableService.downloadCode(tableNames);
genCode(response, data);
}
/**
* 生成zip文件
*/
private void genCode(HttpServletResponse response, byte[] data) throws IOException
{
response.reset();
response.setHeader("Content-Disposition", "attachment; filename=\"jcm.zip\"");
response.addHeader("Content-Length", "" + data.length);
response.setContentType("application/octet-stream; charset=UTF-8");
IOUtils.write(data, response.getOutputStream());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/controller/GenController.java
|
Java
|
unknown
| 5,798
|
package com.jcm.gen.controller;
import com.alibaba.dashscope.exception.ApiException;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.gen.configuration.TableGeneratorConfig;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
/**
* @author lvshihao
*/
@RestController
@AllArgsConstructor
@BusinessName(title = OperationNameConstants.GEN_DATA_TABLE)
@RequestMapping("/tableGen")
public class SysTableGenController {
private final TableGeneratorConfig generateTableStructure;
@GetMapping("/genTable")
public AjaxResult genTable(String prompts) throws ApiException{
HashMap<String, String> dataMap = generateTableStructure.generateTableStructure(prompts);
return AjaxResult.success("成功",dataMap);
}
@PostMapping("/genSql")
public AjaxResult genSql(@RequestBody String prompts) throws ApiException{
System.out.println("表数据");
System.out.println(prompts);
String sql = generateTableStructure.generateSqlStructure(prompts);
return AjaxResult.success("成功",sql);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/controller/SysTableGenController.java
|
Java
|
unknown
| 1,244
|
package com.jcm.gen.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.constant.GenConstants;
import com.jcm.common.core.domain.BaseEntity;
import com.jcm.common.core.utils.StringUtils;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;
import org.apache.commons.lang3.ArrayUtils;
import javax.validation.Valid;
import java.util.List;
/**
* <p>
* 代码生成业务表
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
@Data
@Accessors(chain = true)
@TableName("gen_table")
@ApiModel(value="GenTable对象", description="代码生成业务表")
public class GenTable extends BaseEntity {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "编号")
@TableId(value = "table_id", type = IdType.AUTO)
private Long tableId;
@ApiModelProperty(value = "表名称")
private String tableName;
@ApiModelProperty(value = "表描述")
private String tableComment;
@ApiModelProperty(value = "实体类名称")
private String className;
@ApiModelProperty(value = "使用的模板（crud单表操作 tree树表操作）")
private String tplCategory;
@ApiModelProperty(value = "生成包路径")
private String packageName;
@ApiModelProperty(value = "生成模块名")
private String moduleName;
@ApiModelProperty(value = "生成业务名")
private String businessName;
@ApiModelProperty(value = "生成功能名")
private String functionName;
@ApiModelProperty(value = "生成功能作者")
private String functionAuthor;
@ApiModelProperty(value = "生成代码方式（0zip压缩包 1自定义路径）")
private String genType;
@ApiModelProperty(value = "生成路径（不填默认项目路径）")
private String genPath;
/** 主键信息 */
private GenTableColumn pkColumn;
/** 表列信息 */
@Valid
@TableField(exist = false)
private List<GenTableColumn> columns;
@ApiModelProperty(value = "其它生成选项")
private String options;
/** 树编码字段 */
private String treeCode;
/** 树父编码字段 */
private String treeParentCode;
/** 树名称字段 */
private String treeName;
/** 上级菜单ID字段 */
private String parentMenuId;
/** 上级菜单名称字段 */
private String parentMenuName;
public boolean isTree()
{
return isTree(this.tplCategory);
}
public static boolean isTree(String tplCategory)
{
return tplCategory != null && StringUtils.equals(GenConstants.TPL_TREE, tplCategory);
}
public boolean isCrud()
{
return isCrud(this.tplCategory);
}
public static boolean isCrud(String tplCategory)
{
return tplCategory != null && StringUtils.equals(GenConstants.TPL_CRUD, tplCategory);
}
public boolean isSuperColumn(String javaField)
{
return isSuperColumn(this.tplCategory, javaField);
}
public static boolean isSuperColumn(String tplCategory, String javaField)
{
if (isTree(tplCategory))
{
return StringUtils.equalsAnyIgnoreCase(javaField,
ArrayUtils.addAll(GenConstants.TREE_ENTITY, GenConstants.BASE_ENTITY));
}
return StringUtils.equalsAnyIgnoreCase(javaField, GenConstants.BASE_ENTITY);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/domain/GenTable.java
|
Java
|
unknown
| 3,619
|
package com.jcm.gen.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import com.jcm.common.core.utils.StringUtils;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* <p>
* 代码生成业务表字段
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
@Data
@Accessors(chain = true)
@TableName("gen_table_column")
@ApiModel(value="GenTableColumn对象", description="代码生成业务表字段")
public class GenTableColumn extends BaseEntity {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "编号")
@TableId(value = "column_id", type = IdType.AUTO)
private Long columnId;
@ApiModelProperty(value = "归属表编号")
private Long tableId;
@ApiModelProperty(value = "列名称")
private String columnName;
@ApiModelProperty(value = "列描述")
private String columnComment;
@ApiModelProperty(value = "列类型")
private String columnType;
@ApiModelProperty(value = "JAVA类型")
private String javaType;
@ApiModelProperty(value = "JAVA字段名")
private String javaField;
@ApiModelProperty(value = "是否主键（1是）")
private String isPk;
@ApiModelProperty(value = "是否自增（1是）")
private String isIncrement;
@ApiModelProperty(value = "是否必填（1是）")
private String isRequired;
@ApiModelProperty(value = "是否为插入字段（1是）")
private String isInsert;
@ApiModelProperty(value = "是否编辑字段（1是）")
private String isEdit;
@ApiModelProperty(value = "是否列表字段（1是）")
private String isList;
@ApiModelProperty(value = "是否查询字段（1是）")
private String isQuery;
@ApiModelProperty(value = "查询方式（等于、不等于、大于、小于、范围）")
private String queryType;
@ApiModelProperty(value = "显示类型（文本框、文本域、下拉框、复选框、单选框、日期控件）")
private String htmlType;
@ApiModelProperty(value = "字典类型")
private String dictType;
@ApiModelProperty(value = "排序")
private Integer sort;
public String getCapJavaField()
{
return StringUtils.capitalize(javaField);
}
public boolean isPk()
{
return isPk(this.isPk);
}
/**
* 判断是否为主键
*
* @param isPk 表示是否为主键的字符串标识
* @return 如果isPk为"1"且不为空，则返回true，否则返回false
*/
public boolean isPk(String isPk)
{
return isPk != null && StringUtils.equals("1", isPk);
}
public boolean isIncrement()
{
return isIncrement(this.isIncrement);
}
/**
* 判断是否为自增字段
*
* @param isIncrement 表示是否为自增字段的字符串标识
* @return 如果isIncrement为"1"且不为空，则返回true，否则返回false
*/
public boolean isIncrement(String isIncrement)
{
return isIncrement != null && StringUtils.equals("1", isIncrement);
}
public boolean isRequired()
{
return isRequired(this.isRequired);
}
/**
* 判断字段是否为必填
*
* @param isRequired 表示字段是否必填的字符串标识
* @return 如果isRequired为"1"且不为空，则返回true，否则返回false
*/
public boolean isRequired(String isRequired)
{
return isRequired != null && StringUtils.equals("1", isRequired);
}
public boolean isInsert()
{
return isInsert(this.isInsert);
}
/**
* 判断字段是否在插入时需要
*
* @param isInsert 表示字段是否在插入时需要的字符串标识
* @return 如果isInsert为"1"且不为空，则返回true，否则返回false
*/
public boolean isInsert(String isInsert)
{
return isInsert != null && StringUtils.equals("1", isInsert);
}
public boolean isEdit()
{
return isInsert(this.isEdit);
}
/**
* 判断字段是否在编辑时需要
*
* @param isEdit 表示字段是否在编辑时需要的字符串标识
* @return 如果isEdit为"1"且不为空，则返回true，否则返回false
*/
public boolean isEdit(String isEdit)
{
return isEdit != null && StringUtils.equals("1", isEdit);
}
public boolean isList()
{
return isList(this.isList);
}
/**
* 判断字段是否在列表中显示
*
* @param isList 表示字段是否在列表中显示的字符串标识
* @return 如果isList为"1"且不为空，则返回true，否则返回false
*/
public boolean isList(String isList)
{
return isList != null && StringUtils.equals("1", isList);
}
public boolean isQuery()
{
return isQuery(this.isQuery);
}
/**
* 判断字段是否可用于查询
*
* @param isQuery 表示字段是否可用于查询的字符串标识
* @return 如果isQuery为"1"且不为空，则返回true，否则返回false
*/
public boolean isQuery(String isQuery)
{
return isQuery != null && StringUtils.equals("1", isQuery);
}
public boolean isSuperColumn()
{
return isSuperColumn(this.javaField);
}
/**
* 判断字段是否为超级列（用于忽略某些基础实体或树实体的属性）
*
* @param javaField 字段名
* @return 如果字段名与预定义的超级列名之一匹配（不区分大小写），则返回true，否则返回false
*/
public static boolean isSuperColumn(String javaField)
{
return StringUtils.equalsAnyIgnoreCase(javaField,
// BaseEntity
"create","creator", "createTime", "update", "updater", "updateTime", "remark",
// TreeEntity
"parentName", "parentId", "sort", "ancestors");
}
public boolean isUsableColumn()
{
return isUsableColumn(javaField);
}
/**
* 判断字段是否为可用列（创建页面时需要的属性白名单）
*
* @param javaField 字段名
* @return 如果字段名与预定义的可用列名之一匹配（不区分大小写），则返回true，否则返回false
*/
public static boolean isUsableColumn(String javaField)
{
// isSuperColumn()中的名单用于避免生成多余Domain属性，若某些属性在生成页面时需要用到不能忽略，则放在此处白名单
return StringUtils.equalsAnyIgnoreCase(javaField, "parentId", "sort", "remark");
}
/**
* 读取并转换列的备注信息
*
* @return 转换后的备注信息字符串
*/
public String readConverterExp()
{
// 提取列注释中的备注信息
String remarks = StringUtils.substringBetween(this.columnComment, "（", "）");
StringBuffer sb = new StringBuffer();
if (StringUtils.isNotEmpty(remarks))
{
// 处理备注信息，生成特定格式的字符串
for (String value : remarks.split(" "))
{
if (StringUtils.isNotEmpty(value))
{
Object startStr = value.subSequence(0, 1);
String endStr = value.substring(1);
sb.append("").append(startStr).append("=").append(endStr).append(",");
}
}
// 移除最后的逗号
return sb.deleteCharAt(sb.length() - 1).toString();
}
else
{
// 如果没有备注信息，则直接返回列的注释
return this.columnComment;
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/domain/GenTableColumn.java
|
Java
|
unknown
| 7,977
|
package com.jcm.gen.mapper;
import com.jcm.gen.domain.GenTableColumn;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
/**
* <p>
* 代码生成业务表字段 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
public interface GenTableColumnMapper extends BaseMapper<GenTableColumn> {
/**
* 批量删除业务字段
*
* @param ids 需要删除的数据ID
* @return 结果
*/
public int deleteGenTableColumnByIds(Long[] ids);
/**
* 根据表名称查询列信息
*
* @param tableName 表名称
* @return 列信息
*/
public List<GenTableColumn> selectDbTableColumnsByName(String tableName);
/**
* 新增业务字段
*
* @param genTableColumn 业务字段信息
* @return 结果
*/
public int insertGenTableColumn(GenTableColumn genTableColumn);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/mapper/GenTableColumnMapper.java
|
Java
|
unknown
| 904
|
package com.jcm.gen.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.gen.domain.GenTable;
import java.util.List;
/**
* <p>
* 代码生成业务表 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
public interface GenTableMapper extends BaseMapper<GenTable> {
/**
* 批量删除业务
*
* @param ids 需要删除的数据ID
* @return 结果
*/
public int deleteGenTableByIds(Long[] ids);
/**
* 查询表ID业务信息
*
* @param id 业务ID
* @return 业务信息
*/
public GenTable selectGenTableById(Long id);
/**
* 查询表名称业务信息
*
* @param tableName 表名称
* @return 业务信息
*/
public GenTable selectGenTableByName(String tableName);
/**
* 查询业务列表
*
* @param genTable 业务信息
* @return 业务集合
*/
public List<GenTable> selectGenTableList(GenTable genTable);
/**
* 查询据库列表
*
* @param genTable 业务信息
* @return 数据库表集合
*/
public List<GenTable> selectDbTableList(GenTable genTable);
/**
* 查询据库列表
*
* @param tableNames 表名称组
* @return 数据库表集合
*/
public List<GenTable> selectDbTableListByNames(String[] tableNames);
/**
* 新增业务
*
* @param genTable 业务信息
* @return 结果
*/
public int insertGenTable(GenTable genTable);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/mapper/GenTableMapper.java
|
Java
|
unknown
| 1,531
|
package com.jcm.gen.service;
import com.jcm.gen.domain.GenTableColumn;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 代码生成业务表字段 服务类
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
public interface IGenTableColumnService extends IService<GenTableColumn> {
/**
* 查询业务字段列表
*
* @param tableId 业务字段编号
* @return 业务字段集合
*/
public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/service/IGenTableColumnService.java
|
Java
|
unknown
| 555
|
package com.jcm.gen.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jcm.gen.domain.GenTable;
import java.util.List;
import java.util.Map;
/**
* <p>
* 代码生成业务表 服务类
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
public interface IGenTableService extends IService<GenTable> {
/**
* 预览代码
*
* @param tableId 表编号
* @return 预览数据列表
*/
public Map<String, String> previewCode(Long tableId);
/**
* 删除业务信息
*
* @param tableIds 需要删除的表数据ID
* @return 结果
*/
public void deleteGenTableByIds(Long[] tableIds);
/**
* 查询业务列表
*
* @param genTable 业务信息
* @return 业务集合
*/
public List<GenTable> selectGenTableList(GenTable genTable);
/**
* 查询据库列表
*
* @param genTable 业务信息
* @return 数据库表集合
*/
public List<GenTable> selectDbTableList(GenTable genTable);
/**
* 查询据库列表
*
* @param tableNames 表名称组
* @return 数据库表集合
*/
public List<GenTable> selectDbTableListByNames(String[] tableNames);
/**
* 导入表结构
*
* @param tableList 导入表列表
*/
public void importGenTable(List<GenTable> tableList);
/**
* 查询业务信息
*
* @param id 业务ID
* @return 业务信息
*/
public GenTable selectGenTableById(Long id);
/**
* 修改保存参数校验
*
* @param genTable 业务信息
*/
public void validateEdit(GenTable genTable);
/**
* 修改业务
*
* @param genTable 业务信息
* @return 结果
*/
public void updateGenTable(GenTable genTable);
/**
* 同步数据库
*
* @param tableName 表名称
*/
public void synchDb(String tableName);
/**
* 批量生成代码（下载方式）
*
* @param tableNames 表数组
* @return 数据
*/
public byte[] downloadCode(String[] tableNames);
/**
* 生成代码（自定义路径）
*
* @param tableName 表名称
* @return 数据
*/
public void generatorCode(String tableName);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/service/IGenTableService.java
|
Java
|
unknown
| 2,313
|
package com.jcm.gen.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.gen.domain.GenTableColumn;
import com.jcm.gen.mapper.GenTableColumnMapper;
import com.jcm.gen.service.IGenTableColumnService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 代码生成业务表字段 服务实现类
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
@Service
public class GenTableColumnServiceImpl extends ServiceImpl<GenTableColumnMapper, GenTableColumn> implements IGenTableColumnService {
@Override
public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId) {
LambdaQueryWrapper<GenTableColumn> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(StringUtils.isNotNull(tableId),GenTableColumn::getTableId,tableId);
lambdaQueryWrapper.orderByAsc(GenTableColumn::getSort);
return this.baseMapper.selectList(lambdaQueryWrapper);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/service/impl/GenTableColumnServiceImpl.java
|
Java
|
unknown
| 1,113
|
package com.jcm.gen.service.impl;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.constant.Constants;
import com.jcm.common.core.constant.GenConstants;
import com.jcm.common.core.exception.ServiceException;
import com.jcm.common.core.text.CharsetKit;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.gen.domain.GenTable;
import com.jcm.gen.domain.GenTableColumn;
import com.jcm.gen.mapper.GenTableColumnMapper;
import com.jcm.gen.mapper.GenTableMapper;
import com.jcm.gen.service.IGenTableService;
import com.jcm.gen.util.GenUtils;
import com.jcm.gen.util.VelocityInitializer;
import com.jcm.gen.util.VelocityUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
/**
* <p>
* 代码生成业务表 服务实现类
* </p>
*
* @author 吕世昊
* @since 2025-01-05
*/
@Service
@AllArgsConstructor
public class GenTableServiceImpl extends ServiceImpl<GenTableMapper, GenTable> implements IGenTableService {
private static final Logger log = LoggerFactory.getLogger(GenTableServiceImpl.class);
private final GenTableMapper genTableMapper;
private final GenTableColumnMapper genTableColumnMapper;
/**
* 删除业务对象
*
* @param tableIds 需要删除的数据ID
* @return 结果
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteGenTableByIds(Long[] tableIds)
{
genTableMapper.deleteGenTableByIds(tableIds);
genTableColumnMapper.deleteGenTableColumnByIds(tableIds);
}
/**
* 预览代码
*
* @param tableId 表编号
* @return 预览数据列表
*/
@Override
public Map<String, String> previewCode(Long tableId)
{
Map<String, String> dataMap = new LinkedHashMap<>();
// 查询表信息
GenTable table = genTableMapper.selectGenTableById(tableId);
// 设置主键列信息
setPkColumn(table);
VelocityInitializer.initVelocity();
VelocityContext context = VelocityUtils.prepareContext(table);
// 获取模板列表
List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
for (String template : templates)
{
// 渲染模板
StringWriter sw = new StringWriter();
Template tpl = Velocity.getTemplate(template, Constants.UTF8);
tpl.merge(context, sw);
dataMap.put(template, sw.toString());
}
return dataMap;
}
/**
* 设置主键列信息
*
* @param table 业务表信息
*/
public void setPkColumn(GenTable table)
{
for (GenTableColumn column : table.getColumns())
{
if (column.isPk())
{
table.setPkColumn(column);
break;
}
}
if (StringUtils.isNull(table.getPkColumn()))
{
table.setPkColumn(table.getColumns().get(0));
}
}
/**
* 查询业务列表
*
* @param genTable 业务信息
* @return 业务集合
*/
@Override
public List<GenTable> selectGenTableList(GenTable genTable)
{
return genTableMapper.selectGenTableList(genTable);
}
/**
* 查询据库列表
*
* @param genTable 业务信息
* @return 数据库表集合
*/
@Override
public List<GenTable> selectDbTableList(GenTable genTable)
{
return genTableMapper.selectDbTableList(genTable);
}
/**
* 查询据库列表
*
* @param tableNames 表名称组
* @return 数据库表集合
*/
@Override
public List<GenTable> selectDbTableListByNames(String[] tableNames)
{
return genTableMapper.selectDbTableListByNames(tableNames);
}
/**
* 导入表结构
*
* @param tableList 导入表列表
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void importGenTable(List<GenTable> tableList)
{
String operName = SecurityUtils.getUsername();
try
{
for (GenTable table : tableList)
{
String tableName = table.getTableName();
GenUtils.initTable(table, operName);
int row = genTableMapper.insertGenTable(table);
if (row > 0)
{
// 保存列信息
List<GenTableColumn> genTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
for (GenTableColumn column : genTableColumns)
{
GenUtils.initColumnField(column, table);
genTableColumnMapper.insertGenTableColumn(column);
}
}
}
}
catch (Exception e)
{
throw new ServiceException("导入失败：" + e.getMessage());
}
}
/**
* 查询业务信息
*
* @param id 业务ID
* @return 业务信息
*/
@Override
public GenTable selectGenTableById(Long id)
{
GenTable genTable = genTableMapper.selectGenTableById(id);
setTableFromOptions(genTable);
return genTable;
}
/**
* 设置代码生成其他选项值
*
* @param genTable 设置后的生成对象
*/
public void setTableFromOptions(GenTable genTable)
{
JSONObject paramsObj = JSON.parseObject(genTable.getOptions());
if (StringUtils.isNotNull(paramsObj))
{
String treeCode = paramsObj.getString(GenConstants.TREE_CODE);
String treeParentCode = paramsObj.getString(GenConstants.TREE_PARENT_CODE);
String treeName = paramsObj.getString(GenConstants.TREE_NAME);
String parentMenuId = paramsObj.getString(GenConstants.PARENT_MENU_ID);
String parentMenuName = paramsObj.getString(GenConstants.PARENT_MENU_NAME);
genTable.setTreeCode(treeCode);
genTable.setTreeParentCode(treeParentCode);
genTable.setTreeName(treeName);
genTable.setParentMenuId(parentMenuId);
genTable.setParentMenuName(parentMenuName);
}
}
/**
* 修改保存参数校验
*
* @param genTable 业务信息
*/
@Override
public void validateEdit(GenTable genTable)
{
if (GenConstants.TPL_TREE.equals(genTable.getTplCategory()))
{
String options = JSON.toJSONString(genTable.getParams());
JSONObject paramsObj = JSON.parseObject(options);
if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_CODE)))
{
throw new ServiceException("树编码字段不能为空");
}
else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_PARENT_CODE)))
{
throw new ServiceException("树父编码字段不能为空");
}
else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_NAME)))
{
throw new ServiceException("树名称字段不能为空");
}
}
}
/**
* 修改业务
*
* @param genTable 业务信息
* @return 结果
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void updateGenTable(GenTable genTable)
{
String options = JSON.toJSONString(genTable.getParams());
genTable.setOptions(options);
int row = genTableMapper.updateById(genTable);
if (row > 0)
{
for (GenTableColumn cenTableColumn : genTable.getColumns())
{
genTableColumnMapper.updateById(cenTableColumn);
}
}
}
/**
* 同步数据库
*
* @param tableName 表名称
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void synchDb(String tableName)
{
GenTable table = genTableMapper.selectGenTableByName(tableName);
List<GenTableColumn> tableColumns = table.getColumns();
Map<String, GenTableColumn> tableColumnMap = tableColumns.stream().collect(Collectors.toMap(GenTableColumn::getColumnName, Function.identity()));
List<GenTableColumn> dbTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
if (StringUtils.isEmpty(dbTableColumns))
{
throw new ServiceException("同步数据失败，原表结构不存在");
}
List<String> dbTableColumnNames = dbTableColumns.stream().map(GenTableColumn::getColumnName).collect(Collectors.toList());
dbTableColumns.forEach(column -> {
GenUtils.initColumnField(column, table);
if (tableColumnMap.containsKey(column.getColumnName()))
{
GenTableColumn prevColumn = tableColumnMap.get(column.getColumnName());
column.setColumnId(prevColumn.getColumnId());
if (column.isList())
{
// 如果是列表，继续保留查询方式/字典类型选项
column.setDictType(prevColumn.getDictType());
column.setQueryType(prevColumn.getQueryType());
}
if (StringUtils.isNotEmpty(prevColumn.getIsRequired()) && !column.isPk()
&& (column.isInsert() || column.isEdit())
&& ((column.isUsableColumn()) || (!column.isSuperColumn())))
{
// 如果是(新增/修改&非主键/非忽略及父属性)，继续保留必填/显示类型选项
column.setIsRequired(prevColumn.getIsRequired());
column.setHtmlType(prevColumn.getHtmlType());
}
genTableColumnMapper.updateById(column);
}
else
{
genTableColumnMapper.insertGenTableColumn(column);
}
});
List<Long> delColumns = tableColumns.stream().filter(column -> !dbTableColumnNames.contains(column.getColumnName())).map(GenTableColumn::getColumnId).collect(Collectors.toList());
if (StringUtils.isNotEmpty(delColumns))
{
genTableColumnMapper.deleteBatchIds(delColumns);
}
}
/**
* 生成代码（自定义路径）
*
* @param tableName 表名称
*/
@Override
public void generatorCode(String tableName)
{
// 查询表信息
GenTable table = genTableMapper.selectGenTableByName(tableName);
// 设置主键列信息
setPkColumn(table);
VelocityInitializer.initVelocity();
VelocityContext context = VelocityUtils.prepareContext(table);
// 获取模板列表
List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
for (String template : templates)
{
// 渲染模板
StringWriter sw = new StringWriter();
Template tpl = Velocity.getTemplate(template, Constants.UTF8);
tpl.merge(context, sw);
try
{
String path = getGenPath(table, template);
FileUtils.writeStringToFile(new File(path), sw.toString(), CharsetKit.UTF_8);
}
catch (IOException e)
{
throw new ServiceException("渲染模板失败，表名：" + table.getTableName());
}
}
}
/**
* 获取代码生成地址
*
* @param table 业务表信息
* @param template 模板文件路径
* @return 生成地址
*/
public static String getGenPath(GenTable table, String template)
{
String genPath = table.getGenPath();
if (StringUtils.equals(genPath, "/"))
{
return System.getProperty("user.dir") + File.separator + "src" + File.separator + VelocityUtils.getFileName(template, table);
}
return genPath + File.separator + VelocityUtils.getFileName(template, table);
}
/**
* 批量生成代码（下载方式）
*
* @param tableNames 表数组
* @return 数据
*/
@Override
public byte[] downloadCode(String[] tableNames)
{
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ZipOutputStream zip = new ZipOutputStream(outputStream);
for (String tableName : tableNames)
{
generatorCode(tableName, zip);
}
IOUtils.closeQuietly(zip);
return outputStream.toByteArray();
}
/**
* 查询表信息并生成代码
*/
private void generatorCode(String tableName, ZipOutputStream zip)
{
// 查询表信息
GenTable table = genTableMapper.selectGenTableByName(tableName);
// 设置主键列信息
setPkColumn(table);
VelocityInitializer.initVelocity();
VelocityContext context = VelocityUtils.prepareContext(table);
// 获取模板列表
List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
for (String template : templates)
{
// 渲染模板
StringWriter sw = new StringWriter();
Template tpl = Velocity.getTemplate(template, Constants.UTF8);
tpl.merge(context, sw);
try
{
// 添加到zip
zip.putNextEntry(new ZipEntry(VelocityUtils.getFileName(template, table)));
IOUtils.write(sw.toString(), zip, Constants.UTF8);
IOUtils.closeQuietly(sw);
zip.flush();
zip.closeEntry();
}
catch (IOException e)
{
log.error("渲染模板失败，表名：" + table.getTableName(), e);
}
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/service/impl/GenTableServiceImpl.java
|
Java
|
unknown
| 14,794
|
package com.jcm.gen.util;
import com.jcm.common.core.constant.GenConstants;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.gen.config.GenConfig;
import com.jcm.gen.domain.GenTable;
import com.jcm.gen.domain.GenTableColumn;
import org.apache.commons.lang3.RegExUtils;
import java.util.Arrays;
/**
* 代码生成器 工具类
*
* @author junchenmo
*/
public class GenUtils
{
/**
* 初始化表信息
*/
public static void initTable(GenTable genTable, String operName)
{
//对表的前缀和驼峰命名进行操作转换
genTable.setClassName(convertClassName(genTable.getTableName()));
genTable.setPackageName(GenConfig.getPackageName());
genTable.setModuleName(getModuleName(GenConfig.getPackageName()));
genTable.setBusinessName(getBusinessName(genTable.getTableName()));
genTable.setFunctionName(replaceText(genTable.getTableComment()));
genTable.setFunctionAuthor(GenConfig.getAuthor());
genTable.setCreator(operName);
}
/**
* 初始化列属性字段
*/
public static void initColumnField(GenTableColumn column, GenTable table)
{
String dataType = getDbType(column.getColumnType());
String columnName = column.getColumnName();
column.setTableId(table.getTableId());
column.setCreator(table.getCreator());
// 设置java字段名
column.setJavaField(StringUtils.toCamelCase(columnName));
// 设置默认类型
column.setJavaType(GenConstants.TYPE_STRING);
column.setQueryType(GenConstants.QUERY_EQ);
if (arraysContains(GenConstants.COLUMNTYPE_STR, dataType) || arraysContains(GenConstants.COLUMNTYPE_TEXT, dataType))
{
// 字符串长度超过500设置为文本域
Integer columnLength = getColumnLength(column.getColumnType());
String htmlType = columnLength >= 500 || arraysContains(GenConstants.COLUMNTYPE_TEXT, dataType) ? GenConstants.HTML_TEXTAREA : GenConstants.HTML_INPUT;
column.setHtmlType(htmlType);
}
else if (arraysContains(GenConstants.COLUMNTYPE_TIME, dataType))
{
column.setJavaType(GenConstants.TYPE_DATE);
column.setHtmlType(GenConstants.HTML_DATETIME);
}
else if (arraysContains(GenConstants.COLUMNTYPE_NUMBER, dataType))
{
column.setHtmlType(GenConstants.HTML_INPUT);
// 如果是浮点型 统一用BigDecimal
String[] str = StringUtils.split(StringUtils.substringBetween(column.getColumnType(), "(", ")"), ",");
if (str != null && str.length == 2 && Integer.parseInt(str[1]) > 0)
{
column.setJavaType(GenConstants.TYPE_BIGDECIMAL);
}
// 如果是整形
else if (str != null && str.length == 1 && Integer.parseInt(str[0]) <= 10)
{
column.setJavaType(GenConstants.TYPE_INTEGER);
}
// 长整形
else
{
column.setJavaType(GenConstants.TYPE_LONG);
}
}
// 插入字段（默认所有字段都需要插入）
column.setIsInsert(GenConstants.REQUIRE);
// 编辑字段
if (!arraysContains(GenConstants.COLUMNNAME_NOT_EDIT, columnName) && !column.isPk())
{
column.setIsEdit(GenConstants.REQUIRE);
}
// 列表字段
if (!arraysContains(GenConstants.COLUMNNAME_NOT_LIST, columnName) && !column.isPk())
{
column.setIsList(GenConstants.REQUIRE);
}
// 查询字段
if (!arraysContains(GenConstants.COLUMNNAME_NOT_QUERY, columnName) && !column.isPk())
{
column.setIsQuery(GenConstants.REQUIRE);
}
// 查询字段类型
if (StringUtils.endsWithIgnoreCase(columnName, "name"))
{
column.setQueryType(GenConstants.QUERY_LIKE);
}
// 状态字段设置单选框
if (StringUtils.endsWithIgnoreCase(columnName, "status"))
{
column.setHtmlType(GenConstants.HTML_RADIO);
}
// 类型&性别字段设置下拉框
else if (StringUtils.endsWithIgnoreCase(columnName, "type")
|| StringUtils.endsWithIgnoreCase(columnName, "sex"))
{
column.setHtmlType(GenConstants.HTML_SELECT);
}
// 图片字段设置图片上传控件
else if (StringUtils.endsWithIgnoreCase(columnName, "image"))
{
column.setHtmlType(GenConstants.HTML_IMAGE_UPLOAD);
}
// 文件字段设置文件上传控件
else if (StringUtils.endsWithIgnoreCase(columnName, "file"))
{
column.setHtmlType(GenConstants.HTML_FILE_UPLOAD);
}
// 内容字段设置富文本控件
else if (StringUtils.endsWithIgnoreCase(columnName, "content"))
{
column.setHtmlType(GenConstants.HTML_EDITOR);
}
}
/**
* 校验数组是否包含指定值
*
* @param arr 数组
* @param targetValue 值
* @return 是否包含
*/
public static boolean arraysContains(String[] arr, String targetValue)
{
return Arrays.asList(arr).contains(targetValue);
}
/**
* 获取模块名
*
* @param packageName 包名
* @return 模块名
*/
public static String getModuleName(String packageName)
{
int lastIndex = packageName.lastIndexOf(".");
int nameLength = packageName.length();
return StringUtils.substring(packageName, lastIndex + 1, nameLength);
}
/**
* 获取业务名
*
* @param tableName 表名
* @return 业务名
*/
public static String getBusinessName(String tableName)
{
int lastIndex = tableName.lastIndexOf("_");
int nameLength = tableName.length();
return StringUtils.substring(tableName, lastIndex + 1, nameLength);
}
/**
* 表名转换成Java类名
*
* @param tableName 表名称
* @return 类名
*/
public static String convertClassName(String tableName)
{
//根据AutoRemovePre判断是否去掉前缀名称
//根据TablePrefix获取前缀字符串，并根据,分割，然后便利所有的前缀列表，将匹配成功的表名的第一个前缀替换成空的
boolean autoRemovePre = GenConfig.getAutoRemovePre();
String tablePrefix = GenConfig.getTablePrefix();
if (autoRemovePre && StringUtils.isNotEmpty(tablePrefix))
{
String[] searchList = StringUtils.split(tablePrefix, ",");
tableName = replaceFirst(tableName, searchList);
}
return StringUtils.convertToCamelCase(tableName);
}
/**
* 批量替换前缀
*
* @param replacementm 替换值
* @param searchList 替换列表
* @return
*/
public static String replaceFirst(String replacementm, String[] searchList)
{
String text = replacementm;
for (String searchString : searchList)
{
if (replacementm.startsWith(searchString))
{
text = replacementm.replaceFirst(searchString, "");
break;
}
}
return text;
}
/**
* 关键字替换
*
* @param text 需要被替换的名字
* @return 替换后的名字
*/
public static String replaceText(String text)
{
return RegExUtils.replaceAll(text, "(?:表)", "");
}
/**
* 获取数据库类型字段
*
* @param columnType 列类型
* @return 截取后的列类型
*/
public static String getDbType(String columnType)
{
if (StringUtils.indexOf(columnType, "(") > 0)
{
return StringUtils.substringBefore(columnType, "(");
}
else
{
return columnType;
}
}
/**
* 获取字段长度
*
* @param columnType 列类型
* @return 截取后的列类型
*/
public static Integer getColumnLength(String columnType)
{
if (StringUtils.indexOf(columnType, "(") > 0)
{
String length = StringUtils.substringBetween(columnType, "(", ")");
return Integer.valueOf(length);
}
else
{
return 0;
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/util/GenUtils.java
|
Java
|
unknown
| 8,476
|
package com.jcm.gen.util;
import com.jcm.common.core.constant.Constants;
import org.apache.velocity.app.Velocity;
import java.util.Properties;
/**
* VelocityEngine工厂
*
* @author junchenmo
*/
public class VelocityInitializer
{
/**
* 初始化vm方法
*/
public static void initVelocity()
{
Properties p = new Properties();
try
{
// 加载classpath目录下的vm文件
p.setProperty("resource.loader.file.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
// 定义字符集
p.setProperty(Velocity.INPUT_ENCODING, Constants.UTF8);
// 初始化Velocity引擎，指定配置Properties
Velocity.init(p);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/util/VelocityInitializer.java
|
Java
|
unknown
| 867
|
package com.jcm.gen.util;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.jcm.common.core.constant.GenConstants;
import com.jcm.common.core.utils.DateUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.gen.domain.GenTable;
import com.jcm.gen.domain.GenTableColumn;
import org.apache.velocity.VelocityContext;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 模板工具类
*
* @author junchenmo
*/
public class VelocityUtils
{
/** 项目空间路径 */
private static final String PROJECT_PATH = "main/java";
/** mybatis空间路径 */
private static final String MYBATIS_PATH = "main/resources/mapper";
/** 默认上级菜单，系统工具 */
private static final String DEFAULT_PARENT_MENU_ID = "3";
/** 前端接口枚举内容 */
private static final String DEFAULT_API_ENUM = "${API_ENUM.SERVER_MODE_NAME.***}";
/**
* 设置模板变量信息
*
* @return 模板列表
*/
public static VelocityContext prepareContext(GenTable genTable)
{
String moduleName = genTable.getModuleName();
String businessName = genTable.getBusinessName();
String packageName = genTable.getPackageName();
String tplCategory = genTable.getTplCategory();
String functionName = genTable.getFunctionName();
// 创建一个新的 VelocityContext 实例，用于存储模板变量
VelocityContext velocityContext = new VelocityContext();
// 设置模板类型（如 crud, tree, sub）
velocityContext.put("tplCategory", genTable.getTplCategory());
// 设置表名 tx_vips
velocityContext.put("tableName", genTable.getTableName());
// 设置大写的表名 TX_VIPS
velocityContext.put("tableNameUC", genTable.getTableName().toUpperCase());
// 设置前端接口枚举名称
velocityContext.put("apiEnum", DEFAULT_API_ENUM.replace("***",genTable.getTableName().toUpperCase()));
// 设置功能名称，如果为空则默认为“【请填写功能名称】”
velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
// 设置类名（首字母大写）
velocityContext.put("ClassName", genTable.getClassName());
// 设置类名（首字母小写）
velocityContext.put("className", StringUtils.uncapitalize(genTable.getClassName()));
// 设置模块名
velocityContext.put("moduleName", genTable.getModuleName());
// 设置业务名（首字母大写）
velocityContext.put("BusinessName", StringUtils.capitalize(genTable.getBusinessName()));
// 设置业务名（原样）
velocityContext.put("businessName", genTable.getBusinessName());
// 获取并设置包前缀（去掉最后一个点及其后面的部分）
velocityContext.put("basePackage", getPackagePrefix(packageName));
// 设置完整包路径
velocityContext.put("packageName", packageName);
// 设置生成功能的作者
velocityContext.put("author", genTable.getFunctionAuthor());
// 设置生成代码的时间
velocityContext.put("datetime", DateUtils.getDate());
// 设置主键列信息
velocityContext.put("pkColumn", genTable.getPkColumn());
// 获取并设置需要导入的包列表
velocityContext.put("importList", getImportList(genTable));
// 设置权限前缀（模块名:业务名）
velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));
// 设置表的所有列信息
velocityContext.put("columns", genTable.getColumns());
// 设置整个表对象
velocityContext.put("table", genTable);
// 设置字典信息（用于生成下拉框、单选框等）
velocityContext.put("dicts", getDicts(genTable));
setMenuVelocityContext(velocityContext, genTable);
if (GenConstants.TPL_TREE.equals(tplCategory))
{
setTreeVelocityContext(velocityContext, genTable);
}
return velocityContext;
}
public static void setMenuVelocityContext(VelocityContext context, GenTable genTable)
{
String options = genTable.getOptions();
JSONObject paramsObj = JSON.parseObject(options);
String parentMenuId = getParentMenuId(paramsObj);
context.put("parentMenuId", parentMenuId);
}
public static void setTreeVelocityContext(VelocityContext context, GenTable genTable)
{
String options = genTable.getOptions();
JSONObject paramsObj = JSON.parseObject(options);
String treeCode = getTreecode(paramsObj);
String treeParentCode = getTreeParentCode(paramsObj);
String treeName = getTreeName(paramsObj);
context.put("treeCode", treeCode);
context.put("treeParentCode", treeParentCode);
context.put("treeName", treeName);
context.put("expandColumn", getExpandColumn(genTable));
if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE))
{
context.put("tree_parent_code", paramsObj.getString(GenConstants.TREE_PARENT_CODE));
}
if (paramsObj.containsKey(GenConstants.TREE_NAME))
{
context.put("tree_name", paramsObj.getString(GenConstants.TREE_NAME));
}
}
/**
* 获取模板信息
* @param tplCategory 生成的模板
* @return 模板列表
*/
public static List<String> getTemplateList(String tplCategory)
{
String useWebType = "vm/vue";
List<String> templates = new ArrayList<String>();
templates.add("vm/java/controller.java.vm");
templates.add("vm/java/domain.java.vm");
templates.add("vm/java/service.java.vm");
templates.add("vm/java/serviceImpl.java.vm");
templates.add("vm/java/mapper.java.vm");
templates.add("vm/xml/mapper.xml.vm");
// templates.add("vm/sql/sql.vm");
templates.add("vm/ts/api.ts.vm");
templates.add("vm/store/indexStore.ts.vm");
templates.add(useWebType+"/components/indexAddModal.vue.vm");
templates.add(useWebType+"/components/indexUpdateModal.vue.vm");
if (GenConstants.TPL_CRUD.equals(tplCategory))
{
templates.add(useWebType + "/index.vue.vm");
}
// else if (GenConstants.TPL_TREE.equals(tplCategory))
// {
// templates.add(useWebType + "/index-tree.vue.vm");
// }
return templates;
}
/**
* 获取文件名
*/
public static String getFileName(String template, GenTable genTable)
{
// 文件名称
String fileName = "";
// 包路径
String packageName = genTable.getPackageName();
// 模块名
String moduleName = genTable.getModuleName();
// 大写类名
String className = genTable.getClassName();
// 业务名称
String businessName = genTable.getBusinessName();
String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
String mybatisPath = MYBATIS_PATH + "/";
String vuePath = "vue";
if (template.contains("domain.java.vm"))
{
fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
}
if (template.contains("mapper.java.vm"))
{
fileName = StringUtils.format("{}/mapper/{}Mapper.java", javaPath, className);
}
else if (template.contains("service.java.vm"))
{
fileName = StringUtils.format("{}/service/I{}Service.java", javaPath, className);
}
else if (template.contains("serviceImpl.java.vm"))
{
fileName = StringUtils.format("{}/service/impl/{}ServiceImpl.java", javaPath, className);
}
else if (template.contains("controller.java.vm"))
{
fileName = StringUtils.format("{}/controller/{}Controller.java", javaPath, className);
}
else if (template.contains("mapper.xml.vm"))
{
fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className);
}
else if (template.contains("sql.vm"))
{
fileName = businessName + "Menu.sql";
}
else if (template.contains("api.ts.vm"))
{
fileName = StringUtils.format("{}/api/{}/index.ts", vuePath, moduleName, businessName);
}
else if (template.contains("indexStore.ts.vm"))
{
fileName = StringUtils.format("{}/store/{}/{}.ts", vuePath, moduleName, businessName);
}
else if (template.contains("indexAddModal.vue.vm"))
{
fileName = StringUtils.format("{}/views/{}/{}/components/{}-add-from-modal.vue", vuePath, moduleName, businessName,businessName.replace("_","-"));
}
else if (template.contains("indexUpdateModal.vue.vm"))
{
fileName = StringUtils.format("{}/views/{}/{}/components/{}-update-from-modal.vue", vuePath, moduleName, businessName,businessName.replace("_","-"));
}
else if (template.contains("index.vue.vm"))
{
fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
}
else if (template.contains("index-tree.vue.vm"))
{
fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
}
return fileName;
}
/**
* 获取包前缀
*
* @param packageName 包名称
* @return 包前缀名称
*/
public static String getPackagePrefix(String packageName)
{
int lastIndex = packageName.lastIndexOf(".");
return StringUtils.substring(packageName, 0, lastIndex);
}
/**
* 根据列类型获取导入包
*
* @param genTable 业务表对象
* @return 返回需要导入的包列表
*/
public static HashSet<String> getImportList(GenTable genTable)
{
List<GenTableColumn> columns = genTable.getColumns();
HashSet<String> importList = new HashSet<String>();
for (GenTableColumn column : columns)
{
if (!column.isSuperColumn() && GenConstants.TYPE_DATE.equals(column.getJavaType()))
{
importList.add("java.util.Date");
importList.add("com.fasterxml.jackson.annotation.JsonFormat");
}
else if (!column.isSuperColumn() && GenConstants.TYPE_BIGDECIMAL.equals(column.getJavaType()))
{
importList.add("java.math.BigDecimal");
}
}
return importList;
}
/**
* 根据列类型获取字典组
*
* @param genTable 业务表对象
* @return 返回字典组
*/
public static String getDicts(GenTable genTable)
{
List<GenTableColumn> columns = genTable.getColumns();
Set<String> dicts = new HashSet<String>();
addDicts(dicts, columns);
return StringUtils.join(dicts, ", ");
}
/**
* 添加字典列表
*
* @param dicts 字典列表
* @param columns 列集合
*/
public static void addDicts(Set<String> dicts, List<GenTableColumn> columns)
{
for (GenTableColumn column : columns)
{
if (!column.isSuperColumn() && StringUtils.isNotEmpty(column.getDictType()) && StringUtils.equalsAny(
column.getHtmlType(),
new String[] { GenConstants.HTML_SELECT, GenConstants.HTML_RADIO, GenConstants.HTML_CHECKBOX }))
{
dicts.add("'" + column.getDictType() + "'");
}
}
}
/**
* 获取权限前缀
*
* @param moduleName 模块名称
* @param businessName 业务名称
* @return 返回权限前缀
*/
public static String getPermissionPrefix(String moduleName, String businessName)
{
return StringUtils.format("{}:{}", moduleName, businessName);
}
/**
* 获取上级菜单ID字段
*
* @param paramsObj 生成其他选项
* @return 上级菜单ID字段
*/
public static String getParentMenuId(JSONObject paramsObj)
{
if (StringUtils.isNotEmpty(paramsObj) && paramsObj.containsKey(GenConstants.PARENT_MENU_ID)
&& StringUtils.isNotEmpty(paramsObj.getString(GenConstants.PARENT_MENU_ID)))
{
return paramsObj.getString(GenConstants.PARENT_MENU_ID);
}
return DEFAULT_PARENT_MENU_ID;
}
/**
* 获取树编码
*
* @param paramsObj 生成其他选项
* @return 树编码
*/
public static String getTreecode(JSONObject paramsObj)
{
if (paramsObj.containsKey(GenConstants.TREE_CODE))
{
return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_CODE));
}
return StringUtils.EMPTY;
}
/**
* 获取树父编码
*
* @param paramsObj 生成其他选项
* @return 树父编码
*/
public static String getTreeParentCode(JSONObject paramsObj)
{
if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE))
{
return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_PARENT_CODE));
}
return StringUtils.EMPTY;
}
/**
* 获取树名称
*
* @param paramsObj 生成其他选项
* @return 树名称
*/
public static String getTreeName(JSONObject paramsObj)
{
if (paramsObj.containsKey(GenConstants.TREE_NAME))
{
return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_NAME));
}
return StringUtils.EMPTY;
}
/**
* 获取需要在哪一列上面显示展开按钮
*
* @param genTable 业务表对象
* @return 展开按钮列序号
*/
public static int getExpandColumn(GenTable genTable)
{
String options = genTable.getOptions();
JSONObject paramsObj = JSON.parseObject(options);
String treeName = paramsObj.getString(GenConstants.TREE_NAME);
int num = 0;
for (GenTableColumn column : genTable.getColumns())
{
if (column.isList())
{
num++;
String columnName = column.getColumnName();
if (columnName.equals(treeName))
{
break;
}
}
}
return num;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-gen/src/main/java/com/jcm/gen/util/VelocityUtils.java
|
Java
|
unknown
| 14,745
|
package com.jcm.job;
import com.jcm.common.security.annotation.EnableCustomConfig;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @author lvshihao
*/
@EnableFeignClients("com.jcm.system.api")
@MapperScan("com.jcm.job.mapper")
@EnableCustomConfig
@SpringBootApplication
public class JcmJobApplication {
public static void main(String[] args)
{
SpringApplication.run(JcmJobApplication.class, args);
System.out.println(" (♥◠‿◠)ﾉﾞ 定时任务模块启动成功 ლ(´ڡ`ლ)ﾞ ");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/JcmJobApplication.java
|
Java
|
unknown
| 722
|
package com.jcm.job.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.utils.poi.ExcelUtil;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.job.domain.SysJob;
import com.jcm.job.service.ISysJobService;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* jobController
*
* @author lvshihao
* @date 2025-01-14
*/
@Api(tags="job管理")
@ApiSupport(author = "202252197@qq.com")
@BusinessName(title = OperationNameConstants.SYS_JOB)
@AllArgsConstructor
@RestController
@RequestMapping("/job")
public class SysJobController extends PageBaseController
{
private final ISysJobService sysJobService;
/**
* 查询定时任务调度列表
*/
@RequiresPermissions("job:job:list")
@GetMapping("/list")
public TableDataInfo list(SysJob sysJob)
{
startPage();
List<SysJob> list = sysJobService.selectSysJobList(sysJob);
return getDataTable(list);
}
/**
* 导出定时任务调度列表
*/
@RequiresPermissions("job:job:export")
@Log(functionName = "导出定时任务调度列表", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, SysJob sysJob)
{
List<SysJob> list = sysJobService.selectSysJobList(sysJob);
ExcelUtil<SysJob> util = new ExcelUtil<SysJob>(SysJob.class);
util.exportEasyExcel(response, list, "定时任务调度数据");
}
/**
* 获取定时任务调度详细信息
*/
@RequiresPermissions("job:job:query")
@GetMapping(value = "/{jobId}")
public AjaxResult getInfo(@PathVariable("jobId") Long jobId)
{
return success(sysJobService.selectSysJobByJobId(jobId));
}
/**
* 新增定时任务调度
*/
@RequiresPermissions("job:job:add")
@Log(functionName = "新增定时任务调度", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody SysJob sysJob)
{
return toAjax(sysJobService.insertSysJob(sysJob));
}
/**
* 修改定时任务调度
*/
@RequiresPermissions("job:job:edit")
@Log(functionName = "修改定时任务调度", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody SysJob sysJob)
{
return toAjax(sysJobService.updateSysJob(sysJob));
}
/**
* 删除定时任务调度
*/
@RequiresPermissions("job:job:remove")
@Log(functionName = "删除定时任务调度", businessType = BusinessType.DELETE)
@DeleteMapping("/{jobIds}")
public AjaxResult remove(@PathVariable Long[] jobIds)
{
return toAjax(sysJobService.deleteSysJobByJobIds(jobIds));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/controller/SysJobController.java
|
Java
|
unknown
| 3,271
|
package com.jcm.job.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.core.utils.poi.ExcelUtil;
import io.swagger.annotations.Api;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import lombok.AllArgsConstructor;
import com.jcm.job.domain.SysJobLog;
import com.jcm.job.service.ISysJobLogService;
import com.jcm.common.core.web.page.TableDataInfo;
/**
* logController
*
* @author lvshihao
* @date 2025-01-14
*/
@Api(tags="log管理")
@ApiSupport(author = "202252197@qq.com")
@BusinessName(title = OperationNameConstants.SYS_JOB_LOG)
@AllArgsConstructor
@RestController
@RequestMapping("/log")
public class SysJobLogController extends PageBaseController
{
private final ISysJobLogService sysJobLogService;
/**
* 查询定时任务调度日志列表
*/
@RequiresPermissions("job:log:list")
@GetMapping("/list")
public TableDataInfo list(SysJobLog sysJobLog)
{
startPage();
List<SysJobLog> list = sysJobLogService.selectSysJobLogList(sysJobLog);
return getDataTable(list);
}
/**
* 导出定时任务调度日志列表
*/
@RequiresPermissions("job:log:export")
@Log(functionName = "导出定时任务调度日志列表", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, SysJobLog sysJobLog)
{
List<SysJobLog> list = sysJobLogService.selectSysJobLogList(sysJobLog);
ExcelUtil<SysJobLog> util = new ExcelUtil<SysJobLog>(SysJobLog.class);
util.exportEasyExcel(response, list, "定时任务调度日志数据");
}
/**
* 获取定时任务调度日志详细信息
*/
@RequiresPermissions("job:log:query")
@GetMapping(value = "/{jobLogId}")
public AjaxResult getInfo(@PathVariable("jobLogId") Long jobLogId)
{
return success(sysJobLogService.selectSysJobLogByJobLogId(jobLogId));
}
/**
* 新增定时任务调度日志
*/
@RequiresPermissions("job:log:add")
@Log(functionName = "新增定时任务调度日志", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody SysJobLog sysJobLog)
{
return toAjax(sysJobLogService.insertSysJobLog(sysJobLog));
}
/**
* 修改定时任务调度日志
*/
@RequiresPermissions("job:log:edit")
@Log(functionName = "修改定时任务调度日志", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody SysJobLog sysJobLog)
{
return toAjax(sysJobLogService.updateSysJobLog(sysJobLog));
}
/**
* 删除定时任务调度日志
*/
@RequiresPermissions("job:log:remove")
@Log(functionName = "删除定时任务调度日志", businessType = BusinessType.DELETE)
@DeleteMapping("/{jobLogIds}")
public AjaxResult remove(@PathVariable Long[] jobLogIds)
{
return toAjax(sysJobLogService.deleteSysJobLogByJobLogIds(jobLogIds));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/controller/SysJobLogController.java
|
Java
|
unknown
| 3,906
|
package com.jcm.job.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* job对象 sys_job
*
* @author lvshihao
* @date 2025-01-14
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ExcelIgnoreUnannotated
@TableName("sys_job")
public class SysJob extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 任务ID */
@TableId(type = IdType.AUTO)
@ExcelProperty(value = "${comment}")
private Long jobId;
/** 任务名称 */
@ExcelProperty(value = "任务名称")
private String jobName;
/** 任务组名 */
@ExcelProperty(value = "任务组名")
private String jobGroup;
/** 调用目标字符串 */
@ExcelProperty(value = "调用目标字符串")
private String invokeTarget;
/** cron执行表达式 */
@ExcelProperty(value = "cron执行表达式")
private String cronExpression;
/** 计划执行错误策略（1立即执行 2执行一次 3放弃执行） */
private String misfirePolicy;
/** 是否并发执行（0允许 1禁止） */
private String concurrent;
/** 状态（0正常 1暂停） */
@ExcelProperty(value = "状态（0正常 1暂停）")
private String status;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/domain/SysJob.java
|
Java
|
unknown
| 1,568
|
package com.jcm.job.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* log对象 sys_job_log
*
* @author lvshihao
* @date 2025-01-14
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ExcelIgnoreUnannotated
@TableName("sys_job_log")
public class SysJobLog extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 任务日志ID */
@TableId(type = IdType.AUTO)
@ExcelProperty(value = "${comment}")
private Long jobLogId;
/** 任务名称 */
@ExcelProperty(value = "任务名称")
private String jobName;
/** 任务组名 */
@ExcelProperty(value = "任务组名")
private String jobGroup;
/** 调用目标字符串 */
@ExcelProperty(value = "调用目标字符串")
private String invokeTarget;
/** 日志信息 */
@ExcelProperty(value = "日志信息")
private String jobMessage;
/** 执行状态（0正常 1失败） */
@ExcelProperty(value = "执行状态（0正常 1失败）")
private String status;
/** 异常信息 */
private String exceptionInfo;
/** 开始时间 */
@TableField(exist = false)
private Date startTime;
/** 停止时间 */
@TableField(exist = false)
private Date stopTime;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/domain/SysJobLog.java
|
Java
|
unknown
| 1,684
|
package com.jcm.job.mapper;
import java.util.List;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.job.domain.SysJobLog;
/**
* logMapper接口
*
* @author lvshihao
* @date 2025-01-14
*/
public interface SysJobLogMapper extends BaseMapper<SysJobLog>
{
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/mapper/SysJobLogMapper.java
|
Java
|
unknown
| 286
|
package com.jcm.job.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.job.domain.SysJob;
/**
* jobMapper接口
*
* @author lvshihao
* @date 2025-01-14
*/
public interface SysJobMapper extends BaseMapper<SysJob>
{
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/mapper/SysJobMapper.java
|
Java
|
unknown
| 254
|
package com.jcm.job.service;
import com.jcm.job.domain.SysJobLog;
import java.util.List;
/**
* logService接口
*
* @author lvshihao
* @date 2025-01-14
*/
public interface ISysJobLogService
{
/**
* 查询定时任务调度日志
*
* @param jobLogId 定时任务调度日志主键
* @return 定时任务调度日志
*/
public SysJobLog selectSysJobLogByJobLogId(Long jobLogId);
/**
* 查询定时任务调度日志列表
*
* @param sysJobLog 定时任务调度日志
* @return 定时任务调度日志集合
*/
public List<SysJobLog> selectSysJobLogList(SysJobLog sysJobLog);
/**
* 新增定时任务调度日志
*
* @param sysJobLog 定时任务调度日志
* @return 结果
*/
public int insertSysJobLog(SysJobLog sysJobLog);
/**
* 修改定时任务调度日志
*
* @param sysJobLog 定时任务调度日志
* @return 结果
*/
public int updateSysJobLog(SysJobLog sysJobLog);
/**
* 批量删除定时任务调度日志
*
* @param jobLogIds 需要删除的定时任务调度日志主键集合
* @return 结果
*/
public int deleteSysJobLogByJobLogIds(Long[] jobLogIds);
/**
* 删除定时任务调度日志信息
*
* @param jobLogId 定时任务调度日志主键
* @return 结果
*/
public int deleteSysJobLogByJobLogId(Long jobLogId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/service/ISysJobLogService.java
|
Java
|
unknown
| 1,460
|
package com.jcm.job.service;
import com.jcm.job.domain.SysJob;
import java.util.List;
/**
* jobService接口
*
* @author lvshihao
* @date 2025-01-14
*/
public interface ISysJobService
{
/**
* 查询定时任务调度
*
* @param jobId 定时任务调度主键
* @return 定时任务调度
*/
public SysJob selectSysJobByJobId(Long jobId);
/**
* 查询定时任务调度列表
*
* @param sysJob 定时任务调度
* @return 定时任务调度集合
*/
public List<SysJob> selectSysJobList(SysJob sysJob);
/**
* 新增定时任务调度
*
* @param sysJob 定时任务调度
* @return 结果
*/
public int insertSysJob(SysJob sysJob);
/**
* 修改定时任务调度
*
* @param sysJob 定时任务调度
* @return 结果
*/
public int updateSysJob(SysJob sysJob);
/**
* 批量删除定时任务调度
*
* @param jobIds 需要删除的定时任务调度主键集合
* @return 结果
*/
public int deleteSysJobByJobIds(Long[] jobIds);
/**
* 删除定时任务调度信息
*
* @param jobId 定时任务调度主键
* @return 结果
*/
public int deleteSysJobByJobId(Long jobId);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/service/ISysJobService.java
|
Java
|
unknown
| 1,292
|
package com.jcm.job.service.impl;
import java.util.List;
import java.util.Arrays;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.utils.StringUtils;
import lombok.AllArgsConstructor;
import com.jcm.common.core.utils.DateUtils;
import org.springframework.stereotype.Service;
import com.jcm.job.mapper.SysJobLogMapper;
import com.jcm.job.domain.SysJobLog;
import com.jcm.job.service.ISysJobLogService;
/**
* logService业务层处理
*
* @author lvshihao
* @date 2025-01-14
*/
@Service
@AllArgsConstructor
public class SysJobLogServiceImpl extends ServiceImpl<SysJobLogMapper, SysJobLog> implements ISysJobLogService {
private final SysJobLogMapper sysJobLogMapper;
/**
* 查询定时任务调度日志
*
* @param jobLogId 定时任务调度日志主键
* @return 定时任务调度日志
*/
@Override
public SysJobLog selectSysJobLogByJobLogId(Long jobLogId)
{
return sysJobLogMapper.selectById(jobLogId);
}
/**
* 查询定时任务调度日志列表
*
* @param sysJobLog 定时任务调度日志
* @return 定时任务调度日志
*/
@Override
public List<SysJobLog> selectSysJobLogList(SysJobLog sysJobLog)
{
LambdaQueryWrapper<SysJobLog> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(SysJobLog::getJobLogId, SysJobLog::getJobName, SysJobLog::getJobGroup, SysJobLog::getInvokeTarget, SysJobLog::getJobMessage, SysJobLog::getStatus, SysJobLog::getExceptionInfo, SysJobLog::getRemark, SysJobLog::getCreator, SysJobLog::getCreateTime, SysJobLog::getUpdater, SysJobLog::getUpdateTime, SysJobLog::getDeleted );
queryWrapper.like( StringUtils.isNotEmpty(sysJobLog.getJobName()) , SysJobLog::getJobName, sysJobLog.getJobName());
queryWrapper.eq( StringUtils.isNotEmpty(sysJobLog.getJobGroup()) , SysJobLog::getJobGroup, sysJobLog.getJobGroup());
queryWrapper.eq( StringUtils.isNotEmpty(sysJobLog.getInvokeTarget()) , SysJobLog::getInvokeTarget, sysJobLog.getInvokeTarget());
queryWrapper.eq( StringUtils.isNotEmpty(sysJobLog.getJobMessage()) , SysJobLog::getJobMessage, sysJobLog.getJobMessage());
queryWrapper.eq( StringUtils.isNotEmpty(sysJobLog.getStatus()) , SysJobLog::getStatus, sysJobLog.getStatus());
queryWrapper.eq( StringUtils.isNotEmpty(sysJobLog.getExceptionInfo()) , SysJobLog::getExceptionInfo, sysJobLog.getExceptionInfo());
queryWrapper.eq( StringUtils.isNotNull(sysJobLog.getCreateTime()), SysJobLog::getCreateTime, sysJobLog.getCreateTime());
return sysJobLogMapper.selectList(queryWrapper);
}
/**
* 新增定时任务调度日志
*
* @param sysJobLog 定时任务调度日志
* @return 结果
*/
@Override
public int insertSysJobLog(SysJobLog sysJobLog)
{
return sysJobLogMapper.insert(sysJobLog);
}
/**
* 修改定时任务调度日志
*
* @param sysJobLog 定时任务调度日志
* @return 结果
*/
@Override
public int updateSysJobLog(SysJobLog sysJobLog)
{
return sysJobLogMapper.updateById(sysJobLog);
}
/**
* 批量删除定时任务调度日志
*
* @param jobLogIds 需要删除的定时任务调度日志主键
* @return 结果
*/
@Override
public int deleteSysJobLogByJobLogIds(Long[] jobLogIds)
{
return sysJobLogMapper.deleteBatchIds(Arrays.asList(jobLogIds));
}
/**
* 删除定时任务调度日志信息
*
* @param jobLogId 定时任务调度日志主键
* @return 结果
*/
@Override
public int deleteSysJobLogByJobLogId(Long jobLogId)
{
return sysJobLogMapper.deleteById(jobLogId);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/service/impl/SysJobLogServiceImpl.java
|
Java
|
unknown
| 3,864
|
package com.jcm.job.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jcm.common.core.exception.job.TaskException;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.job.domain.SysJob;
import com.jcm.job.mapper.SysJobMapper;
import com.jcm.job.service.ISysJobService;
import com.jcm.job.util.ScheduleUtils;
import lombok.AllArgsConstructor;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List;
/**
* jobService业务层处理
*
* @author lvshihao
* @date 2025-01-14
*/
@Service
@AllArgsConstructor
public class SysJobServiceImpl extends ServiceImpl<SysJobMapper, SysJob> implements ISysJobService {
private final Scheduler scheduler;
private final SysJobMapper sysJobMapper;
/**
* 项目启动时，初始化定时器 主要是防止手动修改数据库导致未同步到定时任务处理（注：不能手动修改数据库ID和任务组名，否则会导致脏数据）
*/
@PostConstruct
public void init() throws SchedulerException, TaskException
{
scheduler.clear();
List<SysJob> jobList = sysJobMapper.selectList(null);
for (SysJob job : jobList)
{
ScheduleUtils.createScheduleJob(scheduler, job);
}
}
/**
* 查询定时任务调度
*
* @param jobId 定时任务调度主键
* @return 定时任务调度
*/
@Override
public SysJob selectSysJobByJobId(Long jobId)
{
return sysJobMapper.selectById(jobId);
}
/**
* 查询定时任务调度列表
*
* @param sysJob 定时任务调度
* @return 定时任务调度
*/
@Override
public List<SysJob> selectSysJobList(SysJob sysJob)
{
LambdaQueryWrapper<SysJob> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(SysJob::getJobId, SysJob::getJobName, SysJob::getJobGroup, SysJob::getInvokeTarget, SysJob::getCronExpression, SysJob::getMisfirePolicy, SysJob::getConcurrent, SysJob::getStatus, SysJob::getRemark, SysJob::getCreator, SysJob::getCreateTime, SysJob::getUpdater, SysJob::getUpdateTime, SysJob::getDeleted );
queryWrapper.like( StringUtils.isNotEmpty(sysJob.getJobName()) , SysJob::getJobName, sysJob.getJobName());
queryWrapper.eq( StringUtils.isNotEmpty(sysJob.getJobGroup()) , SysJob::getJobGroup, sysJob.getJobGroup());
queryWrapper.eq( StringUtils.isNotEmpty(sysJob.getInvokeTarget()) , SysJob::getInvokeTarget, sysJob.getInvokeTarget());
queryWrapper.eq( StringUtils.isNotEmpty(sysJob.getCronExpression()) , SysJob::getCronExpression, sysJob.getCronExpression());
queryWrapper.eq( StringUtils.isNotEmpty(sysJob.getMisfirePolicy()) , SysJob::getMisfirePolicy, sysJob.getMisfirePolicy());
queryWrapper.eq( StringUtils.isNotEmpty(sysJob.getConcurrent()) , SysJob::getConcurrent, sysJob.getConcurrent());
queryWrapper.eq( StringUtils.isNotEmpty(sysJob.getStatus()) , SysJob::getStatus, sysJob.getStatus());
return sysJobMapper.selectList(queryWrapper);
}
/**
* 新增定时任务调度
*
* @param sysJob 定时任务调度
* @return 结果
*/
@Override
public int insertSysJob(SysJob sysJob)
{
return sysJobMapper.insert(sysJob);
}
/**
* 修改定时任务调度
*
* @param sysJob 定时任务调度
* @return 结果
*/
@Override
public int updateSysJob(SysJob sysJob)
{
return sysJobMapper.updateById(sysJob);
}
/**
* 批量删除定时任务调度
*
* @param jobIds 需要删除的定时任务调度主键
* @return 结果
*/
@Override
public int deleteSysJobByJobIds(Long[] jobIds)
{
return sysJobMapper.deleteBatchIds(Arrays.asList(jobIds));
}
/**
* 删除定时任务调度信息
*
* @param jobId 定时任务调度主键
* @return 结果
*/
@Override
public int deleteSysJobByJobId(Long jobId)
{
return sysJobMapper.deleteById(jobId);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/service/impl/SysJobServiceImpl.java
|
Java
|
unknown
| 4,289
|
package com.jcm.job.task;
import com.jcm.common.core.utils.StringUtils;
import org.springframework.stereotype.Component;
/**
* 定时任务调度测试
*
* @author junchenmo
*/
@Component("ryTask")
public class RyTask
{
public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i)
{
System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}", s, b, l, d, i));
}
public void ryParams(String params)
{
System.out.println("执行有参方法：" + params);
}
public void ryNoParams()
{
System.out.println("执行无参方法");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/task/RyTask.java
|
Java
|
unknown
| 693
|
package com.jcm.job.util;
import com.jcm.common.core.constant.ScheduleConstants;
import com.jcm.common.core.utils.ExceptionUtil;
import com.jcm.common.core.utils.SpringUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.utils.bean.BeanUtils;
import com.jcm.job.domain.SysJob;
import com.jcm.job.domain.SysJobLog;
import com.jcm.job.service.ISysJobLogService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
/**
* 抽象quartz调用
*
* @author junchenmo
*/
public abstract class AbstractQuartzJob implements Job
{
private static final Logger log = LoggerFactory.getLogger(AbstractQuartzJob.class);
/**
* 线程本地变量
*/
private static ThreadLocal<Date> threadLocal = new ThreadLocal<>();
@Override
public void execute(JobExecutionContext context) throws JobExecutionException
{
SysJob sysJob = new SysJob();
BeanUtils.copyBeanProp(sysJob, context.getMergedJobDataMap().get(ScheduleConstants.TASK_PROPERTIES));
try
{
before(context, sysJob);
if (sysJob != null)
{
doExecute(context, sysJob);
}
after(context, sysJob, null);
}
catch (Exception e)
{
log.error("任务执行异常 - ：", e);
after(context, sysJob, e);
}
}
/**
* 执行前
*
* @param context 工作执行上下文对象
* @param sysJob 系统计划任务
*/
protected void before(JobExecutionContext context, SysJob sysJob)
{
threadLocal.set(new Date());
}
/**
* 执行后
*
* @param context 工作执行上下文对象
* @param sysJob 系统计划任务
*/
protected void after(JobExecutionContext context, SysJob sysJob, Exception e)
{
Date startTime = threadLocal.get();
threadLocal.remove();
final SysJobLog sysJobLog = new SysJobLog();
sysJobLog.setJobName(sysJob.getJobName());
sysJobLog.setJobGroup(sysJob.getJobGroup());
sysJobLog.setInvokeTarget(sysJob.getInvokeTarget());
sysJobLog.setStartTime(startTime);
sysJobLog.setStopTime(new Date());
long runMs = sysJobLog.getStopTime().getTime() - sysJobLog.getStartTime().getTime();
sysJobLog.setJobMessage(sysJobLog.getJobName() + " 总共耗时：" + runMs + "毫秒");
if (e != null)
{
sysJobLog.setStatus("1");
String errorMsg = StringUtils.substring(ExceptionUtil.getExceptionMessage(e), 0, 2000);
sysJobLog.setExceptionInfo(errorMsg);
}
else
{
sysJobLog.setStatus("0");
}
// 写入数据库当中
SpringUtils.getBean(ISysJobLogService.class).insertSysJobLog(sysJobLog);
}
/**
* 执行方法，由子类重载
*
* @param context 工作执行上下文对象
* @param sysJob 系统计划任务
* @throws Exception 执行过程中的异常
*/
protected abstract void doExecute(JobExecutionContext context, SysJob sysJob) throws Exception;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/util/AbstractQuartzJob.java
|
Java
|
unknown
| 3,266
|
package com.jcm.job.util;
import org.quartz.CronExpression;
import java.text.ParseException;
import java.util.Date;
/**
* cron表达式工具类
*
* @author junchenmo
*
*/
public class CronUtils
{
/**
* 返回一个布尔值代表一个给定的Cron表达式的有效性
*
* @param cronExpression Cron表达式
* @return boolean 表达式是否有效
*/
public static boolean isValid(String cronExpression)
{
return CronExpression.isValidExpression(cronExpression);
}
/**
* 返回一个字符串值,表示该消息无效Cron表达式给出有效性
*
* @param cronExpression Cron表达式
* @return String 无效时返回表达式错误描述,如果有效返回null
*/
public static String getInvalidMessage(String cronExpression)
{
try
{
new CronExpression(cronExpression);
return null;
}
catch (ParseException pe)
{
return pe.getMessage();
}
}
/**
* 返回下一个执行时间根据给定的Cron表达式
*
* @param cronExpression Cron表达式
* @return Date 下次Cron表达式执行时间
*/
public static Date getNextExecution(String cronExpression)
{
try
{
CronExpression cron = new CronExpression(cronExpression);
return cron.getNextValidTimeAfter(new Date(System.currentTimeMillis()));
}
catch (ParseException e)
{
throw new IllegalArgumentException(e.getMessage());
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/util/CronUtils.java
|
Java
|
unknown
| 1,593
|
package com.jcm.job.util;
import com.jcm.common.core.utils.SpringUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.job.domain.SysJob;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.LinkedList;
import java.util.List;
/**
* 任务执行工具
*
* @author junchenmo
*/
public class JobInvokeUtil
{
/**
* 执行方法
*
* @param sysJob 系统任务
*/
public static void invokeMethod(SysJob sysJob) throws Exception
{
String invokeTarget = sysJob.getInvokeTarget();
String beanName = getBeanName(invokeTarget);
String methodName = getMethodName(invokeTarget);
List<Object[]> methodParams = getMethodParams(invokeTarget);
if (!isValidClassName(beanName))
{
Object bean = SpringUtils.getBean(beanName);
invokeMethod(bean, methodName, methodParams);
}
else
{
Object bean = Class.forName(beanName).getDeclaredConstructor().newInstance();
invokeMethod(bean, methodName, methodParams);
}
}
/**
* 调用任务方法
*
* @param bean 目标对象
* @param methodName 方法名称
* @param methodParams 方法参数
*/
private static void invokeMethod(Object bean, String methodName, List<Object[]> methodParams)
throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (StringUtils.isNotNull(methodParams) && methodParams.size() > 0)
{
Method method = bean.getClass().getMethod(methodName, getMethodParamsType(methodParams));
method.invoke(bean, getMethodParamsValue(methodParams));
}
else
{
Method method = bean.getClass().getMethod(methodName);
method.invoke(bean);
}
}
/**
* 校验是否为为class包名
*
* @param invokeTarget 名称
* @return true是 false否
*/
public static boolean isValidClassName(String invokeTarget)
{
return StringUtils.countMatches(invokeTarget, ".") > 1;
}
/**
* 获取bean名称
*
* @param invokeTarget 目标字符串
* @return bean名称
*/
public static String getBeanName(String invokeTarget)
{
String beanName = StringUtils.substringBefore(invokeTarget, "(");
return StringUtils.substringBeforeLast(beanName, ".");
}
/**
* 获取bean方法
*
* @param invokeTarget 目标字符串
* @return method方法
*/
public static String getMethodName(String invokeTarget)
{
String methodName = StringUtils.substringBefore(invokeTarget, "(");
return StringUtils.substringAfterLast(methodName, ".");
}
/**
* 获取method方法参数相关列表
*
* @param invokeTarget 目标字符串
* @return method方法相关参数列表
*/
public static List<Object[]> getMethodParams(String invokeTarget)
{
String methodStr = StringUtils.substringBetween(invokeTarget, "(", ")");
if (StringUtils.isEmpty(methodStr))
{
return null;
}
String[] methodParams = methodStr.split(",(?=([^\"']*[\"'][^\"']*[\"'])*[^\"']*$)");
List<Object[]> classs = new LinkedList<>();
for (int i = 0; i < methodParams.length; i++)
{
String str = StringUtils.trimToEmpty(methodParams[i]);
// String字符串类型，以'或"开头
if (StringUtils.startsWithAny(str, "'", "\""))
{
classs.add(new Object[] { StringUtils.substring(str, 1, str.length() - 1), String.class });
}
// boolean布尔类型，等于true或者false
else if ("true".equalsIgnoreCase(str) || "false".equalsIgnoreCase(str))
{
classs.add(new Object[] { Boolean.valueOf(str), Boolean.class });
}
// long长整形，以L结尾
else if (StringUtils.endsWith(str, "L"))
{
classs.add(new Object[] { Long.valueOf(StringUtils.substring(str, 0, str.length() - 1)), Long.class });
}
// double浮点类型，以D结尾
else if (StringUtils.endsWith(str, "D"))
{
classs.add(new Object[] { Double.valueOf(StringUtils.substring(str, 0, str.length() - 1)), Double.class });
}
// 其他类型归类为整形
else
{
classs.add(new Object[] { Integer.valueOf(str), Integer.class });
}
}
return classs;
}
/**
* 获取参数类型
*
* @param methodParams 参数相关列表
* @return 参数类型列表
*/
public static Class<?>[] getMethodParamsType(List<Object[]> methodParams)
{
Class<?>[] classs = new Class<?>[methodParams.size()];
int index = 0;
for (Object[] os : methodParams)
{
classs[index] = (Class<?>) os[1];
index++;
}
return classs;
}
/**
* 获取参数值
*
* @param methodParams 参数相关列表
* @return 参数值列表
*/
public static Object[] getMethodParamsValue(List<Object[]> methodParams)
{
Object[] classs = new Object[methodParams.size()];
int index = 0;
for (Object[] os : methodParams)
{
classs[index] = (Object) os[0];
index++;
}
return classs;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/util/JobInvokeUtil.java
|
Java
|
unknown
| 5,660
|
package com.jcm.job.util;
import com.jcm.job.domain.SysJob;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
/**
* 定时任务处理（禁止并发执行）
*
* @author junchenmo
*
*/
@DisallowConcurrentExecution
public class QuartzDisallowConcurrentExecution extends AbstractQuartzJob
{
@Override
protected void doExecute(JobExecutionContext context, SysJob sysJob) throws Exception
{
JobInvokeUtil.invokeMethod(sysJob);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/util/QuartzDisallowConcurrentExecution.java
|
Java
|
unknown
| 496
|
package com.jcm.job.util;
import com.jcm.job.domain.SysJob;
import org.quartz.JobExecutionContext;
/**
* 定时任务处理（允许并发执行）
*
* @author junchenmo
*
*/
public class QuartzJobExecution extends AbstractQuartzJob
{
@Override
protected void doExecute(JobExecutionContext context, SysJob sysJob) throws Exception
{
JobInvokeUtil.invokeMethod(sysJob);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/util/QuartzJobExecution.java
|
Java
|
unknown
| 405
|
package com.jcm.job.util;
import com.jcm.common.core.constant.Constants;
import com.jcm.common.core.constant.ScheduleConstants;
import com.jcm.common.core.exception.job.TaskException;
import com.jcm.common.core.exception.job.TaskException.Code;
import com.jcm.common.core.utils.SpringUtils;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.job.domain.SysJob;
import org.quartz.*;
/**
* 定时任务工具类
*
* @author junchenmo
*
*/
public class ScheduleUtils
{
/**
* 得到quartz任务类
*
* @param sysJob 执行计划
* @return 具体执行任务类
*/
private static Class<? extends Job> getQuartzJobClass(SysJob sysJob)
{
boolean isConcurrent = "0".equals(sysJob.getConcurrent());
return isConcurrent ? QuartzJobExecution.class : QuartzDisallowConcurrentExecution.class;
}
/**
* 构建任务触发对象
*/
public static TriggerKey getTriggerKey(Long jobId, String jobGroup)
{
return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
}
/**
* 构建任务键对象
*/
public static JobKey getJobKey(Long jobId, String jobGroup)
{
return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
}
/**
* 创建定时任务
*/
public static void createScheduleJob(Scheduler scheduler, SysJob job) throws SchedulerException, TaskException
{
Class<? extends Job> jobClass = getQuartzJobClass(job);
// 构建job信息
Long jobId = job.getJobId();
String jobGroup = job.getJobGroup();
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(getJobKey(jobId, jobGroup)).build();
// 表达式调度构建器
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);
// 按新的cronExpression表达式构建一个新的trigger
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(jobId, jobGroup))
.withSchedule(cronScheduleBuilder).build();
// 放入参数，运行时的方法可以获取
jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);
// 判断是否存在
if (scheduler.checkExists(getJobKey(jobId, jobGroup)))
{
// 防止创建时存在数据问题 先移除，然后在执行创建操作
scheduler.deleteJob(getJobKey(jobId, jobGroup));
}
// 判断任务是否过期
if (StringUtils.isNotNull(CronUtils.getNextExecution(job.getCronExpression())))
{
// 执行调度任务
scheduler.scheduleJob(jobDetail, trigger);
}
// 暂停任务
if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
{
scheduler.pauseJob(ScheduleUtils.getJobKey(jobId, jobGroup));
}
}
/**
* 设置定时任务策略
*/
public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job, CronScheduleBuilder cb)
throws TaskException
{
switch (job.getMisfirePolicy())
{
case ScheduleConstants.MISFIRE_DEFAULT:
return cb;
case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
return cb.withMisfireHandlingInstructionIgnoreMisfires();
case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
return cb.withMisfireHandlingInstructionFireAndProceed();
case ScheduleConstants.MISFIRE_DO_NOTHING:
return cb.withMisfireHandlingInstructionDoNothing();
default:
throw new TaskException("The task misfire policy '" + job.getMisfirePolicy()
+ "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
}
}
/**
* 检查包名是否为白名单配置
*
* @param invokeTarget 目标字符串
* @return 结果
*/
public static boolean whiteList(String invokeTarget)
{
String packageName = StringUtils.substringBefore(invokeTarget, "(");
int count = StringUtils.countMatches(packageName, ".");
if (count > 1)
{
return StringUtils.containsAnyIgnoreCase(invokeTarget, Constants.JOB_WHITELIST_STR);
}
Object obj = SpringUtils.getBean(StringUtils.split(invokeTarget, ".")[0]);
String beanPackageName = obj.getClass().getPackage().getName();
return StringUtils.containsAnyIgnoreCase(beanPackageName, Constants.JOB_WHITELIST_STR)
&& !StringUtils.containsAnyIgnoreCase(beanPackageName, Constants.JOB_ERROR_STR);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-job/src/main/java/com/jcm/job/util/ScheduleUtils.java
|
Java
|
unknown
| 4,805
|
package com.jcm.monitor;
import de.codecentric.boot.admin.server.config.EnableAdminServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableAdminServer
@SpringBootApplication
public class JcmMonitorApplication {
public static void main(String[] args) {
SpringApplication.run(JcmMonitorApplication.class, args);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-monitor/src/main/java/com/jcm/monitor/JcmMonitorApplication.java
|
Java
|
unknown
| 412
|
package com.jcm.system;
import com.jcm.common.security.annotation.EnableCustomConfig;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @author 君尘陌
*/
@EnableFeignClients("com.jcm.system.api")
@MapperScan("com.jcm.system.mapper")
@EnableCustomConfig
@SpringBootApplication
public class JcmSystemApplication
{
public static void main(String[] args)
{
SpringApplication.run(JcmSystemApplication.class, args);
System.out.println(" (♥◠‿◠)ﾉﾞ 系统模块启动成功 ლ(´ڡ`ლ)ﾞ ");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/JcmSystemApplication.java
|
Java
|
unknown
| 729
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.service.SysCacheListService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
/**
* <p>
* 缓存列表 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-11-24
*/
@Api(tags="缓存列表")
@ApiSupport(author = "202252197@qq.com",order = 7)
@BusinessName(title = OperationNameConstants.SYSTEM_CACHE_LIST)
@RestController
@AllArgsConstructor
@RequestMapping("/cacheList")
public class SysCacheListController extends PageBaseController {
private final SysCacheListService sysCacheListService;
@ApiOperation(value = "删除键名列表",notes = "根据缓存名称删除键名列表")
@RequiresPermissions("system:dictType:list")
@DeleteMapping("/deleteCacheName")
@PrintParams
public AjaxResult removeCacheName(@RequestParam String cacheName)
{
return toAjax(sysCacheListService.deleteCacheName(cacheName));
}
@ApiOperation(value = "删除缓存",notes = "根据缓存键名删除缓存")
@RequiresPermissions("system:dictType:list")
@DeleteMapping("/deleteCacheKey")
@PrintParams
public AjaxResult removeCacheKey(@RequestParam String keyName)
{
return toAjax(sysCacheListService.deleteCacheKey(keyName));
}
@ApiOperation(value = "查询键名列表",notes = "根据缓存名称查询")
@RequiresPermissions("system:dictType:list")
@GetMapping("/getRedisKeys")
@PrintParams
public AjaxResult getRedisKeys(@RequestParam String cacheName)
{
return AjaxResult.success(sysCacheListService.getRedisKeysByCacheName(cacheName));
}
@ApiOperation(value = "查询缓存内容",notes = "根据键名查询缓存内容")
@RequiresPermissions("system:dictType:list")
@GetMapping("/getRedisKeyData")
@PrintParams
public AjaxResult getRedisKeyData(@RequestParam String keyName)
{
Object redisKeyData = sysCacheListService.getRedisKeyDataByKeyName(keyName);
if(StringUtils.isNotNull(redisKeyData)){
return AjaxResult.success(redisKeyData);
}else{
return AjaxResult.error("站不支持此类型");
}
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysCacheListController.java
|
Java
|
unknown
| 2,719
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.service.SysCacheMonitorService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author lvshihao
*/
@Api(tags="缓存监控")
@ApiSupport(author = "202252197@qq.com",order = 8)
@RestController
@AllArgsConstructor
@RequestMapping("/cacheMonitor")
public class SysCacheMonitorController extends PageBaseController {
private final SysCacheMonitorService sysCacheMonitorService;
@ApiOperation(value = "查询Redis服务基本信息")
@RequiresPermissions("system:dictType:list")
@GetMapping("/getRedisBaseInfo")
@PrintParams
public AjaxResult getRedisBaseInfo()
{
return AjaxResult.success(sysCacheMonitorService.getRedisBaseInfo());
}
@ApiOperation(value = "查询Redis所有配置信息")
@RequiresPermissions("system:dictType:list")
@GetMapping("/getRedisInfo")
@PrintParams
public AjaxResult getRedisInfo()
{
return AjaxResult.success(sysCacheMonitorService.getRedisInfo());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysCacheMonitorController.java
|
Java
|
unknown
| 1,564
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.domain.SysDictData;
import com.jcm.system.service.ISysDictDataService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 数据字典值 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-11-24
*/
@Api(tags="数据字典值管理")
@ApiSupport(author = "202252197@qq.com",order = 5)
@BusinessName(title = OperationNameConstants.SYSTEM_DICT_VALUE)
@RestController
@AllArgsConstructor
@RequestMapping("/dict-data")
public class SysDictDataController extends PageBaseController {
private final ISysDictDataService sysDictDataService;
@ApiOperation(value = "新增字典值")
@RequiresPermissions("system:role:add")
@Log(functionName = "新增字典值",businessType= BusinessType.INSERT)
@PostMapping
@PrintParams
public AjaxResult add(@RequestBody SysDictData dictData)
{
OperLogCover.insertLogMsg(BusinessNameConstant.DICT_DATA,dictData.getName());
return toAjax(sysDictDataService.insertDictData(dictData));
}
@ApiOperation(value = "删除字典值")
@RequiresPermissions("system:menu:remove")
@Log(functionName = "删除字典值",businessType= BusinessType.DELETE)
@DeleteMapping("/{dictDataIds}")
@PrintParams
public AjaxResult remove(@PathVariable List<Long> dictDataIds) {
OperLogCover.deleteLogMsg(BusinessNameConstant.DICT_DATA,dictDataIds.size());
return toAjax(sysDictDataService.deleteDictData(dictDataIds));
}
@ApiOperation(value = "修改字典值")
@RequiresPermissions("system:menu:edit")
@Log(functionName = "修改字典值",businessType= BusinessType.UPDATE)
@PutMapping
@PrintParams
public AjaxResult edit(@RequestBody SysDictData dictData)
{
OperLogCover.updateLogMsg(BusinessNameConstant.MENU,dictData.getDictDataId());
return toAjax(sysDictDataService.updateDictData(dictData));
}
@ApiOperation(value = "分页条件查询字典值列表")
@RequiresPermissions("system:dictData:list")
@GetMapping("/list")
@PrintParams
public TableDataInfo list(SysDictData dictType)
{
startPage();
List<SysDictData> list = sysDictDataService.selectDictDataList(dictType);
return getDataTable(list);
}
@ApiOperation(value = "根据字典名称查询字典信息集合",notes = "用于前端选项值的获取")
@RequiresPermissions("system:dictType:list")
@PostMapping("/getInfoByNames")
@PrintParams
public AjaxResult getInfoList(@RequestBody List<String> names)
{
return AjaxResult.success(sysDictDataService.getInfoList(names));
}
@ApiOperation(value = "刷新字典缓存")
@RequiresPermissions("system:dictType:list")
@GetMapping("/refreshDictDataCache")
@PrintParams
public AjaxResult refreshDictDataCache()
{
sysDictDataService.refreshDictDataCache();
return AjaxResult.success();
}
@ApiOperation(value = "字典项详情")
@RequiresPermissions("system:dictType:list")
@GetMapping("/getInfoByName/{name}")
@PrintParams
public AjaxResult getInfo(@PathVariable(name = "name") String name)
{
return AjaxResult.success(sysDictDataService.getInfo(name));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysDictDataController.java
|
Java
|
unknown
| 4,051
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.domain.SysDictType;
import com.jcm.system.service.ISysDictTypeService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 数据字典项 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-10-31
*/
@Api(tags="数据字典项管理")
@ApiSupport(author = "202252197@qq.com",order = 4)
@BusinessName(title = OperationNameConstants.SYSTEM_DICT_TYPE)
@RestController
@AllArgsConstructor
@RequestMapping("/dict-type")
public class SysDictTypeController extends PageBaseController {
private final ISysDictTypeService sysDictTypeService;
@ApiOperation(value = "新增字典项")
@RequiresPermissions("system:role:add")
@Log(functionName = "新增字典项",businessType= BusinessType.INSERT)
@PostMapping
@PrintParams
public AjaxResult add(@RequestBody SysDictType dictType)
{
OperLogCover.insertLogMsg(BusinessNameConstant.DICT_TYPE,dictType.getName());
return toAjax(sysDictTypeService.insertDictType(dictType));
}
@ApiOperation(value = "删除字典项")
@RequiresPermissions("system:menu:remove")
@Log(functionName = "删除字典项",businessType= BusinessType.DELETE)
@DeleteMapping("/{dictTypeIds}")
@PrintParams
public AjaxResult remove(@PathVariable List<Long> dictTypeIds) {
OperLogCover.deleteLogMsg(BusinessNameConstant.DICT_TYPE,dictTypeIds.size());
return toAjax(sysDictTypeService.deleteDictType(dictTypeIds));
}
@ApiOperation(value = "修改字典项")
@RequiresPermissions("system:menu:edit")
@Log(functionName = "修改字典项",businessType= BusinessType.UPDATE)
@PutMapping
@PrintParams
public AjaxResult edit(@RequestBody SysDictType dictType)
{
OperLogCover.updateLogMsg(BusinessNameConstant.MENU,dictType.getDictTypeId());
return toAjax(sysDictTypeService.updateDictType(dictType));
}
@ApiOperation(value = "分页条件查询字典项列表")
@RequiresPermissions("system:dictType:list")
@GetMapping("/list")
@PrintParams
public TableDataInfo list(SysDictType dictType)
{
startPage();
List<SysDictType> list = sysDictTypeService.selectDictTypeList(dictType);
return getDataTable(list);
}
@ApiOperation(value = "查询字典项的选项值")
@RequiresPermissions("system:dictType:list")
@GetMapping("/optionSelect")
@PrintParams
public AjaxResult optionSelect()
{
return success(sysDictTypeService.selectDictTypeAndExtraAllList());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysDictTypeController.java
|
Java
|
unknown
| 3,359
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.utils.poi.ExcelUtil;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.InnerAuth;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.api.domain.SysLogininfor;
import com.jcm.system.service.ISysLogininforService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* logininforController
*
* @author lvshihao
* @date 2025-01-11
*/
@Api(tags="logininfor管理")
@ApiSupport(author = "202252197@qq.com")
@BusinessName(title = OperationNameConstants.LOGIN_INFO)
@AllArgsConstructor
@RestController
@RequestMapping("/logininfor")
public class SysLogininforController extends PageBaseController
{
private final ISysLogininforService sysLogininforService;
/**
* 查询系统访问记录列表
*/
@RequiresPermissions("system:logininfor:list")
@GetMapping("/list")
public TableDataInfo list(SysLogininfor sysLogininfor)
{
startPage();
List<SysLogininfor> list = sysLogininforService.selectSysLogininforList(sysLogininfor);
return getDataTable(list);
}
/**
* 导出系统访问记录列表
*/
@RequiresPermissions("system:logininfor:export")
@Log(functionName = "导出系统访问记录列表", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, SysLogininfor sysLogininfor)
{
List<SysLogininfor> list = sysLogininforService.selectSysLogininforList(sysLogininfor);
ExcelUtil<SysLogininfor> util = new ExcelUtil<SysLogininfor>(SysLogininfor.class);
util.exportEasyExcel(response, list, "系统访问记录数据");
}
/**
* 新增系统访问记录
*/
@InnerAuth
@PostMapping
public AjaxResult add(@RequestBody SysLogininfor sysLogininfor)
{
return toAjax(sysLogininforService.insertSysLogininfor(sysLogininfor));
}
/**
* 删除系统访问记录
*/
@RequiresPermissions("system:logininfor:remove")
@Log(functionName = "删除系统访问记录", businessType = BusinessType.DELETE)
@DeleteMapping("/{infoIds}")
public AjaxResult remove(@PathVariable Long[] infoIds)
{
return toAjax(sysLogininforService.deleteSysLogininforByInfoIds(infoIds));
}
@ApiOperation(value = "清空系统访问记录")
@RequiresPermissions("system:logininfor:remove")
@Log(functionName = "清空系统访问记录", businessType = BusinessType.CLEAN)
@DeleteMapping("/clear")
@PrintParams
public AjaxResult clear() {
OperLogCover.outherLogMsg(BusinessNameConstant.LOGIN_INFO+"全部清空");
return toAjax(sysLogininforService.clearLogininfor());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysLogininforController.java
|
Java
|
unknown
| 3,498
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.domain.R;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.domain.SysMenu;
import com.jcm.system.domain.vo.RouterVo;
import com.jcm.system.service.ISysMenuService;
import com.jcm.system.service.ISysRoleMenuService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.v3.oas.annotations.Operation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
/**
* <p>
* 菜单管理 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
@Api(tags="菜单管理")
@ApiSupport(author = "202252197@qq.com",order = 3)
@BusinessName(title = OperationNameConstants.SYSTEM_MENU)
@RestController
@RequestMapping("/menu")
@AllArgsConstructor
public class SysMenuController extends PageBaseController {
private final ISysMenuService sysMenuService;
private final ISysRoleMenuService sysRoleMenuService;
@ApiOperation(value = "新增菜单")
@RequiresPermissions("system:menu:add")
@Log(functionName = "新增菜单",businessType= BusinessType.INSERT)
@PostMapping
@PrintParams
public AjaxResult add(@RequestBody SysMenu menu)
{
OperLogCover.insertLogMsg(BusinessNameConstant.MENU,menu.getName());
return toAjax(sysMenuService.insertMenu(menu));
}
@ApiOperation(value = "删除菜单")
@RequiresPermissions("system:menu:remove")
@Log(functionName = "删除菜单",businessType= BusinessType.DELETE)
@DeleteMapping("/{menuId}")
@PrintParams
public AjaxResult remove(@PathVariable("menuId") Long menuId) {
OperLogCover.deleteLogMsg(BusinessNameConstant.MENU,1);
return toAjax(sysMenuService.deleteMenu(menuId));
}
@ApiOperation(value = "修改菜单")
@RequiresPermissions("system:menu:edit")
@Log(functionName = "修改菜单",businessType= BusinessType.UPDATE)
@PutMapping
@PrintParams
public AjaxResult edit(@RequestBody SysMenu menu)
{
OperLogCover.updateLogMsg(BusinessNameConstant.MENU,menu.getMenuId());
return toAjax(sysMenuService.updateMenu(menu));
}
@ApiOperation(value = "分页条件查询菜单列表")
@RequiresPermissions("system:menu:list")
@Operation(summary = "获取全部菜单列表",description = "获取全部菜单列表，管理员才有次权限")
@GetMapping("/list")
@PrintParams
public AjaxResult list(SysMenu menu)
{
List<SysMenu> menus = sysMenuService.selectMenuAllTree(menu);
return success(menus);
}
@ApiOperation(value = "查询用户的路由列表")
@Operation(summary = "获取菜单列表",description = "获取前端路由列表")
@GetMapping("/getRouters")
@PrintParams
public AjaxResult getRouters()
{
Long userId = SecurityUtils.getUserId();
List<SysMenu> menus = sysMenuService.selectMenuTreeByUserId(userId);
List<SysMenu> routers = sysMenuService.selectRouterTreeByUserId(userId);
List<RouterVo> menusVos = sysMenuService.buildMenus(menus, null);
List<RouterVo> routerVos = sysMenuService.buildMenus(routers, null);
HashMap typeMap = new HashMap();
typeMap.put("menus",menusVos);
typeMap.put("routers",routerVos);
return success(typeMap);
}
@ApiOperation(value = "查询新增菜单Sort值",notes = "根据父菜单的ID查询子菜单最大的Sort+100")
@Operation(summary = "查询新增菜单最后的sort值",description = "通过id查询所有子菜单，对子菜单的最大sort加100返回")
@RequiresPermissions("system:menu:list")
@GetMapping("/getChildLastSort/{parentId}")
@PrintParams
public AjaxResult getMenuChildLastSort(@PathVariable("parentId") Long parentId)
{
Integer childLastSort = sysMenuService.getMenuChildLastSort(parentId) + 100;
return success(childLastSort);
}
@ApiOperation(value = "查询首页动态设置的icon图标")
@RequiresPermissions("system:menu:list")
@Operation(summary = "查询首页图标名称",description = "获取首页动态设置的icon图标")
@GetMapping("/getHomeMenuIcon")
@PrintParams
public AjaxResult getHomeMenuIcon()
{
String homeIcon = sysMenuService.getHomeMenuIcon();
return success(homeIcon);
}
@ApiOperation(value = "查询角色菜单")
@PrintParams
@RequiresPermissions("system:menu:list")
@GetMapping("/queryRoleMenus/{roleId}")
public R queryRoleMenus(@PathVariable Integer roleId)
{
return R.ok(sysRoleMenuService.queryMenuIdsByRoleId(roleId));
}
@ApiOperation(value = "修改菜单及子菜单状态")
@PutMapping("/changeStatusWithChildStatus")
@RequiresPermissions("system:user:disableAccount")
@PrintParams
public AjaxResult changeStatusWithChildStatus(@RequestBody SysMenu menu) {
sysMenuService.changeStatusWithChildStatus(menu);
return toAjax(true);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysMenuController.java
|
Java
|
unknown
| 5,670
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.utils.poi.ExcelUtil;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.InnerAuth;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.api.domain.SysOperLog;
import com.jcm.system.service.ISysOperLogService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* <p>
* 操作日志 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-05-03
*/
@Api(tags="操作日志")
@ApiSupport(author = "202252197@qq.com",order = 6)
@BusinessName(title = OperationNameConstants.SYSTEM_OPERATION_LOG)
@RestController
@AllArgsConstructor
@RequestMapping("/operlog")
public class SysOperLogController extends PageBaseController {
private final ISysOperLogService sysOperLogService;
@InnerAuth
@ApiOperation(value = "新增操作日志",notes = "内部服务使用")
@PostMapping
public AjaxResult add(@RequestBody SysOperLog operLog)
{
return toAjax(sysOperLogService.insertOperlog(operLog));
}
@ApiOperation(value = "删除操作日志")
@RequiresPermissions("system:menu:remove")
@DeleteMapping("/{operIds}")
@PrintParams
public AjaxResult remove(@PathVariable List<Long> operIds) {
OperLogCover.deleteLogMsg(BusinessNameConstant.OPERATION_LOG,operIds.size());
return toAjax( sysOperLogService.deleteOperLog(operIds));
}
@ApiOperation(value = "清空操作日志")
@RequiresPermissions("system:menu:remove")
@DeleteMapping("/clear")
@PrintParams
public AjaxResult clear() {
OperLogCover.outherLogMsg(BusinessNameConstant.OPERATION_LOG+"全部清空");
return toAjax(sysOperLogService.clearOperLog());
}
@ApiOperation(value = "分页条件查询操作日志列表")
@RequiresPermissions("system:user:list")
@GetMapping("/list")
@PrintParams
public TableDataInfo list(SysOperLog sysOperLog) {
startPage();
List<SysOperLog> list = sysOperLogService.selectOperLogList(sysOperLog);
return getDataTable(list);
}
@ApiOperation(value = "获取可查询的操作用户选项值")
@RequiresPermissions("system:user:list")
@GetMapping("/nameOptionSelect")
@PrintParams
public AjaxResult nameOptionSelect() {
return AjaxResult.success(sysOperLogService.nameOptionSelect());
}
@ApiOperation(value = "获取可查询的模块标题选项值")
@RequiresPermissions("system:user:list")
@GetMapping("/titleOptionSelect")
@PrintParams
public AjaxResult titleOptionSelect() {
return AjaxResult.success(sysOperLogService.titleOptionSelect());
}
@ApiOperation(value = "获取可查询的业务名称选项值")
@RequiresPermissions("system:user:list")
@GetMapping("/businessNameOptionSelectByTitle")
@PrintParams
public AjaxResult businessNameOptionSelectByTitle(@RequestParam("title") String title) {
return AjaxResult.success(sysOperLogService.businessNameOptionSelectByTitle(title));
}
@ApiOperation(value = "导出日志")
@Log(functionName = "导出日志", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:operlog:export")
@PostMapping("/export")
public void export(HttpServletResponse response, SysOperLog operLog)
{
List<SysOperLog> list = sysOperLogService.selectOperLogList(operLog);
ExcelUtil<SysOperLog> util = new ExcelUtil<>(SysOperLog.class);
util.exportEasyExcel(response, list, "操作日志");
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysOperLogController.java
|
Java
|
unknown
| 4,284
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.domain.SysRole;
import com.jcm.system.service.ISysRoleService;
import com.jcm.system.service.ISysUserRoleService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 角色管理 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
@Api(tags="角色管理")
@ApiSupport(author = "202252197@qq.com",order = 2)
@BusinessName(title = OperationNameConstants.SYSTEM_ROLE)
@RestController
@AllArgsConstructor
@RequestMapping("/role")
public class SysRoleController extends PageBaseController {
private final ISysRoleService sysRoleService;
private final ISysUserRoleService sysUserRoleService;
@ApiOperation(value = "新增角色", notes = "新增角色的时候判断角色名称，角色编码是否存在")
@RequiresPermissions("system:role:add")
@Log(functionName = "新增角色",businessType= BusinessType.INSERT)
@PostMapping
@PrintParams
public AjaxResult add(@RequestBody SysRole role)
{
OperLogCover.insertLogMsg(BusinessNameConstant.ROLE,role.getName());
if (!sysRoleService.checkRoleNameUnique(role))
{
return error("新增角色'" + role.getName() + "'失败，角色名称已存在");
}
else if (!sysRoleService.checkRoleKeyUnique(role))
{
return error("新增角色'" + role.getCode() + "'失败，角色权限已存在");
}
return toAjax(sysRoleService.insertRole(role));
}
@ApiOperation(value = "删除角色")
@RequiresPermissions("system:role:remove")
@Log(functionName = "删除角色",businessType= BusinessType.DELETE)
@DeleteMapping("/{roleIds}")
@PrintParams
public AjaxResult remove(@PathVariable List<Long> roleIds) {
OperLogCover.deleteLogMsg(BusinessNameConstant.ROLE,roleIds.size());
return toAjax(sysRoleService.deleteRole(roleIds));
}
@ApiOperation(value = "修改角色")
@RequiresPermissions("system:role:edit")
@Log(functionName = "修改角色",businessType= BusinessType.UPDATE)
@PutMapping
@PrintParams
public AjaxResult edit(@RequestBody SysRole role)
{
OperLogCover.updateLogMsg(BusinessNameConstant.USER,role.getRoleId());
return toAjax(sysRoleService.updateRole(role));
}
@ApiOperation(value = "分页条件查询角色列表")
@RequiresPermissions("system:role:list")
@GetMapping("/list")
@PrintParams
public TableDataInfo list(SysRole role)
{
startPage();
List<SysRole> list = sysRoleService.selectRoleList(role);
return getDataTable(list);
}
@ApiOperation(value = "禁用角色")
@RequiresPermissions("system:role:editStatus")
@PutMapping("/changeStatus")
public AjaxResult changeStatus(@RequestBody SysRole role)
{
sysRoleService.checkRoleAllowed(role);
return toAjax(sysRoleService.updateRoleStatus(role));
}
@ApiOperation(value = "查询角色选项值")
@RequiresPermissions("system:role:list")
@GetMapping("/optionSelect")
@PrintParams
public AjaxResult optionSelect()
{
return success(sysRoleService.selectRoleAll());
}
@ApiOperation(value = "查询用户角色")
@PrintParams
@RequiresPermissions("system:role:list")
@GetMapping("/authUser/allocatedList/{userId}")
public AjaxResult allocatedList(@PathVariable Long userId)
{
return success(sysUserRoleService.selectAllocatedList(userId));
}
@ApiOperation(value = "授权角色菜单")
@PrintParams
@RequiresPermissions("system:role:authMenu")
@PutMapping("/authMenu")
public AjaxResult insertAuthMenu(Long roleId,Long[] menusId)
{
return toAjax(sysRoleService.insertRoleAuth(roleId,menusId));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysRoleController.java
|
Java
|
unknown
| 4,597
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.service.SysSystemMonitorService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author lvshihao
*/
@Api(tags="服务监控")
@ApiSupport(author = "202252197@qq.com",order = 9)
@RestController
@AllArgsConstructor
@RequestMapping("/systemMonitor")
public class SysSystemMonitorController {
private final SysSystemMonitorService sysSystemMonitorService;
@ApiOperation(value = "查询系统的CPU和内存")
@RequiresPermissions("system:dictType:list")
@GetMapping("/getSystemBaseInfo")
@PrintParams
public AjaxResult getSystemBaseInfo()
{
return AjaxResult.success(sysSystemMonitorService.getSystemBaseInfo());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysSystemMonitorController.java
|
Java
|
unknown
| 1,200
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.constant.UserConstants;
import com.jcm.common.core.domain.R;
import com.jcm.common.core.utils.StringUtils;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.constant.BusinessNameConstant;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.utils.OperLogCover;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.InnerAuth;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.api.domain.SysUser;
import com.jcm.system.api.model.LoginUser;
import com.jcm.system.service.ISysMenuService;
import com.jcm.system.service.ISysRoleService;
import com.jcm.system.service.ISysUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Set;
/**
* <p>
* 用户管理 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
@Api(tags="用户管理")
@ApiSupport(author = "202252197@qq.com",order = 1)
@BusinessName(title = OperationNameConstants.SYSTEM_USER)
@RestController
@AllArgsConstructor
@RequestMapping("/user")
public class SysUserController extends PageBaseController {
private final ISysUserService sysUserService;
private final ISysMenuService sysPermissionService;
private final ISysRoleService sysRoleService;
@InnerAuth
@ApiOperation(value = "获取当前用户信息",notes = "内部服务使用")
@GetMapping("/info/{username}")
public R<LoginUser> info(@PathVariable("username") String username) {
SysUser sysUser = sysUserService.selectUserByUserName(username);
if (StringUtils.isNull(sysUser)) {
return R.fail("用户名或密码错误");
}
// 角色集合
Set<String> roles = sysRoleService.getRolePermission(sysUser);
// 权限集合
Set<String> permissions = sysPermissionService.getMenuPermission(sysUser);
LoginUser sysUserVo = new LoginUser();
sysUserVo.setSysUser(sysUser);
sysUserVo.setRoles(roles);
sysUserVo.setPermissions(permissions);
return R.ok(sysUserVo);
}
@InnerAuth
@ApiOperation(value = "修改用户最后登录时间和IP",notes = "内部服务使用")
@PutMapping("/changeLoginInfo")
public R<Integer> changeLoginInfo(@RequestBody SysUser sysUser) {
return R.ok(sysUserService.changeLoginInfo(sysUser));
}
@ApiOperation(value = "新增用户", notes = "新增用户的时候判断账号账号是否存在、手机号码是否绑定过、邮箱是否绑定过")
@ApiOperationSupport(order = 1)
@RequiresPermissions("system:user:add")
@Log(functionName = "新增用户",businessType= BusinessType.INSERT)
@PostMapping
@PrintParams
public AjaxResult add(@RequestBody SysUser user) {
OperLogCover.insertLogMsg(BusinessNameConstant.USER,user.getUsername());
if (!sysUserService.checkUserNameUnique(user)) {
return error("新增用户'" + user.getUsername() + "'失败，登录账号已存在");
} else if (StringUtils.isNotEmpty(user.getMobile()) && !sysUserService.checkPhoneUnique(user)) {
return error("新增用户'" + user.getUsername() + "'失败，手机号码已存在");
} else if (StringUtils.isNotEmpty(user.getEmail()) && !sysUserService.checkEmailUnique(user)) {
return error("新增用户'" + user.getUsername() + "'失败，邮箱账号已存在");
}
user.setStatus(Integer.valueOf(UserConstants.USER_NORMAL));
user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
return toAjax(sysUserService.insertUser(user));
}
@ApiOperation(value = "删除用户", notes = "将用户账号删除")
@ApiOperationSupport(order = 2)
@RequiresPermissions("system:user:remove")
@Log(functionName = "删除用户",businessType= BusinessType.DELETE)
@DeleteMapping("/{userId}")
@PrintParams
public AjaxResult remove(@PathVariable("userId") Long userId) {
OperLogCover.deleteLogMsg(BusinessNameConstant.USER,1);
sysUserService.checkUserAllowed(userId);
return toAjax(sysUserService.deleteUser(userId));
}
@ApiOperation(value = "修改用户", notes = "修改用户的信息")
@ApiOperationSupport(order = 3)
@RequiresPermissions("system:user:edit")
@Log(functionName = "修改用户信息",businessType= BusinessType.UPDATE,excludeParamNames = {"email","admin"})
@PutMapping
@PrintParams
public AjaxResult edit(@RequestBody SysUser user)
{
OperLogCover.updateLogMsg(BusinessNameConstant.USER,user.getUserId());
sysUserService.checkUserAllowed(user.getUserId());
SysUser sysUser = sysUserService.selectUserById(user.getUserId());
if (StringUtils.isNotEmpty(user.getMobile()) && !sysUserService.checkPhoneUnique(user))
{
if(!sysUser.getMobile().equals(user.getMobile())){
return error("修改用户'" + user.getMobile() + "'失败，手机号码已存在");
}
}
if (StringUtils.isNotEmpty(user.getEmail()) && !sysUserService.checkEmailUnique(user))
{
if(!sysUser.getEmail().equals(user.getEmail())){
return error("修改用户'" + user.getEmail() + "'失败，邮箱账号已存在");
}
}
return toAjax(sysUserService.updateUser(user));
}
@ApiOperation(value= "分页条件查询用户列表")
@ApiOperationSupport(order = 4)
@RequiresPermissions("system:user:list")
@GetMapping("/list")
@PrintParams
public TableDataInfo list(SysUser user) {
startPage();
List<SysUser> list = sysUserService.selectUserList(user);
return getDataTable(list);
}
@ApiOperation(value = "获取当前用户的详细信息",notes = "返回用户信息,角色集合,权限集合")
@GetMapping("/getInfo")
@PrintParams
public AjaxResult getInfo() {
SysUser user = sysUserService.selectUserById(SecurityUtils.getUserId());
// 角色集合
Set<String> roles = sysRoleService.getRolePermission(user);
// 权限集合
Set<String> permissions = sysPermissionService.getMenuPermission(user);
AjaxResult ajax = AjaxResult.success();
ajax.put("user", user);
ajax.put("roles", roles);
ajax.put("permissions", permissions);
return ajax;
}
@ApiOperation(value = "修改用户密码")
@RequiresPermissions("system:user:resetPassword")
@Log(functionName = "重置用户密码",businessType= BusinessType.UPDATE)
@PutMapping("/changePassword")
@PrintParams
public AjaxResult resetPassword(@RequestBody SysUser user) {
sysUserService.checkUserAllowed(user.getUserId());
user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
return toAjax(sysUserService.resetUserPassword(user));
}
@ApiOperation(value= "禁用用户")
@PutMapping("/changeStatus")
@RequiresPermissions("system:user:disableAccount")
@PrintParams
public AjaxResult disable(@RequestBody SysUser user) {
sysUserService.checkUserAllowed(user.getUserId());
return toAjax(sysUserService.disableUser(user.getUserId()));
}
@ApiOperation(value= "授权用户角色",notes = "传入用户ID和角色集合")
@RequiresPermissions("system:user:authRole")
@PutMapping("/authRole")
@PrintParams
public AjaxResult insertAuthRole(Long userId, Long[] roleIds)
{
return toAjax(sysUserService.insertUserAuth(userId, roleIds));
}
@ApiOperation(value = "查询用户选项值")
@RequiresPermissions("system:user:list")
@GetMapping("/optionSelect")
@PrintParams
public AjaxResult optionSelect()
{
return success(sysUserService.selectUserAll());
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysUserController.java
|
Java
|
unknown
| 8,491
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.web.controller.BaseController;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.security.annotation.PrintParams;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.security.utils.SecurityUtils;
import com.jcm.system.domain.SysUserSetting;
import com.jcm.system.service.ISysUserSettingService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.v3.oas.annotations.Operation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
/**
* <p>
* 用户样式设置表 前端控制器
* </p>
*
* @author 吕世昊
* @since 2024-12-18
*/
@Api(tags="用户设置")
@ApiSupport(author = "202252197@qq.com",order = 10)
@BusinessName(title = OperationNameConstants.SYSTEM_USER_SETTING)
@RestController
@AllArgsConstructor
@RequestMapping("/sys-user-setting")
public class SysUserSettingController extends BaseController {
private ISysUserSettingService sysUserSettingService;
@ApiOperation(value="修改用户设置")
@Log(functionName = "修改用户设置信息",businessType= BusinessType.UPDATE)
@RequiresPermissions("system:role:edit")
@PutMapping
@PrintParams
public AjaxResult edit(@RequestBody SysUserSetting userSetting)
{
userSetting.setUserId(SecurityUtils.getUserId());
return toAjax(sysUserSettingService.updateUserSetting(userSetting));
}
@ApiOperation(value="查询用户设置")
@Operation(summary = "获取当前用户设置的详细信息", description = "")
@GetMapping("/getInfo")
@PrintParams
public AjaxResult getInfo() {
SysUserSetting userSetting = sysUserSettingService.selectUserSettingByUserId(SecurityUtils.getUserId());
return AjaxResult.success(userSetting);
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysUserSettingController.java
|
Java
|
unknown
| 2,142
|
package com.jcm.system.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
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.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.core.utils.poi.ExcelUtil;
import io.swagger.annotations.Api;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import lombok.AllArgsConstructor;
import com.jcm.system.domain.SysUserTask;
import com.jcm.system.service.ISysUserTaskService;
import com.jcm.common.core.web.page.TableDataInfo;
/**
* taskController
*
* @author lvshihao
* @date 2025-01-13
*/
@Api(tags="task管理")
@ApiSupport(author = "202252197@qq.com")
@BusinessName(title = OperationNameConstants.SYS_USER_TASK)
@AllArgsConstructor
@RestController
@RequestMapping("/task")
public class SysUserTaskController extends PageBaseController
{
private final ISysUserTaskService sysUserTaskService;
/**
* 查询用户任务列表
*/
@RequiresPermissions("system:task:list")
@GetMapping("/list")
public TableDataInfo list(SysUserTask sysUserTask)
{
startPage();
List<SysUserTask> list = sysUserTaskService.selectSysUserTaskList(sysUserTask);
return getDataTable(list);
}
/**
* 导出用户任务列表
*/
@RequiresPermissions("system:task:export")
@Log(functionName = "导出用户任务列表", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, SysUserTask sysUserTask)
{
List<SysUserTask> list = sysUserTaskService.selectSysUserTaskList(sysUserTask);
ExcelUtil<SysUserTask> util = new ExcelUtil<SysUserTask>(SysUserTask.class);
util.exportEasyExcel(response, list, "用户任务数据");
}
/**
* 获取用户任务详细信息
*/
@RequiresPermissions("system:task:query")
@GetMapping(value = "/{taskId}")
public AjaxResult getInfo(@PathVariable("taskId") Long taskId)
{
return success(sysUserTaskService.selectSysUserTaskByTaskId(taskId));
}
/**
* 新增用户任务
*/
@RequiresPermissions("system:task:add")
@Log(functionName = "新增用户任务", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody SysUserTask sysUserTask)
{
return toAjax(sysUserTaskService.insertSysUserTask(sysUserTask));
}
/**
* 修改用户任务
*/
@RequiresPermissions("system:task:edit")
@Log(functionName = "修改用户任务", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody SysUserTask sysUserTask)
{
return toAjax(sysUserTaskService.updateSysUserTask(sysUserTask));
}
/**
* 删除用户任务
*/
@RequiresPermissions("system:task:remove")
@Log(functionName = "删除用户任务", businessType = BusinessType.DELETE)
@DeleteMapping("/{taskIds}")
public AjaxResult remove(@PathVariable Long[] taskIds)
{
return toAjax(sysUserTaskService.deleteSysUserTaskByTaskIds(taskIds));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/SysUserTaskController.java
|
Java
|
unknown
| 3,862
|
package com.jcm.system.controller;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import com.jcm.common.core.constant.OperationNameConstants;
import com.jcm.common.core.utils.poi.ExcelUtil;
import com.jcm.common.core.web.domain.AjaxResult;
import com.jcm.common.core.web.page.TableDataInfo;
import com.jcm.common.log.annotation.BusinessName;
import com.jcm.common.log.annotation.Log;
import com.jcm.common.log.enums.BusinessType;
import com.jcm.common.mybatis.controller.PageBaseController;
import com.jcm.common.security.annotation.RequiresPermissions;
import com.jcm.system.domain.TxVip;
import com.jcm.system.service.ITxVipService;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* vipController
*
* @author lvshihao
* @date 2025-01-11
*/
@Api(tags="vip管理")
@ApiSupport(author = "202252197@qq.com")
@BusinessName(title = OperationNameConstants.TX_VIP)
@AllArgsConstructor
@RestController
@RequestMapping("/vip")
public class TxVipController extends PageBaseController
{
private final ITxVipService txVipService;
/**
* 查询vip列表
*/
@RequiresPermissions("system:vip:list")
@GetMapping("/list")
public TableDataInfo list(TxVip txVip)
{
startPage();
List<TxVip> list = txVipService.selectTxVipList(txVip);
return getDataTable(list);
}
/**
* 导出vip列表
*/
@RequiresPermissions("system:vip:export")
@Log(functionName = "导出vip列表", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, TxVip txVip)
{
List<TxVip> list = txVipService.selectTxVipList(txVip);
ExcelUtil<TxVip> util = new ExcelUtil<TxVip>(TxVip.class);
util.exportEasyExcel(response, list, "vip数据");
}
/**
* 获取vip详细信息
*/
@RequiresPermissions("system:vip:query")
@GetMapping(value = "/{vipId}")
public AjaxResult getInfo(@PathVariable("vipId") Long vipId)
{
return success(txVipService.selectTxVipByVipId(vipId));
}
/**
* 新增vip
*/
@RequiresPermissions("system:vip:add")
@Log(functionName = "新增vip", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody TxVip txVip)
{
return toAjax(txVipService.insertTxVip(txVip));
}
/**
* 修改vip
*/
@RequiresPermissions("system:vip:edit")
@Log(functionName = "修改vip", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody TxVip txVip)
{
return toAjax(txVipService.updateTxVip(txVip));
}
/**
* 删除vip
*/
@RequiresPermissions("system:vip:remove")
@Log(functionName = "删除vip", businessType = BusinessType.DELETE)
@DeleteMapping("/{vipIds}")
public AjaxResult remove(@PathVariable Long[] vipIds)
{
return toAjax(txVipService.deleteTxVipByVipIds(vipIds));
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/controller/TxVipController.java
|
Java
|
unknown
| 3,078
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 字典配置值
* </p>
*
* @author 吕世昊
* @since 2024-11-24
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("sys_dict_data")
public class SysDictData extends BaseEntity{
private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO)
private Long dictDataId;
private String dictTypeId;
@TableField(exist = false)
private String name;
private String value;
private Integer sort;
private Integer status;
private String description;
private String extra;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysDictData.java
|
Java
|
unknown
| 900
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 字典配置项
* </p>
*
* @author 吕世昊
* @since 2024-10-31
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("sys_dict_type")
public class SysDictType extends BaseEntity{
private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO)
private Long dictTypeId;
private String name;
private String description;
private Integer type;
private Integer status;
/**
* 字典项额外参数
*/
private String extraSchema;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysDictType.java
|
Java
|
unknown
| 806
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
/**
* <p>
*
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("sys_menu")
public class SysMenu extends BaseEntity{
private static final long serialVersionUID = 1L;
/**
* 菜单ID
*/
@TableId(type = IdType.AUTO)
private Long menuId;
/**
* 菜单名称
*/
private String name;
/**
* 权限标识
*/
private String permission;
/**
* 菜单类型(0.目录,1.菜单,2.按钮)
*/
private Integer type;
/**
* 显示顺序
*/
private Integer sort;
/**
* 父菜单ID
*/
private Long parentId;
/**
* 菜单图标
*/
private String icon;
/**
* 组件名称
*/
private String component;
/**
* 外联地址
*/
private String link;
/**
* 是否外联
*/
private Boolean isFrame;
/**
* 菜单状态
*/
private Integer status;
/**
* 是否可见
*/
private Boolean visible;
/**
* 是否缓存
*/
private Boolean keepAlive;
/**
* 路由的子路由列表
*/
@TableField(exist = false)
private List<SysMenu> children;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysMenu.java
|
Java
|
unknown
| 1,644
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
*
* </p>
*
* @author 吕世昊
* @since 2024-04-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("sys_role")
public class SysRole extends BaseEntity{
private static final long serialVersionUID = 1L;
public SysRole(){}
public SysRole(Long roleId) {
this.roleId = roleId;
}
/**
* 角色ID
*/
@TableId( type = IdType.AUTO)
private Long roleId;
/**
* 角色名称
*/
private String name;
/**
* 角色权限字符串
*/
private String code;
/**
* 显示顺序
*/
private Integer sort;
/**
* 角色状态（0正常 1停用）
*/
private Integer status;
public boolean isAdmin()
{
return isAdmin(this.roleId);
}
public static boolean isAdmin(Long roleId)
{
return roleId != null && 1L == roleId;
}
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysRole.java
|
Java
|
unknown
| 1,180
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* <p>
* 角色和菜单关联关系表
* </p>
*
* @author 吕世昊
* @since 2024-04-20
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("sys_role_menu")
@Tag(name="SysRoleMenu对象", description="角色和菜单关联关系表")
public class SysRoleMenu implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(description = "角色id")
private Long roleId;
@Schema(description = "菜单id")
private Long menuId;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysRoleMenu.java
|
Java
|
unknown
| 756
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* <p>
* 用户和角色关联关系表
* </p>
*
* @author 吕世昊
* @since 2024-04-20
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("sys_user_role")
@Tag(name="SysUserRole对象", description="用户和角色关联关系表")
public class SysUserRole implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(description = "用户id")
private Long userId;
@Schema(description = "角色id")
private Long roleId;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysUserRole.java
|
Java
|
unknown
| 758
|
package com.jcm.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jcm.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 用户前端样式设置表
* </p>
*
* @author 吕世昊
* @since 2024-12-18
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sys_user_setting")
public class SysUserSetting extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 界面设置ID
*/
@TableId(value = "setting_id", type = IdType.AUTO)
private Long settingId;
/**
* 用户ID
*/
private Long userId;
/**
* 界面主题
*/
private Integer theme;
/**
* 界面主题颜色
*/
private String themeColor;
/**
* 导航栏
*/
private Boolean navigationBar;
/**
* 多页签
*/
private Boolean tabs;
/**
* 多页签图标
*/
private Boolean tabsIcon;
/**
* 面包屑
*/
private Boolean breadcrumb;
/**
* 菜单栏
*/
private Boolean menu;
/**
* 顶部菜单栏
*/
private Boolean topMenu;
/**
* 版权内容
*/
private Boolean copyright;
/**
* 用户水印
*/
private Boolean watermark;
/**
* 弱色模式
*/
private Boolean weakColor;
/**
* 黑白模式
*/
private Boolean grayscale;
/**
* 高斯模式
*/
private Boolean blur;
/**
* 对比度
*/
private Boolean contrast;
/**
* 色相旋转
*/
private Boolean hueRotate;
/**
* 饱和度
*/
private Boolean saturate;
/**
* 数据加载动画
*/
private Boolean dataLoading;
/**
* 表格默认页数
*/
private Integer size;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysUserSetting.java
|
Java
|
unknown
| 2,020
|
package com.jcm.system.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jcm.common.core.domain.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
/**
* task对象 sys_user_task
*
* @author lvshihao
* @date 2025-01-13
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ExcelIgnoreUnannotated
@TableName("sys_user_task")
public class SysUserTask extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 任务ID，主键 */
@TableId(type = IdType.AUTO)
@ExcelProperty(value = "${comment}")
private Long taskId;
/** 任务标题 */
@ExcelProperty(value = "任务标题")
private String title;
/** 任务描述 */
@ExcelProperty(value = "任务描述")
private String description;
/** 任务开始日期 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ExcelProperty(value = "任务开始日期")
private LocalDateTime startDate;
/** 任务结束日期 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ExcelProperty(value = "任务结束日期")
private LocalDateTime endDate;
/** 任务优先级（0:一般、1:中等、2:加急） */
@ExcelProperty(value = "任务优先级（0:一般、1:中等、2:加急）")
private Long priority;
/** 任务状态（0:未开始、1:进行中、2:已完成） */
@ExcelProperty(value = "任务状态（0:未开始、1:进行中、2:已完成）")
private Long status;
/** 任务类型（0:修复bug，1：新增功能） */
@ExcelProperty(value = "任务类型（0:修复bug，1：新增功能）")
private Long type;
/** 执行任务的用户ID */
@ExcelProperty(value = "执行任务的用户ID")
private Long userId;
@TableField(exist = false)
@ExcelProperty(value = "用户名称")
private String username;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/SysUserTask.java
|
Java
|
unknown
| 2,412
|
package com.jcm.system.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jcm.common.core.domain.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* vip对象 tx_vip
*
* @author lvshihao
* @date 2025-01-11
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ExcelIgnoreUnannotated
@TableName("tx_vip")
public class TxVip extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 会员id */
@TableId(type = IdType.AUTO)
@ExcelProperty(value = "${comment}")
private Long vipId;
/** 咸鱼名称 */
@ExcelProperty(value = "咸鱼名称")
private String xyName;
/** 起始时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@ExcelProperty(value = "起始时间")
private Date startingTime;
/** 结束时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@ExcelProperty(value = "结束时间")
private Date stopingTime;
/** 开通天数 */
@ExcelProperty(value = "开通天数")
private String purchaseDays;
/** 设备名称 */
@ExcelProperty(value = "设备名称")
private String unitType;
/** 状态(0在用，1下线) */
private Boolean status;
/** 登录方式（QQ或微信） */
@ExcelProperty(value = "登录方式（QQ或微信）")
private String loginMethod;
/** 登录账号 */
private String loginAccount;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/TxVip.java
|
Java
|
unknown
| 1,866
|
package com.jcm.system.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* 路由显示信息
*
* @author junchenmo
*/
@Data
@AllArgsConstructor
public class MetaVo
{
/**
* 设置该路由在侧边栏和面包屑中展示的名字
*/
private String title;
/**
* 是否隐藏路由，当设置 true 的时候该路由不会再侧边栏出现
*/
private boolean hidden;
/**
* 是否外联，当为 true 的时候跳转到外联地址，当为false就是内联地址
*/
private boolean isFrame;
/**
* 设置该路由的图标，对应路径src/assets/icons/svg
*/
private String icon;
/**
* 设置为true，则会被 <keep-alive>缓存
*/
private boolean cache;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/vo/MetaVo.java
|
Java
|
unknown
| 782
|
package com.jcm.system.domain.vo;
import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* 路由配置信息
*
* @author junchenmo
*/
@Schema(description ="统一返回格式")
@Data
@JsonInclude(JsonInclude.Include.NON_EMPTY)
public class RouterVo
{
/**
* 路由地址
*/
private String path;
/**
* 路由名称
*/
private String name;
/**
* 组件地址
*/
private String component;
/**
* 转发请求地址
*/
private String redirect;
/**
* 其他元素
*/
private MetaVo meta;
/**
* 子路由
*/
private List<RouterVo> children;
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/domain/vo/RouterVo.java
|
Java
|
unknown
| 756
|
package com.jcm.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jcm.system.domain.SysDictData;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 字典配置值 Mapper 接口
* </p>
*
* @author 吕世昊
* @since 2024-11-24
*/
public interface SysDictDataMapper extends BaseMapper<SysDictData> {
List<SysDictData> selectListByCondition(SysDictData dictType);
List<SysDictData> getInfoList(List<String> names);
int deleteByDictTypeIds(@Param("dictTypeIds") List<Long> dictTypeIds);
}
|
2022521971/JUNCHENMO-After
|
jcm-modules/jcm-system/src/main/java/com/jcm/system/mapper/SysDictDataMapper.java
|
Java
|
unknown
| 573
|