Compare commits

...

1 Commits

Author SHA1 Message Date
熊正 d0a6ddde3f 更新
3 years ago

@ -1,39 +0,0 @@
package com.arm.equipment.system.admin.app;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.util.IntrospectorCleanupListener;
/**
*
*
* @author admin
*/
@SpringBootApplication
@ComponentScan("com.arm.equipment.system")
@EnableTransactionManagement
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400)
@EnableAsync
@EnableCaching
@EnableScheduling
public class AdminApplication {
public static void main(String[] args) {
SpringApplication.run(AdminApplication.class, args);
}
@Bean
public ServletListenerRegistrationBean introspectorCleanupListener() {
ServletListenerRegistrationBean listenerRegistration = new ServletListenerRegistrationBean();
listenerRegistration.setListener(new IntrospectorCleanupListener());
return listenerRegistration;
}
}

@ -1,38 +0,0 @@
package com.arm.equipment.system.admin.app;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
/**
* CORS
*/
@Configuration
public class AdminCorsConfiguration {
@Bean
public CorsFilter corsFilter() {
// 添加CORS配置信息
CorsConfiguration config = new CorsConfiguration();
// 放行哪些原始域
config.addAllowedOriginPattern("*");
// 是否发送Cookie信息
config.setAllowCredentials(true);
// 放行哪些原始域(请求方式)
config.addAllowedMethod("*");
// 放行哪些原始域(头部信息)
config.addAllowedHeader("*");
// 暴露哪些头部信息(因为跨域访问默认不能获取全部头部信息)
// config.addExposedHeader("*");
//2.添加映射路径
UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
configSource.registerCorsConfiguration("/**", config);
//3.返回新的CorsFilter.
return new CorsFilter(configSource);
}
}

@ -1,80 +0,0 @@
package com.arm.equipment.system.admin.app;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.arm.equipment.system.admin.filter.LoginPermissionsFilter;
import com.arm.equipment.system.admin.filter.SysLogFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import java.math.BigInteger;
import java.util.List;
/**
* @author: admin
* @time: 2022/9/16 11:20
*/
@Configuration
public class InterceptorConfiguration extends WebMvcConfigurationSupport {
@Autowired
private LoginPermissionsFilter loginPermissionsFilter;
@Autowired
private SysLogFilter sysLogFilter;
@Override
protected void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(sysLogFilter).addPathPatterns("/**/*");
registry.addInterceptor(loginPermissionsFilter).addPathPatterns("/**/*")
.excludePathPatterns("/file/**");;
super.addInterceptors(registry);
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
/**
* @Description: , /Path/** <img src="/Path/picName.jpg" />便
* "file:/+本地图片的地址"
*/
String os = System.getProperty("os.name");
//Windows操作系统
String resourcePath = System.getProperty("user.dir");
if (os != null && os.toLowerCase().startsWith("windows")) {
resourcePath = resourcePath + "\\";
} else {
resourcePath = resourcePath + "/";
}
registry.addResourceHandler("/file/**").addResourceLocations("file:" + resourcePath);
super.addResourceHandlers(registry);
}
@Override
protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
ObjectMapper objectMapper = new ObjectMapper();
/**
* json,longstring
* jsjava long
*/
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
simpleModule.addSerializer(BigInteger.class, ToStringSerializer.instance);
// 反序列化时忽略多余字段
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 注册
objectMapper.registerModule(simpleModule);
jackson2HttpMessageConverter.setObjectMapper(objectMapper);
converters.add(0, jackson2HttpMessageConverter);
super.extendMessageConverters(converters);
}
}

@ -1,17 +0,0 @@
package com.arm.equipment.system.admin.app;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
@Configuration
public class RedisListenerConfiguration {
@Bean
RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory lettuceConnectionFactory) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(lettuceConnectionFactory);
return container;
}
}

@ -1,29 +0,0 @@
package com.arm.equipment.system.admin.app;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
/**
*
* @author admin
*/
@Configuration
public class SchedulerConfiguration implements SchedulingConfigurer {
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.setScheduler(taskExecutor());
}
/**
* 线
* @return
*/
public ScheduledExecutorService taskExecutor() {
return Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors() + 1);
}
}

@ -1,33 +0,0 @@
package com.arm.equipment.system.admin.controller.common;
import com.arm.equipment.system.data.service.common.IDictService;
import com.arm.equipment.system.data.vo.RespJSON;
import com.arm.equipment.system.data.vo.dict.DictVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
*
*/
@RestController
@RequestMapping("/common/dict")
public class DictController {
@Autowired
private IDictService dictService;
/**
*
*
* @param name , com.arm.equipment.system.data.enums.dict
* @return
*/
@RequestMapping("/getDictDataByName/{name}")
public RespJSON getDictDataByName(@PathVariable String name) {
List<DictVO> dictData = dictService.getDictData(name);
return RespJSON.success(dictData);
}
}

@ -1,53 +0,0 @@
package com.arm.equipment.system.admin.controller.file;
import com.arm.equipment.system.admin.controller.BaseController;
import com.arm.equipment.system.data.enums.file.EnumUpload;
import com.arm.equipment.system.data.exception.BusinessException;
import com.arm.equipment.system.data.service.file.IFileService;
import com.arm.equipment.system.data.util.StringUtils;
import com.arm.equipment.system.data.vo.RespJSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
/**
*
*
* @author: xly
* @time: 2023/3/10 10:56
*/
@RestController
@RequestMapping("/file/upload")
public class UploadController extends BaseController {
@Autowired
private IFileService fileService;
/**
*
*
* @param file
* @return
*/
@PostMapping("/upload")
public RespJSON upload(String uploadItem, @RequestParam("file") MultipartFile file) {
if (null == file) {
throw new BusinessException("文件不合法");
}
EnumUpload enumUploadItem = EnumUpload.RES_PHOTO_LIB;
if (StringUtils.isNotBlank(uploadItem)) {
enumUploadItem = EnumUpload.getEnum(uploadItem);
}
if (enumUploadItem == null) {
throw new BusinessException("上传文件类目不正确");
}
try {
return RespJSON.success(fileService.upload(file, enumUploadItem));
} catch (Exception e) {
logger.error("文件上传错误", e);
throw new BusinessException("文件上传错误");
}
}
}

@ -1,91 +0,0 @@
package com.arm.equipment.system.admin.filter;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* request
*/
public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {
private final byte[] body;
private String bodyStr;
public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
String bodyString = getBodyString(request);
body = bodyString.getBytes(StandardCharsets.UTF_8);
bodyStr = bodyString;
}
public String getBodyStr() {
return bodyStr;
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return byteArrayInputStream.read();
}
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
};
}
public String getBodyString(HttpServletRequest request) throws IOException {
StringBuilder sb = new StringBuilder();
InputStream inputStream = null;
BufferedReader reader = null;
try {
inputStream = request.getInputStream();
reader = new BufferedReader(
new InputStreamReader(inputStream, Charset.forName("UTF-8")));
char[] bodyCharBuffer = new char[1024];
int len = 0;
while ((len = reader.read(bodyCharBuffer)) != -1) {
sb.append(new String(bodyCharBuffer, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return sb.toString();
}
}

@ -1,81 +0,0 @@
package com.arm.equipment.system.admin.filter;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Throwables;
import com.arm.equipment.system.admin.util.CurrentUserUtils;
import com.arm.equipment.system.data.domain.system.SysUser;
import com.arm.equipment.system.data.vo.RespJSON;
import com.arm.equipment.system.data.vo.ReturnCode;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.List;
/**
* @author: admin
* @time: 2022/9/16 11:20
*/
@Order(1001)
@Configuration
public class LoginPermissionsFilter implements HandlerInterceptor {
private final static Logger logger = LoggerFactory.getLogger(LoginPermissionsFilter.class);
@Value("${domain.admin}")
private String adminDomain;
private static final List<String> IGNORE_URL_LIST = Arrays.asList("/login", "/file/upload", "/common/dict", "/verifycode/getVerifyCode");
private final String RETURN_INFO = JSON.toJSONString(RespJSON.returnCode(ReturnCode.NOT_LOGIN_ERROR));
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 将 options 请求放过
String method = request.getMethod();
if ("options".equalsIgnoreCase(method)) {
return true;
}
String uri = request.getRequestURI();
for (String ignoreUrl : IGNORE_URL_LIST) {
if (StringUtils.contains(uri, ignoreUrl)) {
return true;
}
}
SysUser sysUser = (SysUser) request.getSession().getAttribute(CurrentUserUtils.SYSTEM_USER);
if (null != sysUser) {
return true;
}
returnNoLogin(response, request);
return false;
}
private void returnNoLogin(HttpServletResponse response, HttpServletRequest request) {
String origin = adminDomain;
String originHeader = request.getHeader("Origin");
if (StringUtils.isNotEmpty(originHeader)) {
origin = originHeader;
}
response.setCharacterEncoding("UTF-8");
response.setHeader("Content-Type", "application/json; charset=utf-8");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Access-Control-Allow-Origin", origin);
PrintWriter writer = null;
try {
writer = response.getWriter();
writer.write(RETURN_INFO);
} catch (IOException e) {
logger.error(Throwables.getStackTraceAsString(e));
} finally {
writer.close();
}
}
}

@ -1,37 +0,0 @@
package com.arm.equipment.system.admin.filter;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
*
*/
@Component
@WebFilter(filterName = "httpServletRequestWrapperFilter", urlPatterns = {"/"})
public class RequestBodyFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if (request instanceof HttpServletRequest) {
HttpServletRequest httpRequest = (HttpServletRequest) request;
//遇到post方法才对request进行包装
String methodType = httpRequest.getMethod();
String contentType = ((HttpServletRequest) request).getHeader("Content-Type");
if (StringUtils.isNotEmpty(contentType) && contentType.contains("application/json") && "POST".equals(methodType)) {
requestWrapper = new BodyReaderHttpServletRequestWrapper((HttpServletRequest) request);
}
}
if (null == requestWrapper) {
chain.doFilter(request, response);
} else {
chain.doFilter(requestWrapper, response);
}
}
}

@ -1,101 +0,0 @@
package com.arm.equipment.system.admin.filter;
import com.alibaba.fastjson.JSONObject;
import com.arm.equipment.system.admin.util.CurrentUserUtils;
import com.arm.equipment.system.data.domain.system.SysLog;
import com.arm.equipment.system.data.domain.system.SysUser;
import com.arm.equipment.system.data.enums.dict.EnumSysLogType;
import com.arm.equipment.system.data.service.system.ISysLogService;
import com.arm.equipment.system.data.util.IPUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* filter,
*/
@Order(1002)
@Configuration
public class SysLogFilter implements HandlerInterceptor {
private final static Logger logger = LoggerFactory.getLogger(SysLogFilter.class);
@Autowired
private ISysLogService sysLogService;
/**
* 50线, ,
*/
private final static ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(50, 50, 120, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.AbortPolicy());
/**
*
*/
private final static String LOGIN_PATH = "/system/sysUser/login";
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
THREAD_POOL_EXECUTOR.submit(() -> {
String userAgent = request.getHeader("User-Agent");
SysLog sysLog = new SysLog();
sysLog.setType(EnumSysLogType.LOG.getCode());
// todo 尽量设置访问链接的菜单
sysLog.setTitle(" ");
sysLog.setRemoteAddr(IPUtil.getRemoteAddress(request));
sysLog.setUserAgent(userAgent);
sysLog.setRequestUri(buildUri(request));
sysLog.setMethod(request.getMethod());
String requestBody = getRequestBody(((BodyReaderHttpServletRequestWrapper) request).getBodyStr());
sysLog.setParams(requestBody);
//登录接口日志特殊处理 不显示密码
if (sysLog.getRequestUri().contains(LOGIN_PATH)) {
JSONObject loginInfoJson = JSONObject.parseObject(requestBody);
loginInfoJson.put("password", "");
sysLog.setParams(loginInfoJson.toJSONString());
}
SysUser sysUser = (SysUser) request.getSession().getAttribute(CurrentUserUtils.SYSTEM_USER);
if (null != sysUser) {
sysLogService.save(sysLog, sysUser.getUsername());
} else {
sysLogService.save(sysLog, "SYSTEM");
}
});
return true;
}
private Map<String, String> getAllHeader(HttpServletRequest request) {
Enumeration<String> headerNames = request.getHeaderNames();
Map<String, String> map = new HashMap<>();
while (headerNames.hasMoreElements()) {
String key = headerNames.nextElement();
map.put(key, request.getHeader(key));
}
return map;
}
private String getRequestBody(String requestBody) {
if (StringUtils.isEmpty(requestBody)) {
return null;
}
return requestBody;
}
private String buildUri(HttpServletRequest request) {
String path = request.getRequestURL().toString();
String query = request.getQueryString();
if (StringUtils.isEmpty(query)) {
return path;
}
return path + "?" + query;
}
}

@ -1,13 +0,0 @@
package com.arm.equipment.system.admin.util;
/**
*
*
* @author: admin
* @time: 2022/9/16 11:20
*/
public class CurrentUserUtils {
public static final String SYSTEM_USER = "system_user";
}

@ -1,34 +0,0 @@
env: dev
spring:
datasource:
url: jdbc:mysql://127.0.0.1:3306/arm-equipment-system?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=convertToNull
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password:
type: com.zaxxer.hikari.HikariDataSource
hikari:
auto-commit: true
connection-timeout: 30000
idle-timeout: 600000
max-lifetime: 1800000
minimum-idle: 1
maximum-pool-size: 10
pool-name: hikaricp
validation-timeout: 5000
redis:
host: 127.0.0.1
port: 6379
password:
database: 0
timeout: 5000ms
lettuce:
pool:
max-idle: 100
min-idle: 1
max-active: 1000
web:
resources:
static-locations: file:admin/src/main/resources/static
# 域名配置
domain:
admin: http://localhost:9527

@ -1,25 +0,0 @@
git:
version: "@git.commit.id.abbrev@"
commitTime: "@git.commit.time@"
server:
port: 18081
compression:
enabled: true
mime-types: application/javascript,text/css,application/json,application/xml,text/html,text/xml,text/plain
spring:
jackson:
serialization:
write-dates-as-timestamps: true
output:
ansi:
enabled: always
webflux:
static-path-pattern: /**
session:
store-type: redis
timeout: 86400
profiles:
active: dev
servlet:
multipart:
max-file-size: 1024MB

@ -1,44 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/base.xml"/>
<substitutionProperty name="log.base" value="logs/app" />
<springProfile name="dev">
<logger name="com.arm.equipment.system" level="debug" additivity="false">
<appender-ref ref="CONSOLE" />
</logger>
<logger name="io.swagger.models.parameters.AbstractSerializableParameter" level="error" additivity="false">
<appender-ref ref="CONSOLE" />
</logger>
<root level="info">
<appender-ref ref="CONSOLE" />
</root>
</springProfile>
<springProfile name="prod,test">
<appender name="logfile" class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>${log.base}.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<cleanHistoryOnStart>true</cleanHistoryOnStart>
<maxHistory>30</maxHistory>
<FileNamePattern>
${log.base}.%d{yyyy-MM-dd}.log
</FileNamePattern>
</rollingPolicy>
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>
%date [%thread] %-5level %logger{80} - %msg%n
</pattern>
</layout>
</appender>
<logger name="io.swagger.models.parameters.AbstractSerializableParameter" level="error" additivity="false">
<appender-ref ref="CONSOLE" />
<appender-ref ref="logfile" />
</logger>
<root level="info">
<appender-ref ref="CONSOLE" />
<appender-ref ref="logfile" />
</root>
</springProfile>
</configuration>

@ -1,38 +0,0 @@
package com.arm.equipment.system.admin;
import com.arm.equipment.system.admin.app.AdminApplication;
import com.arm.equipment.system.data.service.common.IIdWorkerService;
import com.arm.equipment.system.data.util.passwordEncoder.BCryptPasswordEncoderUtils;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit.jupiter.SpringExtension;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = AdminApplication.class)
@ActiveProfiles(profiles = "dev")
public class AdminApplicationTests {
@Autowired
private BCryptPasswordEncoderUtils bCryptPasswordEncoder;
@Test
public void test() {
System.out.println(bCryptPasswordEncoder.encode("123123"));
}
@Autowired
IIdWorkerService idWorkerService;
@Test
public void aa(){
for (int i = 0; i < 30; i++) {
System.out.println(idWorkerService.getNextId());
}
}
}

@ -1,141 +0,0 @@
package com.arm.equipment.system.admin;
import com.google.common.collect.ImmutableMap;
import com.arm.equipment.system.admin.app.AdminApplication;
import com.arm.equipment.system.data.domain.system.SysResource;
import com.arm.equipment.system.data.service.system.ISysResourceService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = AdminApplication.class)
@ActiveProfiles(profiles = "dev")
public class SysResourceTests {
@Autowired
private ISysResourceService sysResourceService;
/**
* map
*/
private final static Map<String, String> MAP = ImmutableMap.<String, String>builder()
.put("list", "查询")
.put("add", "添加")
.put("edit", "编辑")
.put("delete", "删除")
.put("audit", "审核")
.put("unAudit", "取消审核")
.put("publish", "发布")
.put("unPublish", "取消发布")
.put("archives", "归档")
.put("unArchives", "取消归档")
.put("setPosition", "调整位置")
.put("exportToExcel", "导出Excel")
.put("recommend", "推荐")
.put("unRecommend", "取消推荐")
.put("used", "标记使用")
.put("clueFee", "线索费")
.put("show", "显示")
.put("unShow", "取消显示")
.put("send", "发放红包")
.put("refuse", "拒绝")
.put("top", "置顶")
.put("unTop", "取消置顶")
.put("handle", "处理")
.put("onShelves", "上架")
.put("offShell", "下架")
.put("push", "推送")
.put("recruit", "招聘管理")
.put("download", "下载简历模板")
.put("recruitmentDeliverInfoList", "查看职位投递信息")
.put("updateStatus", "操作提醒状态")
.put("option", "直播间设置")
.put("startLuckyBag", "直播间开启福袋")
.put("closeLuckyBag", "直播间关闭福袋")
.put("modifyLuckyBag", "直播间修改福袋")
.put("startRedPacket", "直播间开启红包")
.put("modifyRedPacket", "直播间修改红包")
.put("interaction", "直播间互动")
.put("data", "直播间数据")
.put("split", "直播间拆条")
.put("startLive", "直播间开始直播")
.put("stopLive", "直播间结束直播")
.put("modifyLive", "直播间修改直播")
.put("addLine", "直播间新增线路")
.put("breakLine", "直播间断开线路")
.put("restoreLine", "直播间恢复线路")
.put("modifyLine", "直播间修改线路")
.put("deleteLine", "直播间删除线路")
.put("addVote", "直播间添加投票")
.put("modifyVote", "直播间修改投票")
.put("deleteVote", "直播间删除投票")
.put("deleteComment", "直播间删除评论")
.put("cancelTopComment", "直播间取消置顶评论")
.put("topComment", "直播间置顶评论")
.put("addDraw", "直播间创建抽奖")
.put("addCoupon", "直播间创建优惠券")
.put("startCoupon", "直播间开启优惠券")
.put("closeCoupon", "直播间关闭优惠券")
.put("modifyCoupon", "直播间修改优惠券")
.put("updateBrowseMultiple", "浏览倍率")
.put("sliderManage", "轮播管理")
.put("navManage", "导航栏管理")
.put("start", "导播台开启")
.put("stop", "导播台关闭")
.put("detail", "导播台详情")
.put("canPublish", "可发布文章")
.put("sign", "标记")
.build();
/**父级菜单查询条件 这里是根据路径找到对象 根据需求更换*/
private final static String URL_WHERE = "/live/liveStudioGiftsList";
/**按钮标识前缀 根据需求更换*/
private final static String SUFFIX_IDENTITY = "live_studio_gifts"+"_";
/**按钮名称前缀 根据需求更换*/
private final static String SUFFIX_NAME = "直播间礼物";
/**需要生成的按钮权限 已公共map中的为准 有其他公共权限可以自行添加到map 一般如果存在多个按钮 list按钮权限最好生成 根据需求更换*/
private final static List<String> COMMON_ROLE = Arrays.asList("list", "add","edit","delete","audit","unAudit");
// "startRedPacket", "modifyRedPacket", "interaction", "data", "split", "startLive", "stopLive", "modifyLive",
// "addLine", "breakLine", "restoreLine", "modifyLine", "deleteLine", "addVote", "modifyVote", "deleteVote",
// "deleteComment", "cancelTopComment", "topComment", "addDraw", "addCoupon", "startCoupon", "closeCoupon");
/**
*
*/
@Test
public void commonSave() {
SysResource where = new SysResource();
where.setUrl(URL_WHERE);
List<SysResource> sysResourcesListDB = sysResourceService.getList(where);
COMMON_ROLE.forEach(item -> {
buildSave(sysResourcesListDB.get(0).getId().toString(), SUFFIX_IDENTITY + item, SUFFIX_NAME + MAP.get(item));
});
}
/**
*
*/
// @Test
// public void save() {
// SysResource where = new SysResource();
// where.setUrl(URL_WHERE);
// List<SysResource> sysResourcesListDB = sysResourceService.getList(where);
// buildSave(sysResourcesListDB.get(0).getId(), SUFFIX_IDENTITY + "generalize", SUFFIX_NAME + "微兔眼爆料跟踪信息");
// }
private void buildSave(String parentId, String identity, String name) {
SysResource req = new SysResource();
req.setIdentity(identity);
req.setName(name);
req.setParentId(parentId);
req.setType(2);
req.setSort(1);
req.setIsShow(1);
sysResourceService.save(req, "admin");
}
}

@ -1,13 +0,0 @@
package com.arm.equipment.system.api.annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* 使
* @author admin
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginCheck {
}

@ -1,35 +0,0 @@
package com.arm.equipment.system.api.app;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.util.IntrospectorCleanupListener;
/**
*
*
* @author admin
*/
@SpringBootApplication
@ComponentScan("com.arm.equipment.system")
@EnableTransactionManagement
@EnableRedisHttpSession
@EnableCaching
public class ApiApplication {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
@Bean
public ServletListenerRegistrationBean introspectorCleanupListener() {
ServletListenerRegistrationBean listenerRegistration = new ServletListenerRegistrationBean();
listenerRegistration.setListener(new IntrospectorCleanupListener());
return listenerRegistration;
}
}

@ -1,38 +0,0 @@
package com.arm.equipment.system.api.app;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
/**
* CORS
*/
@Configuration
public class ApiCorsConfiguration {
@Bean
public CorsFilter corsFilter() {
// 添加CORS配置信息
CorsConfiguration config = new CorsConfiguration();
// 放行哪些原始域
config.addAllowedOriginPattern("*");
// 是否发送Cookie信息
config.setAllowCredentials(true);
// 放行哪些原始域(请求方式)
config.addAllowedMethod("*");
// 放行哪些原始域(头部信息)
config.addAllowedHeader("*");
// 暴露哪些头部信息(因为跨域访问默认不能获取全部头部信息)
// config.addExposedHeader("*");
//2.添加映射路径
UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
configSource.registerCorsConfiguration("/**", config);
//3.返回新的CorsFilter.
return new CorsFilter(configSource);
}
}

@ -1,77 +0,0 @@
package com.arm.equipment.system.api.app;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.arm.equipment.system.api.filter.LoginFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import java.math.BigInteger;
import java.util.List;
/**
* @author: admin
* @time: 2022/9/16 11:20
*/
@Configuration
public class InterceptorConfiguration extends WebMvcConfigurationSupport {
@Autowired
private LoginFilter loginFilter;
@Override
protected void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loginFilter)
.excludePathPatterns("/file/**");
super.addInterceptors(registry);
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
/**
* @Description: , /Path/** <img src="/Path/picName.jpg" />便
* "file:/+本地图片的地址"
*/
String os = System.getProperty("os.name");
//Windows操作系统
String resourcePath = System.getProperty("user.dir");
if (os != null && os.toLowerCase().startsWith("windows")) {
resourcePath = resourcePath + "\\";
} else {
resourcePath = resourcePath + "/";
}
registry.addResourceHandler("/file/**").addResourceLocations("file:" + resourcePath);
super.addResourceHandlers(registry);
}
@Override
protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
ObjectMapper objectMapper = new ObjectMapper();
/**
* json,longstring
* jsjava long
*/
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
simpleModule.addSerializer(BigInteger.class, ToStringSerializer.instance);
// 反序列化时忽略多余字段
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 注册
objectMapper.registerModule(simpleModule);
jackson2HttpMessageConverter.setObjectMapper(objectMapper);
converters.add(0, jackson2HttpMessageConverter);
super.extendMessageConverters(converters);
}
}

@ -1,91 +0,0 @@
package com.arm.equipment.system.api.filter;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* request
*/
public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {
private final byte[] body;
private String bodyStr;
public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
String bodyString = getBodyString(request);
body = bodyString.getBytes(StandardCharsets.UTF_8);
bodyStr = bodyString;
}
public String getBodyStr() {
return bodyStr;
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return byteArrayInputStream.read();
}
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
};
}
public String getBodyString(HttpServletRequest request) throws IOException {
StringBuilder sb = new StringBuilder();
InputStream inputStream = null;
BufferedReader reader = null;
try {
inputStream = request.getInputStream();
reader = new BufferedReader(
new InputStreamReader(inputStream, Charset.forName("UTF-8")));
char[] bodyCharBuffer = new char[1024];
int len = 0;
while ((len = reader.read(bodyCharBuffer)) != -1) {
sb.append(new String(bodyCharBuffer, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return sb.toString();
}
}

@ -1,93 +0,0 @@
package com.arm.equipment.system.api.filter;
import com.alibaba.fastjson.JSON;
import com.arm.equipment.system.api.annotation.LoginCheck;
import com.arm.equipment.system.api.util.LoginUtil;
import com.google.common.base.Throwables;
import com.arm.equipment.system.data.domain.user.AppUser;
import com.arm.equipment.system.data.util.StringUtils;
import com.arm.equipment.system.data.vo.RespJSON;
import com.arm.equipment.system.data.vo.ReturnCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;
/**
*
* session
**/
@Order(1004)
@Configuration
public class LoginFilter implements HandlerInterceptor {
private final static Logger logger = LoggerFactory.getLogger(LoginFilter.class);
private final String NO_LOGIN_RETURN_INFO = JSON.toJSONString(RespJSON.returnCode(ReturnCode.NOT_LOGIN_ERROR));
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 将 options 请求放过
String method = request.getMethod();
if ("options".equalsIgnoreCase(method)) {
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) handler;
LoginCheck loginCheckAnnotation = handlerMethod.getMethodAnnotation(LoginCheck.class);
String userTokenHeader = request.getHeader("User-Token");
AppUser loginUser;
// 不需要登录的接口直接放过
if (null == loginCheckAnnotation) {
if (StringUtils.isEmpty(userTokenHeader)) {
return true;
}
// 没有获取到用户信息 直接报错
loginUser = LoginUtil.getLoginUser(userTokenHeader);
} else {
// 请求头没有token 直接报错
if (StringUtils.isEmpty(userTokenHeader)) {
returnNoLogin(response);
return false;
}
// 没有获取到用户信息 直接报错
loginUser = LoginUtil.getLoginUser(userTokenHeader);
if (null == loginUser) {
returnNoLogin(response);
return false;
}
}
// 用户信息保存到session
AppUser finalLoginUser = loginUser;
HttpSession session = request.getSession();
session.setAttribute(LoginUtil.LOGIN_USER_SESSION_KEY, finalLoginUser);
return true;
}
/**
*
*
* @param response
* @return
*/
private void returnNoLogin(HttpServletResponse response) {
response.setCharacterEncoding("UTF-8");
response.setHeader("Content-Type", "application/json; charset=utf-8");
PrintWriter writer = null;
try {
writer = response.getWriter();
writer.write(NO_LOGIN_RETURN_INFO);
} catch (IOException e) {
logger.error(Throwables.getStackTraceAsString(e));
} finally {
writer.close();
}
}
}

@ -1,37 +0,0 @@
package com.arm.equipment.system.api.filter;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
*
*/
@Component
@WebFilter(filterName = "httpServletRequestWrapperFilter", urlPatterns = {"/"})
public class RequestBodyFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if (request instanceof HttpServletRequest) {
HttpServletRequest httpRequest = (HttpServletRequest) request;
//遇到post方法才对request进行包装
String methodType = httpRequest.getMethod();
String contentType = ((HttpServletRequest) request).getHeader("Content-Type");
if (StringUtils.isNotEmpty(contentType) && contentType.contains("application/json") && "POST".equals(methodType)) {
requestWrapper = new BodyReaderHttpServletRequestWrapper((HttpServletRequest) request);
}
}
if (null == requestWrapper) {
chain.doFilter(request, response);
} else {
chain.doFilter(requestWrapper, response);
}
}
}

@ -1,121 +0,0 @@
package com.arm.equipment.system.api.util;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.arm.equipment.system.data.constant.RedisKeys;
import com.arm.equipment.system.data.domain.user.AppUser;
import com.arm.equipment.system.data.util.UuidUtils;
import com.arm.equipment.system.data.util.WJAssert;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
*
*/
@Component
public class LoginUtil {
private final static Logger logger = LoggerFactory.getLogger(LoginUtil.class);
private static RedisTemplate redisTemplate;
private static ValueOperations<String, String> valueOps;
/**
* sessionkey
*/
public static final String LOGIN_USER_SESSION_KEY = "appUserSessionKey";
/**
* 50线, ,
*/
private final static ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(50, 50, 120, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.AbortPolicy());
public static AppUser getLoginUser(String token) {
WJAssert.isMaxLength(token, 500, "token非法");
String key = RedisKeys.getAppUserSessionKey(token);
String s = valueOps.get(key);
if (StringUtils.isEmpty(s)) {
return null;
}
return JSONObject.parseObject(s, AppUser.class);
}
/**
* redis
* token
*
* @param appUser
* @param request
* @return
*/
public static AppUser refreshCache(AppUser appUser, HttpServletRequest request) {
String key = RedisKeys.getAppUserSessionKey(appUser.getToken());
valueOps.set(key, JSON.toJSONString(appUser), 1, TimeUnit.DAYS);
HttpSession session = request.getSession();
if (null == session) {
logger.info("session 是空的");
return null;
}
session.setAttribute(LoginUtil.LOGIN_USER_SESSION_KEY, appUser);
return appUser;
}
/**
* redis
* token
*
* @param appUser
* @param request
* @return
*/
public static AppUser saveInCache(AppUser appUser, HttpServletRequest request) {
appUser.setToken(UuidUtils.uuid());
refreshCache(appUser, request);
// 保存token和用户的关系, 是个 set
String appUsernameByTokenSetKey = RedisKeys.getAppUsernameByTokenSetKey(appUser.getUsername());
SetOperations<String, String> setOps = redisTemplate.opsForSet();
setOps.add(appUsernameByTokenSetKey, appUser.getToken());
// 清除set中的过期token, 避免set过大
clearUserTokenSet(appUsernameByTokenSetKey);
return appUser;
}
/**
* token set
*
* @param appUsernameByTokenSetKey
*/
private static void clearUserTokenSet(String appUsernameByTokenSetKey) {
THREAD_POOL_EXECUTOR.submit(() -> {
SetOperations<String, String> setOps = redisTemplate.opsForSet();
Set<String> tokenSet = setOps.members(appUsernameByTokenSetKey);
if (CollectionUtils.isEmpty(tokenSet)) {
return;
}
tokenSet.forEach(token -> {
String appUserSessionKey = RedisKeys.getAppUserSessionKey(token);
Long expire = redisTemplate.getExpire(appUserSessionKey);
if (null == expire || expire < 0) {
logger.info("删除过期key {}", token);
setOps.remove(appUsernameByTokenSetKey, token);
}
});
});
}
@Autowired
public void setRedisTemplate(RedisTemplate redisTemplate) {
LoginUtil.redisTemplate = redisTemplate;
LoginUtil.valueOps = redisTemplate.opsForValue();
}
}

@ -1,24 +0,0 @@
package com.arm.equipment.system.api.vo.user;
public class RefreshTokenVO {
/** 手机号 */
private String data;
/** 平台 */
private Integer platform;
public Integer getPlatform() {
return platform;
}
public void setPlatform(Integer platform) {
this.platform = platform;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
}

@ -1,72 +0,0 @@
package com.arm.equipment.system.api.vo.user;
import java.util.Date;
/**
*
* VO
* @author: xly
* @time: 2022/9/19 12:00
*/
public class UpdateUserVO {
/** 生日 */
private Date birthday;
/** 昵称 */
private String nickname;
/** 性别 1 男 2 女 */
private Integer genderCode;
/** 所在地址 */
private String address;
/** 学历 */
private String education;
/**头像 */
private String avatarPath;
public String getAvatarPath() {
return avatarPath;
}
public void setAvatarPath(String avatarPath) {
this.avatarPath = avatarPath;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public Integer getGenderCode() {
return genderCode;
}
public void setGenderCode(Integer genderCode) {
this.genderCode = genderCode;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getEducation() {
return education;
}
public void setEducation(String education) {
this.education = education;
}
}

@ -1,34 +0,0 @@
package com.arm.equipment.system.api.vo.user;
/**
* VO
* @author: xly
* @time: 2021/11/19 17:41
*/
public class UserCenterVO {
/**
* ID
*/
private String userId;
/**
*
* type (0 1 )
*/
private Integer type;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
}

@ -1,110 +0,0 @@
package com.arm.equipment.system.api.vo.user;
/**
* VO
*
* @author ousei
* @date 202011415:17:48
*/
public class UserLoginVO {
/** 手机号 */
private String username;
/** 验证码 */
private String verifyCode;
/** 设备TOKEN */
private String deviceToken;
/** unionid */
private String unionid;
/** 登录的类型 */
private Integer loginType;
/**用户密码*/
private String password;
/**平台*/
private Integer platform;
/**邀请码*/
private String invcode;
/**微信code**/
private String code;
/**一键登录手机号token*/
private String usernameToken;
public String getUsernameToken() {
return usernameToken;
}
public void setUsernameToken(String usernameToken) {
this.usernameToken = usernameToken;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public Integer getPlatform() {
return platform;
}
public void setPlatform(Integer platform) {
this.platform = platform;
}
public String getInvcode() {
return invcode;
}
public void setInvcode(String invcode) {
this.invcode = invcode;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Integer getLoginType() {
return loginType;
}
public void setLoginType(Integer loginType) {
this.loginType = loginType;
}
public String getUnionid() {
return unionid;
}
public void setUnionid(String unionid) {
this.unionid = unionid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getVerifyCode() {
return verifyCode;
}
public void setVerifyCode(String verifyCode) {
this.verifyCode = verifyCode;
}
public String getDeviceToken() {
return deviceToken;
}
public void setDeviceToken(String deviceToken) {
this.deviceToken = deviceToken;
}
}

@ -1,31 +0,0 @@
env: dev
spring:
datasource:
url: jdbc:mysql://127.0.0.1:3306/arm-equipment-system?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=convertToNull
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password:
type: com.zaxxer.hikari.HikariDataSource
hikari:
auto-commit: true
connection-timeout: 30000
idle-timeout: 600000
max-lifetime: 1800000
minimum-idle: 1
maximum-pool-size: 10
pool-name: hikaricp
validation-timeout: 5000
redis:
host: 127.0.0.1
port: 6379
password:
database: 0
timeout: 5000ms
lettuce:
pool:
max-idle: 100
min-idle: 1
max-active: 1000
web:
resources:
static-locations: file:admin/src/main/resources/static

@ -1,21 +0,0 @@
git:
version: "@git.commit.id.abbrev@"
commitTime: "@git.commit.time@"
server:
port: 8088
compression:
enabled: true
mime-types: application/javascript,text/css,application/json,application/xml,text/html,text/xml,text/plain
spring:
jackson:
serialization:
write-dates-as-timestamps: true
output:
ansi:
enabled: always
webflux:
static-path-pattern: /**
session:
store-type: redis
profiles:
active: dev

@ -1,41 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/base.xml"/>
<substitutionProperty name="log.base" value="logs/app" />
<springProfile name="dev">
<logger name="com.arm.equipment.system" level="debug" additivity="false">
<appender-ref ref="CONSOLE" />
</logger>
<root level="info">
<appender-ref ref="CONSOLE" />
</root>
</springProfile>
<springProfile name="prod,test">
<appender name="logfile" class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>${log.base}.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<cleanHistoryOnStart>true</cleanHistoryOnStart>
<maxHistory>30</maxHistory>
<FileNamePattern>
${log.base}.%d{yyyy-MM-dd}.log
</FileNamePattern>
</rollingPolicy>
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>
%date [%thread] %-5level %logger{80} - %msg%n
</pattern>
</layout>
</appender>
<logger name="io.swagger.models.parameters.AbstractSerializableParameter" level="error" additivity="false">
<appender-ref ref="CONSOLE" />
<appender-ref ref="logfile" />
</logger>
<root level="info">
<appender-ref ref="CONSOLE" />
<appender-ref ref="logfile" />
</root>
</springProfile>
</configuration>

@ -1,22 +0,0 @@
package com.arm.equipment.system.api;
import com.arm.equipment.system.api.app.ApiApplication;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit.jupiter.SpringExtension;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = ApiApplication.class)
@ActiveProfiles(profiles = "dev")
public class ApiApplicationTests {
private final static Logger LOGGER = LoggerFactory.getLogger(ApiApplicationTests.class);
@Test
public void test() {
}
}

@ -1,36 +0,0 @@
package com.arm.equipment.system.data.app;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
/**
* spring
* @author admin
*/
@Configuration
@EnableAsync
public class AsyncConfiguration {
@Bean
public Executor threadPoolTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(1);
executor.setMaxPoolSize(100);
executor.setQueueCapacity(1000);
executor.setThreadNamePrefix("thread-pool-");
executor.setKeepAliveSeconds(120);
executor.setDaemon(true);
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(90);
// CALLER_RUNS当抛出RejectedExecutionException异常时会调rejectedExecution方法 调用者运行策略实现了一种调节机制,
// 该策略既不会抛弃任务也不会爆出异常,而是将任务退回给调用者,从而降低新任务的流量
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
}

@ -1,25 +0,0 @@
package com.arm.equipment.system.data.app;
import com.arm.equipment.system.data.util.passwordEncoder.BCryptPasswordEncoderUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
*
*
* @author: admin
* @time: 2022/9/16 11:20
*/
@Configuration
public class BCryptConfiguration {
/**
* BCrypt
*
* @return
*/
@Bean
public BCryptPasswordEncoderUtils bCryptPasswordEncoder() {
return new BCryptPasswordEncoderUtils(5, null);
}
}

@ -1,17 +0,0 @@
package com.arm.equipment.system.data.app;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@SpringBootApplication
@EnableTransactionManagement
@ComponentScan("com.arm.equipment.system")
public class DataApplication {
public static void main(String[] args) {
SpringApplication.run(DataApplication.class, args);
}
}

@ -1,52 +0,0 @@
package com.arm.equipment.system.data.app;
import com.arm.equipment.system.data.exception.BusinessException;
import com.zaxxer.hikari.HikariDataSource;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.ibatis.mapping.VendorDatabaseIdProvider;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
/**
* mybatis
* @author admin
*/
@MapperScan("com.arm.equipment.system.data.mapper")
@Configuration
public class MyBatisConfiguration {
@Bean(name = "sessionFactory")
public SqlSessionFactory sessionFactory(HikariDataSource dataSource) {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
bean.setDatabaseIdProvider(new VendorDatabaseIdProvider());
bean.setTypeHandlersPackage("com.arm.equipment.system.data.mybatis.type");
//添加XML目录
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
try {
//设置xml扫描路径
Resource[] baseMapperResource = resolver.getResources("classpath*:/mybatis/base-mapper.xml");
Resource[] resources = resolver.getResources("classpath*:/mybatis/**/*.xml");
bean.setMapperLocations(ArrayUtils.addAll(resources, resources));
return bean.getObject();
} catch (Exception e) {
throw new BusinessException("sessionFactory init fail",e);
}
}
/**
*
*/
@Bean(name = "transactionManager")
public DataSourceTransactionManager transactionManager(HikariDataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}

@ -1,174 +0,0 @@
package com.arm.equipment.system.data.app;
import com.arm.equipment.system.data.constant.RedisKeys;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.Lifecycle;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* redis
*
* @author admin
*/
@Configuration
public class RedisConfiguration implements ApplicationListener<ApplicationEvent> {
@Autowired
private RedisProperties redisProperties;
/**
* 100线, ,
*/
private final static ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(100, 100, 120, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.AbortPolicy());
/**
* lettuce
*
* @return
*/
@Bean
public LettuceConnectionFactory lettuceConnectionFactory() {
RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
configuration.setHostName(redisProperties.getHost());
configuration.setDatabase(redisProperties.getDatabase());
configuration.setPort(redisProperties.getPort());
configuration.setPassword(redisProperties.getPassword());
//连接池配置
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
RedisProperties.Pool pool = redisProperties.getLettuce().getPool();
poolConfig.setMaxIdle(20);
poolConfig.setMinIdle(1);
poolConfig.setMaxTotal(100);
poolConfig.setMaxWaitMillis(3000);
poolConfig.setTimeBetweenEvictionRunsMillis(20000);
poolConfig.setTestWhileIdle(true);
LettucePoolingClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder()
.commandTimeout(Duration.ofSeconds(10))
.poolConfig(poolConfig).build();
return new LettuceConnectionFactory(configuration, clientConfiguration);
}
@Bean
public RedisTemplate getTemplate(@Qualifier(value = "redisTemplate") RedisTemplate template) {
template.setConnectionFactory(lettuceConnectionFactory());
template.setDefaultSerializer(new StringRedisSerializer());
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new StringRedisSerializer());
template.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
return template;
}
/**
*
* 1.1
*
* @return
*/
@Bean
@Primary
public RedisCacheManager cacheManager() {
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(lettuceConnectionFactory());
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.string()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
.entryTtl(Duration.ofDays(1));
RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisCacheWriter)
.cacheDefaults(redisCacheConfiguration)
.withInitialCacheConfigurations(getRedisCacheConfigurationMap()).build();
return redisCacheManager;
}
/**
* key
*
* @return
*/
private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
redisCacheConfigurationMap.put(RedisKeys.WECHAT_ACCESS_TOKEN, getRedisCacheConfigurationWithTtl(600));
// 直播间统计ID集合 默认保存七天
return redisCacheConfigurationMap;
}
private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
return RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.string()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
.computePrefixWith(name -> name + ":").entryTtl(Duration.ofSeconds(seconds));
}
/**
* , ,
*
* @param redisConnectionFactory
* @return
*/
@Bean
public StreamMessageListenerContainer<String, MapRecord<String, String, String>> streamMessageListenerContainer(RedisConnectionFactory redisConnectionFactory) {
// 创建配置对象
StreamMessageListenerContainer.StreamMessageListenerContainerOptions<String, MapRecord<String, String, String>> listenerContainerOptions = StreamMessageListenerContainer.StreamMessageListenerContainerOptions
.builder()
// 一次性最多拉取多少条消息
.batchSize(100)
.executor(THREAD_POOL_EXECUTOR)
.build();
// 根据配置对象创建监听容器
StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer = StreamMessageListenerContainer.create(redisConnectionFactory, listenerContainerOptions);
return listenerContainer;
}
/**
* 1.springredis
* 2.springredis
*
* @param applicationEvent
*/
@Override
public void onApplicationEvent(ApplicationEvent applicationEvent) {
if (applicationEvent instanceof ApplicationStartedEvent) {
// 启动redis stream 监听
((ApplicationStartedEvent) applicationEvent).getApplicationContext()
.getBeanProvider(StreamMessageListenerContainer.class)
.ifAvailable(Lifecycle::start);
}
if (applicationEvent instanceof ContextClosedEvent) {
// 启动redis stream 监听
((ContextClosedEvent) applicationEvent).getApplicationContext()
.getBeanProvider(StreamMessageListenerContainer.class)
.ifAvailable(Lifecycle::stop);
}
}
}

@ -1,47 +0,0 @@
package com.arm.equipment.system.data.app;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class RestTemplateConfiguration {
@Bean(name = "restTemplate")
public RestTemplate getRestTemplate() {
List messageConverters = new ArrayList<>();
messageConverters.add(new FormHttpMessageConverter());
messageConverters.add(getFastJsonHttpMessageConverter());
messageConverters.add(new StringHttpMessageConverter());
RestTemplate restTemplate = new RestTemplate(getHttpRequestFactory());
restTemplate.setMessageConverters(messageConverters);
return restTemplate;
}
private FastJsonHttpMessageConverter getFastJsonHttpMessageConverter() {
FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
fastJsonHttpMessageConverter.setFastJsonConfig(getFastJsonConfig());
return fastJsonHttpMessageConverter;
}
private FastJsonConfig getFastJsonConfig() {
FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteDateUseDateFormat);
return fastJsonConfig;
}
private SimpleClientHttpRequestFactory getHttpRequestFactory() {
SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();
simpleClientHttpRequestFactory.setConnectTimeout(120000);
simpleClientHttpRequestFactory.setReadTimeout(120000);
return simpleClientHttpRequestFactory;
}
}

@ -1,13 +0,0 @@
package com.arm.equipment.system.data.constant;
import java.util.Arrays;
import java.util.List;
/**
*
* @author wyd
*/
public class ConstantValues {
/** request请求中的参数 */
public final static String REQUEST_BODY = "WJ-Request-Body";
}

@ -1,29 +0,0 @@
package com.arm.equipment.system.data.constant;
/**
* redisKey
*/
public class RedisKeys {
public final static String SYS_BASE_PARAM_KEY = "sysBaseParamKey";
/** * 微信accesstoken*/
public final static String WECHAT_ACCESS_TOKEN = "wechatAccessToken";
/*** id worker service中的worker id*/
public static final String SNOW_FLAKE_WORKER_ID = "snow:flake_worker:id";
/**系统用户登陆错误次数*/
public static final String SYS_USER_LOGIN_ERROR_NUM = "sys:user:login:error:num:%s";
/**
* token
* <p>
* : SET
*
* @param token
* @return
*/
public static String getAppUsernameByTokenSetKey(String token) {
return String.format("app:user:token:%s", token);
}
public static String getAppUserSessionKey(String token) {
return String.format("app:user:session:%s", token);
}
}

@ -1,65 +0,0 @@
package com.arm.equipment.system.data.domain;
import java.util.Date;
/**
*
* @author admin
*/
public class BaseDomain extends BasePage {
/** 主键 */
private Long id;
/** 创建时间 */
private Date createTime;
/** 更新时间 */
private Date updateTime;
/** 更新时间结束 */
private Date updateTimeEnd;
/** 操作人*/
private String operator;
/** 备注 */
private String remark;
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getCreateTime() { return createTime; }
public void setCreateTime(Date createTime) { this.createTime = createTime; }
public Date getUpdateTime() { return updateTime; }
public void setUpdateTime(Date updateTime) { this.updateTime = updateTime; }
public Date getUpdateTimeEnd() { return updateTimeEnd; }
public void setUpdateTimeEnd(Date updateTimeEnd) { this.updateTimeEnd = updateTimeEnd; }
public String getRemark() { return remark; }
public void setRemark(String remark) { this.remark = remark; }
@Override
public String toString() {
return "BaseDomain{" +
"id=" + id +
", createTime=" + createTime +
", updateTime=" + updateTime +
", updateTimeEnd=" + updateTimeEnd +
", remark='" + remark + '\'' +
'}';
}
}

@ -1,49 +0,0 @@
package com.arm.equipment.system.data.domain;
import com.fasterxml.jackson.annotation.JsonIgnore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.Serializable;
/**
* ,
* @author admin
*/
public class BasePage implements Serializable {
private static final Logger LOGGER = LoggerFactory.getLogger(BasePage.class);
private static final long serialVersionUID = -320995871886379593L;
/** 页码 */
private Integer pageNo;
/** 每页大小 */
private Integer pageSize;
public Integer getPageNo() {
return pageNo;
}
public void setPageNo(Integer pageNo) {
this.pageNo = pageNo;
}
public Integer getPageSize() {
//最大限制为5000
if (null != pageSize && pageSize > 5000) {
LOGGER.warn(" pageSize 过大pageSize={}", pageSize);
return 5000;
}
return pageSize;
}
public void setPageSize(Integer pageSize) {
this.pageSize = pageSize;
}
@JsonIgnore
public Integer getStartIndex() {
if (pageNo == null || pageSize == null) {
return null;
}
return (this.pageNo - 1) * this.pageSize;
}
}

@ -1,94 +0,0 @@
package com.arm.equipment.system.data.domain;
import java.util.Collection;
/**
* @author admin
*/
public class PageResult {
/** 页数 */
private int pageNo;
/** 总页数 */
private int pageCount;
/** 总条数 */
private int total;
/** 数据 */
private Collection<?> rows;
/** 页大小 */
private int pageSize;
public PageResult() {
}
public PageResult(int pageNo, int pageSize, int total, Collection<?> rows) {
this.pageNo = pageNo;
this.total = total;
this.rows = rows;
this.pageSize = pageSize;
this.pageCount = calcPageCount(total);
}
private int calcPageCount(int count) {
if (pageSize == 0) {
return 0;
}
if (count % pageSize == 0) {
return count / pageSize;
} else {
return count / pageSize + 1;
}
}
public static int getPageCount(int count, int pageSize) {
if (pageSize == 0) {
return 0;
}
if (count % pageSize == 0) {
return count / pageSize;
} else {
return count / pageSize + 1;
}
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getPageCount() {
return pageCount;
}
public void setPageCount(int pageCount) {
this.pageCount = pageCount;
}
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = total;
}
public Collection<?> getRows() {
return rows;
}
public void setRows(Collection<?> rows) {
this.rows = rows;
}
}

@ -1,67 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
/**
* --
*
* @author Administrator
* @date 20211026 16:36:52
*/
public class SysBaseParam extends BaseDomain {
/** 唯一编码 */
private String uniCode;
/** 值 */
private String value;
/** 描述 */
private String description;
/** 操作人 */
private String operator;
/** 数据状态 */
private Integer status;
public String getUniCode() {
return uniCode;
}
public void setUniCode(String uniCode) {
this.uniCode = uniCode;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}

@ -1,111 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
/**
*
*
* @author admin
* @date 20220916 12:41:35
*/
public class SysLog extends BaseDomain {
/** 日志类型(1接入日志2错误日志) */
private Integer type;
/** 日志标题 */
private String title;
/** 操作IP地址 */
private String remoteAddr;
/** 用户代理 */
private String userAgent;
/** 请求URI */
private String requestUri;
/** 操作方式 */
private String method;
/** 操作提交的数据 */
private String params;
/** 异常信息 */
private String exception;
/** 状态 */
private Integer status;
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getRemoteAddr() {
return remoteAddr;
}
public void setRemoteAddr(String remoteAddr) {
this.remoteAddr = remoteAddr;
}
public String getUserAgent() {
return userAgent;
}
public void setUserAgent(String userAgent) {
this.userAgent = userAgent;
}
public String getRequestUri() {
return requestUri;
}
public void setRequestUri(String requestUri) {
this.requestUri = requestUri;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public String getParams() {
return params;
}
public void setParams(String params) {
this.params = params;
}
public String getException() {
return exception;
}
public void setException(String exception) {
this.exception = exception;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}

@ -1,166 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.List;
/**
* --
*
* @author admin
* @date 20211020 08:59:10
*/
public class SysResource extends BaseDomain {
/** 菜单名称 */
private String name;
/** 链接地址 */
private String url;
/** 父菜单ID */
private String parentId;
/** 图标 */
private String icon;
/** 排序 */
private Integer sort;
/** 菜单类型 */
private Integer type;
/** 权限标识 */
private String identity;
/** 是否显示 */
private Integer isShow;
/** 状态 */
private Integer status;
/** 操作人 */
private String operator;
/** 根路径,用.分隔 */
private String rootPath;
/********VO******/
/**子集集合*/
private List<SysResource> children;
/**标签*/
private String label;
/**ID集合*/
private List<Long> idsList;
public List<Long> getIdsList() {
return idsList;
}
public void setIdsList(List<Long> idsList) {
this.idsList = idsList;
}
public String getLabel() {
return label;
}
public void setLabel(String label) {
this.label = label;
}
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 getParentId() {
return parentId;
}
public void setParentId(String parentId) {
this.parentId = parentId;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public Integer getSort() {
return sort;
}
public void setSort(Integer sort) {
this.sort = sort;
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
public String getIdentity() {
return identity;
}
public void setIdentity(String identity) {
this.identity = identity;
}
public Integer getIsShow() {
return isShow;
}
public void setIsShow(Integer isShow) {
this.isShow = isShow;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
public String getRootPath() {
return rootPath;
}
public void setRootPath(String rootPath) {
this.rootPath = rootPath;
}
public List<SysResource> getChildren() {
return children;
}
public void setChildren(List<SysResource> children) {
this.children = children;
}
}

@ -1,69 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.List;
/**
* --
*
* @author admin
* @date 20211019 15:06:47
*/
public class SysRole extends BaseDomain {
/** 角色名称 */
private String name;
/** 描述 */
private String description;
/** 状态 */
private Integer status;
/** 操作人 */
private String operator;
/****** VO ***/
/**角色ID集合*/
private List<Long> sysRoleIdList;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
public List<Long> getSysRoleIdList() {
return sysRoleIdList;
}
public void setSysRoleIdList(List<Long> sysRoleIdList) {
this.sysRoleIdList = sysRoleIdList;
}
}

@ -1,70 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.List;
/**
* -
*
* @author admin
* @date 20211019 15:06:41
*/
public class SysRoleResource extends BaseDomain {
/** 角色ID */
private Long sysRoleId;
/** 权限ID */
private Long sysResourceId;
/** 状态 */
private Integer status;
/** 操作人 */
private String operator;
/****** VO ***/
/**添加新权限(修改权限)*/
private List<String> newResources;
public List<String> getNewResources() {
return newResources;
}
public void setNewResources(List<String> newResources) {
this.newResources = newResources;
}
public Long getSysRoleId() {
return sysRoleId;
}
public void setSysRoleId(Long sysRoleId) {
this.sysRoleId = sysRoleId;
}
public Long getSysResourceId() {
return sysResourceId;
}
public void setSysResourceId(Long sysResourceId) {
this.sysResourceId = sysResourceId;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
}

@ -1,172 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.List;
/**
* --
*
* @author admin
* @date 20211019 15:07:06
*/
public class SysUser extends BaseDomain {
/** 用户名 */
private String username;
/** 密码 */
private String password;
/** 手机 */
private String phone;
/** 姓名 */
private String name;
/** 邮箱 */
private String email;
/**
*
* @see
* */
private String tag;
/** 状态 */
private Integer status;
/**是否需要二次登陆*/
private Integer isSecondLanding;
/******VO****/
/**
*
*/
private String verifyCode;
/**
*
*/
private List<SysRole> sysRoleList;
/**
*
*/
private List<String> sysResourceIdentityList;
/**
*
*/
private List<SysResource> sysResourceList;
/**标签集合*/
private List<String> tagList;
/**二次登陆验证码*/
private String twoVerifyCode;
public String getTwoVerifyCode() {
return twoVerifyCode;
}
public void setTwoVerifyCode(String twoVerifyCode) {
this.twoVerifyCode = twoVerifyCode;
}
public Integer getIsSecondLanding() {
return isSecondLanding;
}
public void setIsSecondLanding(Integer isSecondLanding) {
this.isSecondLanding = isSecondLanding;
}
public List<String> getTagList() {
return tagList;
}
public void setTagList(List<String> tagList) {
this.tagList = tagList;
}
public String getVerifyCode() {
return verifyCode;
}
public void setVerifyCode(String verifyCode) {
this.verifyCode = verifyCode;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public List<SysRole> getSysRoleList() {
return sysRoleList;
}
public void setSysRoleList(List<SysRole> sysRoleList) {
this.sysRoleList = sysRoleList;
}
public List<String> getSysResourceIdentityList() {
return sysResourceIdentityList;
}
public void setSysResourceIdentityList(List<String> sysResourceIdentityList) {
this.sysResourceIdentityList = sysResourceIdentityList;
}
public List<SysResource> getSysResourceList() {
return sysResourceList;
}
public void setSysResourceList(List<SysResource> sysResourceList) {
this.sysResourceList = sysResourceList;
}
public String getTag() {
return tag;
}
public void setTag(String tag) {
this.tag = tag;
}
}

@ -1,56 +0,0 @@
package com.arm.equipment.system.data.domain.system;
import com.arm.equipment.system.data.domain.BaseDomain;
/**
* --
*
* @author admin
* @date 20211019 15:06:59
*/
public class SysUserRole extends BaseDomain {
/** 角色ID */
private Long sysRoleId;
/** 用户ID */
private Long sysUserId;
/** 状态 */
private Integer status;
/** 执行者 */
private String operator;
public Long getSysRoleId() {
return sysRoleId;
}
public void setSysRoleId(Long sysRoleId) {
this.sysRoleId = sysRoleId;
}
public Long getSysUserId() {
return sysUserId;
}
public void setSysUserId(Long sysUserId) {
this.sysUserId = sysUserId;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
}

@ -1,89 +0,0 @@
package com.arm.equipment.system.data.domain.user;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.Date;
/**
* APP
*
* @author admin
* @date 20230313 22:34:47
*/
public class AppUser extends BaseDomain {
/** 用户昵称 */
private String nickname;
/** 登录账号 */
private String username;
/** 密码 */
private String password;
/** 手机号 */
private String phone;
/** 数据状态 */
private Integer status;
/** 登录时间 */
private Date loginTime;
private String token;
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Date getLoginTime() {
return loginTime;
}
public void setLoginTime(Date loginTime) {
this.loginTime = loginTime;
}
}

@ -1,124 +0,0 @@
package com.arm.equipment.system.data.domain.weaponry;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.Date;
/**
*
*
* @author admin
* @date 20230323 10:29:48
*/
public class Weaponry extends BaseDomain {
/** 武器名称 */
private String name;
/** 武器封面 */
private String imgPath;
/** 弹夹容量(发) */
private Integer cartridgeCapacity;
/** 子弹口径mm */
private Double bulletCaliber;
/** 有效射程 */
private Integer effectiveRange;
/** 总库存 */
private Integer totalInventory;
/** 锁定库存 */
private Integer lockInventory;
/** 数据状态 */
private Integer status;
/**VO*/
/**是否已借出*/
private Integer isLend;
/**锁定数起始值*/
private Integer lockInventoryStart;
public Integer getLockInventoryStart() {
return lockInventoryStart;
}
public void setLockInventoryStart(Integer lockInventoryStart) {
this.lockInventoryStart = lockInventoryStart;
}
public Integer getIsLend() {
return isLend;
}
public void setIsLend(Integer isLend) {
this.isLend = isLend;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getImgPath() {
return imgPath;
}
public void setImgPath(String imgPath) {
this.imgPath = imgPath;
}
public Integer getCartridgeCapacity() {
return cartridgeCapacity;
}
public void setCartridgeCapacity(Integer cartridgeCapacity) {
this.cartridgeCapacity = cartridgeCapacity;
}
public Double getBulletCaliber() {
return bulletCaliber;
}
public void setBulletCaliber(Double bulletCaliber) {
this.bulletCaliber = bulletCaliber;
}
public Integer getEffectiveRange() {
return effectiveRange;
}
public void setEffectiveRange(Integer effectiveRange) {
this.effectiveRange = effectiveRange;
}
public Integer getTotalInventory() {
return totalInventory;
}
public void setTotalInventory(Integer totalInventory) {
this.totalInventory = totalInventory;
}
public Integer getLockInventory() {
return lockInventory;
}
public void setLockInventory(Integer lockInventory) {
this.lockInventory = lockInventory;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}

@ -1,92 +0,0 @@
package com.arm.equipment.system.data.domain.weaponry;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.Date;
/**
*
*
* @author admin
* @date 20230323 11:02:17
*/
public class WeaponryLendRecord extends BaseDomain {
/** 武器ID */
private Long weaponryId;
/** 武器名称 */
private String weaponryName;
/** 借出数量 */
private Integer num;
/** 归还时间 */
private Date returnTime;
/** 归还状态0未归还 1已归还 */
private Integer returnStatus;
/** 数据状态 */
private Integer status;
/****************VO**************/
private Weaponry weaponry;
public Weaponry getWeaponry() {
return weaponry;
}
public void setWeaponry(Weaponry weaponry) {
this.weaponry = weaponry;
}
public Long getWeaponryId() {
return weaponryId;
}
public void setWeaponryId(Long weaponryId) {
this.weaponryId = weaponryId;
}
public String getWeaponryName() {
return weaponryName;
}
public void setWeaponryName(String weaponryName) {
this.weaponryName = weaponryName;
}
public Integer getNum() {
return num;
}
public void setNum(Integer num) {
this.num = num;
}
public Date getReturnTime() {
return returnTime;
}
public void setReturnTime(Date returnTime) {
this.returnTime = returnTime;
}
public Integer getReturnStatus() {
return returnStatus;
}
public void setReturnStatus(Integer returnStatus) {
this.returnStatus = returnStatus;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}

@ -1,91 +0,0 @@
package com.arm.equipment.system.data.domain.weaponry;
import com.arm.equipment.system.data.domain.BaseDomain;
import java.util.Date;
/**
*
*
* @author admin
* @date 20230323 11:03:25
*/
public class WeaponryReturnRecord extends BaseDomain {
/** 武器ID */
private Long weaponryId;
/** 武器名称 */
private String weaponryName;
/** 记录ID */
private Long lendRecordId;
/** 借出数量 */
private Integer num;
/** 归还时间 */
private Date returnTime;
/** 数据状态 */
private Integer status;
/****************VO**************/
private Weaponry weaponry;
public Weaponry getWeaponry() {
return weaponry;
}
public void setWeaponry(Weaponry weaponry) {
this.weaponry = weaponry;
}
public Long getWeaponryId() {
return weaponryId;
}
public void setWeaponryId(Long weaponryId) {
this.weaponryId = weaponryId;
}
public String getWeaponryName() {
return weaponryName;
}
public void setWeaponryName(String weaponryName) {
this.weaponryName = weaponryName;
}
public Long getLendRecordId() {
return lendRecordId;
}
public void setLendRecordId(Long lendRecordId) {
this.lendRecordId = lendRecordId;
}
public Integer getNum() {
return num;
}
public void setNum(Integer num) {
this.num = num;
}
public Date getReturnTime() {
return returnTime;
}
public void setReturnTime(Date returnTime) {
this.returnTime = returnTime;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}

@ -1,37 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/***
*
*
* @author: admin
* @time: 2021/11/17 17:35
*/
public enum EnumFileResourceType {
/** */
IMG(1, "图片"),
VIDEO(2, "视频"),
;
private Integer code;
private String text;
EnumFileResourceType(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}}

@ -1,51 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
import com.arm.equipment.system.data.exception.BusinessException;
/**
*
* @author admin
*/
public enum EnumGender {
/** 审核 */
MALE(1, "男"),
/** The release. */
FEMALE(2, "女"),
;
private Integer code;
private String text;
EnumGender(Integer code, String text) {
this.code = code;
this.text = text;
}
public static EnumGender getByCode(Integer code) {
if (null == code) {
return null;
}
for (EnumGender type : EnumGender.values()) {
if (type.getCode().equals(code)) {
return type;
}
}
throw new BusinessException("内容类型非法");
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}}

@ -1,51 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
*
*
* @author: xly
* @time: 2022/9/16 18:30
*/
public enum EnumSortType {
ASC(1, "升序"),
DESC(2, "降序"),
;
private Integer code;
private String text;
EnumSortType(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public static EnumSortType getByCode(Integer code) {
if (code == null) {
return null;
}
EnumSortType[] values = EnumSortType.values();
for (EnumSortType v : values) {
if (v.getCode().equals(code)) {
return v;
}
}
return null;
}
}

@ -1,56 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
*
*
* @author admin
*/
public enum EnumStatus {
/**
* The new.
*/
NEW(0, "新增"),
AUDIT(1, "已审核"),
DEL(-9, "已删除");
private Integer code;
private String text;
EnumStatus(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
/**
* code
*
* @param code
* @return
*/
public static EnumStatus getByCode(Integer code) {
EnumStatus[] values = EnumStatus.values();
for (EnumStatus type : values) {
if (type.code.equals(code)) {
return type;
}
}
return NEW;
}
}

@ -1,56 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
*
*
* @author admin
*/
public enum EnumSysLogType {
/**
* The new.
*/
LOG(1, "普通日志"),
EXCEPTION_LOG(2, "异常日志"),
;
private Integer code;
private String text;
EnumSysLogType(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
/**
* code
*
* @param code
* @return
*/
public static EnumSysLogType getByCode(Integer code) {
EnumSysLogType[] values = EnumSysLogType.values();
for (EnumSysLogType type : values) {
if (type.code.equals(code)) {
return type;
}
}
return null;
}
}

@ -1,41 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
*
*
* @author: admin
* @time: 2021/10/19 18:02
*/
public enum EnumSysResourceType {
/**
*
*/
CATALOGUE(0, "目录"),
MENU(1, "菜单"),
BUTTON(2, "按钮"),
;
private Integer code;
private String text;
EnumSysResourceType(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
}

@ -1,50 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
* @author: xly
* @time: 2023/3/23 9:02
*/
public enum EnumWeaponryLendRecordReturnStatus {
NOT_RETURN(0, "未归还"),
RETURN(1, "已经归还"),
;
private Integer code;
private String text;
EnumWeaponryLendRecordReturnStatus(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
/**
* code
*
* @param code
* @return
*/
public static EnumSysLogType getByCode(Integer code) {
EnumSysLogType[] values = EnumSysLogType.values();
for (EnumSysLogType type : values) {
if (type.getCode().equals(code)) {
return type;
}
}
return null;
}
}

@ -1,51 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
* @author: xly
* @time: 2023/3/23 9:02
*/
public enum EnumWeaponryLendRecordStatus {
NEW(0, "新增"),
ADOPT(1, "通过"),
REFUSE(2, "拒绝"),
;
private Integer code;
private String text;
EnumWeaponryLendRecordStatus(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
/**
* code
*
* @param code
* @return
*/
public static EnumSysLogType getByCode(Integer code) {
EnumSysLogType[] values = EnumSysLogType.values();
for (EnumSysLogType type : values) {
if (type.getCode().equals(code)) {
return type;
}
}
return null;
}
}

@ -1,36 +0,0 @@
package com.arm.equipment.system.data.enums.dict;
/**
* yes no
* @author admin
*/
public enum EnumYesNo {
/** */
NO(0, "否"),
YES(1, "是")
;
private Integer code;
private String text;
EnumYesNo(Integer code, String text) {
this.code = code;
this.text = text;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}}

@ -1,73 +0,0 @@
package com.arm.equipment.system.data.enums.file;
import org.apache.commons.lang3.StringUtils;
/**
*
* 1.
* 2.
*
* @author admin
*/
public enum EnumUpload {
RES_PHOTO_LIB("resPhotoLib", "jpg", "上传图片"),
RES_VIDEO_LIB("resVideoLib", "mp4", "上传视频"),
QR_CODE("qrCode", "jpg", "二维码"),
;
EnumUpload(String baseDir, String suffix, String desc) {
this.baseDir = baseDir;
this.suffix = suffix;
this.desc = desc;
}
/**
* ,
*
*/
String baseDir;
/**
* jpgpngtxtapk
*/
String suffix;
/**
*
*/
String desc;
public static EnumUpload getEnum(String baseDir) {
if (StringUtils.isEmpty(baseDir)) {
return null;
}
for (EnumUpload type : EnumUpload.values()) {
if (type.getBaseDir().equals(baseDir)) {
return type;
}
}
return null;
}
public String getBaseDir() {
return baseDir;
}
public void setBaseDir(String baseDir) {
this.baseDir = baseDir;
}
public String getSuffix() {
return suffix;
}
public void setSuffix(String suffix) {
this.suffix = suffix;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}

@ -1,62 +0,0 @@
package com.arm.equipment.system.data.exception;
import com.arm.equipment.system.data.vo.ReturnCode;
/**
* @author
* @Date 2019/7/27 17:11
**/
public class AuthException extends RuntimeException {
private static final long serialVersionUID = -7429924842303522242L;
String message;
ReturnCode returnCode;
public AuthException() {
super();
}
public AuthException(String message) {
this.message = message;
}
public AuthException(ReturnCode returnCode) {
this.returnCode = returnCode;
}
public AuthException(String message, ReturnCode returnCode) {
this.message = message;
this.returnCode = returnCode;
}
public AuthException(String message, Throwable cause) {
super(message, cause);
}
public AuthException(Throwable cause) {
super(cause);
}
protected AuthException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
@Override
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public ReturnCode getReturnCode() {
return returnCode;
}
public void setReturnCode(ReturnCode returnCode) {
this.returnCode = returnCode;
}
}

@ -1,48 +0,0 @@
package com.arm.equipment.system.data.exception;
/**
* service使
*/
public class BusinessException extends RuntimeException {
private static final long serialVersionUID = -6053475656376646723L;
Integer errorCode;
String message;
public BusinessException(String message) {
this.message = message;
}
public BusinessException(Integer errorCode, String message) {
this.errorCode = errorCode;
this.message = message;
}
public BusinessException(Throwable cause) {
super(cause);
}
public BusinessException(String message, Throwable cause) {
super(message, cause);
}
public Integer getErrorCode() {
return errorCode;
}
public void setErrorCode(Integer errorCode) {
this.errorCode = errorCode;
}
@Override
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}

@ -1,80 +0,0 @@
package com.arm.equipment.system.data.util;
import org.bouncycastle.util.encoders.Hex;
import sun.misc.BASE64Decoder;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
/**
* Aes /
*/
public class AesUtil {
private static final String ALGORITHM = "AES";
private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
public String encrypt(String input, String key) {
byte[] decodeKey = Hex.decode(key);
byte[] crypted = null;
try {
SecretKeySpec skey = new SecretKeySpec(decodeKey, ALGORITHM);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.ENCRYPT_MODE, skey);
crypted = cipher.doFinal(input.getBytes());
} catch (Exception e) {
System.out.println(e.toString());
}
return parseByte2HexStr(crypted);
}
/**
*
*
* @param content
* @param key key
* @param platform @see EnumPlatform
* @return
* @throws Exception
*/
public static String decrypt(String content, String key, Integer platform) throws Exception {
content = new String(new BASE64Decoder().decodeBuffer(content));
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
byte[] keyBytes = key.getBytes();
SecretKeySpec sk = new SecretKeySpec(keyBytes, "AES");
//7.初始化密码器,第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作第二个参数为使用的KEY
cipher.init(Cipher.DECRYPT_MODE, sk);
byte[] bytes = parseHexStr2Byte(content);
byte[] decode = cipher.doFinal(bytes);
return new String(decode, "utf-8");
}
private static byte[] parseHexStr2Byte(String hexStr) {
if (hexStr.length() < 1) {
return null;
}
byte[] result = new byte[hexStr.length() / 2];
for (int i = 0; i < hexStr.length() / 2; i++) {
int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
result[i] = (byte) (high * 16 + low);
}
return result;
}
private static String parseByte2HexStr(byte buf[]) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < buf.length; i++) {
String hex = Integer.toHexString(buf[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
sb.append(hex.toUpperCase());
}
return sb.toString();
}
}

@ -1,33 +0,0 @@
package com.arm.equipment.system.data.util;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import java.util.HashSet;
import java.util.Set;
/**
* @author admin
*/
public class BeanUtil {
/**
* null
* @param source
* @return
*/
public static String[] getNullPropertyNames (Object source) {
final BeanWrapper src = new BeanWrapperImpl(source);
java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors();
Set<String> emptyNames = new HashSet<String>();
for(java.beans.PropertyDescriptor pd : pds) {
Object srcValue = src.getPropertyValue(pd.getName());
if (srcValue == null){
emptyNames.add(pd.getName());
}
}
String[] result = new String[emptyNames.size()];
return emptyNames.toArray(result);
}
}

@ -1,67 +0,0 @@
package com.arm.equipment.system.data.util;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.UUID;
/**
*
*
* Update by xy on 2017/4/27.
*/
public class DATAUtil {
/**
*
*
* @param sql
* @param jdbcTemplate
* @param pageSize
* @return
*/
public static final int getPageCount(String sql, JdbcTemplate jdbcTemplate, int pageSize, Object... objects) {
try {
Integer totalCount = jdbcTemplate.queryForObject(sql, objects, Integer.class);
int pageCount = (totalCount - 1) / pageSize;
return pageCount + 1;
} catch (DataAccessException e) {
return 0;
}
}
/**
*
* @param totalCount
* @param pageSize
* @return
*/
public static int getPageCount(int totalCount, int pageSize) {
int pageCount = (totalCount - 1) / pageSize;
return pageCount + 1;
}
/**
* UUID
*
* @return
*/
public static String uuid() {
return UUID.randomUUID().toString().replace("-", "");
}
/**
*
*
* @return
*/
public static String getCode() {
String code = Math.round(Math.random() * 1000000) + "";
if (code.length() < 6) {
code = ((1+ Math.round(Math.random())) * 100000) +"";
//生成一个以1开头的6位数
}
code = code.substring(0,6);//防止第一次生成code时round方法对六个9四舍五入导致可能超过6位的情况
return code;
}
}

@ -1,343 +0,0 @@
package com.arm.equipment.system.data.util;
import org.apache.commons.lang.time.DateFormatUtils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
/**
* , org.apache.commons.lang.time.DateUtils
*/
public class DateUtils extends org.apache.commons.lang.time.DateUtils {
/**
*
*/
public static final String[] NUM_ARRAY = {"一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"};
private static String[] parsePatterns = {
"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
"yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM",
"yyyy-MM-dd HH"};
/**
* yyyy-MM-dd
*/
public static String getDate() {
return getDate("yyyy-MM-dd");
}
/**
* yyyy-MM-dd pattern"yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String getDate(String pattern) {
return DateFormatUtils.format(new Date(), pattern);
}
/**
* yyyy-MM-dd pattern"yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String formatDate(Date date, Object... pattern) {
String formatDate = null;
if (pattern != null && pattern.length > 0) {
formatDate = DateFormatUtils.format(date, pattern[0].toString());
} else {
formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
}
return formatDate;
}
/**
* yyyy-MM-dd HH:mm:ss
*/
public static String formatDateTime(Date date) {
return formatDate(date, "yyyy-MM-dd HH:mm:ss");
}
/**
* HH:mm:ss
*/
public static String getTime() {
return formatDate(new Date(), "HH:mm:ss");
}
/**
* yyyy-MM-dd HH:mm:ss
*/
public static String getDateTime() {
return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
}
/**
* yyyy
*/
public static String getYear() {
return formatDate(new Date(), "yyyy");
}
/**
* MM
*/
public static String getMonth() {
return formatDate(new Date(), "MM");
}
/**
* dd
*/
public static String getDay() {
return formatDate(new Date(), "dd");
}
/**
* E
*/
public static String getWeek() {
return formatDate(new Date(), "E");
}
/**
*
* { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
* "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm",
* "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm" }
*/
public static Date parseDate(Object str) {
if (str == null) {
return null;
}
try {
return parseDate(str.toString(), parsePatterns);
} catch (ParseException e) {
return null;
}
}
/**
*
*
* @param date
* @return
*/
public static long pastDays(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (24 * 60 * 60 * 1000);
}
/**
*
*
* @param date
* @return
*/
public static long pastHour(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (60 * 60 * 1000);
}
/**
*
*
* @param date
* @return
*/
public static long pastMinutes(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (60 * 1000);
}
/**
* ,::.
*
* @param timeMillis
* @return
*/
public static String formatDateTime(long timeMillis) {
long day = timeMillis / (24 * 60 * 60 * 1000);
long hour = (timeMillis / (60 * 60 * 1000) - day * 24);
long min = ((timeMillis / (60 * 1000)) - day * 24 * 60 - hour * 60);
long s = (timeMillis / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
long sss = (timeMillis - day * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000 - s * 1000);
return (day > 0 ? day + "," : "") + hour + ":" + min + ":" + s + "." + sss;
}
/**
*
*
* @param before
* @param after
* @return
*/
public static double getDistanceOfTwoDate(Date before, Date after) {
long beforeTime = before.getTime();
long afterTime = after.getTime();
return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
}
/**
* Date
*
* @param appendDay
* @return
*/
public static Date addAppendDay(int appendDay) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date dt = new Date();
Calendar rightNow = Calendar.getInstance();
rightNow.setTime(dt);
rightNow.add(Calendar.DAY_OF_YEAR, appendDay);
return rightNow.getTime();
}
/**
*
*
* @param date
* @return
*/
public static Date getStartTimeOfDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
}
/**
* 23:59:59:999
*
* @param date
* @return
*/
public static Date getEndTimeOfDate(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 999);
return cal.getTime();
}
/**
*
*
* @return
*/
public static Date getYesterdayDateTime() {
Calendar cal = Calendar.getInstance();
cal.add(5, -1);
return cal.getTime();
}
/**
*
*
* @param beginDate
* @param endDate
* @return List
*/
public static List<Date> getDatesBetweenTwoDate(Date beginDate, Date endDate) {
if (beginDate.getTime() >= endDate.getTime()) {
throw new RuntimeException("endDate must after beginDate ...");
}
List<Date> lDate = new ArrayList<Date>();
lDate.add(beginDate);// 把开始时间加入集合
Calendar cal = Calendar.getInstance();
// 使用给定的 Date 设置此 Calendar 的时间
cal.setTime(beginDate);
boolean bContinue = true;
while (bContinue) {
// 根据日历的规则,为给定的日历字段添加或减去指定的时间量
cal.add(Calendar.DAY_OF_MONTH, 1);
// 测试此日期是否在指定日期之后
if (endDate.after(cal.getTime())) {
lDate.add(cal.getTime());
} else {
break;
}
}
lDate.add(endDate);// 把结束时间加入集合
return lDate;
}
/**
* 0
*
* @return
*/
public static Date getYesterDayZEROTIME() {
return getSpecifiedDay(-1, 0, 0, 0);
}
/**
*
*
* @param day
* @param hour
* @param minute
* @param second
* @return
*/
public static Date getSpecifiedDay(int day, int hour, int minute, int second) {
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) + day);
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, minute);
calendar.set(Calendar.SECOND, second);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 0
*
* @return
*/
public static Date getZEROTIME() {
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* /**
* n
*
* @param type 0 1
* @param n n
* @return
*/
public static Date getDateBeforeOneHour(Date date, int type, int n) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) - n);
String dateStr = formatDate(calendar.getTime(), "yyyy-MM-dd HH");
if (type == 1) {
return parseDate(dateStr + ":59:59");
}
return parseDate(dateStr + ":00:00");
}
/**
*
*
* @param date
* @return
*/
public static int getHourByDate(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.HOUR_OF_DAY);
}
}

@ -1,32 +0,0 @@
package com.arm.equipment.system.data.util;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.metadata.BaseRowModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
public class EasyExcelListener<T extends BaseRowModel> extends AnalysisEventListener<T> {
private final static Logger logger = LoggerFactory.getLogger(EasyExcelListener.class);
private final List<T> rows = new ArrayList<>();
@Override
public void invoke(T object, AnalysisContext context) {
rows.add(object);
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
logger.info("read {} rows %n", rows.size());
}
public List<T> getRows() {
logger.info("read {} rows %n", rows);
return rows;
}
}

@ -1,60 +0,0 @@
package com.arm.equipment.system.data.util;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
/**
*
*/
@Component
public class EnvUtil implements EnvironmentAware {
/** 系统环境 */
private static Environment environment;
/**
*
* @return
*/
public static boolean isDev() {
return isEnv("dev");
}
/**
*
* @return
*/
public static boolean isTest() {
return isEnv("test");
}
/**
*
* @return
*/
public static boolean isProd() {
return isEnv("prod");
}
/**
* profile
* @param env
* @return
*/
private static boolean isEnv(String env) {
return environment.getProperty("env").equalsIgnoreCase(env);
}
public static String getEnv() {
return environment.getProperty("env");
}
@Override
public void setEnvironment(Environment environment) {
EnvUtil.environment = environment;
}
public static boolean isESEnable() {
return true;
}
}

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

Loading…
Cancel
Save