Compare commits

...

11 Commits

Binary file not shown.

@ -0,0 +1,18 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.7/apache-maven-3.8.7-bin.zip
wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.1/maven-wrapper-3.1.1.jar

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="FacetManager">
<facet type="Spring" name="Spring">
<configuration />
</facet>
</component>
</module>

@ -0,0 +1,279 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.11</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>WhiteListManageSys</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<!--<packaging>jar</packaging>-->
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<!--websocket -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- 外置依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<!-- 添加MySQL数据库驱动 -->
<!-- <dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>-->
<!-- oracle驱动-->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.3</version>
</dependency>
<!-- sqlserver驱动-->
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>8.4.1.jre8</version>
</dependency>
<!-- 引入 japidoc 接口文档说明-->
<dependency>
<groupId>io.github.yedaxia</groupId>
<artifactId>japidocs</artifactId>
<version>1.4.4</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
<exclusions>
<exclusion>
<artifactId>mybatis-plus-extension</artifactId>
<groupId>com.baomidou</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- 数据库链接包-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-extension</artifactId>
<version>3.5.3.1</version>
</dependency>
<!-- 复合主键-->
<dependency>
<groupId>com.github.jeffreyning</groupId>
<artifactId>mybatisplus-plus</artifactId>
<version>1.7.3-RELEASE</version>
</dependency>
<dependency>
<groupId>com.microsoft</groupId>
<artifactId>sqljdbc4</artifactId>
<version>3.0</version>
</dependency>
<!--JWT鉴权-->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>4.3.0</version>
</dependency>
<!-- 密码加密-->
<dependency>
<groupId>com.enc</groupId>
<artifactId>EndPassJava</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!--spring-session-->
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.25</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
</dependency>
<dependency>
<groupId>com.dm</groupId>
<artifactId>DmJdbcDriver18</artifactId>
<version>1.8.0</version>
<scope>compile</scope>
</dependency>
<!--工具类 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.25</version>
</dependency>
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.2.0.Final</version>
</dependency>
<!-- <dependency>
<groupId>org.apache.axis</groupId>
<artifactId>axis</artifactId>
<version>1.4</version>
</dependency>-->
<dependency>
<groupId>com.tetragramato</groupId>
<artifactId>custom-spring-boot-resttemplate</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-spring-boot-starter-jaxws</artifactId>
<version>3.2.5</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-ws</artifactId>
<version>1.3.3.RELEASE</version>
</dependency>
<dependency>
<groupId>wsdl4j</groupId>
<artifactId>wsdl4j</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-websocket</artifactId>
<version>5.3.27</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-websocket</artifactId>
<version>9.0.80</version>
</dependency>
<!--excel导出 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>3.3.4</version>
</dependency>
<!-- goldenDB数据库的驱动-->
<dependency>
<groupId>goldenDB</groupId>
<artifactId>gdb-mysql-connector</artifactId>
<version>5.1.46</version>
</dependency>
<!-- <dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<version>1.6.6</version>
</dependency>-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-annotation</artifactId>
<version>3.5.3.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!--引入Knife4j的官方start包,该指南选择Spring Boot版本<3.0,开发者需要注意-->
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
<version>4.4.0</version>
</dependency>
</dependencies>
<build>
<finalName>WhiteListManageSys</finalName>
<plugins>
<!--maven 支持的单元测试组件需要搭配Junit使用 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<testFailureIgnore>true</testFailureIgnore>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<includeSystemScope>true</includeSystemScope>
<!--目的是跳过这个插件配置某则打成的jar包别的模块无法使用 -->
<skip>true</skip>
</configuration>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<!--打包时去除配置文件-->
<resource>
<directory>src/main/resources</directory>
<excludes>
<exclude>*.properties</exclude>
<!-- <exclude>static/**</exclude>
<exclude>excel/**</exclude>
<exclude>META-INF/spring.factories</exclude>-->
</excludes>
<includes>
<include>logback-spring.xml</include>
<include>static/**</include>
<include>excel/**</include>
<include>META-INF/spring.factories</include>
</includes>
</resource>
</resources>
</build>
</project>

@ -0,0 +1,84 @@
package com.nmgs;
import com.nmgs.util.PathUtil;
import com.trkf.PasswordEncryption.PassWordUtils;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.env.EnvironmentPostProcessor;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.PropertiesPropertySource;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
@Configuration
public class MyEnvironmentPostProcessor implements EnvironmentPostProcessor {
@Override
public void postProcessEnvironment(ConfigurableEnvironment configurableEnvironment, SpringApplication application) {
System.out.println("WhiteListManageSys读取公用配置文件======");
//公用配置文件路径
String path = PathUtil.applicationPath;
//本项目配置文件路径
String NewPath = PathUtil.projectApplicationPath;
System.out.println("Loading local settings from : " + path);
System.out.println("Loading local settings from : " + NewPath);
Properties properties = new Properties();
Properties Newproperties = new Properties();
try {
File fileproperties = new File(path);
File fileNewproperties = new File(NewPath);
// 判断文件夹是否存在
if (!fileproperties.exists()) {
fileproperties.createNewFile();
}
if (!fileNewproperties.exists()) {
fileNewproperties.createNewFile();
}
properties.load(new FileInputStream(path));
String DBType = properties.getProperty("DBType") == null ? "1" : properties.getProperty("DBType");
Newproperties.load(new FileInputStream(NewPath));
properties.setProperty("spring.logback.logPath",PathUtil.TomcatPath+"/logs");
properties.setProperty("spring.datasource.url",properties.getProperty("DBUrl"));
properties.setProperty("spring.datasource.username",properties.getProperty("DBUserName"));
properties.setProperty("spring.datasource.password",PassWordUtils.decrypt(properties.getProperty("DBPassWord")));
if(DBType.equals("1")){
properties.setProperty("spring.datasource.driver-class-name",Newproperties.getProperty("sqlClassName"));
properties.setProperty("spring.datasource.validationQuery",Newproperties.getProperty("sqlvalidationQuery"));
properties.setProperty("spring.datasource.hikari.connection-test-query",Newproperties.getProperty("sqlvalidationQuery"));
}else if(DBType.equals("2")){
properties.setProperty("spring.datasource.driver-class-name",Newproperties.getProperty("OracleClassName"));
properties.setProperty("spring.datasource.validationQuery",Newproperties.getProperty("OraclevalidationQuery"));
properties.setProperty("spring.datasource.hikari.connection-test-query",Newproperties.getProperty("OraclevalidationQuery"));
}else if(DBType.equals("3")){
properties.setProperty("spring.datasource.driver-class-name",Newproperties.getProperty("DMClassName"));
properties.setProperty("spring.datasource.validationQuery",Newproperties.getProperty("DMvalidationQuery"));
properties.setProperty("spring.datasource.hikari.connection-test-query",Newproperties.getProperty("DMvalidationQuery"));
}else if(DBType.equals("4")){
properties.setProperty("spring.datasource.driver-class-name",Newproperties.getProperty("MySQLClassName"));
properties.setProperty("spring.datasource.validationQuery",Newproperties.getProperty("MySQLvalidationQuery"));
properties.setProperty("spring.datasource.hikari.connection-test-query",Newproperties.getProperty("MySQLvalidationQuery"));
} else if (DBType.equals("5")) {
properties.setProperty("spring.datasource.driver-class-name", Newproperties.getProperty("MySQLGOADENDBClassName"));
properties.setProperty("spring.datasource.validationQuery", Newproperties.getProperty("MySQLGOADENDBvalidationQuery"));
properties.setProperty("spring.datasource.hikari.connection-test-query", Newproperties.getProperty("MySQLGOADENDBvalidationQuery"));
}
System.out.println("---------------------------specialEvent本次载入数据库----------------------");
System.out.println("server.port: " + properties.getProperty("server.port"));
System.out.println(" url : " + properties.getProperty("spring.datasource.url"));
System.out.println(" username : " + properties.getProperty("spring.datasource.username"));
System.out.println(" password : " + properties.getProperty("spring.datasource.password"));
System.out.println(" driver-class-name : " + properties.getProperty("spring.datasource.driver-class-name"));
//环境名称随意取,但尽量不能和其他环境名称相同,避免不生效
PropertiesPropertySource propertySource = new PropertiesPropertySource("environmentPostProcessor", properties);
PropertiesPropertySource newPropertySource = new PropertiesPropertySource("newEnvironmentPostProcessor", Newproperties);
//外部的文件是最先导入的
configurableEnvironment.getPropertySources().addFirst(propertySource);
//如果公用配置文件没有配置的则使用本项目的配置文件
configurableEnvironment.getPropertySources().addLast(newPropertySource);
} catch (Exception e) {
e.printStackTrace();
}
}
}

@ -0,0 +1,23 @@
package com.nmgs;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@EnableAsync
@SpringBootApplication
@EnableTransactionManagement
public class WhiteListManageSysApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(WhiteListManageSysApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(WhiteListManageSysApplication.class, args);
}
}

@ -0,0 +1,25 @@
package com.nmgs.annotation;
import java.lang.annotation.*;
/**
* <h2></h2>
* <p>
*
* </p>
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperationLogDesc {
/**
*
*/
String module();
/**
*
*/
String events();
}

@ -0,0 +1,162 @@
package com.nmgs.aop;
import com.alibaba.fastjson.JSONObject;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.entity.WhiteOperationLog;
import com.nmgs.service.IOperationLogService;
import com.nmgs.util.IpUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
*
**/
@Aspect
@Component
@Slf4j
public class LoggerAspect{
/**
* FastThreadLocal netty,netty使jdk ThreadLocal
*/
final ThreadLocal<WhiteOperationLog> logFastThreadLocal = new ThreadLocal<>();
final SimpleDateFormat dateTimeFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public IOperationLogService operationLogService;
@Autowired
public void setOperationLogService(IOperationLogService operationLogServiceTemp) {
this.operationLogService = operationLogServiceTemp;
}
/**
* 使 controller
*/
@Pointcut(value = "execution(* com.nmgs.controller..*(..)))")
public void logPointcut() {
}
/**
*
*/
@Before("logPointcut()")
public void beforLogger(JoinPoint joinPoint) throws ParseException {
Object[] args = joinPoint.getArgs();
Object o = args.length > 1 ? args[1] : args[0];
// 获取请求参数
String params = "";
if(o instanceof HashMap){
params= JSONObject.toJSONString((Map)o);
}else if(o instanceof ArrayList){
params= JSONObject.toJSONString((ArrayList)o);
}else if(o instanceof String){
params= o.toString();
}else{
params=Arrays.toString(args);
}
String userId = null;
String userName = null;
log.info("--------请求前置日志输出开始--------");
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
userId=(String)request.getSession().getAttribute("userId");
log.info("请求访问时间: {}", dateTimeFormatter.format(new Date()));
// 获取请求url
String requestUrl = request.getRequestURL().toString();
log.info("请求url: {}", requestUrl);
// 获取method
log.info("请求方式: {}", request.getMethod());
log.info("请求参数列表: {}", params);
log.info("操作人ID: {}", userId);
// 验证请求方法是否带有操作日志注解
Method signature = ((MethodSignature) joinPoint.getSignature()).getMethod();
OperationLogDesc operationLogDesc = signature.getAnnotation(OperationLogDesc.class);
if (operationLogDesc != null) {
// 操作日志记录
WhiteOperationLog operationLog = WhiteOperationLog.getInstance();
operationLog.setOperationTime(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
operationLog.setOperationModule(operationLogDesc.module());
operationLog.setOperationEvents(operationLogDesc.events());
operationLog.setOperationData(params);
operationLog.setOperationUrl(requestUrl);
// 操作人ID
operationLog.setOperationUserId(userId);
operationLog.setOperationUserName(userName);
// IP地址
operationLog.setOperationIp(IpUtil.getIpAddr(request));
logFastThreadLocal.set(operationLog);
}
}
/**
*
*
* @param result json
*/
@AfterReturning(value = "logPointcut()", returning = "result")
public void afterReturningLogger(Object result) {
// 保存操作日志
WhiteOperationLog operationLog = logFastThreadLocal.get();
if (operationLog != null) {
operationLog.setOperationStatus(true);
// 用的 是 阿里巴巴的 fastjson
operationLog.setOperationResult(JSONObject.toJSONString(result));
// 调用具体的 service 保存到数据库中
operationLogService.saveData(operationLog);
// 移除本地线程数据
logFastThreadLocal.remove();
}
}
/**
*
*/
@AfterThrowing(value = "logPointcut()", throwing = "throwable")
public void throwingLogger(Throwable throwable) {
// 保存操作日志
WhiteOperationLog operationLog = logFastThreadLocal.get();
if (operationLog != null) {
operationLog.setOperationStatus(false);
String throwableStr = throwable.toString();
if(throwableStr.contains(":")){
throwableStr = throwableStr.substring(throwableStr.indexOf(":") + 1);
}
operationLog.setOperationResult(throwableStr);
// 调用具体的 service 保存到数据库中
operationLogService.saveData(operationLog);
// 移除本地线程数据
logFastThreadLocal.remove();
}
}
}

@ -0,0 +1,71 @@
package com.nmgs.config;
/**
*
* SpringMVCConfig使FilterConfig
*
* @author Administrator
*/
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;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import javax.annotation.Resource;
@SuppressWarnings("deprecation")
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Resource
private FilterConfig filterconfig;
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 设置拦截类
registry.addInterceptor(filterconfig)
.addPathPatterns("/**")
// 是否允许证书
.excludePathPatterns(
"/MenuIndex/**",
"/Manager/**",
"/logManager/**",
"/wxCarUserInfo/**",
"/404/**",
"/MenuIndex/**",
"/index.html",
"/assets/**",
"/img/**",
"/static/**",
"/doc.html",
"/error/**"
);
}
/**
*
*/
@Bean
public CorsFilter corsFilter() {
CorsConfiguration config = new CorsConfiguration();
// 设置容许跨域请求的域名
config.addAllowedOriginPattern("*");
// config.addAllowedOrigin("*");
// 设置容许的方法
config.addAllowedMethod("*");
// 容许任何头
config.addAllowedHeader("*");
config.addExposedHeader("token");
//是否支持cookie跨域
config.setAllowCredentials(true);
UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
configSource.registerCorsConfiguration("/**", config);
return new CorsFilter(configSource);
}
}

@ -0,0 +1,17 @@
package com.nmgs.config;
import org.springframework.boot.web.server.ErrorPage;
import org.springframework.boot.web.server.ErrorPageRegistrar;
import org.springframework.boot.web.server.ErrorPageRegistry;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
@Component
public class ErrorConfig implements ErrorPageRegistrar {
@Override
public void registerErrorPages(ErrorPageRegistry registry) {
ErrorPage error404Page = new ErrorPage(HttpStatus.NOT_FOUND, "/index.html");
registry.addErrorPages(error404Page);
}
}

@ -0,0 +1,67 @@
package com.nmgs.config;
/**
*
*
* @author Administrator
*/
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
@Component
@Slf4j
public class FilterConfig implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if(request.getHeader("Origin")==null){
System.out.println("request.getHeader(\"Origin\")=======>为空");
response.setHeader("Access-Control-Allow-Origin", "*");//支持跨域请求
}else{
System.out.println("request.getHeader(\"Origin\")=======>" + request.getHeader("Origin"));
response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));//支持跨域请求
}
response.setHeader("Access-Control-Allow-Credentials", "true");//是否支持cookie跨域
response.setHeader("Access-Control-Allow-Methods", "*");//X-forwared-port,X-forwarded-host,
response.setHeader("Access-Control-Allow-Headers", "Authorization,Origin, X-Requested-With, Content-Type, Accept,Access-Token");//Origin, X-Requested-With, Content-Type, Accept,Access-Token
response.setHeader("Set-Cookie", "SameSite=None");
String token = request.getHeader("token");
String userId = request.getHeader("userId");
if(userId != null){
request.getSession().setAttribute("userId",userId);
}
if (token != null) {
if (token.equals("test")) {
return true;
}
//boolean result = TokenUtil.verify(token,request);
if (true) {
log.info("通过拦截器");
return true;
}
}else{
return true;
}
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
JSONObject res = new JSONObject();
res.put("status", "-1");
res.put("msg", "鉴权失败");
PrintWriter out = null;
out = response.getWriter();
out.write(res.toString());
out.flush();
out.close();
return false;
}
}

@ -0,0 +1,69 @@
package com.nmgs.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.RequestHandler;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Predicate;
@Configuration
@EnableSwagger2WebMvc
public class Knife4jConfiguration {
@Bean(value = "dockerBean")
public Docket dockerBean() {
//指定使用Swagger2规范
Docket docket=new Docket(DocumentationType.SWAGGER_2)
.apiInfo(new ApiInfoBuilder()
//描述字段支持Markdown语法
.description("白名单管理系统")
.termsOfServiceUrl("http://域名:端口/WhiteListManageSys/")
.contact("天润科丰")
.version("1.0")
.build())
//分组名称
.groupName("白名单服务")
.select()
//这里指定Controller扫描包路径
.apis(basePackage("com.nmgs.controller"+";"+"com.nmgs.AppController"))
//.apis(basePackage("com.nmgs.controller"))
.paths(PathSelectors.any())
.build();
return docket;
}
/**
*
* @param basePackage
* @return
*/
private static Function<Class<?>, Boolean> handlerPackage(final String basePackage) {
return (input) -> {
// 循环判断匹配
for (String strPackage : basePackage.split(";")) {
boolean isMatch = input.getPackage().getName().startsWith(strPackage);
if (isMatch) {
return true;
}
}
return false;
};
}
public static Predicate<RequestHandler> basePackage(final String basePackage) {
return (input) -> {
return (Boolean)declaringClass(input).map(handlerPackage(basePackage)).orElse(true);
};
}
private static Optional<? extends Class<?>> declaringClass(RequestHandler input) {
return Optional.ofNullable(input.declaringClass());
}
}

@ -0,0 +1,26 @@
package com.nmgs.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.nmgs.util.PropertiesUtil;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
if(PropertiesUtil.getValue("DBType").equals("1")){
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQL_SERVER2005));
}else if(PropertiesUtil.getValue("DBType").equals("2")){
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.ORACLE));
}else if(PropertiesUtil.getValue("DBType").equals("3")){
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.DM));
}else if(PropertiesUtil.getValue("DBType").equals("4")){
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
}
return interceptor;
}
}

@ -0,0 +1,34 @@
package com.nmgs.config;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
@Configuration
//当spring.redis.enable为false时或为空时 不启用redis
//prefix = "rest"application.properties配置文件中有关本配置项的前缀。
//name = "auth-open"application.properties配置文件中本次配置项的key
//havingValue = "true"从配置文件读取的值跟havingValue中设置的值做比较如果一样则返回true否则返回false。如果返回值为false则该configuration不生效为true才生效。
//matchIfMissing = true表示如果没有在application.properties匹配到该属性参数时默认返回true即不配置时也满足条件。
@ConditionalOnProperty(prefix = "spring.redis", name = "enable")
@EnableRedisHttpSession
public class RedisSessionConfig {
// 下面都是自定义配置默认为spingboot默认使用redis
// private String host;
// private String password;
// private String port;
// private String timeout;
// private String database;
//
// @Bean
// public JedisConnectionFactory redisConnectionFactory() {
// JedisConnectionFactory factory = new JedisConnectionFactory();
// factory.setHostName(host);
// factory.setPassword(password);
// factory.setPort(Integer.parseInt(port));
//// 设置连接超时时间
// factory.setTimeout(Integer.parseInt(timeout));
// factory.setDatabase(Integer.parseInt(database));
// return factory;
// }
}

@ -0,0 +1,162 @@
package com.nmgs.config;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
*
*
* @author javadog
**/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResultData<T> {
/**
*
*/
private Integer code;
/**
*
*/
private int count;
/**
*
*/
private String message;
/**
*
*/
private T data;
/**
*
*
* @param code
* @param count
* @param message
* @param data
* @param <T>
* @return {@link ResultData<T>}
*/
private static <T> ResultData<T> response(Integer code, Integer count, String message, T data) {
ResultData<T> responseResult = new ResultData<>();
responseResult.setCode(code);
responseResult.setCount(count);
responseResult.setMessage(message);
responseResult.setData(data);
return responseResult;
}
/**
*
*
* @param code
* @param count
* @param message
* @param <T>
* @return {@link ResultData<T>}
*/
private static <T> ResultData<T> response(Integer code, Integer count, String message) {
ResultData<T> responseResult = new ResultData<>();
responseResult.setCode(code);
responseResult.setCount(count);
responseResult.setMessage(message);
return responseResult;
}
/**
* +
*
* @param code
* @param message
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> success(Integer code, String message) {
return response(code, 0, message);
}
/**
* +
*
* @param message
* @param data
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> success(String message, T data,Integer count) {
return response(1, count, message, data);
}
/**
*
*
* @param data
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> success(T data) {
return response(1, 0, "成功", data);
}
/**
* +
*
* @param code
* @param message
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> fail(Integer code, String message) {
return response(code, 0, message);
}
/**
* +
*
* @param message
* @param data
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> fail(String message, T data) {
return response(-1, 0, message, data);
}
/**
* ++
*
* @param code
* @param message
* @param data
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> fail(Integer code, String message, T data) {
return response(code, 0, message, data);
}
/**
*
*
* @param message
* @param <T>
* @return {@link ResultData<T>}
*/
public static <T> ResultData<T> fail(String message) {
return response(-1, 0, message, null);
}
}

@ -0,0 +1,34 @@
package com.nmgs.config;
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 org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
@Configuration
@EnableAsync
public class ThreadPoolConfig {
@Bean("specaiEventThreadPool") //线程池实例名,多个线程池配置需要声明,一个线程池可有可无
public Executor executorNormal() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(3);
executor.setMaxPoolSize(5);
executor.setQueueCapacity(3);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("NORMAL--");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
executor.initialize();
return executor;
}
@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
ThreadPoolTaskScheduler ThreadPoolTaskScheduler = new ThreadPoolTaskScheduler();
// ThreadPoolTaskScheduler.initialize();
return ThreadPoolTaskScheduler;
}
}

@ -0,0 +1,15 @@
package com.nmgs.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
@Configuration
@EnableWebSocket
public class WebSocketConfig {
//如果是外部tomcat 启动war 包,需要注释掉,要不会报错
/* @Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}*/
}

@ -0,0 +1,59 @@
package com.nmgs.controller;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.config.ResultData;
import com.nmgs.entity.*;
import com.nmgs.service.impl.ExcelDateImpl;
import com.nmgs.util.ExcelUtil;
import com.nmgs.util.LogUtil;
import com.nmgs.util.PubTools;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.HttpMethod;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
@Controller
@RequestMapping("/exportData")
@Api(tags="导出")
public class ExportData {
@Autowired
private ExcelDateImpl excelDateImpl;
@GetMapping(value="/exportWhiteCarnoList")
@ApiOperation(httpMethod="GET",value = "白名单数据导出")
@OperationLogDesc(module = "白名单管理",events = "白名单数据导出")
public void exportDivOutPortGroadList(String paramsData,@RequestBody(required = false) Object req,HttpServletResponse response) throws SQLException {
try {
if(req==null && !PubTools.isNull(paramsData)){
req=JSONObject.parse(paramsData);
}
List<WhiteCarnoListDto> list = excelDateImpl.exportDivOutPortGroadList((Map<String, Object>)req);
ExcelUtil.exportExcel(response,list, WhiteCarnoListDto.class,"白名单数据信息","白名单数据信息");
} catch (IOException e) {
e.printStackTrace();
LogUtil.WriteLog_Error("白名单数据导出失败"+e.getMessage(),"ExportData");
}
}
}

@ -0,0 +1,48 @@
package com.nmgs.controller;
import com.alibaba.fastjson.JSONObject;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.config.ResultData;
import com.nmgs.service.impl.SelectDataImpl;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Map;
/**
*
*/
@RestController
@RequestMapping("/selectData")
@Api(tags="下拉值查询")
public class SelectController {
@Autowired
public SelectDataImpl selectDataImpl;
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
//获取查验数据
@PostMapping(value="/getListByType")
@ApiOperation(httpMethod="POST",value = "下拉值查询")
public ResultData<List> submitCheck(HttpServletRequest request, @RequestBody Object req) throws SQLException {
JSONObject paramsData=new JSONObject();
if(req instanceof Map){
paramsData=(JSONObject)JSONObject.toJSON(req);
}else if(req instanceof JSONObject){
paramsData=(JSONObject)req;
}
List ret=selectDataImpl.getDataByType(paramsData);
if(ret==null){
return ResultData.fail(-1,"查询数据失败");
}
return ResultData.success("查询成功",ret,0);
}
}

@ -0,0 +1,97 @@
package com.nmgs.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.config.ResultData;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.service.IWhiteAccountSerive;
import com.nmgs.util.PubTools;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Map;
/**
*
*/
@RestController
@RequestMapping("/whiteAccount")
@Api(tags = "单位信息管理")
public class WhiteAccountTextController {
public IWhiteAccountSerive iWhiteAccountSerive;
@Autowired
public void setiWhiteAccountSerive(IWhiteAccountSerive iWhiteAccountSerive) {
this.iWhiteAccountSerive = iWhiteAccountSerive;
}
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
@PostMapping(value="/getAccountByPage")
@ApiOperation(httpMethod="POST",value="查询单位信息管理数据")
public Object getListByPage(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws SQLException {
Page<WhiteAccountText> whiteCarnoListList =null;
try{
whiteCarnoListList = iWhiteAccountSerive.getWhiteAccountTextByPage(req);
if (PubTools.isEmpty(whiteCarnoListList)) {
return ResultData.fail(-1,"数据查询失败");
}
}catch (Exception e){
String throwableStr = e.getCause().toString();
if(throwableStr.contains(":")){
throwableStr = throwableStr.substring(throwableStr.indexOf(":") + 1);
}
return ResultData.fail(-1,"数据查询失败==>"+throwableStr);
}
return whiteCarnoListList;
}
@PostMapping(value = "/addData")
@OperationLogDesc(module = "单位信息管理>新增", events = "新增记录")
@ApiOperation(httpMethod="POST",value="新增记录")
public ResultData<String> addData(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws Exception {
int ret = iWhiteAccountSerive.insertData((WhiteAccountText)PubTools.map2Object(req,WhiteAccountText.class));
if(ret>-1){
return ResultData.success("新增成功","",0);
}else{
if(ret==-2){
return ResultData.fail("单位编码已经存在!");
}
}
return ResultData.fail("新增失败");
}
@PostMapping(value = "/batchDelDatas")
@OperationLogDesc(module = "单位信息管理>批量删除", events = "删除记录")
@ApiOperation(httpMethod="POST",value="删除记录")
public ResultData<String> batchDelDatas(HttpServletRequest request, @RequestBody Object req) throws Exception {
int ret = iWhiteAccountSerive.batchDelDatas(req);
if(ret>-1){
return ResultData.success("删除成功","",0);
}
return ResultData.fail("删除失败");
}
@PostMapping(value = "/updateById")
@OperationLogDesc(module = "单位信息管理>修改", events = "修改记录")
@ApiOperation(httpMethod="POST",value="修改记录")
public ResultData<String> updateById(HttpServletRequest request, @RequestBody(required = false) WhiteAccountText req) throws Exception {
try{
int ret = iWhiteAccountSerive.updateById(req);
if(ret>-1){
return ResultData.success("保存成功");
}
}catch (Exception e){
return ResultData.fail("保存失败:"+e.getMessage());
}
return ResultData.fail("保存失败");
}
}

@ -0,0 +1,159 @@
package com.nmgs.controller;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.poi.excel.ExcelReader;
import cn.hutool.poi.excel.ExcelUtil;
import com.alibaba.fastjson.JSONObject;
import com.nmgs.config.ResultData;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import com.nmgs.service.IWhiteBatchImportSerive;
import com.nmgs.util.LogUtil;
import com.nmgs.util.PubTools;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/whiteBatchImport")
@Api(tags = "白名单批量导入")
public class WhiteBatchImportController {
public IWhiteBatchImportSerive iWhiteBatchImportSerive;
@Autowired
public void setiWhiteBatchImportSerive(IWhiteBatchImportSerive iWhiteBatchImportSerive) {
this.iWhiteBatchImportSerive = iWhiteBatchImportSerive;
}
//实现Spring Boot 的文件下载功能,映射网址为/download
@ApiOperation(value = "模板下载",httpMethod = "GET",ignoreJsonView = false )
@ApiImplicitParams(
@ApiImplicitParam(value = "fileName",defaultValue = "gasstation")
)
@RequestMapping(value = "/download", method = RequestMethod.GET, produces = {"application/json;charset=UTF-8"})
@ResponseBody
public String downloadFile(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException {
String fileName = request.getParameter("fileName");
if(PubTools.isNull(fileName)){
fileName="白名单模板空白";
}
fileName =fileName+".xlsx";
String fileP=com.nmgs.util.PathUtil.webappsPath+"//"+ fileName;
LogUtil.WriteLog_Info("模板下载地址====="+fileP,"WhiteBatchImportController");
File file = new File(fileP);
// 如果文件名存在,则进行下载
if (file.exists()) {
// 配置文件下载
response.setHeader("content-type", "application/octet-stream");
response.setContentType("application/octet-stream");
// 下载文件能正常显示中文
response.addHeader("Content-Length", String.valueOf(file.length()));
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(file.getName(), "UTF-8"));
// 实现文件下载
byte[] buffer = new byte[1024*1024*100];
FileInputStream fis = null;
BufferedInputStream bis = null;
try {
fis = new FileInputStream(file);
bis = new BufferedInputStream(fis);
OutputStream os = response.getOutputStream();
int i = bis.read(buffer);
while (i != -1) {
os.write(buffer, 0, i);
i = bis.read(buffer);
}
System.out.println("Download the song successfully!");
return "下载成功!";
}
catch (Exception e) {
System.out.println("Download the song failed!");
return "下载失败!";
}
finally {
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//return "Download the song successfully!";
}
}else{
return file.getPath()+"文件不存在!";
}
}
/**
* excel
* @param params
* @throws Exception
*/
@PostMapping("/importExcel")
public ResultData<JSONObject> importExcel(@RequestBody Object params ) throws Exception {
JSONObject ret=iWhiteBatchImportSerive.insertData(params);
return ResultData.success("",ret,1);
}
@PostMapping("/uploadFile")
public ResultData<String> uploadFile(HttpServletRequest request, HttpServletResponse response,@RequestParam("file") MultipartFile file) throws UnsupportedEncodingException {
response.setHeader("content-type", "application/octet-stream");
response.setContentType("application/octet-stream");
// 下载文件能正常显示中文
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(file.getName(), "UTF-8"));
//当前项目的目录
SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMdd");
String fileDirName = sdf.format(new Date());
String folderPath = com.nmgs.util.PathUtil.webappsPath + "\\CarNoFile\\"+fileDirName;
//每天创建一个文件目录
SimpleDateFormat sdfs=new SimpleDateFormat("hhmmss");
String afterSuffix = sdfs.format(new Date());
String originalFilename = file.getOriginalFilename();
String[] split = originalFilename.split("\\.");
File fileTemp=new File(folderPath);
if (!fileTemp.exists())
{
fileTemp.mkdirs();
}
String fileName="";
if (file != null){
try
{
fileName = split[0]+afterSuffix+"."+split[1];
File fileDocument=new File(folderPath,fileName);
File fileExists=new File(folderPath+"//"+fileName);
if(fileExists.exists()){
fileExists.delete();
}else{
fileDocument.mkdir();
file.transferTo(fileDocument);
}
}
catch (Exception ex)
{
return ResultData.fail("文件异常:"+ ex.getMessage());
}
}
return ResultData.success(1,fileName);
}
}

@ -0,0 +1,84 @@
package com.nmgs.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.config.ResultData;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.entity.WhiteCarnoDic;
import com.nmgs.service.IWhiteAccountSerive;
import com.nmgs.service.IWhiteCarnoDicService;
import com.nmgs.util.PubTools;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Map;
/**
*
*/
@RestController
@RequestMapping("/whiteCarnoDic")
@Api(tags = "自定义白名单管理")
public class WhiteCarnoDicController {
public IWhiteCarnoDicService iWhiteCarnoDicService;
@Autowired
public void setiWhiteCarnoDicService(IWhiteCarnoDicService iWhiteCarnoDicService) {
this.iWhiteCarnoDicService = iWhiteCarnoDicService;
}
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
@PostMapping(value="/getCarnoDicByPage")
@ApiOperation(httpMethod="POST",value="查询自定义白名单管理数据")
public Object getCarnoDicByPage(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws SQLException {
Page<WhiteCarnoDic> whiteCarnoListList =null;
try{
whiteCarnoListList = iWhiteCarnoDicService.getWhiteCarnoDicByPage(req);
if (PubTools.isEmpty(whiteCarnoListList)) {
return ResultData.fail(-1,"数据查询失败");
}
}catch (Exception e){
String throwableStr = e.getCause().toString();
if(throwableStr.contains(":")){
throwableStr = throwableStr.substring(throwableStr.indexOf(":") + 1);
}
return ResultData.fail(-1,"数据查询失败==>"+throwableStr);
}
return whiteCarnoListList;
}
@PostMapping(value = "/addCarnoDicData")
@OperationLogDesc(module = "自定义白名单管理>新增", events = "新增记录")
@ApiOperation(httpMethod="POST",value="新增记录")
public ResultData<String> addCarnoDicData(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws Exception {
int ret = iWhiteCarnoDicService.insertData(req);
if(ret>-1){
return ResultData.success("新增成功","",0);
}else{
if(ret==-2){
return ResultData.fail("此数据已存在!");
}
}
return ResultData.fail("新增失败");
}
@PostMapping(value = "/batchDelCarnoDicDatas")
@OperationLogDesc(module = "自定义白名单管理>批量删除", events = "删除记录")
@ApiOperation(httpMethod="POST",value="删除记录")
public ResultData<String> batchDelCarnoDicDatas(HttpServletRequest request, @RequestBody Object req) throws Exception {
int ret = iWhiteCarnoDicService.batchDelDatas(req);
if(ret>-1){
return ResultData.success("删除成功","",0);
}
return ResultData.fail("删除失败");
}
}

@ -0,0 +1,136 @@
package com.nmgs.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.config.ResultData;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.service.IWhiteCarnoListSerive;
import com.nmgs.util.PubTools;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Map;
/**
*
*/
@RestController
@RequestMapping("/whiteCarnoList")
@Api(tags = "白名单管理")
public class WhiteCarnoListController {
@Autowired
public IWhiteCarnoListSerive divOutPortDroadSerive;
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
@PostMapping(value="/getListByPage")
@ApiOperation(httpMethod="POST",value="查询分页白名单数据")
public Object getListByPage(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws SQLException {
Page<WhiteCarnoList> whiteCarnoListList =null;
try{
whiteCarnoListList = divOutPortDroadSerive.getWhiteCarnoListByPage(req);
if (PubTools.isEmpty(whiteCarnoListList)) {
return ResultData.fail(-1,"数据查询失败");
}
}catch (Exception e){
String throwableStr = e.getCause().toString();
if(throwableStr.contains(":")){
throwableStr = throwableStr.substring(throwableStr.indexOf(":") + 1);
}
return ResultData.fail(-1,"数据查询失败==>"+throwableStr);
}
return whiteCarnoListList;
}
@PostMapping(value = "/addData")
@OperationLogDesc(module = "白名单管理>新增", events = "新增记录")
@ApiOperation(httpMethod="POST",value="新增记录")
public ResultData<String> addData(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws Exception {
int ret = divOutPortDroadSerive.insertData((WhiteCarnoList)PubTools.map2Object(req,WhiteCarnoList.class));
if(ret>-1){
return ResultData.success("新增成功");
}else{
if(ret==-2){
return ResultData.fail("白名单存在该信息!");
}
}
return ResultData.fail("新增失败");
}
@PostMapping(value = "/batchDelDatas")
@OperationLogDesc(module = "白名单管理>批量删除", events = "删除记录")
@ApiOperation(httpMethod="POST",value="删除记录")
public ResultData<String> batchDelDatas(HttpServletRequest request, @RequestBody Object req) throws Exception {
int ret = divOutPortDroadSerive.batchDelDatas(req);
if(ret>-1){
return ResultData.success("删除成功");
}
return ResultData.fail("删除失败");
}
@PostMapping(value = "/updateById")
@OperationLogDesc(module = "白名单管理>修改", events = "修改记录")
@ApiOperation(httpMethod="POST",value="修改记录")
public ResultData<String> updateById(HttpServletRequest request, @RequestBody(required = false) WhiteCarnoList req) throws Exception {
try{
int ret = divOutPortDroadSerive.updateById(req);
if(ret>-1){
return ResultData.success("保存成功");
}
}catch (Exception e){
return ResultData.fail("保存失败:"+e.getMessage());
}
return ResultData.fail("保存失败");
}
@PostMapping(value = "/batchUpdateById")
@OperationLogDesc(module = "白名单管理>批量修改", events = "批量修改记录")
@ApiOperation(httpMethod="POST",value="批量修改记录")
public ResultData<String> batchUpdateById(HttpServletRequest request, @RequestBody(required = false) Map<String,Object> req) throws Exception {
try{
int ret = divOutPortDroadSerive.batchUpdateById(req);
if(ret>-1){
return ResultData.success("保存成功");
}
}catch (Exception e){
return ResultData.fail("保存失败:"+e.getMessage());
}
return ResultData.fail("保存失败");
}
@PostMapping(value = "/getVersion")
@ApiOperation(httpMethod="POST",value="生成最新版本号")
public ResultData<Map> getVersion(HttpServletRequest request, @RequestBody(required = false) Map<String,Object> req) throws Exception {
try{
Map ret = divOutPortDroadSerive.getVersion(req);
if(!PubTools.isEmpty(ret)){
return ResultData.success("生成最新版本号成功",ret,1);
}
}catch (Exception e){
return ResultData.fail("生成最新版本号失败:"+e.getMessage());
}
return ResultData.fail("生成最新版本号失败");
}
@PostMapping(value = "/publishVersion")
@OperationLogDesc(module = "白名单管理>发布新版本", events = "发布新版本")
@ApiOperation(httpMethod="POST",value="发布新版本")
public ResultData<String> publishVersion(HttpServletRequest request, @RequestBody(required = false) Map<String,Object> req) throws Exception {
try{
int ret = divOutPortDroadSerive.publishVersion(req);
if(ret>-1){
return ResultData.success("发布成功","发布成功",1);
}
}catch (Exception e){
return ResultData.fail("发布失败:"+e.getMessage());
}
return ResultData.fail("发布失败");
}
}

@ -0,0 +1,61 @@
package com.nmgs.controller;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.annotation.OperationLogDesc;
import com.nmgs.config.ResultData;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import com.nmgs.service.IWhiteCarnoListSerive;
import com.nmgs.service.IWhiteCarnoLogService;
import com.nmgs.util.PubTools;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Map;
/**
*
*/
@RestController
@RequestMapping("/whiteCarnoLog")
@Api(tags = "白名单日志管理")
public class WhiteCarnoLogController {
@Autowired
public IWhiteCarnoLogService iWhiteCarnoLogSerive;
/* @Autowired
public void setiWhiteCarnoLogSerive(IWhiteCarnoLogService iWhiteCarnoLogSerive) {
this.iWhiteCarnoLogSerive = iWhiteCarnoLogSerive;
}*/
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
@PostMapping(value="/getListByPage")
@ApiOperation(httpMethod="POST",value="查询分页白名单日志数据")
public Object getListByPage(HttpServletRequest request, @RequestBody(required = false) Map<String, Object> req) throws SQLException {
Page<WhiteCarnoLogTable> whiteCarnoListList =null;
try{
whiteCarnoListList=iWhiteCarnoLogSerive.getWhiteCarnoLogByPage(req);
if (PubTools.isEmpty(whiteCarnoListList)) {
return ResultData.fail(-1,"数据查询失败");
}
}catch (Exception e){
String throwableStr=e.toString();
if(throwableStr.contains(":")){
throwableStr = throwableStr.substring(throwableStr.indexOf(":") + 1);
}
return ResultData.fail(-1,"数据查询失败==>"+throwableStr);
}
return whiteCarnoListList;
}
}

@ -0,0 +1,22 @@
package com.nmgs.entity;
/**
*
*/
public class Consistent {
//属于交通集团的路段NO
public static int[] ROAD_JTJT = {10, 15, 11, 20, 24, 25, 26, 27, 28, 37, 38, 39, 42, 43, 46, 48, 49, 50, 53, 54, 60, 61, 62, 63, 64, 65, 66, 67, 81, 84, 85, 86, 87, 88, 89, 90};
//白名单数据操作类型
public static int ADD=1;
public static String ADD_NAME="新增产生";
public static int UPDATE=3;
public static String UPDATE_NAME="修改产生";
public static int UPDATE_BATCH=5;
public static String UPDATE_BATCH_NAME="批量更新产生";
public static int DELETE=2;
public static String DELETE_NAME="删除产生";
public static int UPDATE_VERSION=4;
public static String UPDATE_VERSION_NAME="版本更新产生";
public static int IMPORT_BATCH=6;
public static String IMPORT_BATCH_NAME="批量导入产生";
}

@ -0,0 +1,20 @@
package com.nmgs.entity;
import java.util.HashMap;
import java.util.Map;
public class MyReturnMap {
private static final long serialVersionUID = 1L;
public static Map<String, Object> returnMap = new HashMap();
public MyReturnMap() {
}
public static void setMap(Map<String, Object> newMap) {
returnMap.putAll(newMap);
}
static {
returnMap.put("InfoType", "1");
}
}

@ -0,0 +1,24 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("WHITE_ACCOUNT_TEXT")
public class WhiteAccountText {
@TableField("ACOUNTID")
private int acountid;
@TableField("ACOUNTNAME")
private String acountname;
}

@ -0,0 +1,26 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("WHITE_CARNO_DIC_TABLE")
public class WhiteCarnoDic {
@TableField("MEMO")
private String memo;
@TableField("DISCRP")
private String discrp;
@TableField("DICNAME")
private String dicname;
@TableField("UNUSER1")
private String unuser1;
@TableField("UNUSER2")
private int unuser2;
}

@ -0,0 +1,87 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("WHITE_CARNO_TABLE")
public class WhiteCarnoList {
@TableId(type = IdType.AUTO)
private String id;
@TableField("ACARNO")
private String acarno;
@TableField("COLOR")
private int color;
@TableField("DT")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date dt;
@TableField("BEGDT")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date begdt;
@TableField("ENDDT")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date enddt;
@TableField("VEHICLE_TYPE")
private int vehicleType;
@TableField("DATAFLAG")
private String dataflag;
@TableField("DESCRIB")
private String describ;
@TableField("BEGDATE")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date begdate;
@TableField("ACCOUNT")
private int account;
@TableField("VERNO")
private String verno;
@TableField("BAK1")
private String bak1;
@TableField("BAK2")
private String bak2;
@TableField("BAK3")
private String bak3;
@TableField("MEMO")
private String memo;
@TableField("VEHICLE_CLASS")
private int vehicleClass;
@TableField("DISCRP")
private String discrp;
@TableField(exist = false)
private String colorName;
@TableField(exist = false)
private String flagName;
@TableField(exist = false)
private String accountName;
@TableField(exist = false)
private String vehicleClassName;
@TableField(exist = false)
private String vehicleTypeName;
@TableField(exist = false)
private String promperty;
@TableField(exist = false)
private String opermano;
@TableField(exist = false)
private String opermaname;
@TableField(exist = false)
private String qm;
@TableField(exist = false)
private String mfld;
@TableField(exist = false)
private String mfzzh;
@TableField(exist = false)
private String zdyzh;
public WhiteCarnoList(String verno) {
this.verno = verno;
}
}

@ -0,0 +1,182 @@
package com.nmgs.entity;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import com.alibaba.excel.annotation.write.style.ContentFontStyle;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.enums.poi.BorderStyleEnum;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import com.alibaba.excel.enums.poi.VerticalAlignmentEnum;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@ExcelIgnoreUnannotated
public class WhiteCarnoListDto {
@ExcelProperty("ID")
@ColumnWidth(10)
@ContentStyle(verticalAlignment= VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
@ExcelIgnore
private int id;
@ExcelProperty("启用时间")
@ColumnWidth(30)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private Date begdate;
@ExcelProperty("车牌")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String acarno;
@ExcelProperty("车牌颜色")
//@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String colorName;
@ExcelProperty("起始时间")
@ColumnWidth(30)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private Date begdt;
@ExcelProperty("终止时间")
@ColumnWidth(30)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private Date enddt;
@ExcelProperty("类型")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String vehicleClassName;
@ExcelProperty("状态")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String flagName;
@ExcelProperty("车型")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private int vehicleName;
@ExcelProperty("状态码")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String dataflag;
@ExcelProperty("车辆描述")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String describ;
@ExcelProperty("录入时间")
@ColumnWidth(30)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private Date dt;
@ExcelProperty("所属分公司编号")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private int account;
@ExcelProperty("所属公司")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String accountName;
@ExcelProperty("版本")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String verno;
@ExcelProperty("备注1")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String bak1;
@ExcelProperty("备注2")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String bak2;
@ExcelProperty("备注3")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String bak3;
@ExcelProperty("减免路段/收费站")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private String discrp;
@ExcelProperty("车种code")
@ExcelIgnore
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
private int vehicleClass;
@ExcelProperty("重点提示")
@ColumnWidth(10)
@ContentStyle(verticalAlignment=VerticalAlignmentEnum.CENTER,horizontalAlignment = HorizontalAlignmentEnum.CENTER,
borderBottom = BorderStyleEnum.THIN,
borderLeft = BorderStyleEnum.THIN,
borderRight = BorderStyleEnum.THIN)
@ContentFontStyle(color = 10)
private String promperty;
}

@ -0,0 +1,83 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("WHITE_CARNO_LOG_TABLE")
public class WhiteCarnoLogTable {
@TableId(type = IdType.INPUT)
private String id;
@TableField("ACARNO")
private String acarno;
@TableField("COLOR")
private int color;
@TableField("DT")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date dt;
@TableField("BEGDT")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date begdt;
@TableField("ENDDT")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date enddt;
@TableField("VEHICLE_TYPE")
private int vehicleType;
@TableField("DATAFLAG")
private String dataflag;
@TableField("DESCRIB")
private String describ;
@TableField("BEGDATE")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date begdate;
@TableField("ACCOUNT")
private int account;
@TableField("VERNO")
private String verno;
@TableField("BAK1")
private String bak1;
@TableField("BAK2")
private String bak2;
@TableField("BAK3")
private String bak3;
@TableField("MEMO")
private String memo;
@TableField("VEHICLE_CLASS")
private int vehicleClass;
@TableField(exist = false)
private String flagName;
@TableField(exist = false)
private String accountName;
@TableField(exist = false)
private String colorName;
@TableField(exist = false)
private String vehicleClassName;
@TableField(exist = false)
private String vehicleTypeName;
@TableField("OPERTYPE")
private Integer opertype;
@TableField("OPERTYPENAME")
private String opertypename;
@TableField("OPERDATE")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date operdate;
@TableField("OPERMANO")
private String opermano;
@TableField("OPERMANAME")
private String opermaname;
@TableField("COMNO")
private String comno="test";
@TableField("IDBUSINESS")
private String idbusiness;
}

@ -0,0 +1,20 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("white_account_text")
public class WhiteComnoText {
@TableField("VALUE")
private String value;
@TableField("TEXT")
private String text;
}

@ -0,0 +1,110 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.apache.commons.lang3.builder.ToStringBuilder;
import java.time.LocalDateTime;
import java.util.Date;
/**
*
*/
@Data
@TableName("white_operation_log")
@ApiModel(value = "WhiteOperationLog对象", description = "操作日志表")
public class WhiteOperationLog {
private static final long serialVersionUID = 1L;
/**
* Cloneable
*
*/
private static final WhiteOperationLog log = new WhiteOperationLog();
/**
* , new
* @return {@link WhiteOperationLog}
*/
public static WhiteOperationLog getInstance(){
try {
return log.clone();
} catch (CloneNotSupportedException e) {
return new WhiteOperationLog();
}
}
/**
*
* @return {@link WhiteOperationLog}
*/
public WhiteOperationLog clone() throws CloneNotSupportedException {
return (WhiteOperationLog) super.clone();
}
/**
* new
*/
private WhiteOperationLog(){
this.operationDeleted = false;
}
@TableId(type = IdType.ASSIGN_UUID)
private String id;
@ApiModelProperty("操作人ID")
private String operationUserId;
@ApiModelProperty("操作人名称")
private String operationUserName;
@ApiModelProperty("操作模块")
private String operationModule;
@ApiModelProperty("具体操作事件")
private String operationEvents;
@ApiModelProperty("操作Url")
private String operationUrl;
@ApiModelProperty("操作附带数据")
private String operationData;
@ApiModelProperty("操作是否正常1正常操作 0 操作异常")
private Boolean operationStatus;
@ApiModelProperty("操作结果")
private String operationResult;
@ApiModelProperty("操作所在IP")
private String operationIp;
@ApiModelProperty("操作时间")
private Date operationTime;
@ApiModelProperty("1 删除0 未删除")
private Boolean operationDeleted;
@Override
public String toString() {
return new ToStringBuilder(this)
.append("id", id)
.append("operationUserId", operationUserId)
.append("operationUserName", operationUserName)
.append("operationModule", operationModule)
.append("operationEvents", operationEvents)
.append("operationUrl", operationUrl)
.append("operationData", operationData)
.append("operationStatus", operationStatus)
.append("operationResult", operationResult)
.append("operationIp", operationIp)
.append("operationTime", operationTime)
.append("operationDeleted", operationDeleted)
.toString();
}
}

@ -0,0 +1,21 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("white_vehicle_class")
public class WhiteVehicleClass {
@TableField("VALUE")
private String value;
@TableField("TEXT")
private String text;
}

@ -0,0 +1,20 @@
package com.nmgs.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("white_vehicle_type")
public class WhiteVehicleType {
@TableField("VALUE")
private String value;
@TableField("TEXT")
private String text;
}

@ -0,0 +1,25 @@
package com.nmgs.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.MyReturnMap;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
@org.apache.ibatis.annotations.Mapper
public interface Mapper extends BaseMapper<MyReturnMap> {
Map<String, Object> select(@Param("sql") String sql);
List selectforlist(@Param("sql") String sql);
int update(@Param("sql") String sql);
IPage<Map<String,Object>> selectpage(@Param("sql") String sql, Page<Map<String, Object>> page);
Map<String, Object> selectlow(@Param("sql") String sql);
List selectforlistlow(@Param("sql") String sql);
int insert(@Param("sql") String sql);
}

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nmgs.mapper.Mapper">
<select id="select" parameterType="String" resultType="java.util.HashMap">
${sql}
</select>
<select id="selectforlist" parameterType="String" resultType="java.util.HashMap">
${sql}
</select>
<update id="update" parameterType="String">
${sql}
</update>
<insert id="insert" parameterType="String">
${sql}
</insert>
<select id="selectpage" parameterType="String" resultType="java.util.HashMap">
${sql}
</select>
<select id="selectlow" parameterType="String" resultType="java.util.HashMap">
${sql}
</select>
<select id="selectforlistlow" parameterType="String" resultType="java.util.HashMap">
${sql}
</select>
</mapper>

@ -0,0 +1,20 @@
package com.nmgs.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.entity.WhiteAccountText;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
@Mapper
public interface WhiteAccountMapper extends BaseMapper<WhiteAccountText> {
Page<WhiteAccountText> getWhiteAccountByPage(Page<WhiteAccountText> page, @Param("params") Map<String, Object> params);
int insertData(@Param("params") WhiteAccountText params);
int delDataById(@Param("ids") List<Integer> ids);
int updateById(@Param("params") WhiteAccountText params);
List<WhiteAccountText> getWhiteAccountText(@Param("params") Map<String, Object> params);
}

@ -0,0 +1,51 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nmgs.mapper.WhiteAccountMapper">
<select id="getWhiteAccountByPage" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteAccountText">
select
t.ACOUNTID,t.ACOUNTNAME
FROM WHITE_ACCOUNT_TEXT t
<where>
<if test="params.id != null and params.id != ''">
AND t.acountid = #{params.id}
</if>
<if test="params.name != null and params.name != ''">
AND t.acountname like '%'|| #{params.name} || '%'
</if>
</where>
</select>
<update id="updateById" parameterType="com.nmgs.entity.WhiteAccountText">
update WHITE_ACCOUNT_TEXT
<set>
acountname=#{params.acountname},
</set>
where acountid=#{params.acountid}
</update>
<insert id="insertData" parameterType="com.nmgs.entity.WhiteAccountText">
insert into WHITE_ACCOUNT_TEXT(VALUE,TEXT) values(#{params.acountid},#{params.text})
</insert>
<delete id="delDataById">
DELETE FROM WHITE_ACCOUNT_TEXT WHERE acountid IN
<foreach item="str" collection="ids" open="(" separator="," close=")">
#{str}
</foreach>
</delete>
<select id="getWhiteAccountText" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteAccountText">
select
t.acountid,t.acountname
FROM WHITE_ACCOUNT_TEXT t
<where>
<if test="params.id != null and params.id != ''">
AND t.acountid = #{params.id}
</if>
<if test="params.name != null and params.name != ''">
AND t.acountname like '%'|| #{params.name} || '%'
</if>
</where>
</select>
</mapper>

@ -0,0 +1,20 @@
package com.nmgs.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.entity.WhiteCarnoDic;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
@Mapper
public interface WhiteCarnoDicMapper extends BaseMapper<WhiteCarnoDic> {
Page<WhiteCarnoDic> getWhiteCarnoDicByPage(Page<WhiteCarnoDic> page, @Param("params") Map<String, Object> params);
int insertData(@Param("params") WhiteCarnoDic params);
int delDataById(@Param("ids") List<String> ids);
int updateById(@Param("params") WhiteCarnoDic params);
List<WhiteCarnoDic> getWhiteCarnoDicList(@Param("params") Map<String, Object> params);
}

@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nmgs.mapper.WhiteCarnoDicMapper">
<select id="getWhiteCarnoDicByPage" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteCarnoDic">
select
t.memo,t.discrp,t.dicname,t.unuser1,t.unuser2
FROM WHITE_CARNO_DIC_TABLE t
<where>
<if test="params.memo != null and params.memo != ''">
AND t.memo = #{params.memo}
</if>
<if test="params.dicname != null and params.dicname != ''">
AND t.dicname like '%'|| #{params.dicname} || '%'
</if>
</where>
</select>
<insert id="insertData" parameterType="com.nmgs.entity.WhiteCarnoDic">
insert into WHITE_CARNO_DIC_TABLE(memo,discrp,dicname) values(#{params.memo},#{params.discrp},#{params.dicname})
</insert>
<delete id="delDataById">
DELETE FROM WHITE_CARNO_DIC_TABLE WHERE memo IN
<foreach item="str" collection="ids" open="(" separator="," close=")">
#{str}
</foreach>
</delete>
<select id="getWhiteCarnoDicList" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteCarnoDic">
select
t.memo,t.discrp,t.dicname,t.unuser1,t.unuser2
FROM WHITE_CARNO_DIC_TABLE t
<where>
<if test="params.memo != null and params.memo != ''">
AND t.memo = #{params.memo}
</if>
<if test="params.dicname != null and params.dicname != ''">
AND t.dicname like '%'|| #{params.dicname} || '%'
</if>
</where>
</select>
</mapper>

@ -0,0 +1,25 @@
package com.nmgs.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteCarnoList;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
@Mapper
public interface WhiteCarnoListMapper extends BaseMapper<WhiteCarnoList> {
Page<WhiteCarnoList> getWhiteCarnoListByPage(Page<WhiteCarnoList> page, @Param("params") Map<String, Object> params);
int insertData(@Param("params") WhiteCarnoList params);
int insertDataBatch(@Param("list") List<WhiteCarnoList> params);
int delDataBatch(@Param("ids") List<String> ids);
int updateById(@Param("params") WhiteCarnoList params);
List<WhiteCarnoList> getWhiteCarnoList(@Param("params") Map<String, Object> params);
int batchUpdateById(@Param("ids") String[] str,@Param("params") Map<String, Object> params);
public List<WhiteCarnoList> getWhiteCarno(@Param("params") Map<String, Object> params);
public int publishVersion(@Param("params") Map<String, Object> params);
}

@ -0,0 +1,522 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nmgs.mapper.WhiteCarnoListMapper">
<select id="getWhiteCarnoListByPage" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteCarnoList">
select
t.id,t.acarno,t.COLOR,t.DT,t.BEGDT,t.ENDDT,
t.VEHICLE_TYPE,t.DATAFLAG,t.DESCRIB,t.BEGDATE,
t.ACCOUNT,t.VERNO,t.bak1,t.bak2,t.bak3,t.memo,t.VEHICLE_CLASS,t.DISCRP,
<if test="params.DBTYPE ==1">
(case when t.ENDDT&lt; dateadd(day,0,#{params.CURRENTDATE}) THEN '已过期'
when t.ENDDT&lt; dateadd(day,0,#{params.CURRENTWILLDATE}) THEN '将到期'
else '正常' end) AS promperty,
</if>
<if test="params.DBTYPE ==2">
(case
when t.ENDDT&lt; to_Date(#{params.CURRENTDATE},'YYYY-MM-DD HH24:mi:ss') THEN '已过期'
when t.ENDDT&lt; to_Date(#{params.CURRENTWILLDATE},'YYYY-MM-DD HH24:mi:ss') THEN '将到期'
else '正常' end) AS promperty,
</if>
<if test="params.DBTYPE ==3">
(case
when t.ENDDT&lt; to_Date(#{params.CURRENTDATE},'YYYY-MM-DD HH24:mi:ss') THEN '已过期'
when t.ENDDT&lt; to_Date(#{params.CURRENTWILLDATE},'YYYY-MM-DD HH24:mi:ss') THEN '将到期'
else '正常' end) AS promperty,
</if>
<if test="params.DBTYPE ==4">
(case
when t.ENDDT&lt; STR_TO_DATE(#{params.CURRENTDATE},'%Y-%m-%d %H:%k:%s') THEN '已过期'
when t.ENDDT&lt; STR_TO_DATE(#{params.CURRENTWILLDATE},'%Y-%m-%d %H:%k:%s') THEN '将到期'
else '正常' end) AS promperty,
</if>
(case when t.DATAFLAG='1' then '在用' else '停用' end) as flagName,
wct.acountname as accountName,wpc.text as colorName,wvc.text as vehicleClassName,'' as vehicleTypeName
FROM WHITE_CARNO_TABLE t
left join white_ACCOUNT_text wct on(t.ACCOUNT = wct.acountid)
left join white_plate_color wpc on(t.COLOR = wpc.value)
left join WHITE_VEHICLE_CLASS wvc on(t.VEHICLE_CLASS = wvc.value)
<where>
<if test="params.id != null and params.id != ''">
AND t.id = #{params.id}
</if>
<if test="params.queryStartTime!= null and params.queryStartTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDT >= dateadd(day,0,#{params.queryStartTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDT >= TO_DATE(#{params.queryStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDT >= TO_DATE(#{params.queryStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDT >= STR_TO_DATE(#{params.queryStartTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryEndTime!= null and params.queryEndTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDT &lt;= dateadd(day,0,#{params.queryEndTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDT &lt;= TO_DATE(#{params.queryEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDT &lt;= TO_DATE(#{params.queryEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDT &lt;= STR_TO_DATE(#{params.queryEndTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryEndTimeS!= null and params.queryEndTimeS!= ''">
<if test="params.DBTYPE == 1">
AND t.ENDDT = dateadd(day,0,#{params.queryEndTimeS})
</if>
<if test="params.DBTYPE == 2">
AND t.ENDDT >= TO_DATE(#{params.queryEndTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.ENDDT >= TO_DATE(#{params.queryEndTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.ENDDT >= STR_TO_DATE(#{params.queryEndTimeS}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryEndTimeE!= null and params.queryEndTimeE!= ''">
<if test="params.DBTYPE == 1">
AND t.ENDDT &lt;= dateadd(day,0,#{params.queryEndTimeE})
</if>
<if test="params.DBTYPE == 2">
AND t.ENDDT &lt;= TO_DATE(#{params.queryEndTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.ENDDT &lt;= TO_DATE(#{params.queryEndTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.ENDDT &lt;= STR_TO_DATE(#{params.queryEndTimeE}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryOperStartTime!= null and params.queryOperStartTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDATE >= dateadd(day,0,#{params.queryOperStartTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDATE >= TO_DATE(#{params.queryOperStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDATE >= TO_DATE(#{params.queryOperStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDATE >= STR_TO_DATE(#{params.queryOperStartTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryOperEndTime!= null and params.queryOperEndTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDATE &lt;= dateadd(day,0,#{params.queryOperEndTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDATE &lt;= TO_DATE(#{params.queryOperEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDATE &lt;= TO_DATE(#{params.queryOperEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDATE &lt;= STR_TO_DATE(#{params.queryOperEndTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryCreateTimeS!= null and params.queryCreateTimeS!= ''">
<if test="params.DBTYPE == 1">
AND t.DT >= dateadd(day,0,#{params.queryCreateTimeS})
</if>
<if test="params.DBTYPE == 2">
AND t.DT >= TO_DATE(#{params.queryCreateTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.DT >= TO_DATE(#{params.queryCreateTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.DT >= STR_TO_DATE(#{params.queryCreateTimeS}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryCreateTimeE!= null and params.queryCreateTimeE!= ''">
<if test="params.DBTYPE == 1">
AND t.DT &lt;= dateadd(day,0,#{params.queryCreateTimeE})
</if>
<if test="params.DBTYPE == 2">
AND t.DT &lt;= TO_DATE(#{params.queryCreateTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.DT &lt;= TO_DATE(#{params.queryCreateTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.DT &lt;= STR_TO_DATE(#{params.queryCreateTimeE}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.WILLDATE!= null and params.WILLDATE!= ''">
<if test="params.DBTYPE == 1">
AND t.ENDDT &lt; dateadd(day,0,#{params.WILLDATE})
</if>
<if test="params.DBTYPE == 2">
AND t.ENDDT &lt; TO_DATE(#{params.WILLDATE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.ENDDT &lt; TO_DATE(#{params.WILLDATE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.ENDDT &lt; STR_TO_DATE(#{params.WILLDATE}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.SVEHICLEID != null and params.SVEHICLEID != ''">
AND t.acarno like '%'|| #{params.SVEHICLEID} || '%'
</if>
<if test="params.SCOMNO != null and params.SCOMNO != ''">
AND t.ACCOUNT = #{params.SCOMNO}
</if>
<if test="params.SSTATUS != null and params.SSTATUS != ''">
AND t.DATAFLAG = #{params.SSTATUS}
</if>
<if test="params.SVECHECLASS != null and params.SVECHECLASS != ''">
AND t.VEHICLECLASS = #{params.SVECHECLASS}
</if>
<if test="params.SVECHETYPE != null and params.SVECHETYPE != ''">
AND t.VEHICLETYPE = #{params.SVECHETYPE}
</if>
<if test="params.SDESCRIBE != null and params.SDESCRIBE != ''">
AND t.DESCRIB = #{params.SDESCRIBE}
</if>
<if test="params.SPROMPOTY != null and params.SPROMPOTY != ''">
<!-- 7天之内 将要过期 -->
<if test="params.SPROMPOTY =='WILL'">
</if>
</if>
</where>
</select>
<update id="updateById" parameterType="com.nmgs.entity.WhiteCarnoList">
update WHITE_CARNO_TABLE
<set>
ACARNO=#{params.acarno},
COLOR=#{params.color},
BEGDT= #{params.begdt},
ENDDT= #{params.enddt},
VEHICLE_TYPE=#{params.vehicleType} ,
DATAFLAG= #{params.dataflag},
DESCRIB= #{params.describ},
BEGDATE= #{params.begdate},
ACCOUNT= #{params.account},
<if test="params.verno !='' and params.verno != null">
VERNO= #{params.verno},
</if>
<if test="params.bak1 !='' and params.bak1 != null">
BAK1= #{params.bak1},
</if>
<if test="params.bak2 !='' and params.bak2 != null">
BAK2= #{params.bak12},
</if>
<if test="params.bak3 !='' and params.bak3 != null">
BAK3= #{params.bak3},
</if>
<if test="params.discrp !='' and params.discrp != null">
DISCRP= #{params.discrp},
</if>
<if test="params.vehicleClass !='' and params.vehicleClass != null">
VEHICLE_CLASS=#{params.vehicleClass},
</if>
MEMO= #{params.memo}
</set>
where ID=#{params.id}
</update>
<update id="batchUpdateById" parameterType="java.util.HashMap">
update WHITE_CARNO_TABLE
<set>
<if test="params.DBType == 1">
BEGDT = dateadd(day,0,#{params.begdt}),
ENDDT= dateadd(day,0,#{params.enddt}),
</if>
<if test="params.DBType == 2">
BEGDT= TO_DATE(#{params.begdt}, 'YYYY-MM-DD HH24:mi:ss'),
ENDDT= TO_DATE(#{params.enddt}, 'YYYY-MM-DD HH24:mi:ss'),
</if>
<if test="params.DBType == 3">
BEGDT = TO_DATE(#{params.begdt}, 'YYYY-MM-DD HH24:mi:ss'),
ENDDT= TO_DATE(#{params.enddt}, 'YYYY-MM-DD HH24:mi:ss'),
</if>
<if test="params.DBType == 4">
BEGDT= STR_TO_DATE(#{params.begdt}, '%Y-%m-%d %H:%k:%s'),
ENDDT= STR_TO_DATE(#{params.enddt}, '%Y-%m-%d %H:%k:%s'),
</if>
DATAFLAG= #{params.dataflag},
ACCOUNT= #{params.account}
</set>
where ID IN
<foreach item="str" collection="ids" open="(" separator="," close=")">
#{str}
</foreach>
</update>
<update id="publishVersion" parameterType="java.util.HashMap">
update WHITE_CARNO_TABLE
<set>
<if test="params.DBType == 1">
BEGDATE = dateadd(day,0,#{params.begdate})
</if>
<if test="params.DBType == 2">
BEGDATE= TO_DATE(#{params.begdate}, 'YYYY-MM-DD HH24:mi:ss'),
</if>
<if test="params.DBType == 3">
BEGDATE = TO_DATE(#{params.begdate}, 'YYYY-MM-DD HH24:mi:ss'),
</if>
<if test="params.DBType == 4">
BEGDATE= STR_TO_DATE(#{params.begdate}, '%Y-%m-%d %H:%k:%s'),
</if>
VERNO= #{params.verno}
</set>
</update>
<insert id="insertData" parameterType="com.nmgs.entity.WhiteCarnoList">
insert into WHITE_CARNO_TABLE(ID,
acarno,
COLOR,
DT,BEGDT,ENDDT,
VEHICLE_TYPE,
DATAFLAG,DESCRIB,BEGDATE,ACCOUNT,VERNO,
BAK1,BAK2,BAK3,MEMO,
VEHICLE_CLASS,DISCRP)
values(#{params.id},
#{params.acarno},
#{params.color},
#{params.dt},
#{params.begdt},
#{params.enddt},
#{params.vehicleType},
#{params.dataflag},#{params.describ},#{params.begdate},
#{params.account},#{params.verno},#{params.bak1},
#{params.bak2},#{params.bak3},#{params.memo},
#{params.vehicleClass},#{params.discrp}
)
</insert>
<insert id="insertDataBatch" parameterType="java.util.List">
insert into WHITE_CARNO_TABLE(ID,acarno,COLOR,DT,BEGDT,ENDDT,VEHICLE_TYPE,
DATAFLAG,DESCRIB,BEGDATE,ACCOUNT,VERNO,BAK1,BAK2,BAK3,MEMO,
VEHICLE_CLASS,DISCRP) values
<foreach collection="list" item="params" separator=",">
(#{params.id},#{params.acarno},#{params.color},#{params.dt},#{params.begdt},
#{params.enddt},#{params.vehicleType},#{params.dataflag},#{params.describ},#{params.begdate},
#{params.account},#{params.verno},#{params.bak1},#{params.bak2},#{params.bak3},#{params.memo},#{params.vehicleClass},#{params.discrp}
)
</foreach>
</insert>
<delete id="delDataBatch">
DELETE FROM WHITE_CARNO_TABLE WHERE ID IN
<foreach item="str" collection="ids" open="(" separator="," close=")">
#{str}
</foreach>
</delete>
<select id="getWhiteCarnoList" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteCarnoList">
select
t.id,t.acarno,t.COLOR,t.DT,t.BEGDT,t.ENDDT,
t.VEHICLE_TYPE,t.DATAFLAG,t.DESCRIB,t.BEGDATE,
t.ACCOUNT,t.VERNO,t.bak1,t.bak2,t.bak3,t.memo,t.VEHICLE_CLASS,t.DISCRP,
<if test="params.DBTYPE ==1">
(case when t.ENDDT&lt; dateadd(day,0,#{params.CURRENTDATE}) THEN '已过期'
when t.ENDDT&lt; dateadd(day,0,#{params.CURRENTWILLDATE}) THEN '将到期'
else '正常' end) AS promperty,
</if>
<if test="params.DBTYPE ==2">
(case
when t.ENDDT&lt; to_Date(#{params.CURRENTDATE},'YYYY-MM-DD HH24:mi:ss') THEN '已过期'
when t.ENDDT&lt; to_Date(#{params.CURRENTWILLDATE},'YYYY-MM-DD HH24:mi:ss') THEN '将到期'
else '正常' end) AS promperty,
</if>
<if test="params.DBTYPE ==3">
(case
when t.ENDDT&lt; to_Date(#{params.CURRENTDATE},'YYYY-MM-DD HH24:mi:ss') THEN '已过期'
when t.ENDDT&lt; to_Date(#{params.CURRENTWILLDATE},'YYYY-MM-DD HH24:mi:ss') THEN '将到期'
else '正常' end) AS promperty,
</if>
<if test="params.DBTYPE ==4">
(case
when t.ENDDT&lt; STR_TO_DATE(#{params.CURRENTDATE},'%Y-%m-%d %H:%k:%s') THEN '已过期'
when t.ENDDT&lt; STR_TO_DATE(#{params.CURRENTWILLDATE},'%Y-%m-%d %H:%k:%s') THEN '将到期'
else '正常' end) AS promperty,
</if>
(case when t.DATAFLAG='1' then '在用' else '停用' end) as flagName,
wct.acountname as accountName,wpc.text as colorName,wvc.text as vehicleClassName,'' as vehicleTypeName
FROM WHITE_CARNO_TABLE t
left join white_account_text wct on(t.ACCOUNT = wct.acountid)
left join white_plate_color wpc on(t.COLOR = wpc.value)
left join WHITE_VEHICLE_CLASS wvc on(t.VEHICLE_CLASS = wvc.value)
<where>
<if test="params.id != null and params.id != ''">
AND t.id = #{params.id}
</if>
<if test="params.queryStartTime!= null and params.queryStartTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDT >= dateadd(day,0,#{params.queryStartTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDT >= TO_DATE(#{params.queryStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDT >= TO_DATE(#{params.queryStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDT >= STR_TO_DATE(#{params.queryStartTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryEndTime!= null and params.queryEndTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDT &lt;= dateadd(day,0,#{params.queryEndTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDT &lt;= TO_DATE(#{params.queryEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDT &lt;= TO_DATE(#{params.queryEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDT &lt;= STR_TO_DATE(#{params.queryEndTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryEndTimeS!= null and params.queryEndTimeS!= ''">
<if test="params.DBTYPE == 1">
AND t.ENDDT = dateadd(day,0,#{params.queryEndTimeS})
</if>
<if test="params.DBTYPE == 2">
AND t.ENDDT >= TO_DATE(#{params.queryEndTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.ENDDT >= TO_DATE(#{params.queryEndTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.ENDDT >= STR_TO_DATE(#{params.queryEndTimeS}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryEndTimeE!= null and params.queryEndTimeE!= ''">
<if test="params.DBTYPE == 1">
AND t.ENDDT &lt;= dateadd(day,0,#{params.queryEndTimeE})
</if>
<if test="params.DBTYPE == 2">
AND t.ENDDT &lt;= TO_DATE(#{params.queryEndTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.ENDDT &lt;= TO_DATE(#{params.queryEndTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.ENDDT &lt;= STR_TO_DATE(#{params.queryEndTimeE}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryOperStartTime!= null and params.queryOperStartTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDATE >= dateadd(day,0,#{params.queryOperStartTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDATE >= TO_DATE(#{params.queryOperStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDATE >= TO_DATE(#{params.queryOperStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDATE >= STR_TO_DATE(#{params.queryOperStartTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryOperEndTime!= null and params.queryOperEndTime!= ''">
<if test="params.DBTYPE == 1">
AND t.BEGDATE &lt;= dateadd(day,0,#{params.queryOperEndTime})
</if>
<if test="params.DBTYPE == 2">
AND t.BEGDATE &lt;= TO_DATE(#{params.queryOperEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.BEGDATE &lt;= TO_DATE(#{params.queryOperEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.BEGDATE &lt;= STR_TO_DATE(#{params.queryOperEndTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryCreateTimeS!= null and params.queryCreateTimeS!= ''">
<if test="params.DBTYPE == 1">
AND t.DT >= dateadd(day,0,#{params.queryCreateTimeS})
</if>
<if test="params.DBTYPE == 2">
AND t.DT >= TO_DATE(#{params.queryCreateTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.DT >= TO_DATE(#{params.queryCreateTimeS}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.DT >= STR_TO_DATE(#{params.queryCreateTimeS}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryCreateTimeE!= null and params.queryCreateTimeE!= ''">
<if test="params.DBTYPE == 1">
AND t.DT &lt;= dateadd(day,0,#{params.queryCreateTimeE})
</if>
<if test="params.DBTYPE == 2">
AND t.DT &lt;= TO_DATE(#{params.queryCreateTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.DT &lt;= TO_DATE(#{params.queryCreateTimeE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.DT &lt;= STR_TO_DATE(#{params.queryCreateTimeE}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.WILLDATE!= null and params.WILLDATE!= ''">
<if test="params.DBTYPE == 1">
AND t.ENDDT &lt; dateadd(day,0,#{params.WILLDATE})
</if>
<if test="params.DBTYPE == 2">
AND t.ENDDT &lt; TO_DATE(#{params.WILLDATE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.ENDDT &lt; TO_DATE(#{params.WILLDATE}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.ENDDT &lt; STR_TO_DATE(#{params.WILLDATE}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.SVEHICLEID != null and params.SVEHICLEID != ''">
AND t.acarno like '%'|| #{params.SVEHICLEID} || '%'
</if>
<if test="params.acarNo != null and params.acarNo != ''">
AND t.acarno =#{params.acarNo}
</if>
<if test="params.color != null and params.color != ''">
AND t.COLOR =#{params.color}
</if>
<if test="params.SCOMNO != null and params.SCOMNO != ''">
AND t.account = #{params.SCOMNO}
</if>
<if test="params.SSTATUS != null and params.SSTATUS != ''">
AND t.dataflag = #{params.SSTATUS}
</if>
<if test="params.SVECHECLASS != null and params.SVECHECLASS != ''">
AND t.VEHICLECLASS = #{params.SVECHECLASS}
</if>
<if test="params.SVECHETYPE != null and params.SVECHETYPE != ''">
AND t.VEHICLETYPE = #{params.SVECHETYPE}
</if>
<if test="params.SDESCRIBE != null and params.SDESCRIBE != ''">
AND t.DESCRIB = #{params.SDESCRIBE}
</if>
</where>
</select>
<select id="getWhiteCarno" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteCarnoList">
select
max(t.VERNO) as verno
FROM WHITE_CARNO_TABLE t
<where>
<if test="params.whereSql != null and params.whereSql != ''">
${params.whereSql}
</if>
</where>
</select>
</mapper>

@ -0,0 +1,22 @@
package com.nmgs.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import com.nmgs.entity.WhiteOperationLog;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
*
*/
@Mapper
public interface WhiteCarnoLogMapper extends BaseMapper<WhiteCarnoLogTable> {
int insertBatch(@Param("list") List<WhiteCarnoLogTable> list);
Page<WhiteCarnoLogTable> getWhiteCarnoLogByPage(Page<WhiteCarnoLogTable> page, @Param("params") Map<String, Object> params);
}

@ -0,0 +1,90 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nmgs.mapper.WhiteCarnoLogMapper">
<insert id="insertBatch" parameterType="java.util.List">
<foreach collection="list" item="params" separator=";">
insert into WHITE_CARNO_LOG_TABLE(ID,acarno,COLOR,DT,BEGDT,ENDDT,VEHICLE_TYPE,
STATUS,DESCRIB,BEGDATE,ACCOUNT,VERNO,BAK1,BAK2,BAK3,MEMO,
VEHICLE_CLASS,OPERTYPE,OPERTYPENAME,OPERDATE,OPERMANO,OPERMANAME,COMNO,IDBUSINESS)
values
(#{params.id},#{params.acarno},#{params.color},#{params.dt},#{params.begdt},
#{params.enddt},#{params.vehicleType},#{params.dataflag},#{params.describ},#{params.begdate},
#{params.account},#{params.verno},#{params.bak1},#{params.bak2},#{params.bak3},#{params.memo},
#{params.vehicleClass},#{params.opertype},#{params.opertypename},#{params.operdate},
#{params.opermano},#{params.opermaname},#{params.comno},#{params.idbusiness}
)
</foreach>
</insert>
<select id="getWhiteCarnoLogByPage" parameterType="java.util.HashMap" resultType="com.nmgs.entity.WhiteCarnoLogTable">
select
t.id,t.acarno,t.COLOR,t.DT,t.BEGDT,t.ENDDT,
t.VEHICLE_TYPE,t.DATAFLAG,t.DESCRIB,t.BEGDATE,
t.ACCOUNT,t.VERNO,t.bak1,t.bak2,t.bak3,t.memo,t.VEHICLE_CLASS AS vehicleClass,
(case when t.DATAFLAG='1' then '在用' else '停用' end) as flagName,
wct.acountname as accountName,wpc.text as colorName,wvc.text as vehicleClassName,'' as vehicleTypeName,
t.OPERTYPE,t.OPERTYPENAME,t.OPERDATE,t.OPERMANO,t.OPERMANAME,t.COMNO,t.IDBUSINESS
FROM WHITE_CARNO_LOG_TABLE t
left join white_ACCOUNT_text wct on(t.ACCOUNT = wct.acountid)
left join white_plate_color wpc on(t.COLOR = wpc.value)
left join WHITE_VEHICLE_CLASS wvc on(t.VEHICLE_CLASS = wvc.value)
<where>
<if test="params.id != null and params.id != ''">
AND t.id = #{params.id}
</if>
<if test="params.queryOperStartTime!= null and params.queryOperStartTime!= ''">
<if test="params.DBTYPE == 1">
AND t.OPERDATE >= dateadd(day,0,#{params.queryOperStartTime})
</if>
<if test="params.DBTYPE == 2">
AND t.OPERDATE >= TO_DATE(#{params.queryOperStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.OPERDATE >= TO_DATE(#{params.queryOperStartTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.OPERDATE >= STR_TO_DATE(#{params.queryOperStartTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.queryOperEndTime!= null and params.queryOperEndTime!= ''">
<if test="params.DBTYPE == 1">
AND t.OPERDATE &lt;= dateadd(day,0,#{params.queryOperEndTime})
</if>
<if test="params.DBTYPE == 2">
AND t.OPERDATE &lt;= TO_DATE(#{params.queryOperEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 3">
AND t.OPERDATE &lt;= TO_DATE(#{params.queryOperEndTime}, 'YYYY-MM-DD HH24:mi:ss')
</if>
<if test="params.DBTYPE == 4">
AND t.OPERDATE &lt;= STR_TO_DATE(#{params.queryOperEndTime}, '%Y-%m-%d %H:%k:%s')
</if>
</if>
<if test="params.SVEHICLEID != null and params.SVEHICLEID != ''">
AND t.acarno like '%'|| #{params.SVEHICLEID} || '%'
</if>
<if test="params.SCOLOR != null and params.SCOLOR != ''">
AND t.COLOR = #{params.SCOLOR}
</if>
<if test="params.SOPERTYPE != null and params.SOPERTYPE != ''">
AND t.OPERTYPE = #{params.SOPERTYPE}
</if>
<if test="params.SOPERMANAME != null and params.SOPERMANAME != ''">
AND t.OPERMANAME like '%'|| #{params.SOPERMANAME} || '%'
</if>
<if test="params.SVECHECLASS != null and params.SVECHECLASS != ''">
AND t.VEHICLECLASS = #{params.SVECHECLASS}
</if>
<if test="params.SVECHETYPE != null and params.SVECHETYPE != ''">
AND t.VEHICLETYPE = #{params.SVECHETYPE}
</if>
<if test="params.SDESCRIBE != null and params.SDESCRIBE != ''">
AND t.DESCRIB = #{params.SDESCRIBE}
</if>
</where>
order by t.OPERDATE DESC
</select>
</mapper>

@ -0,0 +1,10 @@
package com.nmgs.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nmgs.entity.WhiteOperationLog;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface WhiteOperationLogMapper extends BaseMapper<WhiteOperationLog> {
}

@ -0,0 +1,7 @@
package com.nmgs.service;
import com.nmgs.entity.WhiteOperationLog;
public interface IOperationLogService {
int saveData(WhiteOperationLog operationLog);
}

@ -0,0 +1,10 @@
package com.nmgs.service;
import com.alibaba.fastjson.JSONObject;
import java.util.List;
import java.util.Map;
public interface ISelectData {
public List getDataByType(JSONObject paramsData);
}

@ -0,0 +1,47 @@
package com.nmgs.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import java.util.List;
import java.util.Map;
public interface IWhiteAccountSerive {
/**
*
* @param params
* @return
*/
Page<WhiteAccountText> getWhiteAccountTextByPage(Map<String, Object> params);
/**
*
* @param whiteCarnoList
* @return
* @throws Exception
*/
int insertData(WhiteAccountText whiteCarnoList) throws Exception;
/**
*
* @param params
* @return
* @throws Exception
*/
int batchDelDatas(Object params) throws Exception;
/**
*
* @param params
* @return
* @throws Exception
*/
int updateById(WhiteAccountText params) throws Exception;
/**
*
* @param params
* @return
*/
List<WhiteAccountText> getWhiteAccountText(Map<String, Object> params);
}

@ -0,0 +1,20 @@
package com.nmgs.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import java.util.List;
import java.util.Map;
public interface IWhiteBatchImportSerive {
/**
*
* @param params
* @return
* @throws Exception
*/
JSONObject insertData(Object params) throws Exception;
}

@ -0,0 +1,40 @@
package com.nmgs.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.entity.WhiteCarnoDic;
import java.util.List;
import java.util.Map;
public interface IWhiteCarnoDicService {
/**
*
* @param params
* @return
*/
Page<WhiteCarnoDic> getWhiteCarnoDicByPage(Map<String, Object> params);
/**
*
* @param params
* @return
* @throws Exception
*/
int insertData(Map<String, Object> params) throws Exception;
/**
*
* @param params
* @return
* @throws Exception
*/
int batchDelDatas(Object params) throws Exception;
/**
*
* @param params
* @return
*/
List<WhiteCarnoDic> getWhiteCarnoDicList(Map<String, Object> params);
}

@ -0,0 +1,92 @@
package com.nmgs.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteCarnoList;
import org.apache.ibatis.annotations.Param;
import java.text.ParseException;
import java.util.List;
import java.util.Map;
public interface IWhiteCarnoListSerive {
/**
*
* @param params
* @return
*/
Page<WhiteCarnoList> getWhiteCarnoListByPage(Map<String, Object> params);
/**
*
* @param whiteCarnoList
* @return
* @throws Exception
*/
int insertData(WhiteCarnoList whiteCarnoList) throws Exception;
/**
*
* @param list
* @return
* @throws Exception
*/
int insertDataBatch(List<WhiteCarnoList> list) throws Exception;
/**
*
* @param params
* @return
* @throws Exception
*/
int batchDelDatas(Object params) throws Exception;
/**
*
* @param params
* @return
* @throws Exception
*/
int updateById(WhiteCarnoList params) throws Exception;
/**
*
* @param params
* @return
*/
List<WhiteCarnoList> getWhiteCarnoList(Map<String, Object> params);
/**
*
* @param req
* @return
*/
int batchUpdateById(Map<String, Object> req) throws Exception;
/**
*
* @return
*/
int getIOCount();
/**
*
* @param req
* @return
* @throws Exception
*/
int publishVersion(Map<String, Object> req) throws Exception;
/**
*
* @param req
* @return
* @throws Exception
*/
Map<String,String> getVersion(Map<String, Object> req) throws Exception;
/**
*
* @param params
* @return
*/
List<WhiteCarnoList> getWhiteCarno(Map<String, Object> params);
}

@ -0,0 +1,22 @@
package com.nmgs.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import java.util.List;
import java.util.Map;
public interface IWhiteCarnoLogService extends IService<WhiteCarnoLogTable> {
int saveData(WhiteCarnoLogTable operationLog);
// int insertBatch(List<WhiteCarnoLogTable> list);
/**
*
* @param params
* @return
*/
public Page<WhiteCarnoLogTable> getWhiteCarnoLogByPage(Map<String, Object> params);
}

@ -0,0 +1,42 @@
package com.nmgs.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.*;
import com.nmgs.mapper.Mapper;
import com.nmgs.service.IWhiteCarnoListSerive;
import com.nmgs.util.LogUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
@Service
public class ExcelDateImpl {
@Autowired
public Mapper mapperI;
@Autowired
public IWhiteCarnoListSerive iDivOutPortDroadSerive;
public List<WhiteCarnoListDto> exportDivOutPortGroadList(Map<String, Object> req) {
List<WhiteCarnoListDto> listRet=new ArrayList<WhiteCarnoListDto>();
//从配置文件中读取数据库连接类型
List<WhiteCarnoList> records = iDivOutPortDroadSerive.getWhiteCarnoList(req);
try{
if(records.size()>0){
//解析特情值不是查询总数
for(int i=0;i<records.size();i++){
WhiteCarnoListDto dto=new WhiteCarnoListDto();
BeanUtils.copyProperties(records.get(i),dto);
listRet.add(dto);
}
}
}catch(Exception e){
LogUtil.WriteLog_Error("查询白名单数据失败==="+e.getMessage(),"ExcelDateImpl");
return new ArrayList();
}
return listRet;
}
}

@ -0,0 +1,17 @@
package com.nmgs.service.impl;
import com.nmgs.entity.WhiteOperationLog;
import com.nmgs.mapper.WhiteOperationLogMapper;
import com.nmgs.service.IOperationLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class OperationLogServiceImpl implements IOperationLogService {
@Autowired
WhiteOperationLogMapper whiteOperationLogMapper;
@Override
public int saveData(WhiteOperationLog operationLog) {
return whiteOperationLogMapper.insert(operationLog);
}
}

@ -0,0 +1,82 @@
package com.nmgs.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.nmgs.mapper.Mapper;
import com.nmgs.service.ISelectData;
import com.nmgs.util.LogUtil;
import com.nmgs.util.PubTools;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*/
@Service
public class SelectDataImpl implements ISelectData {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHH");
@Autowired
public Mapper mapperI;
@Override
public List getDataByType(JSONObject paramsData) {
List ret = new ArrayList();
String sql="";
String selectType=paramsData.get("selectType").toString();
String roadNoSql="";
if(!PubTools.isEmpty(paramsData.get("roadNoSql"))){
roadNoSql=paramsData.get("roadNoSql").toString();
}
if("ROAD".equals(selectType)){//自定义白名单全部路段
sql="select a.roadno value,a.roadname||':'||a.roadno label from ROAD_TABLE a where 1=1 ";
if(!PubTools.isNull(roadNoSql)){
sql += roadNoSql;
}
sql +=" order by a.roadname ";
} else if("ROAD_STA_STA".equals(selectType)){//自定义白名单全:站站路段,需要排除全部路段
sql="select a.roadno value,a.roadname||':'||a.roadno label from ROAD_TABLE a where 1=1 ";
if(!PubTools.isNull(roadNoSql)){
sql += roadNoSql;
}
sql +=" order by a.roadname ";
} else if ("STANONAME".equals(selectType)) {//站名称
sql = "select a.stano as value,a.staname||':'||a.stano as label from NAME_TABLE a where 1=1 AND a.STATYPE=1 ";
if(!PubTools.isNull(roadNoSql)){
sql += roadNoSql;
}
sql += " order by a.roadname,a.STANAME ";
}else if("GANTRY".equals(selectType)){//省界门架出口名称
sql="select distinct a.gantryhex as value,a.name as label from GANTRY_TABLE a where a.boundarytype=2 group by a.name,a.gantryhex order by a.name ";
}else if("INTERFLOW".equals(selectType)){//互通名称
sql="select distinct a.INTER_HEX as value,a.INTER_NAME as label from DIV_INTERFLOW_TABLE a where a.IN_OUT='OUT' order by a.INTER_HEX ";
} else if ("PLATECOLOR".equals(selectType)) {//车牌颜色
sql = "select a.value as VALUE,a.text as LABEL from PLATECOLOR_TEXT a order by a.value ";
} else if ("EXITFEETYPE".equals(selectType)) {//计费类型
sql = "select a.value as VALUE,a.text as LABEL from EXITFEETYPE_TEXT a order by a.value ";
} else if ("SPECIAL".equals(selectType)) {//特情
sql = "select a.value as VALUE,a.text as LABEL from FLAG_TEXT a order by a.value ";
}else if ("COMNO".equals(selectType)) {//所属公司,白名单使用
sql = "select a.acountid as VALUE,a.acountname as LABEL from WHITE_ACCOUNT_TEXT a order by a.acountname ";
}else if ("WHITE_VEH_CLASS".equals(selectType)) {//车种,白名单使用
sql = "select a.value as VALUE,a.text as LABEL from WHITE_VEHICLE_CLASS a WHERE a.useflag='1' order by a.value ";
}else if ("WHITE_PLATECOLOR".equals(selectType)) {//车牌颜色,白名单使用
sql = "select a.value as VALUE,a.text as LABEL from white_PLATE_COLOR a WHERE a.useflag='1' order by a.value ";
}else if ("WHITE_ZDYZH".equals(selectType)) {//自定义组合,白名单使用
sql = "select a.memo as VALUE,a.DICNAME as LABEL,a.DISCRP as discrp from WHITE_CARNO_DIC_TABLE a WHERE 1=1 ";
}
try {
ret=mapperI.selectforlist(sql);
} catch (Exception e) {
LogUtil.WriteLog_Error("下拉数据"+selectType+"查询失败=====" + e.getMessage(), "SelectDataImpl");
ret = new ArrayList();
}
return ret;
}
}

@ -0,0 +1,110 @@
package com.nmgs.service.impl;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.mapper.Mapper;
import com.nmgs.mapper.WhiteAccountMapper;
import com.nmgs.service.IWhiteAccountSerive;
import com.nmgs.util.LogUtil;
import com.nmgs.util.PropertiesUtil;
import com.nmgs.util.PubTools;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.SimpleDateFormat;
import java.util.*;
@Transactional(rollbackFor = Exception.class)
@Service
public class WhiteAccountSeriveImpl implements IWhiteAccountSerive {
@Autowired
public WhiteAccountMapper whiteAccountMapper;
@Autowired
public Mapper mapperI;
SimpleDateFormat dateTimeFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public Page<WhiteAccountText> getWhiteAccountTextByPage(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PropertiesUtil.getValue("DBType"));
//设置分页
Integer pageNum = (Integer) params.get("pageNum");
Integer pageSize = (Integer) params.get("pageSize");
Page<WhiteAccountText> page = new Page<>(pageNum,pageSize);
page = whiteAccountMapper.getWhiteAccountByPage(page,params);
return page;
}
@Override
public int insertData(WhiteAccountText whiteAccountText) throws Exception {
int ret=-1;
try{
//先根据车牌号与颜色判断是否已经存在
Map<String,Object> params=new HashMap<String,Object>();
params.put("id",whiteAccountText.getAcountid());
List<WhiteAccountText> whiteCarnoList1 = whiteAccountMapper.getWhiteAccountText(params);
if(whiteCarnoList1.size()>0){
return -2;//白名单存在该信息!
}
ret= whiteAccountMapper.insert(whiteAccountText);
}catch (Exception e){
LogUtil.WriteLog_Error("新增单位信息出错:"+e.getMessage(),"WhiteAccountSeriveImpl");
throw new Exception(e);
}
return ret;
}
@Override
public int batchDelDatas(Object params) throws Exception {
int ret=-1;
List<Integer> ids=new ArrayList<Integer>();
try{
if(!PubTools.isEmpty(params)){
if(params instanceof ArrayList){
List<Map<String,Object>> whiteAccount= (ArrayList<Map<String,Object>>) params;
if(whiteAccount.size()>0){
for(int i=0;i<whiteAccount.size();i++){
WhiteAccountText wcl=(WhiteAccountText)PubTools.map2Object(whiteAccount.get(i),WhiteAccountText.class);
ids.add(wcl.getAcountid());
}
}
}else if(params instanceof JSONArray){
JSONArray json=(JSONArray)params;
if(json.size()>0){
for(int i=0;i<json.size();i++){
JSONObject jo=(JSONObject)json.get(i);
WhiteAccountText wcl= jo.toJavaObject(WhiteAccountText.class);
ids.add(wcl.getAcountid());
}
}
}
}
if(ids.size()>0){
ret= whiteAccountMapper.delDataById(ids);
}
}catch (Exception e){
throw new Exception(e);
}
return ret;
}
@Override
public int updateById(WhiteAccountText params) throws Exception {
int ret=-1;
try{
ret= whiteAccountMapper.updateById(params);
}catch (Exception e){
throw new Exception(e);
}
return ret;
}
@Override
public List<WhiteAccountText> getWhiteAccountText(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PubTools.getDBType());
List<WhiteAccountText> records = whiteAccountMapper.getWhiteAccountText(params);
return records;
}
}

@ -0,0 +1,275 @@
package com.nmgs.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.UUID;
import cn.hutool.poi.excel.ExcelReader;
import cn.hutool.poi.excel.ExcelUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.config.ResultData;
import com.nmgs.entity.Consistent;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import com.nmgs.mapper.Mapper;
import com.nmgs.mapper.WhiteCarnoListMapper;
import com.nmgs.mapper.WhiteCarnoLogMapper;
import com.nmgs.service.ISelectData;
import com.nmgs.service.IWhiteBatchImportSerive;
import com.nmgs.service.IWhiteCarnoListSerive;
import com.nmgs.service.IWhiteCarnoLogService;
import com.nmgs.util.LogUtil;
import com.nmgs.util.PropertiesUtil;
import com.nmgs.util.PubTools;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.File;
import java.io.FileInputStream;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
@Transactional(rollbackFor = Exception.class)
@Service
public class WhiteBatchImportSeriveImpl implements IWhiteBatchImportSerive {
public Mapper iMapper;
@Autowired
public void setiMapper(Mapper iMapper) {
this.iMapper = iMapper;
}
public WhiteCarnoListMapper whiteCarnoListMapper;
public WhiteCarnoLogMapper whiteCarnoLogMapper;
@Autowired
public void setWhiteCarnoListMapper(WhiteCarnoListMapper whiteCarnoListMapper) {
this.whiteCarnoListMapper = whiteCarnoListMapper;
}
@Autowired
public void setWhiteCarnoLogMapper(WhiteCarnoLogMapper whiteCarnoLogMapper) {
this.whiteCarnoLogMapper = whiteCarnoLogMapper;
}
@Override
public JSONObject insertData(Object params) throws Exception {
Map<String,Object> map=(Map<String,Object>)params;
JSONObject json=new JSONObject();
String txtLog="";
String logShowExist="";
String filename=map.get("filename").toString();
String opermano=map.get("opermano").toString();
String opermaname=map.get("opermaname").toString();
String zdyzh=map.get("zdyzh").toString();
String zdyzhAccount=map.get("zdyzhAccount").toString();
String mfld=map.get("mfld").toString();
String mfldAccount=map.get("mfldAccount").toString();
String zdyzhDis=map.get("zdyzhDis").toString();
String mfldDis=map.get("mfldDis").toString();
List<WhiteCarnoList> users = new ArrayList<WhiteCarnoList>();//新增的数据
List<WhiteCarnoList> usersUpdate = new ArrayList<WhiteCarnoList>();//修改的数据:根据车牌号和颜色查询是否存在数据,存在则更新
List<WhiteCarnoLogTable> carnoLogAdd = new ArrayList<WhiteCarnoLogTable>();//操作日志
int count = 0;
//当前项目的目录
SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMdd");
String fileDirName = sdf.format(new Date());
String folderPath = com.nmgs.util.PathUtil.webappsPath + "\\CarNoFile\\"+fileDirName+"\\"+filename;
File fileTemp=new File(folderPath);
if (!fileTemp.exists())
{
txtLog="附件不存在";
json.put("txtLog",txtLog);
return json;
}else{
FileInputStream fileInputStream = new FileInputStream(folderPath);
ExcelReader reader = ExcelUtil.getReader(fileInputStream);
List<List<Object>> read = reader.read(3);
// 方式2忽略表头的中文直接读取表的内容
SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
txtLog += "\n";
if(read.size()>0){
txtLog += PubTools.getCurrentDate() + "白名单批量导入文件名称-->" + filename + "\n";
}
for ( int k=0;k<read.size()-1;k++) {//由于最后一行内容是填报人信息, 所以不管
List<Object> row=read.get(k);
try{
if(!PubTools.isEmpty(row.get(1)) && !PubTools.isEmpty(row.get(2)) && !PubTools.isEmpty(row.get(3))
&& !PubTools.isNull(row.get(1).toString()) && !PubTools.isNull(row.get(2).toString()) &&
!PubTools.isNull(row.get(3).toString())){
}
//
WhiteCarnoList user = new WhiteCarnoList();
WhiteCarnoLogTable carNoLog = new WhiteCarnoLogTable();
//校验车牌
boolean isregex = PubTools.isregex(row.get(1).toString());
if(!isregex){
txtLog += PubTools.getCurrentDate() + row.get(1).toString() + ":车牌号码不正确!" + "\n";
}else{
if (row.get(1).toString().trim().toUpperCase().contains("I") || row.get(1).toString().trim().toUpperCase().contains("O"))
{
txtLog += PubTools.getCurrentDate() + row.get(1).toString() + "车牌号码不能包含I/O(i/o)字母!";
json.put("txtLog",txtLog);
return json;
}
}
int color = getColor(row.get(2).toString());
if(color <0){
txtLog += PubTools.getCurrentDate() + row.get(1).toString() + ":车牌颜色选择错误!";
json.put("txtLog",txtLog);
return json;
}
count++;
user.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
user.setAcarno(row.get(1).toString());//车牌号
user.setColor(color);//车牌颜色
user.setDescrib(row.get(3).toString());//车辆描述
user.setEnddt(sd.parse(row.get(4).toString()));//有效结束日期
user.setDt(sd.parse(PubTools.getCurrentDate()));
user.setBegdt(sd.parse(PubTools.getCurrentDate()));
user.setBegdate(sd.parse(PubTools.getCurrentDate()));
user.setDataflag("1");//默认启用
user.setVerno("0");
//处理所属单位以及memo信息处理
if(!PubTools.isNull(zdyzh)){//自定义组合
user.setMemo(zdyzh);
user.setDiscrp(zdyzhDis);
user.setAccount(Integer.parseInt(zdyzhAccount));
}else{
if (!PubTools.isNull(mfld)){
String[] ckgFree=mfld.split(",");
String memoDb="";
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
if (!PubTools.isNull(ckgFree[i]+"")){
//不足两位补0,
if (Integer.parseInt(ckgFree[i]+"") < 10){
memoDb += PubTools.GetHex("0" + ckgFree[i]+"" + "0" + ckgFree[i]+"" + "00" + "0" + ckgFree[i]+"" + "00");
}else if(Integer.parseInt(ckgFree[i]+"") < 100 && Integer.parseInt(ckgFree[i]+"")>=10){//两位的
memoDb += PubTools.GetHex(ckgFree[i]+"" + ckgFree[i]+"" + "00" + ckgFree[i]+"" + "00");
}else{
memoDb += PubTools.GetHex(ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2));
}
}
}
user.setMemo(memoDb);
user.setDiscrp(mfldDis);
user.setAccount(Integer.parseInt(mfldAccount));
}
}
//根据车牌和颜色判断车牌是否已经存在
Map<String,Object> mapParas=new HashMap<String,Object>();
mapParas.put("acarNo",row.get(1).toString()) ;
mapParas.put("color",color) ;
List<WhiteCarnoList> whiteCarnoList = whiteCarnoListMapper.getWhiteCarnoList(mapParas);
if(whiteCarnoList.size()>0){
WhiteCarnoList whiteCarnoList1 = whiteCarnoList.get(0);
logShowExist += whiteCarnoList1.getAcarno() + ",";
user.setId(whiteCarnoList1.getId());
user.setVehicleType(whiteCarnoList1.getVehicleType());
user.setVehicleClass(whiteCarnoList1.getVehicleClass());
user.setBak1(whiteCarnoList1.getBak1());
user.setBak2(whiteCarnoList1.getBak2());
user.setBak3(whiteCarnoList1.getBak3());
usersUpdate.add(user);
}else{
user.setVehicleType(0);
user.setVehicleClass(0);
user.setBak1("");
user.setBak2("");
user.setBak3("");
users.add(user);
}
//memo设置
BeanUtils.copyProperties(user,carNoLog,"id");
carNoLog.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
carNoLog.setOperdate(sd.parse(PubTools.getCurrentDate()));
carNoLog.setOpertype(Consistent.IMPORT_BATCH);
carNoLog.setOpertypename(Consistent.IMPORT_BATCH_NAME);
carNoLog.setOpermano(opermano);
carNoLog.setOpermaname(opermaname);
carNoLog.setIdbusiness(user.getId());
carnoLogAdd.add(carNoLog);
}catch (Exception e){
txtLog += PubTools.getCurrentDate() + row.get(1).toString() + "【白名单文件没有按规定填写,请检查!!】 ";
json.put("txtLog",txtLog);
return json;
}
}
}
try
{
int ret=-1;
if (users.size()>0){
for(WhiteCarnoList whiteCarnoList:users){
int i = this.whiteCarnoListMapper.insertData(whiteCarnoList);
if(i<1){
txtLog += PubTools.getCurrentDate() + "导入失败!! ";
json.put("txtLog",txtLog);
return json;
}
}
}
if (usersUpdate.size()>0){
for(WhiteCarnoList whiteCarnoList:usersUpdate){
int i = this.whiteCarnoListMapper.updateById(whiteCarnoList);
if(i<1){
txtLog += PubTools.getCurrentDate() + "导入失败!! ";
json.put("txtLog",txtLog);
return json;
}
}
}
if (carnoLogAdd.size()>0){
for(WhiteCarnoLogTable whiteCarnoList:carnoLogAdd){
int i = this.whiteCarnoLogMapper.insert(whiteCarnoList);
if(i<1){
txtLog += PubTools.getCurrentDate() + "导入失败!! ";
json.put("txtLog",txtLog);
return json;
}
}
}
if(!PubTools.isNull(logShowExist)){
txtLog += "已存在车牌:"+logShowExist + "\n";
}
txtLog += PubTools.getCurrentDate() + "成功,共计:【" + count + "】条 ";
}
catch (Exception ex)
{
txtLog += PubTools.getCurrentDate() + "白名单批量导入异常:" + ex.getMessage() + "\n";
}
json.put("txtLog",txtLog);
return json;
}
private int getColor(String colorName){
String sql="select t.VALUE AS LABEL from white_PLATE_COLOR t where t.TEXT='"+colorName+"'";
List selectforlist = this.iMapper.selectforlist(sql);
int ret=-1;
if(selectforlist.size()>0){
Map<String,Object> o =(Map<String,Object>) selectforlist.get(0);
if(o.get("LABEL") instanceof BigDecimal){
ret=((BigDecimal) o.get("LABEL")).intValue();
}else if(o.get("LABEL") instanceof Integer){
ret=(Integer) o.get("LABEL");
}else{
ret=Integer.parseInt(o.get("LABEL").toString()) ;
}
}
return ret;
}
}

@ -0,0 +1,132 @@
package com.nmgs.service.impl;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.WhiteAccountText;
import com.nmgs.entity.WhiteCarnoDic;
import com.nmgs.mapper.Mapper;
import com.nmgs.mapper.WhiteCarnoDicMapper;
import com.nmgs.service.IWhiteCarnoDicService;
import com.nmgs.util.LogUtil;
import com.nmgs.util.PropertiesUtil;
import com.nmgs.util.PubTools;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class WhiteCarnoDicSeviceImpl implements IWhiteCarnoDicService {
@Autowired
public WhiteCarnoDicMapper whiteCarnoDicMapper;
@Autowired
public Mapper mapperI;
SimpleDateFormat dateTimeFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public Page<WhiteCarnoDic> getWhiteCarnoDicByPage(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PubTools.getDBType());
//设置分页
Integer pageNum = (Integer) params.get("pageNum");
Integer pageSize = (Integer) params.get("pageSize");
Page<WhiteCarnoDic> page = new Page<>(pageNum,pageSize);
page = whiteCarnoDicMapper.getWhiteCarnoDicByPage(page,params);
return page;
}
@Override
public int insertData(Map<String, Object> params) throws Exception {
int ret=-1;
try{
//先根据车牌号与颜色判断是否已经存在
WhiteCarnoDic whiteAccountText=new WhiteCarnoDic();
String memo=params.get("memo").toString();//免费路段的值
String memoSS=params.get("memoSS").toString();//站站免费中的路段值
String memoDb="";
if (!PubTools.isNull(memo)){
String[] ckgFree=memo.split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
if (!PubTools.isNull(ckgFree[i]+"")){
//不足两位补0,
if (Integer.parseInt(ckgFree[i]+"") < 10){
memoDb += PubTools.GetHex("0" + ckgFree[i]+"" + "0" + ckgFree[i]+"" + "00" + "0" + ckgFree[i]+"" + "00");
}else if(Integer.parseInt(ckgFree[i]+"") < 100 && Integer.parseInt(ckgFree[i]+"")>=10){//两位的
memoDb += PubTools.GetHex(ckgFree[i]+"" + ckgFree[i]+"" + "00" + ckgFree[i]+"" + "00");
}else{
memoDb += PubTools.GetHex(ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2));
}
}
}
}
if (!PubTools.isNull(memoSS)){
String[] ckgFree=memoSS.split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
memoDb += PubTools.GetHex(r);
}
}
whiteAccountText.setDicname(params.get("dicname").toString());
whiteAccountText.setDiscrp(params.get("discrp").toString());
whiteAccountText.setMemo(memoDb);
Map<String,Object> paramsQuery=new HashMap<String,Object>();
paramsQuery.put("memo",whiteAccountText.getMemo());
List<WhiteCarnoDic> whiteCarnoList1 = whiteCarnoDicMapper.getWhiteCarnoDicList(paramsQuery);
if(whiteCarnoList1.size()>0){
return -2;//字典表中存在该信息!
}
ret= whiteCarnoDicMapper.insert(whiteAccountText);
}catch (Exception e){
LogUtil.WriteLog_Error("新增自定义白名单出错:"+e.getMessage(),"WhiteCarnoDicSeviceImpl");
throw new Exception(e);
}
return ret;
}
@Override
public int batchDelDatas(Object params) throws Exception {
int ret=-1;
List<String> ids=new ArrayList<String>();
try{
if(!PubTools.isEmpty(params)){
if(params instanceof ArrayList){
List<Map<String,Object>> whiteAccount= (ArrayList<Map<String,Object>>) params;
if(whiteAccount.size()>0){
for(int i=0;i<whiteAccount.size();i++){
WhiteCarnoDic wcl=(WhiteCarnoDic)PubTools.map2Object(whiteAccount.get(i),WhiteCarnoDic.class);
ids.add(wcl.getMemo());
}
}
}else if(params instanceof JSONArray){
JSONArray json=(JSONArray)params;
if(json.size()>0){
for(int i=0;i<json.size();i++){
JSONObject jo=(JSONObject)json.get(i);
WhiteCarnoDic wcl= jo.toJavaObject(WhiteCarnoDic.class);
ids.add(wcl.getMemo());
}
}
}
}
if(ids.size()>0){
ret= whiteCarnoDicMapper.delDataById(ids);
}
}catch (Exception e){
throw new Exception(e);
}
return ret;
}
@Override
public List<WhiteCarnoDic> getWhiteCarnoDicList(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PubTools.getDBType());
List<WhiteCarnoDic> records = whiteCarnoDicMapper.getWhiteCarnoDicList(params);
return records;
}
}

@ -0,0 +1,416 @@
package com.nmgs.service.impl;
import cn.hutool.core.lang.UUID;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nmgs.entity.Consistent;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import com.nmgs.mapper.WhiteCarnoListMapper;
import com.nmgs.mapper.Mapper;
import com.nmgs.service.IWhiteCarnoListSerive;
import com.nmgs.service.ISelectData;
import com.nmgs.service.IWhiteCarnoLogService;
import com.nmgs.util.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
@Transactional(rollbackFor = Exception.class)
@Service
public class WhiteCarnoListSeriveImpl implements IWhiteCarnoListSerive {
@Autowired
public WhiteCarnoListMapper whiteCarnoListMapper;
@Autowired
public Mapper mapperI;
@Autowired
public ISelectData iSelectData;
IWhiteCarnoLogService iWhiteCarnoLogService;
@Autowired
public void setiWhiteCarnoLogService(IWhiteCarnoLogService iWhiteCarnoLogService) {
this.iWhiteCarnoLogService = iWhiteCarnoLogService;
}
SimpleDateFormat dateTimeFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public Page<WhiteCarnoList> getWhiteCarnoListByPage(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PubTools.getDBType());
//设置分页
Integer pageNum = (Integer) params.get("pageNum");
Integer pageSize = (Integer) params.get("pageSize");
String whiteOutTimeT = PropertiesUtil.getValue("WhiteOutTime");
params.put("CURRENTDATE",PubTools.getCurrentDate());
params.put("CURRENTWILLDATE",PubTools.getAddNumDate(Integer.parseInt(whiteOutTimeT)));
Page<WhiteCarnoList> page = new Page<>(pageNum,pageSize);
//到期数据条件需要做处理
if(!PubTools.isEmpty(params.get("SPROMPOTY"))){
String sprompoty = params.get("SPROMPOTY").toString();
if("2".equals(sprompoty)){//将到期,从配置文件获取距离结束日期 还有几天算将到期
String whiteOutTime = PropertiesUtil.getValue("WhiteOutTime");
params.put("WILLDATE",PubTools.getAddNumDate(Integer.parseInt(whiteOutTime)));
}else if("3".equals(sprompoty)){//已到期
params.put("WILLDATE",PubTools.getCurrentDate());
}else{
}
}
page = whiteCarnoListMapper.getWhiteCarnoListByPage(page,params);
/* //获取数据
List<WhiteCarnoList> records = page.getRecords();
//解析里面字典数据
for (WhiteCarnoList divOutPortDroad : records) {
divOutPortDroad.setVehicleClassName(iSelectData.getSelect("VECHECLASS", divOutPortDroad.getVehicleClass()+""));
divOutPortDroad.setVehicleTypeName(iSelectData.getSelect("VECHETYPE", divOutPortDroad.getVehicleType()+""));
divOutPortDroad.setVehicleColorName(iSelectData.getSelect("PLATECOLOR", divOutPortDroad.getVehicleColor()+""));
}
page.setRecords(records);*/
return page;
}
@Override
public int insertData(WhiteCarnoList whiteCarnoList) throws Exception {
int ret=-1;
try{
//先根据车牌号与颜色判断是否已经存在
Map<String,Object> params=new HashMap<String,Object>();
params.put("acarNo",whiteCarnoList.getAcarno());
params.put("color",whiteCarnoList.getColor());
List<WhiteCarnoList> whiteCarnoList1 = whiteCarnoListMapper.getWhiteCarnoList(params);
if(whiteCarnoList1.size()>0){
return -2;//白名单存在该信息!
}
whiteCarnoList.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
whiteCarnoList.setDt(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
String memoDb="";
if(!PubTools.isNull(whiteCarnoList.getQm()) && "1".equals(whiteCarnoList.getQm())){//免费类型:全免的话默认为零
memoDb="0000000000";
whiteCarnoList.setDiscrp("");
}else{
//免费路段处理
if (!PubTools.isNull(whiteCarnoList.getMfld())){
String[] ckgFree=whiteCarnoList.getMfld().split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
if (!PubTools.isNull(ckgFree[i]+"")){
//不足两位补0,
if (Integer.parseInt(ckgFree[i]+"") < 10){
memoDb += PubTools.GetHex("0" + ckgFree[i]+"" + "0" + ckgFree[i]+"" + "00" + "0" + ckgFree[i]+"" + "00");
}else if(Integer.parseInt(ckgFree[i]+"") < 100 && Integer.parseInt(ckgFree[i]+"")>=10){//两位的
memoDb += PubTools.GetHex(ckgFree[i]+"" + ckgFree[i]+"" + "00" + ckgFree[i]+"" + "00");
}else{
memoDb += PubTools.GetHex(ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2));
}
}
}
}
//免费站站组合
if (!PubTools.isNull(whiteCarnoList.getMfzzh())){
String[] ckgFree=whiteCarnoList.getMfzzh().split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
memoDb += PubTools.GetHex(r);
}
}
//自定义组合
if (!PubTools.isNull(whiteCarnoList.getZdyzh())){
String[] ckgFree=whiteCarnoList.getZdyzh().split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
memoDb += r;
}
}
}
whiteCarnoList.setMemo(memoDb);
ret= whiteCarnoListMapper.insert(whiteCarnoList);
if(ret>0){
WhiteCarnoLogTable wclt=new WhiteCarnoLogTable();
BeanUtils.copyProperties(whiteCarnoList,wclt,"id");
wclt.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
wclt.setOperdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setOpertype(Consistent.ADD);
wclt.setOpertypename(Consistent.ADD_NAME);
wclt.setIdbusiness(whiteCarnoList.getId());
iWhiteCarnoLogService.saveData(wclt);
}
}catch (Exception e){
LogUtil.WriteLog_Error("新增白名单出错:"+e.getMessage(),"WhiteCarnoListSeriveImpl");
throw new Exception(e);
}
return ret;
}
@Override
public int insertDataBatch(List<WhiteCarnoList> whiteCarnoList) throws Exception {
int ret=-1;
try{
ret= whiteCarnoListMapper.insertDataBatch(whiteCarnoList);
}catch (Exception e){
throw new Exception(e);
}
return ret;
}
@Override
public int batchDelDatas(Object params) throws Exception {
int ret=-1;
List<String> ids=new ArrayList<String>();
List<WhiteCarnoLogTable> listLog=new ArrayList<WhiteCarnoLogTable>();
try{
JSONArray json=new JSONArray();
if(!PubTools.isEmpty(params)){
if(params instanceof ArrayList){
List<Map<String,Object>> whiteCarnoList= (ArrayList<Map<String,Object>>) params;
if(whiteCarnoList.size()>0){
for(int i=0;i<whiteCarnoList.size();i++){
WhiteCarnoList wcl=(WhiteCarnoList)PubTools.map2Object(whiteCarnoList.get(i),WhiteCarnoList.class);
ids.add(wcl.getId());
WhiteCarnoLogTable wclt=new WhiteCarnoLogTable();
BeanUtils.copyProperties(wcl,wclt,"id");
wclt.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
wclt.setOperdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setOpertype(Consistent.DELETE);
wclt.setOpertypename(Consistent.DELETE_NAME);
wclt.setIdbusiness(wcl.getId());
listLog.add(wclt);
}
}
}else if(params instanceof JSONArray){
json=(JSONArray)params;
if(json.size()>0){
for(int i=0;i<json.size();i++){
JSONObject jo=(JSONObject)json.get(i);
WhiteCarnoList wcl= jo.toJavaObject(WhiteCarnoList.class);
ids.add(wcl.getId());
WhiteCarnoLogTable wclt=new WhiteCarnoLogTable();
BeanUtils.copyProperties(wcl,wclt,"id");
wclt.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
wclt.setOperdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setOpertype(Consistent.DELETE);
wclt.setOpertypename(Consistent.DELETE_NAME);
wclt.setIdbusiness(wcl.getId());
listLog.add(wclt);
}
}
}
}
if(ids.size()>0){
ret= whiteCarnoListMapper.delDataBatch(ids);
if(ret>0){
iWhiteCarnoLogService.saveBatch(listLog);
}
}
}catch (Exception e){
throw new Exception(e);
}
return ret;
}
@Override
public int updateById(WhiteCarnoList params) throws Exception {
int ret=-1;
try{
String memoDb="";
if(!PubTools.isNull(params.getQm()) && "1".equals(params.getQm())){//免费类型:全免的话默认为零
memoDb="0000000000";
}else{
//免费路段处理
if (!PubTools.isNull(params.getMfld())){
String[] ckgFree=params.getMfld().split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
if (!PubTools.isNull(ckgFree[i]+"")){
//不足两位补0,
if (Integer.parseInt(ckgFree[i]+"") < 10){
memoDb += PubTools.GetHex("0" + ckgFree[i]+"" + "0" + ckgFree[i]+"" + "00" + "0" + ckgFree[i]+"" + "00");
}else if(Integer.parseInt(ckgFree[i]+"") < 100 && Integer.parseInt(ckgFree[i]+"")>=10){//两位的
memoDb += PubTools.GetHex(ckgFree[i]+"" + ckgFree[i]+"" + "00" + ckgFree[i]+"" + "00");
}else{
memoDb += PubTools.GetHex(ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2)+ ckgFree[i].substring(0,2));
}
}
}
}
//免费站站组合
if (!PubTools.isNull(params.getMfzzh())){
String[] ckgFree=params.getMfzzh().split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
memoDb += PubTools.GetHex(r);
}
}
//自定义组合
if (!PubTools.isNull(params.getZdyzh())){
String[] ckgFree=params.getZdyzh().split(",");
for (int i = 0; i < ckgFree.length; i++){
String r = ckgFree[i]+"";
memoDb += r;
}
}
}
params.setMemo(memoDb);
ret= whiteCarnoListMapper.updateById(params);
WhiteCarnoLogTable wclt=new WhiteCarnoLogTable();
BeanUtils.copyProperties(params,wclt,"id");
wclt.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
wclt.setOperdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setOpertype(Consistent.UPDATE);
wclt.setOpertypename(Consistent.UPDATE_NAME);
wclt.setIdbusiness(params.getId());
iWhiteCarnoLogService.saveData(wclt);
}catch (Exception e){
throw new Exception(e);
}
return ret;
}
@Override
public List<WhiteCarnoList> getWhiteCarnoList(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PubTools.getDBType());
String whiteOutTimeT = PropertiesUtil.getValue("WhiteOutTime");
params.put("CURRENTDATE",PubTools.getCurrentDate());
params.put("CURRENTWILLDATE",PubTools.getAddNumDate(Integer.parseInt(whiteOutTimeT)));
//到期数据条件需要做处理
if(!PubTools.isEmpty(params.get("SPROMPOTY"))){
String sprompoty = params.get("SPROMPOTY").toString();
if("2".equals(sprompoty)){//将到期,从配置文件获取距离结束日期 还有几天算将到期
String whiteOutTime = PropertiesUtil.getValue("WhiteOutTime");
params.put("WILLDATE",PubTools.getAddNumDate(Integer.parseInt(whiteOutTime)));
}else if("3".equals(sprompoty)){//已到期
params.put("WILLDATE",PubTools.getCurrentDate());
}else{
}
}
List<WhiteCarnoList> records = whiteCarnoListMapper.getWhiteCarnoList(params);
//获取数据
//解析里面字典数据
/* for (WhiteCarnoList divOutPortDroad : records) {
divOutPortDroad.setVehicleClassName(iSelectData.getSelect("VECHECLASS", divOutPortDroad.getVehicleClass()+""));
divOutPortDroad.setVehicleTypeName(iSelectData.getSelect("VECHETYPE", divOutPortDroad.getVehicleType()+""));
divOutPortDroad.setVehicleColorName(iSelectData.getSelect("PLATECOLOR", divOutPortDroad.getColor()+""));
}*/
return records;
}
@Override
public int batchUpdateById(Map<String, Object> req) throws Exception {
try{
req.put("DBType",PubTools.getDBType());
if(!PubTools.isEmpty(req.get("id"))){
String[] ids = req.get("id").toString().split(",");
int i = whiteCarnoListMapper.batchUpdateById(ids, req);
if(i>0){
for(String str:ids){
Map<String,Object> params2=new HashMap<String,Object>();
params2.put("id",str);
List<WhiteCarnoList> whiteCarnoList1 = whiteCarnoListMapper.getWhiteCarnoList(params2);
WhiteCarnoList params = whiteCarnoList1.get(0);
WhiteCarnoLogTable wclt=new WhiteCarnoLogTable();
BeanUtils.copyProperties(params,wclt,"id");
wclt.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
wclt.setOperdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setOpertype(Consistent.UPDATE);
wclt.setOpertypename(Consistent.UPDATE_NAME);
wclt.setIdbusiness(params.getId());
wclt.setOpermano(req.get("opermano").toString());
wclt.setOpermaname(req.get("opermaname").toString());
iWhiteCarnoLogService.saveData(wclt);
}
}
return 1;
}
}catch (Exception e){
throw new Exception(e);
}
return -1;
}
@Override
public int getIOCount() {
String sql="select COUNT(1) from CARNO_TABLE where ACARNO like '%I%' or ACARNO like '%O%'";
List selectforlist = this.mapperI.selectforlist(sql);
return selectforlist.size();
}
@Override
public int publishVersion(Map<String, Object> req) throws Exception {
req.put("DBType",PubTools.getDBType());
int ret= this.whiteCarnoListMapper.publishVersion(req);
if(ret>-1){
WhiteCarnoLogTable wclt = new WhiteCarnoLogTable();
wclt.setId(UUID.randomUUID().toString().replace("-","").substring(0,32));
wclt.setOperdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setOpertype(Consistent.UPDATE_VERSION);
wclt.setOpertypename(Consistent.UPDATE_VERSION_NAME);
wclt.setIdbusiness("0000000000000");
wclt.setOpermano(req.get("opermano").toString());
wclt.setOpermaname(req.get("opermaname").toString());
wclt.setAcarno("版本更新");
wclt.setColor(1);
wclt.setBegdate(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setBegdt(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setEnddt(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setDescrib("为版本更新时产生的日志");
wclt.setDt(dateTimeFormatter.parse(dateTimeFormatter.format(new Date())));
wclt.setAccount(0);
wclt.setVerno(req.get("verno").toString());
iWhiteCarnoLogService.saveData(wclt);
}
return ret;
}
@Override
public Map<String,String> getVersion(Map<String, Object> req) throws Exception {
req.put("DBType",PubTools.getDBType());
String verN = "";
String oldVerno = "0";
Map<String,String> map=new HashMap<String,String>();
//获取当前时间
SimpleDateFormat sdf=new SimpleDateFormat("yyMMdd");
String nydm = sdf.format(new Date());
int newymd = Integer.parseInt(nydm);
if(PubTools.isEmpty(req)){
req=new HashMap<String, Object>();
}
req.put("whereSql"," t.VERNO !='0' and VERNO is not null");
List<WhiteCarnoList> whiteCarno = this.getWhiteCarno(req);
//获取老版本数据
if (whiteCarno.size() > 0 && !PubTools.isEmpty(whiteCarno.get(0))) {
if ( !PubTools.isNull(whiteCarno.get(0).getVerno()) && whiteCarno.get(0).getVerno().length() > 6) {
//获取老版本版本号
oldVerno =whiteCarno.get(0).getVerno();
//获取老版本时间
String oymd = oldVerno.substring(0, 6);
int oldymd = Integer.parseInt(oymd);
if (oldymd == newymd) {//当天更改的 每次加 1
int count = Integer.parseInt(oldVerno.substring(oldVerno.length() - 1));
int i = count + 1;
verN = nydm + (i+"");
}
else{
verN = (nydm + "1");
}
}
}
else{
verN = nydm + "1";
}
map.put("oldVerno",oldVerno);
map.put("verno",verN);
return map;
}
@Override
public List<WhiteCarnoList> getWhiteCarno(Map<String, Object> params) {
return this.whiteCarnoListMapper.getWhiteCarno(params);
}
}

@ -0,0 +1,47 @@
package com.nmgs.service.impl;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.nmgs.entity.WhiteCarnoList;
import com.nmgs.entity.WhiteCarnoLogTable;
import com.nmgs.entity.WhiteOperationLog;
import com.nmgs.mapper.WhiteCarnoLogMapper;
import com.nmgs.mapper.WhiteOperationLogMapper;
import com.nmgs.service.IOperationLogService;
import com.nmgs.service.IWhiteCarnoLogService;
import com.nmgs.util.PropertiesUtil;
import com.nmgs.util.PubTools;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
@Service
public class WhiteCarnoLogServiceImpl extends ServiceImpl<WhiteCarnoLogMapper,WhiteCarnoLogTable> implements IWhiteCarnoLogService {
WhiteCarnoLogMapper whiteOperationLogMapper;
@Autowired
public void setWhiteOperationLogMapper(WhiteCarnoLogMapper whiteOperationLogMapper) {
this.whiteOperationLogMapper = whiteOperationLogMapper;
}
@Override
public int saveData(WhiteCarnoLogTable operationLog) {
return whiteOperationLogMapper.insert(operationLog);
}
@Override
public Page<WhiteCarnoLogTable> getWhiteCarnoLogByPage(Map<String, Object> params) {
//从配置文件中读取数据库连接类型
params.put("DBTYPE", PubTools.getDBType());
//设置分页
Integer pageNum = (Integer) params.get("pageNum");
Integer pageSize = (Integer) params.get("pageSize");
Page<WhiteCarnoLogTable> page = new Page<>(pageNum,pageSize);
page = whiteOperationLogMapper.getWhiteCarnoLogByPage(page,params);
return page;
}
}

@ -0,0 +1,121 @@
package com.nmgs.util;
import java.io.UnsupportedEncodingException;
public class CRCUtil {
private static String[] Crc32Table2;
private static long[] Crc32Table = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
static void initCrcTable() {
long Crc = 0;
long UlPolynomial = 0x04C11DB7L;
long bb = 0x80000000L;
Crc32Table = new long[256];
for (int i = 0; i < 256; i++) {
Crc32Table[i] = CRC_Reflect(i, 8) << 24L;
for (int j = 0; j < 8; j++) {
if ((Crc32Table[i] & bb) > 0)
Crc32Table[i] = (Crc32Table[i] << 1L) ^ UlPolynomial;
else
Crc32Table[i] = (Crc32Table[i] << 1L);
}
Crc32Table[i] = CRC_Reflect(Crc32Table[i], 32);
}
}
static long CRC_Reflect(long refValue, int ch) {
long Value = 0L;
for (int i = 0; i < ch; i++) {
if ((refValue & 1L) > 0)
Value = Value | (1L << (ch - i - 1));
refValue = refValue >> 1L;
}
return Value;
}
public static int CRC_AddData(long InitCRC, String crcStr) {
initCrcTable();
byte[] Txt = new byte[0];
try {
Txt = crcStr.getBytes("gb2312");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("以gb2312编码获取byte[]失败CRC加密失败");
}
int ten = Txt.length;
for (int i = 0; i < ten; i++) {
int aa = Txt[i];
while (aa < 0) {
aa = 256 + aa;
}
InitCRC = ((InitCRC >> 8) ^ Crc32Table[(int) ((InitCRC & 0xFF) ^ aa)]);
}
return (int)InitCRC;
}
}

@ -0,0 +1,185 @@
package com.nmgs.util;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.io.*;
import java.security.Key;
import java.util.Base64;
public class DESUtil {
/**
* 8
*/
private final static String IV_PARAMETER = "12345678";
/**
*
*/
private static final String ALGORITHM = "DES";
/**
* /--
*/
private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
/**
*
*/
private static final String CHARSET = "utf-8";
/**
*
*/
private static final String PASSWORD = "58612911";
/**
* key
*
* @param password
* @return
* @throws Exception
*/
private static Key generateKey(String password) throws Exception {
DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
return keyFactory.generateSecret(dks);
}
/**
* DES
*
* @param data
* @return
*/
public static String encrypt( String data) {
String password=PASSWORD;
if (password== null || password.length() < 8) {
throw new RuntimeException("加密失败key不能小于8位");
}
if (data == null)
return null;
try {
Key secretKey = generateKey(password);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
byte[] rgbiv={0x12,0x34,0x56,0x78, (byte) 0x90, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF};
// IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
IvParameterSpec iv = new IvParameterSpec(rgbiv);
cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
//JDK1.8及以上可直接使用Base64JDK1.7及以下可以使用BASE64Encoder
//Android平台可以使用android.util.Base64
// return new String(Base64.getEncoder().encode(bytes));
return new String(Base64.getEncoder().encode(bytes));
} catch (Exception e) {
e.printStackTrace();
return data;
}
}
/**
* DES
*
* @param data
* @return
*/
public static String decrypt( String data) {
String password=PASSWORD;
if (password== null || password.length() < 8) {
throw new RuntimeException("加密失败key不能小于8位");
}
if (data == null)
return null;
try {
Key secretKey = generateKey(password);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
byte[] rgbiv={0x12,0x34,0x56,0x78, (byte) 0x90, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF};
// IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
IvParameterSpec iv = new IvParameterSpec(rgbiv);
cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
} catch (Exception e) {
e.printStackTrace();
return data;
}
}
/**
* DES
*
* @param srcFile
* @param destFile
* @return
*/
public static String encryptFile( String srcFile, String destFile) {
String password=PASSWORD;
if (password== null || password.length() < 8) {
throw new RuntimeException("加密失败key不能小于8位");
}
try {
IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, generateKey(password), iv);
InputStream is = new FileInputStream(srcFile);
OutputStream out = new FileOutputStream(destFile);
CipherInputStream cis = new CipherInputStream(is, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = cis.read(buffer)) > 0) {
out.write(buffer, 0, r);
}
cis.close();
is.close();
out.close();
return destFile;
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* DES
*
* @param srcFile
* @param destFile
* @return
*/
public static String decryptFile( String srcFile, String destFile) {
String password=PASSWORD;
if (password== null || password.length() < 8) {
throw new RuntimeException("加密失败key不能小于8位");
}
try {
File file = new File(destFile);
if (!file.exists()) {
file.getParentFile().mkdirs();
file.createNewFile();
}
IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, generateKey(password), iv);
InputStream is = new FileInputStream(srcFile);
OutputStream out = new FileOutputStream(destFile);
CipherOutputStream cos = new CipherOutputStream(out, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = is.read(buffer)) >= 0) {
cos.write(buffer, 0, r);
}
cos.close();
is.close();
out.close();
return destFile;
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
public static void main(String[] args) {
System.out.println(decrypt("vp98+kUHT48="));
}
}

@ -0,0 +1,175 @@
package com.nmgs.util;
import org.apache.commons.lang3.time.DateFormatUtils;
import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
*
*
* @author ruoyi
*/
public class DateUtils extends org.apache.commons.lang3.time.DateUtils
{
public static String YYYY = "yyyy";
public static String YYYY_MM = "yyyy-MM";
public static String YYYY_MM_DD = "yyyy-MM-dd";
public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
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"};
/**
* Date
*
* @return Date()
*/
public static Date getNowDate()
{
return new Date();
}
/**
* , yyyy-MM-dd
*
* @return String
*/
public static String getDate()
{
return dateTimeNow(YYYY_MM_DD);
}
public static final String getTime()
{
return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
}
public static final String dateTimeNow()
{
return dateTimeNow(YYYYMMDDHHMMSS);
}
public static final String dateTimeNow(final String format)
{
return parseDateToStr(format, new Date());
}
public static final String dateTime(final Date date)
{
return parseDateToStr(YYYY_MM_DD, date);
}
public static final String parseDateToStr(final String format, final Date date)
{
return new SimpleDateFormat(format).format(date);
}
public static final Date dateTime(final String format, final String ts)
{
try
{
return new SimpleDateFormat(format).parse(ts);
}
catch (ParseException e)
{
throw new RuntimeException(e);
}
}
/**
* // 2018/08/08
*/
public static final String datePath()
{
Date now = new Date();
return DateFormatUtils.format(now, "yyyy-MM-dd");
}
/**
* // 20180808
*/
public static final String dateTime()
{
Date now = new Date();
return DateFormatUtils.format(now, "yyyyMMdd");
}
/**
*
*/
public static Date parseDate(Object str)
{
if (str == null)
{
return null;
}
try
{
return parseDate(str.toString(), parsePatterns);
}
catch (ParseException e)
{
return null;
}
}
/**
*
*/
public static Date getServerStartDate()
{
long time = ManagementFactory.getRuntimeMXBean().getStartTime();
return new Date(time);
}
/**
*
*/
public static String getDatePoor(Date endDate, Date nowDate) {
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = diff % nd / nh;
// 计算差多少分钟
long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果
long sec = diff % nd % nh % nm / ns;
return day + "天" + hour + "小时" + min + "分钟" + sec + "秒";
}
public static String getDatePoorForMinSec(Date endDate, Date nowDate) {
long nm = 1000 * 60;
long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少分钟
long min = diff / nm;
// 计算差多少秒//输出结果
long sec = diff % nm / ns;
return min + "分钟" + sec + "秒";
}
public static long getDatePoorForSec(Date endDate, Date nowDate) {
long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少秒//输出结果
long sec = diff / ns;
return sec;
}
}

@ -0,0 +1,42 @@
package com.nmgs.util;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.support.ExcelTypeEnum;
import org.apache.commons.io.Charsets;
import org.springframework.http.HttpHeaders;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
public class ExcelUtil {
/**
* excel
* @param response http
* @param list list
* @param clazz
* @param fileNamePre
* @param sheetName sheet
* @throws IOException IO
*/
public static void exportExcel(HttpServletResponse response, List list, Class clazz, String fileNamePre, String sheetName) throws IOException {
// 导出时候会出现中文无法识别问题,需要转码
//String fileName = new String(fileNamePre.getBytes(Charsets.UTF_8), Charsets.ISO_8859_1);
String fileName = fileNamePre;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HHmmss");
Date date = new Date();
fileName = fileName + "_"+simpleDateFormat.format(date)+ ExcelTypeEnum.XLSX.getValue();
response.setContentType("application/vnd.ms-excel");
response.setCharacterEncoding("utf-8");
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, String.format("attachment; filename=%s", new String(URLEncoder.encode(fileName, Charsets.UTF_8.name())
.getBytes(Charsets.UTF_8), Charsets.ISO_8859_1)));
// 调用工具类
EasyExcel.write(response.getOutputStream(),clazz)
.excelType(ExcelTypeEnum.XLSX)
.sheet(sheetName)
.doWrite(list);
}
}

@ -0,0 +1,14 @@
package com.nmgs.util;
import java.io.PrintWriter;
import java.io.StringWriter;
public class ExceptionUtil {
public static String getExceptionStr(Exception e){
StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
e.printStackTrace(writer);
StringBuffer buffer = stringWriter.getBuffer();
return buffer.toString();
}
}

@ -0,0 +1,101 @@
package com.nmgs.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
public class IpUtil {
private static final Logger log = LoggerFactory.getLogger(IpUtil.class);
private IpUtil() {
}
public static String getIpAddr(HttpServletRequest request) {
String ipAddress;
try {
ipAddress = request.getHeader("x-forwarded-for");
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getRemoteAddr();
if ("127.0.0.1".equals(ipAddress)) {
InetAddress inet = null;
try {
inet = InetAddress.getLocalHost();
} catch (UnknownHostException var4) {
log.error(var4.getMessage(), var4);
}
ipAddress = ((InetAddress) Objects.requireNonNull(inet)).getHostAddress();
}
}
if (ipAddress != null && ipAddress.length() > 15 && ipAddress.indexOf(",") > 0) {
ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
}
} catch (Exception var5) {
ipAddress = "";
}
return ipAddress;
}
public static String getIpAddr() {
return getV4OrV6IP();
}
public static String getV4OrV6IP() {
String ip = null;
String test = "http://test.ipw.cn";
StringBuilder inputLine = new StringBuilder();
BufferedReader in = null;
try {
URL url = new URL(test);
HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
in = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), StandardCharsets.UTF_8));
String read;
while((read = in.readLine()) != null) {
inputLine.append(read);
}
ip = inputLine.toString();
} catch (Exception var16) {
log.error("获取网络IP地址异常这是具体原因: ", var16);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException var15) {
var15.printStackTrace();
}
}
}
if (ip == null) {
ip = "127.0.0.1";
log.info("获取网络IP地址异常, 赋值默认ip: 【{}】", ip);
}
return ip;
}
}

@ -0,0 +1,106 @@
package com.nmgs.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.Properties;
public class LogUtil {
public static void WriteLog_Info(String msg, String disStr) {
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd-HH");
String fileName = f.format(new Date()) + "_Info";
WriteLog(fileName, msg, disStr);
}
public static void WriteLog_Error(String msg, String disStr) {
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd-HH");
String fileName = f.format(new Date()) + "_Error";
WriteLog(fileName, msg, disStr);
}
private static void WriteLog(String suffix, String content, String disStr) {
try {
SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
Properties Newproperties = new Properties();
Newproperties.load(new FileInputStream((PathUtil.projectApplicationPath)));
String baseDir = PathUtil.TomcatPath + "/logs/" + Newproperties.getProperty("spring.logback.appName") + "/" + disStr + "/";
fileCreat(baseDir);
StringBuffer sb = new StringBuffer();
String str = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss SSS")) + "-->类【" + disStr + "】:";
sb.append(str);
sb.append(content);
sb.append("\r\n");
File logPathFile = new File(baseDir);
if (!logPathFile.isDirectory()) {
Boolean _f = logPathFile.mkdir();
}
String fileDic = format.format(new Date());
File filedir = new File(baseDir + fileDic);
if (!filedir.isDirectory()) {
filedir.mkdir();
File[] fs = logPathFile.listFiles();
LocalDateTime now = LocalDateTime.now();
int delFlag = Integer.parseInt(now.minus(7, ChronoUnit.DAYS).format(DateTimeFormatter.ofPattern("yyyyMMdd")));
if (fs != null) {
for (File f : fs) {
int deldir = Integer.parseInt(f.getName());
if (deldir < delFlag) {
if (f.isDirectory()) {
deleteDirectory(f);
}
}
}
}
}
String fullFilePath = baseDir + fileDic + "/" + suffix + ".txt";
try (RandomAccessFile reader = new RandomAccessFile(new File(fullFilePath), "rw");
) {
// FileLock lock1 = reader.getChannel().lock()
reader.seek(reader.length());
reader.write(sb.toString().getBytes());
} catch (IOException e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
} catch (Exception exception) {
exception.printStackTrace();
System.out.println(exception.getMessage());
}
}
private static void deleteDirectory(File file) {
if (file.isFile()) {// 表示该文件不是文件夹
file.delete();
} else {
// 首先得到当前的路径
String[] childFilePaths = file.list();
for (String childFilePath : childFilePaths) {
File childFile = new File(file.getAbsolutePath() + "/" + childFilePath);
deleteDirectory(childFile);
}
file.delete();
}
}
public static void fileCreat(String path) {
File file = new File(path);
if (!file.isDirectory()) {
file.mkdirs();
}
}
}

@ -0,0 +1,62 @@
package com.nmgs.util;
import java.text.Normalizer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class LogUtils {
public static final String LOG_APP_USER = "AppUser";
public static final String LOG_APP_DEBUG = "AppDebug";
public static final String LOG_SECURITY = "Sec";
public static final String LOG_DATA = "Data";
public static final String SQL_MSG = "SqlMsg";
public static Logger getAppLog() {
Logger log = LogManager.getLogger("AppUser");
return log;
}
public static Logger getAppDebugLog() {
Logger log = LogManager.getLogger("AppDebug");
return log;
}
public static Logger getSecLog() {
Logger log = LogManager.getLogger("Sec");
return log;
}
public static Logger getDataLog() {
Logger log = LogManager.getLogger("Data");
return log;
}
public static Logger getSqlLog() {
Logger log = LogManager.getLogger("SqlMsg");
return log;
}
public static Logger getLog(String moduleName) {
Logger log = LogManager.getLogger(moduleName);
return log;
}
public static String filterLogForging(String str) {
List<String> sensitiveStr = new ArrayList();
sensitiveStr.add("%0d");
sensitiveStr.add("%0a");
sensitiveStr.add("%0A");
sensitiveStr.add("%0D");
sensitiveStr.add("\r");
sensitiveStr.add("\n");
String normalize = Normalizer.normalize(str, Normalizer.Form.NFKC);
Iterator<String> iterator = sensitiveStr.iterator();
while (iterator.hasNext()) {
normalize.replace((CharSequence) iterator.next(), "");
}
return normalize;
}
}

@ -0,0 +1,40 @@
package com.nmgs.util;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.ArrayList;
import java.util.List;
public class PagesUtils {
public static Page getPages(Integer currentPage, Integer pageSize, List list) {
Page page = new Page();
if (list.size() > 0) {
int size = list.size();
if (pageSize > size) {
pageSize = size;
}
// 求出最大页数防止currentPage越界
int maxPage = size % pageSize == 0 ? size / pageSize : size / pageSize + 1;
if (currentPage > maxPage) {
currentPage = maxPage;
}
// 当前页第一条数据的下标
int curIdx = currentPage > 1 ? (currentPage - 1) * pageSize : 0;
List pageList = new ArrayList();
// 将当前页的数据放进pageList
for (int i = 0; i < pageSize && curIdx + i < size; i++) {
pageList.add(list.get(curIdx + i));
}
page.setCurrent(currentPage).setSize(pageSize).setTotal(list.size()).setRecords(pageList);
}
return page;
}
}

@ -0,0 +1,139 @@
package com.nmgs.util;
import org.springframework.util.ClassUtils;
import java.io.UnsupportedEncodingException;
import java.net.*;
import java.util.Enumeration;
import java.util.Properties;
public class PathUtil {
public static String TomcatPath = System.getProperty("catalina.home");
public static String webappsPath = "";
public static String applicationPath = "";
public static String applicationTextPath = "";
public static String projectApplicationPath;
public static String webPath = "";
public static String websockifyPath = "";
public static String noVNCPath = "";
public static boolean isWin = false;
static {
try {
projectApplicationPath = URLDecoder.decode(ClassUtils.getDefaultClassLoader().getResource("").getPath(), "UTF-8") + "static/application.properties";
websockifyPath = URLDecoder.decode(ClassUtils.getDefaultClassLoader().getResource("").getPath(), "UTF-8") + "static/websockify";
noVNCPath = URLDecoder.decode(ClassUtils.getDefaultClassLoader().getResource("").getPath(), "UTF-8") + "static/noVNC";
webPath = URLDecoder.decode(ClassUtils.getDefaultClassLoader().getResource("").getPath(), "UTF-8") + "static";
} catch (UnsupportedEncodingException e) {
projectApplicationPath = ClassUtils.getDefaultClassLoader().getResource("").getPath() + "static/application.properties";
webPath = ClassUtils.getDefaultClassLoader().getResource("").getPath() + "static";
websockifyPath = ClassUtils.getDefaultClassLoader().getResource("").getPath() + "static/websockify";
noVNCPath = ClassUtils.getDefaultClassLoader().getResource("").getPath() + "static/noVNC";
}
}
public static String uploadPath = "";
public static String uploadWarPath = "";
public static String downloadWarPath = "";
public static String hostAddress;
public static String WebServiceWarPath;
public static String tomcatUserXMLPath;
public static String webName = "/noVNC";
static {
Properties props = System.getProperties();
String os = props.getProperty("os.name").toLowerCase();
if (os.startsWith("win")) {
isWin = true;
// TomcatPath = System.getProperty("user.dir").substring(0, System.getProperty("user.dir").lastIndexOf('\\'));
webappsPath = TomcatPath + "\\webapps";
uploadPath = TomcatPath + "\\uploadfiles";
uploadWarPath = TomcatPath + "\\taskWarFiles\\uploadWarFile";
downloadWarPath = TomcatPath + "\\taskWarFiles\\downloadWarFile";
webPath = webPath.substring(1, webPath.length()) + webName;
} else {
webappsPath = TomcatPath + "/webapps";
uploadPath = TomcatPath + "/uploadfiles";
uploadWarPath = TomcatPath + "/taskWarFiles/uploadWarFile";
downloadWarPath = TomcatPath + "/taskWarFiles/downloadWarFile";
webPath = webPath + webName;
}
applicationPath = webappsPath + "/application.properties";
applicationTextPath = webappsPath + "/applicationText.properties";
WebServiceWarPath = TomcatPath + "/WebServiceWar";
tomcatUserXMLPath = TomcatPath + "/conf/tomcat-users.xml";
// hostAddress = Inet4Address.getLocalHost().getHostAddress();
hostAddress = String.valueOf(getInet4Address());
if(isWin){
if (hostAddress.charAt(0) == '/' || hostAddress.charAt(0) == '\\') {
hostAddress = hostAddress.substring(1);
}
if (applicationPath.charAt(0) == '/' || applicationPath.charAt(0) == '\\') {
applicationPath = applicationPath.substring(1);
}
if (applicationTextPath.charAt(0) == '/' || applicationTextPath.charAt(0) == '\\') {
applicationTextPath = applicationTextPath.substring(1);
}
if (projectApplicationPath.charAt(0) == '/' || projectApplicationPath.charAt(0) == '\\') {
projectApplicationPath = projectApplicationPath.substring(1);
}
if (noVNCPath.charAt(0) == '/' || noVNCPath.charAt(0) == '\\') {
noVNCPath = noVNCPath.substring(1);
}
if (websockifyPath.charAt(0) == '/' || websockifyPath.charAt(0) == '\\') {
websockifyPath = websockifyPath.substring(1);
}
}
/*
*/
}
public static InetAddress getInet4Address() {
try {
//获取所有网络接口
Enumeration<NetworkInterface> allNetworkInterfaces = NetworkInterface.getNetworkInterfaces();
//遍历所有网络接口
for (; allNetworkInterfaces.hasMoreElements(); ) {
NetworkInterface networkInterface = allNetworkInterfaces.nextElement();
//如果此网络接口为 回环接口 或者 虚拟接口(子接口) 或者 未启用 或者 描述中包含VM
if (networkInterface.isLoopback() || networkInterface.isVirtual() || !networkInterface.isUp() || networkInterface.getDisplayName().contains("VM")) {
//继续下次循环
continue;
}
//如果不是Intel与Realtek的网卡
// if(!(networkInterface.getDisplayName().contains("Intel"))&&!(networkInterface.getDisplayName().contains("Realtek"))){
// //继续下次循环
// continue;
// }
//遍历此接口下的所有IP因为包括子网掩码各种信息
for (Enumeration<InetAddress> inetAddressEnumeration = networkInterface.getInetAddresses(); inetAddressEnumeration.hasMoreElements(); ) {
InetAddress inetAddress = inetAddressEnumeration.nextElement();
//如果此IP不为空
if (inetAddress != null) {
//如果此IP为IPV4 则返回
if (inetAddress instanceof Inet4Address) {
return inetAddress;
}
/*
// -------这样判断IPV4更快----------
if(inetAddress.getAddress().length==4){
return inetAddress;
}
*/
}
}
}
return null;
} catch (SocketException e) {
e.printStackTrace();
return null;
}
}
}

@ -0,0 +1,34 @@
package com.nmgs.util;
public class PlateRegexutil {
public static boolean isregex (String plateid) {
String start = "(" +
"京|津|冀|晋|蒙|辽|吉|黑|沪|苏|浙|皖|闽|赣|鲁|" +
"豫|鄂|湘|粤|桂|琼|渝|川|贵|云|藏|陕|甘|青|宁|" +
"新|港|澳|" +
"军|空|海|北|沈|兰|济|南|广|成|临" +
")";
String regex[] = {
start + "[a-zA-Z]{1}[a-zA-Z0-9]{6}", //新能源车牌
start + "[a-zA-Z]{1}[a-zA-Z0-9]{5}", //常规车牌
start + "[a-zA-Z]{1}[a-zA-Z0-9]{4}(警|使|学|挂|领|港|澳|超|临)", //常规特种车牌
"(WJ)[0-9]{2}[a-zA-Z0-9]{5}", //武警普通
"(WJ)[0-9]{2}(消|边|通|森|金|警|电)[a-zA-Z0-9]{4}", //武警特种
"(WJ)[a-zA-Z0-9]{1}[a-zA-Z0-9]{5}",
"(WJ)[0-9]{2}(消|边|通|森|金|警|电|[a-zA-Z0-9])[a-zA-Z0-9]{4}", //武警(综合)
"(WJ)(消|边|通|森|金|警|电|[a-zA-Z0-9])[a-zA-Z0-9]{5}",
start + "[a-zA-Z]{1}[a-zA-Z0-9]{4}(警|使|学|挂|领|港|澳|超|临|[a-zA-Z0-9])"//常规(综合)
};
//总综合
// regex = new String[]{"(" + start + "[a-zA-Z]{1}[a-zA-Z0-9]{4}(警|使|学|挂|领|港|澳|超|临|[a-zA-Z0-9]))|((WJ)[0-9]{2}(消|边|通|森|金|警|电|[a-zA-Z0-9])[a-zA-Z0-9]{4})"};
boolean relseltflag=false;
for (int j = 0; j < regex.length; j++) {
if (plateid.matches(regex[j])) {
relseltflag= true;
}
}
return relseltflag;
}
}

@ -0,0 +1,345 @@
package com.nmgs.util;
import java.io.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
public class PropertiesUtil {
public static String getValue(String key) {
String path = PathUtil.applicationPath;
FileInputStream fIn = null;
InputStreamReader in = null;
try {
// File updateFile = new File(path);
Properties properties = new Properties();
// BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(path), "gb2312"));
fIn = new FileInputStream(path);
in = new InputStreamReader(fIn, "UTF-8");
BufferedReader bf = new BufferedReader(in);
properties.load(bf);
return properties.getProperty(key);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fIn != null) {
fIn.close();
}
if (in != null) {
in.close();
}
} catch (Exception e) {
}
}
return "";
}
//目标文件
public File file;
//目标路径
public String path;
//默认字符编码
public String charset = "UTF-8";
//文件的每一行
public String[] lines;
//注释符
public static final String ANNOTATION_CHAR = "#";
public PropertiesUtil(File file) throws IOException {
this.file = file;
this.lines = getFileLines(file);
}
public PropertiesUtil(String path) throws IOException {
this.path = path;
this.lines = getFileLines(path);
}
/*
*
*
* @param key
* @return: java.lang.String
*/
public String get(String key) {
for (String line : lines) {
if (hasKey(line, key)) {
return getLineValue(line);
}
}
return null;
}
/**
*
*
* @param key
* @param value
* @param descriptions
* @return: boolean
*/
public boolean add(String key, String value, String... descriptions) {
List<String> lineList = new ArrayList<>(Arrays.asList(lines));
for (String description : descriptions) {
lineList.add(ANNOTATION_CHAR + description);
}
lineList.add(key.trim() + "=" + value.trim());
return commit(lineList.toArray(new String[0]));
}
/**
*
*
* @param key
* @param value
* @return: boolean
*/
public boolean set(String key, String value) {
boolean isHave = false;
for (int i = 0; i < lines.length; i++) {
if (hasKey(lines[i], key)) {
isHave = true;
lines[i] = key + "=" + value;
}
}
if (!isHave) {
add(key, value);
}
return commit(lines);
}
/**
*
*
* @param key
* @param value
* @return: boolean
*/
public boolean set(String key, String value, String... descriptions) {
boolean isHave = false;
for (int i = 0; i < lines.length; i++) {
if (hasKey(lines[i], key)) {
isHave = true;
lines[i] = key + "=" + value;
List<String> lineList = new ArrayList<>(Arrays.asList(lines));
for (String description : descriptions) {
while (1 == 1) {
if (i - 1 >= 0 && lineList.get(i - 1).toString().contains("#")) {
lineList.remove(i - 1);
i = i - 1;
} else {
break;
}
}
lineList.add(i, ANNOTATION_CHAR + description);
}
lines = lineList.toArray(new String[0]);
break;
}
}
if (!isHave) {
add(key, value, descriptions);
}
return commit(lines);
}
/*
*
*
* @param key
* @return: boolean
*/
public boolean delete(String key) {
List<String> lineList = new ArrayList<>(Arrays.asList(lines));
lineList.removeIf(line -> hasKey(line, key));
return commit(lineList.toArray(new String[0]));
}
/*
*
*
* @param lines
* @return: boolean
*/
public boolean commit(String[] lines) {
synchronized (this) {
this.lines = lines;
try (BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset))) {
StringBuilder data = new StringBuilder();
for (String line : lines) {
data.append(line).append('\n');
}
bufferedWriter.write(data.toString());
return true;
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}
/*
* key
*
* @param line
* @return: java.lang.String
*/
public String getLineKey(String line) {
return line.substring(0, line.indexOf('=')).trim();
}
/**
* value
*
* @param line
* @return: java.lang.String
*/
public String getLineValue(String line) {
return line.substring(line.indexOf('=') + 1).trim();
}
/**
* ( # = ) true false
*
* @return: boolean
*/
public boolean isValidLine(String line) {
return !line.trim().startsWith("#") && line.contains("=");
}
/**
* key
*
* @param line
* @param key
* @return: boolean
*/
public boolean hasKey(String line, String key) {
return isValidLine(line) && key.equals(getLineKey(line));
}
public boolean hasKey(String key) {
List<String> lineList = new ArrayList<>(Arrays.asList(lines));
for (int i = 0; i < lineList.size(); i++) {
String line = lineList.get(i);
if (hasKey(line, key)) {
return true;
}
if (i == lineList.size() - 1) {
return false;
}
}
return false;
}
/**
*
*
* @param file
* @return: java.lang.String[]
*/
public String[] getFileLines(File file) {
try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), charset));) {
String line;
List<String> lines = new ArrayList<>();
while ((line = bufferedReader.readLine()) != null) {
lines.add(line);
}
return lines.toArray(new String[0]);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* resource resourceIOException
*
* @param path
* @return: java.lang.String[]
*/
public String[] getFileLines(String path) throws IOException {
File file = new File(path);
if (file.isFile()) {
this.file = file;
return getFileLines(file);
} else {
URL url = getClass().getClassLoader().getResource(path);
if (url == null) {
throw new FileNotFoundException("resource path is not found");
}
file = new File(url.getPath());
if (file.isFile()) {
this.file = file;
return getFileLines(file);
} else {
throw new FileNotFoundException("properties file is not found");
}
}
}
// Type conversion
public boolean getBoolean(String key) {
return Boolean.parseBoolean(get(key));
}
public int getInt(String key) {
return Integer.parseInt(get(key));
}
public float getFloat(String key) {
return Float.parseFloat(get(key));
}
public double getDouble(String key) {
return Double.parseDouble(get(key));
}
public short getShort(String key) {
return Short.parseShort(get(key));
}
public long getLong(String key) {
return Long.parseLong(get(key));
}
//getter and setter
public File getFile() {
return file;
}
public void setFile(File file) {
this.file = file;
}
public String getCharset() {
return charset;
}
public void setCharset(String charset) {
this.charset = charset;
}
public String[] getLines() {
return lines;
}
public void setLines(String[] lines) {
this.lines = lines;
}
}

@ -0,0 +1,209 @@
package com.nmgs.util;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
public class PubTools {
static SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
*
* yyp 20190305
* @param anObject
* @return true :false:
*/
public static boolean isNull(String anObject ) {
if(null==anObject||"".equals(anObject)||"null".equals(anObject)){
return true;
}else{
return false;
}
}
public static boolean isEmpty(Object anObject ) {
if (anObject == null) return true;
else if (anObject instanceof CharSequence) return ((CharSequence) anObject).length() == 0;
else if (anObject instanceof Collection) return ((Collection) anObject).isEmpty();
else if (anObject instanceof Map) return ((Map) anObject).isEmpty();
//else if (anObject.getClass().isArray()) return Array.getLength(anObject) == 0;
return false;
}
/**
*
*
* @param IDCard
* @return
*/
public static Integer getAge(String IDCard) {
String age ="0";
Calendar cal = Calendar.getInstance();
int yearNow = cal.get(Calendar.YEAR);
int monthNow = cal.get(Calendar.MONTH)+1;
int dayNow = cal.get(Calendar.DATE);
String IDCardNew=((IDCard.length()==15)?IDCard.substring(0, 6)+"19"+IDCard.substring(6)+"0":IDCard);
System.out.println("IDCardNew==="+IDCardNew);
int year = Integer.valueOf(IDCardNew.substring(6,10));
int month = Integer.valueOf(IDCard.substring(10,12));
int day = Integer.valueOf(IDCard.substring(12,14));
System.out.println("year==="+year+"====month==="+month+"====day==="+day);
if ((month < monthNow) || (month == monthNow && day<= dayNow) ){
age = String.valueOf(yearNow - year);
}else {
age = String.valueOf(yearNow - year-1);
}
return Integer.parseInt(age);
}
public static JSONArray revertList(JSONObject json){
JSONArray listArray=new JSONArray();
listArray.add(json);
return listArray;
}
public static String getCurrentDate(){
return df.format(new Date());
}
//查询新增num天之后的日期
public static String getAddNumDate(int b){
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_YEAR, b); // 将日期向后推2天
Date date = calendar.getTime();
return df.format(date);
}
public static double doubleSave1(double number) {
BigDecimal bd = BigDecimal.valueOf(number);
bd = bd.setScale(3, BigDecimal.ROUND_HALF_UP);
double roundedNumber = bd.doubleValue();
return roundedNumber;
}
public static double doubleSave2(double number) {
BigDecimal bd = BigDecimal.valueOf(number);
bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP);
double roundedNumber = bd.doubleValue();
return roundedNumber;
}
public static void main(String[] args) {
System.out.println(PubTools.doubleSave1(60.0098));
}
/**
* Map
*
* @param map
* @param clazz
* @return
*/
public static Object map2Object(Map<String, Object> map, Class<?> clazz) {
if (map == null) {
return null;
}
Object obj = null;
try {
obj = clazz.newInstance();
Field[] fields = obj.getClass().getDeclaredFields();
for (Field field : fields) {
int mod = field.getModifiers();
if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
continue;
}
String name = field.getType().getName();
field.setAccessible(true);
if(!PubTools.isEmpty(map.get(field.getName()))){
switch(name){
case "int":
if(map.get(field.getName()) instanceof String){
field.set(obj, Integer.parseInt(map.get(field.getName()).toString()));
}else if(map.get(field.getName()) instanceof Object){
field.set(obj, (Integer)(map.get(field.getName())));
}
break;
case "java.util.Date":
field.set(obj, df.parse(map.get(field.getName()).toString()));
break;
default:
field.set(obj, map.get(field.getName()).toString());
break;
}
}else{
if("java.lang.String".equals(name)){
field.set(obj, "");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return obj;
}
//车牌号校验
public static boolean isregex (String plateid) {
String start = "(" +
"京|津|冀|晋|蒙|辽|吉|黑|沪|苏|浙|皖|闽|赣|鲁|" +
"豫|鄂|湘|粤|桂|琼|渝|川|贵|云|藏|陕|甘|青|宁|" +
"新|港|澳|" +
"军|空|海|北|沈|兰|济|南|广|成|临" +
")";
String regex[] = {
start + "[a-zA-Z]{1}[a-zA-Z0-9]{6}", //新能源车牌
start + "[a-zA-Z]{1}[a-zA-Z0-9]{5}", //常规车牌
start + "[a-zA-Z]{1}[a-zA-Z0-9]{4}(警|使|学|挂|领|港|澳|超|临)", //常规特种车牌
"(WJ)[0-9]{2}[a-zA-Z0-9]{5}", //武警普通
"(WJ)[0-9]{2}(消|边|通|森|金|警|电)[a-zA-Z0-9]{4}", //武警特种
"(WJ)[a-zA-Z0-9]{1}[a-zA-Z0-9]{5}",
"(WJ)[0-9]{2}(消|边|通|森|金|警|电|[a-zA-Z0-9])[a-zA-Z0-9]{4}", //武警(综合)
"(WJ)(消|边|通|森|金|警|电|[a-zA-Z0-9])[a-zA-Z0-9]{5}",
start + "[a-zA-Z]{1}[a-zA-Z0-9]{4}(警|使|学|挂|领|港|澳|超|临|[a-zA-Z0-9])"//常规(综合)
};
//总综合
// regex = new String[]{"(" + start + "[a-zA-Z]{1}[a-zA-Z0-9]{4}(警|使|学|挂|领|港|澳|超|临|[a-zA-Z0-9]))|((WJ)[0-9]{2}(消|边|通|森|金|警|电|[a-zA-Z0-9])[a-zA-Z0-9]{4})"};
if(plateid.equals("00000000")){
return true;
}
boolean relseltflag=false;
for (int j = 0; j < regex.length; j++) {
if (plateid.matches(regex[j])) {
relseltflag= true;
}
}
return relseltflag;
}
public static String getDBType(){
return PropertiesUtil.getValue("DBType");
}
public static String GetHex(Object o)
{
String r = "", s1 = "", s2 = "";
String s = o.toString();
if (s.length() >= 10)
{
r = "00" + Integer.toHexString(Integer.parseInt(s.substring(0, 2)));
s1 = "0000" + Integer.toHexString(Integer.parseInt(s.substring(2, 6)));
s2 = "0000" + Integer.toHexString(Integer.parseInt(s.substring(6, 10)));
r = r.substring(r.length() - 2, r.length());
s1 = s1.substring(s1.length() - 4, s1.length());
s2 = s2.substring(s2.length() - 4, s2.length());
}
return r + s1 + s2;
}
}

@ -0,0 +1,142 @@
package com.nmgs.util;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ReadExcel {
private final static String excel2003L = ".xls"; //2003- 版本的excel
private final static String excel2007U = ".xlsx"; //2007+ 版本的excel
/**
* Excel
*/
public static List<Map<String,Object>> getBankListByExcel(InputStream in, String fileName, int index) throws Exception {
List<Map<String,Object>> list = null;
//创建Excel工作薄
Workbook work = getWorkbook(in, fileName);
FormulaEvaluator evaluator=work.getCreationHelper().createFormulaEvaluator();
if (null == work) {
throw new Exception("创建Excel工作薄为空");
}
Sheet sheet = null;
Row row = null;
Cell cell = null;
list = new ArrayList<>();
//遍历Excel中所有的sheet
for (int i = 0; i < work.getNumberOfSheets(); i++) {
sheet = work.getSheetAt(i);
if (sheet == null) {
continue;
}
//遍历当前sheet中的所有行
//包涵头部,所以要小于等于最后一列数,这里也可以在初始值加上头部行数,以便跳过头部
for (int j = sheet.getFirstRowNum() + 1; j <= sheet.getLastRowNum(); j++) {
Map<String,Object> map=new HashMap<>();
//读取一行
row = sheet.getRow(j);
//去掉空行和表头
if (row == null || row.getFirstCellNum() == j) {
continue;
}
//遍历所有的列
List<Object> li = new ArrayList<>();
Boolean b = true;
if(j+1==1577){
System.out.println("aaa");
}
for (int y = row.getFirstCellNum(); y < index; y++) {
cell = row.getCell(y);
if ("".equals(getCellValue(cell,evaluator)) && y == row.getFirstCellNum()) {
b = false;
break;
}
li.add(getCellValue(cell,evaluator));
}
if (b) {
map.put("rowIndex",j+1);
map.put("list",li);
list.add(map);
}
}
}
return list;
}
/**
*
*/
public static Workbook getWorkbook(InputStream inStr, String fileName) throws Exception {
Workbook wb = null;
String fileType = fileName.substring(fileName.lastIndexOf("."));
if (excel2003L.equals(fileType)) {
wb = new HSSFWorkbook(inStr); //2003-
} else if (excel2007U.equals(fileType)) {
wb = new XSSFWorkbook(inStr); //2007+
} else {
throw new RuntimeException("Excel版本错误");
}
return wb;
}
/**
*
*/
public static Object getCellValue(Cell cell,FormulaEvaluator evaluator) {
Object value = null;
DecimalFormat df = new DecimalFormat("0"); //格式化字符类型的数字
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); //日期格式化
SimpleDateFormat sdf2 = new SimpleDateFormat(DateUtils.YYYY_MM_DD_HH_MM_SS); //日期格式化
DecimalFormat df2 = new DecimalFormat("0.00"); //格式化数字
if (cell == null) {
value = "";
return value;
}
switch (cell.getCellType()) {
case STRING:
value = cell.getRichStringCellValue().getString().replace("","").replace("\n","").trim();
break;
case NUMERIC:
System.out.println(cell.getCellStyle().getDataFormatString());
if ("General".equals(cell.getCellStyle().getDataFormatString())) {
value = cell.getNumericCellValue();
} else if ("m\\/d\\/yyyy".equals(cell.getCellStyle().getDataFormatString())) {
value = cell.getDateCellValue();
} else if ("m/d/yy".equals(cell.getCellStyle().getDataFormatString())) {
value = cell.getDateCellValue();
} else if ("yyyy/m/d;@".equals(cell.getCellStyle().getDataFormatString())) {
value = cell.getDateCellValue();
} else if ("yyyy-m-d hh:mm:ss".equals(cell.getCellStyle().getDataFormatString())) {
value = cell.getDateCellValue();
} else if ("yyyy\\-m\\-d\\ hh:mm:ss".equals(cell.getCellStyle().getDataFormatString())) {
value = cell.getDateCellValue();
} else {
value = cell.getNumericCellValue();
}
break;
case BOOLEAN:
value = cell.getBooleanCellValue();
break;
case BLANK:
value = "";
break;
case FORMULA:
value = evaluator.evaluate(cell).getStringValue().replace("","").replace("\n","").trim();
break;
default:
break;
}
return value;
}
}

@ -0,0 +1,95 @@
package com.nmgs.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import lombok.extern.slf4j.Slf4j;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
@Slf4j
public class TokenUtil {
/**
* token
*/
private static final String TOKEN_SECRET = "apiManager";
/**
*
*/
private static final long EXPIRE_DATE = 30 * 60 * 100000;
public static String token(String secreteKey) {
String token = "";
try {
//过期时间
Date date = new Date(System.currentTimeMillis() + EXPIRE_DATE);
//秘钥及加密算法
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
//设置头部信息
Map<String, Object> header = new HashMap<>();
header.put("typ", "JWT");
header.put("alg", "HS256");
//携带usernamepassword信息生成签名
token = JWT.create()
.withHeader(header)
.withClaim("secreteKey", secreteKey)
.withExpiresAt(date)
.sign(algorithm);
} catch (Exception e) {
log.error("获取token异常", e);
return null;
}
return token;
}
public static boolean verify(String token, HttpServletRequest request) {
/**
* @desc tokentrue
* @params [token]
**/
try {
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
JWTVerifier verifier = JWT.require(algorithm).build();
DecodedJWT jwt = verifier.verify(token);
HttpSession session = request.getSession();
String Man = jwt.getClaim("Man").asString().replaceAll("\\\"","");;
String Manid = jwt.getClaim("Manid").toString().replaceAll("\\\"","");;
String Manno = jwt.getClaim("Manno").toString().replaceAll("\\\"","");;
if (Man == null || Man.equals("") ||
Manid == null || Manid.equals("") ||
Manno == null || Manno.equals("")) {
return false;
}
session.setAttribute("Man", Man);
session.setAttribute("Manid", Manid);
session.setAttribute("Manno", Manno);
return true;
} catch (Exception e) {
log.error("验证token异常", e);
return false;
}
}
public static boolean verify(String token) {
/**
* @desc tokentrue
* @params [token]
**/
try {
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
JWTVerifier verifier = JWT.require(algorithm).build();
DecodedJWT jwt = verifier.verify(token);
return true;
} catch (Exception e) {
log.error("验证token异常", e);
return false;
}
}
}

@ -0,0 +1,360 @@
package com.nmgs.util;
import com.alibaba.fastjson.JSONObject;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
import org.apache.cxf.transport.http.HTTPConduit;
import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;
public class WebServiceUtil {
public static Logger logger = LoggerFactory.getLogger("PSAM");
// public static Call LWZXCommonServicePsamAuthCall;
public static String toWebService(String path, String methodName, String params) {
// 创建动态客户端
Client client = getClient(path);
// 需要密码的情况需要加上用户名和密码
// client.getOutInterceptors().add(new ClientLoginInterceptor(USER_NAME, PASS_WORD));
Object[] objects = new Object[0];
//json的形式
//JSONObject jsonMap = new JSONObject(params);
if (params != null && !params.trim().equals("")) {
try {
Map<String, Object> map = com.alibaba.fastjson.JSONObject.parseObject(params);
} catch (Exception e) {
// LogUtil.error(params + "--jsonParams参数格式不正确请确认是json的KeyValue格式", WebServiceUtil.class);
return params + "--jsonParams参数格式不正确请确认是json的KeyValue格式";
}
Object[] aaa = new Object[]{params};
try {
objects = client.invoke(methodName, aaa);
} catch (Exception e) {
throw new RuntimeException(e);
}
} else {
try {
objects = client.invoke(methodName);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if (objects.length > 0) {
return objects[0].toString();
} else {
return null;
}
}
public static Map<String, Object> toWebService(String path, String WebServiceName, Map<String, Object> params) {
// 创建动态客户端
Client client = getClient(path);
try {
Object[] objects;
//json的形式
JSONObject jsonMap = new JSONObject(params);
objects = client.invoke(WebServiceName, new Object[]{jsonMap.toString()});
if (objects.length > 0) {
return getResult(objects[0].toString());
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static String toWebService(String path, String methodName, Object[] params) {
// 创建动态客户端
Client client = getClient(path);
Object[] objects;
try {
objects = client.invoke(methodName, params);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (objects.length > 0) {
return objects[0].toString();
} else {
return null;
}
}
public static Object toWCFWebService(String path, String methodName, Object[] params) {
// 创建动态客户端
Client client = getClient(path);
Object[] objects;
try {
objects = client.invoke(methodName, params);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (objects.length > 0) {
return objects[0];
} else {
return null;
}
}
public static String toWebService(String path, String methodName) {
// 创建动态客户端
Client client = getClient(path);
Object[] objects;
try {
objects = client.invoke(methodName);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (objects.length > 0) {
return objects[0].toString();
} else {
return null;
}
}
public static String toWebService(String path, String methodName, Object[] params, int timeOut) {
// 创建动态客户端
Client client = getClient(path, timeOut);
Object[] objects;
try {
objects = client.invoke(methodName, params);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
if (objects.length > 0) {
return objects[0].toString();
} else {
return null;
}
}
/* private static void trustAllHttpsCertficates() {
TrustManager[] trustManagers = new TrustManager[1];
TrustManager tm = new miTM();
trustManagers[0] = tm;
SSLContext sc = null;
try {
sc = SSLContext.getInstance("SSL");
sc.init(null, trustManagers, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
HostnameVerifier allHostsValid = new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
} catch (Exception e) {
e.printStackTrace();
}
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
}*/
/* public String toHRWebService(String path, String methodName, Object[] params) {
//跳过HTTPS访问接口
trustAllHttpsCertficates();
// 创建动态客户端
Client client = getHRClient(path);
Object[] objects;
try {
objects = client.invoke(methodName, params);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (objects.length > 0) {
return objects[0].toString();
} else {
return null;
}
}*/
public static Client getHRClient(String path) {
// 创建动态客户端
int CXF_CLIENT_CONNECT_TIMEOUT = 2 * 1000;
int CXF_CLIENT_RECEIVE_TIMEOUT = 2 * 1000;
JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
// dcf.setJaxbContextProperties();
Client client = dcf.createClient(path);
HTTPConduit conduit = (HTTPConduit) client.getConduit();
HTTPClientPolicy policy = new HTTPClientPolicy();
policy.setConnectionTimeout(CXF_CLIENT_CONNECT_TIMEOUT);
policy.setReceiveTimeout(CXF_CLIENT_RECEIVE_TIMEOUT);
conduit.setClient(policy);
return client;
}
public static Client getClient(String path) {
// 创建动态客户端
int CXF_CLIENT_CONNECT_TIMEOUT = 40 * 10000;
int CXF_CLIENT_RECEIVE_TIMEOUT = 40 * 10000;
JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
// dcf.setJaxbContextProperties();
Client client = dcf.createClient(path);
HTTPConduit conduit = (HTTPConduit) client.getConduit();
HTTPClientPolicy policy = new HTTPClientPolicy();
policy.setConnectionTimeout(CXF_CLIENT_CONNECT_TIMEOUT);
policy.setReceiveTimeout(CXF_CLIENT_RECEIVE_TIMEOUT);
conduit.setClient(policy);
return client;
}
public static Client getClient(String path, int timeOut) {
timeOut = timeOut * 1000;
// 创建动态客户端
int CXF_CLIENT_CONNECT_TIMEOUT = timeOut;
int CXF_CLIENT_RECEIVE_TIMEOUT = timeOut;
JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
Client client = dcf.createClient(path);
HTTPConduit conduit = (HTTPConduit) client.getConduit();
HTTPClientPolicy policy = new HTTPClientPolicy();
policy.setConnectionTimeout(CXF_CLIENT_CONNECT_TIMEOUT);
policy.setReceiveTimeout(CXF_CLIENT_RECEIVE_TIMEOUT);
conduit.setClient(policy);
return client;
}
/* public static String toCWebService(String url, String methodName, Map<String, Object> params) throws RemoteException, ServiceException {
String result = "";
if (!url.contains("?wsdl")) {
url += "?wsdl";
}
String namespace = "http://tempuri.org/";
String soapActionURI = "http://tempuri.org/" + methodName;
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress(url);
call.setUseSOAPAction(true);
call.setSOAPActionURI(soapActionURI);
call.setOperationName(new QName(namespace, methodName));
call.setTimeout(5000);
call.setReturnType(XMLType.XSD_STRING);
call.removeAllParameters();
logger.info("开始写入参数---PSAM_ 1");
Object[] str = new Object[params.size()];
int i = 0;
for (String key : params.keySet()) {
call.addParameter(new QName("http://tempuri.org/", key), XMLType.XSD_STRING, ParameterMode.IN);
str[i] = params.get(key).toString();
i++;
}
//对传入的参数进行赋值操作
//开始调用服务
logger.info("参数写入完成,LWZXCommonServiceUrl" + url + "开始请求---PSAM_ 1");
Long startTime = new Date().getTime();
Object obj = call.invoke(str);
result = (String) obj;
Long endTime = new Date().getTime();
logger.info("LWZXCommonServiceUrl" + url + "请求时间:" + (endTime - startTime) + "ms---PSAM_ 1");
return result;
}*/
/*public static String getMyWebService(String url, String methodName, Map<String, Object> params) throws RemoteException, ServiceException {
Logger myLogger = LoggerFactory.getLogger("ImgListNo");
String result = "";
myLogger.info("servicePsamAuthCall开始创建接口链接" + url);
if (!url.contains("?wsdl")) {
url += "?wsdl";
}
String namespace = "http://tempuri.org/";
String soapActionURI = "http://tempuri.org/" + methodName;
Service service = new Service();
Call servicePsamAuthCall = (Call) service.createCall();
servicePsamAuthCall.setTargetEndpointAddress(url);
servicePsamAuthCall.setUseSOAPAction(true);
servicePsamAuthCall.setSOAPActionURI(soapActionURI);
servicePsamAuthCall.setOperationName(new QName(namespace, methodName));
servicePsamAuthCall.setReturnType(XMLType.XSD_STRING);
servicePsamAuthCall.removeAllParameters();
servicePsamAuthCall.setTimeout(30000);
myLogger.info("开始写入参数");
Object[] str = new Object[params.size()];
int i = 0;
for (String key : params.keySet()) {
servicePsamAuthCall.addParameter(new QName("http://tempuri.org/", key), XMLType.XSD_STRING, ParameterMode.IN);
str[i] = params.get(key).toString();
System.out.println(key+"="+str[i]);
i++;
}
//对传入的参数进行赋值操作
//开始调用服务
myLogger.info("参数写入完成,Url" + url + "开始请求");
Long startTime = new Date().getTime();
Object obj = servicePsamAuthCall.invoke(str);
result = (String) obj;
Long endTime = new Date().getTime();
myLogger.info("Url" + url + "请求时间:" + (endTime - startTime) + "ms");
return result;
}*/
/* public static String toCWebService(String url, String methodName, Map<String, Object> params, String namespace, int timeOut) throws RemoteException, ServiceException {
String result = "";
if (!url.contains("?wsdl")) {
url += "?wsdl";
}
String soapActionURI = namespace + methodName;
Service service = new Service();
Call call;
call = (Call) service.createCall();
call.setTargetEndpointAddress(url);
call.setUseSOAPAction(true);
call.setSOAPActionURI(soapActionURI);
call.setOperationName(new QName(namespace, methodName));
call.setTimeout(timeOut * 1000);
call.setReturnType(XMLType.XSD_STRING);
Object[] str = new Object[params.size()];
int i = 0;
for (String key : params.keySet()) {
call.addParameter(new QName(namespace, key), XMLType.XSD_STRING, ParameterMode.IN);
str[i] = params.get(key).toString();
i++;
}
Object obj = call.invoke(str);
result = (String) obj;
return result;
}*/
public static Map<String, Object> getResult(String obj) {
if (obj == null || obj.equals("")) {
return null;
}
Map<String, Object> map = com.alibaba.fastjson.JSONObject.parseObject(obj);
return map;
}
/* public static String getImgStrByWebService(String imgType, String listNO, Holder<String> imgTBName, Holder<Integer> staNo, Map<String, Object> returnMap, String url) {
Logger myLogger = LoggerFactory.getLogger("ImgListNo");
Map<String, Object> params = new HashMap<>();
if (imgType.equals("4")) {
params.put("listNO", listNO);
params.put("transferFlag", StaInfo.UserType);
params.put("staNo", staNo.value);
try {
return WebServiceUtil.getMyWebService(url, "GetImgByGantry", params);
} catch (Exception e) {
myLogger.info("访问 " + url + " 接口错误 " + ExceptionUtil.getExceptionStr(e));
returnMap.put("resultData", "[]");
returnMap.put("resultCode", "0");
returnMap.put("resultText", "访问 " + url + " 接口错误 " + e.getMessage());
return new JSONObject(returnMap).toString();
}
} else {
params.put("bucketName", "bucket" + imgTBName.value);
params.put("listNO", listNO);
params.put("transferFlag", StaInfo.UserType);
params.put("staNo", staNo.value);
params.put("imgType", imgType);
try {
return WebServiceUtil.getMyWebService(url, "GetImgByBucket", params);
} catch (Exception e) {
myLogger.info("访问 " + url + " 接口错误 " + ExceptionUtil.getExceptionStr(e));
returnMap.put("resultData", "[]");
returnMap.put("resultCode", "0");
returnMap.put("resultText", "访问 " + url + " 接口错误 " + e.getMessage());
return new JSONObject(returnMap).toString();
}
}
}*/
}

@ -0,0 +1,141 @@
package com.nmgs.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
import javax.websocket.Session;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* Websocket
* 线
*/
public class WebsocketUtil {
/**
*
*/
private static final Logger log = LoggerFactory.getLogger(WebsocketUtil.class);
/**
* 线Session
*/
private static Map<String, Session> ONLINE_SESSION = new ConcurrentHashMap<>();
public static final String sessionKey = "socketId";
/**
* session
*
* @param userId
* @param session
*/
public static void addSession(String userId, Session session) {
// 此处只允许一个用户的session链接。一个用户的多个连接我们视为无效。
ONLINE_SESSION.putIfAbsent(userId, session);
}
/**
* session
*
* @param userId
*/
public static void removeSession(String userId) {
ONLINE_SESSION.remove(userId);
}
/**
*
*
* @param session
* @param message
*/
public static void sendMessage(Session session, String message) {
if (session == null) {
return;
}
synchronized(session) {
try {
session.getBasicRemote().sendText(message);
} catch (IOException e) {
}
}
}
/**
* 线
*
* @param message
*/
public static void sendMessageForAll(String message) {
//jdk8 新方法
ONLINE_SESSION.forEach((sessionId, session) -> {
if (session.isOpen()) {
sendMessage(session, message);
}
});
}
/**
* ID
*
* @param result
*/
// public static void sendMessage(String sessionId, AjaxResult result) {
// sendMessage(sessionId, JSON.toJSONString(result));
// }
/**
* ID
*
* @param message
*/
public static void sendMessage(String sessionId, String message) {
Session session = ONLINE_SESSION.get(sessionId);
//判断是否存在该用户的session判断是否还在线
if (session == null || !session.isOpen()) {
return;
}
sendMessage(session, message);
}
/**
* IDSession
*
* @param sessionId
*/
public static Session getSession(String sessionId) {
Session session = ONLINE_SESSION.get(sessionId);
return session;
}
public static int getSessionSize() {
int sessionSize = ONLINE_SESSION.size();
return sessionSize;
}
/**
* keysession
*
* @param key
* @param session
* @return
*/
public static String getParam(String key, Session session) {
Map map = session.getRequestParameterMap();
Object userId1 = map.get(key);
if (userId1 == null) {
return null;
}
String s = userId1.toString();
s = s.replaceAll("\\[", "").replaceAll("]", "");
if (!StringUtils.isEmpty(s)) {
return s;
}
return null;
}
}

@ -0,0 +1,96 @@
package com.nmgs.util;
import com.trkf.PasswordEncryption.PassWordUtils;
import java.io.UnsupportedEncodingException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class main {
private static long[] Crc32Table = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
public static void main(String[] args) throws ParseException, UnsupportedEncodingException {
// String memo="A900000000".substring(2,6);
// System.out.println(Long.parseLong(memo,16));
System.out.println(PassWordUtils.encrypt("sysadmin"));
System.out.println(PassWordUtils.encrypt("123456"));
SimpleDateFormat dateTimeFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String r = "0041", s1 = "00001425", s2 = "00001964";
r = r.substring(r.length() - 2, 2);
s1 = s1.substring(s1.length() - 4, s1.length());
s2 = s2.substring(s2.length() - 4, s2.length());
System.out.println(" r=====>"+r); // 输出格式化后的Date
System.out.println(" s1=====>"+s1); // 输出格式化后的Date
System.out.println(" s2=====>"+s2); // 输出格式化后的Date
// crc32.update(bytes);
}
}

@ -0,0 +1,45 @@
Manifest-Version: 1.0
Main-Class:
Class-Path: spring-ws-core-3.1.6.jar xmlschema-core-2.2.3.jar java-jwt-4
.3.0.jar spring-boot-starter-logging-2.7.11.jar commons-lang3-3.12.0.ja
r spring-websocket-5.3.27.jar spring-xml-3.1.6.jar wsdl4j-1.6.3.jar tom
cat-embed-websocket-9.0.80.jar japidocs-1.4.4.jar xmlbeans-2.3.0.jar ac
tivation-1.1.jar tomcat-annotations-api-9.0.74.jar spring-data-keyvalue
-2.7.11.jar javaparser-core-3.6.16.jar jakarta.annotation-api-1.3.5.jar
fastjson2-extension-2.0.25.jar classmate-1.5.1.jar mysql-connector-jav
a-8.0.23.jar spring-data-commons-2.7.11.jar spring-context-support-5.3.
27.jar mybatis-plus-boot-starter-3.5.3.1.jar spring-data-redis-2.7.11.j
ar spring-session-data-redis-2.7.1.jar mybatis-plus-core-3.5.3.1.jar lo
g4j-api-2.17.2.jar poi-ooxml-3.8.jar stax2-api-3.1.4.jar spring-web-5.3
.27.jar axis-1.4.jar mybatisplus-plus-1.7.3-RELEASE.jar slf4j-api-1.7.3
6.jar hutool-all-5.8.25.jar cxf-spring-boot-autoconfigure-3.2.5.jar cxf
-spring-boot-starter-jaxws-3.2.5.jar lombok-1.18.26.jar spring-ws-suppo
rt-3.1.6.jar jackson-databind-2.13.5.jar asm-5.2.jar xml-resolver-1.2.j
ar freemarker-2.3.32.jar spring-boot-starter-ws-1.3.3.RELEASE.jar jboss
-logging-3.4.3.Final.jar spring-session-core-2.7.1.jar fastjson-2.0.25.
jar spring-beans-5.3.27.jar cxf-rt-bindings-soap-3.2.5.jar woodstox-cor
e-5.0.3.jar spring-oxm-5.3.27.jar jakarta.validation-api-2.0.2.jar spri
ng-boot-starter-2.7.11.jar DmJdbcDriver18-1.8.0.jar hibernate-validator
-6.2.0.Final.jar snakeyaml-1.30.jar spring-aop-5.3.27.jar spring-core-5
.3.27.jar spring-boot-starter-jdbc-2.7.11.jar jackson-datatype-jsr310-2
.13.5.jar cxf-rt-transports-http-3.2.5.jar tomcat-embed-core-9.0.74.jar
mybatis-spring-2.0.7.jar cxf-rt-frontend-jaxws-3.2.5.jar mybatis-plus-
3.5.3.1.jar spring-boot-2.7.11.jar spring-boot-starter-json-2.7.11.jar
mybatis-3.5.10.jar sqljdbc4-3.0.jar cxf-core-3.2.5.jar spring-boot-star
ter-web-2.7.11.jar spring-context-5.3.27.jar spring-boot-autoconfigure-
2.7.11.jar jsqlparser-4.4.jar cxf-rt-ws-policy-3.2.5.jar javax.mail-1.6
.0.jar xml-apis-1.0.b2.jar spring-messaging-5.3.27.jar spring-webmvc-5.
3.27.jar jackson-core-2.13.5.jar cxf-rt-frontend-simple-3.2.5.jar commo
ns-codec-1.15.jar spring-boot-starter-websocket-2.7.11.jar spring-tx-5.
3.27.jar logback-classic-1.2.12.jar spring-session-jdbc-2.7.1.jar mybat
is-plus-annotation-3.5.3.1.jar spring-jms-5.3.27.jar spring-jcl-5.3.27.
jar cxf-rt-databinding-jaxb-3.2.5.jar jackson-module-parameter-names-2.
13.5.jar neethi-3.1.1.jar jackson-annotations-2.13.5.jar cxf-rt-ws-addr
-3.2.5.jar log4j-to-slf4j-2.17.2.jar protobuf-java-3.11.4.jar validatio
n-api-2.0.1.Final.jar fastjson2-2.0.25.jar jul-to-slf4j-1.7.36.jar myba
tis-plus-extension-3.5.3.1.jar EndPassJava-1.0.0.jar spring-jdbc-5.3.27
.jar HikariCP-4.0.3.jar logback-core-1.2.12.jar poi-3.8.jar cxf-rt-bind
ings-xml-3.2.5.jar stax-api-1.0.1.jar poi-ooxml-schemas-3.8.jar cxf-rt-
wsdl-3.2.5.jar custom-spring-boot-resttemplate-1.0.0.jar jackson-dataty
pe-jdk8-2.13.5.jar spring-expression-5.3.27.jar dom4j-1.6.1.jar

@ -0,0 +1,2 @@
org.springframework.boot.env.EnvironmentPostProcessor=\
com.nmgs.MyEnvironmentPostProcessor

@ -0,0 +1,255 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL如果设置为WARN则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时配置文件如果发生改变将会被重新加载默认值为true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔如果没有给出时间单位默认单位是毫秒。当scan为true时此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时将打印出logback内部日志信息实时查看logback运行状态。默认值为false。 -->
<configuration scan="false" scanPeriod="10 seconds" debug="true">
<springProperty scope="context" name="logLevel" source="spring.logback.level"/>
<springProperty scope="context" name="APP_NAME" source="spring.logback.appName"/>
<springProperty scope="context" name="myMaxHistory" source="spring.logback.myMaxHistory"/>
<springProperty scope="context" name="myFileSize" source="spring.logback.myFileSize"/>
<springProperty scope="context" name="myTotalSizeCap" source="spring.logback.myTotalSizeCap"/>
<springProperty scope="context" name="logPath" source="spring.logback.logPath"/>
<contextName>${APP_NAME}</contextName>
<!-- 彩色日志 -->
<!-- 彩色日志依赖的渲染类 -->
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
<conversionRule conversionWord="wex"
converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
<conversionRule conversionWord="wEx"
converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
<!--彩色日志输出格式-->
<property name="CONSOLE_LOG_PATTERN"
value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%level){blue} %clr(${PID}){magenta} %clr([%thread]){orange} %clr(%logger){cyan} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>
<!--非彩色日志输出格式-->
<property name="PATTERN"
value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level 服务名称:${APP_NAME} %logger{36} - %msg%n"/>
<!--dev文件路径src同级目录logs,如果上级目录不存在会自动创建-->
<property name="DEV_FILE_PATH" value="${logPath}/${APP_NAME}/"/>
<!-- pro文件路径 -->
<property name="PRO_FILE_PATH" value="${logPath}/${APP_NAME}/"/>
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<!--<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%level] [%thread] [%class:%line] %logger{50} - %m %n</pattern>-->
<!--格式化输出:%d表示日期%thread表示线程名%-5level级别从左显示5个字符宽度%msg日志消息%n是换行符-->
<pattern>${PATTERN}</pattern>
<!-- <charset>UTF-8</charset>-->
</encoder>
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>INFO</level>
</filter>
</appender>
<!-- 按照每天生成输出日志文件 -->
<appender name="fileAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
<encoder>
<!--格式化输出:%d表示日期%thread表示线程%-5level级别从左显示五个字符宽度%logger{36}logger是class的全名,后面的数字代表限制最长的字符,%msg日志消息%n换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
<!--滚动策略按照时间滚动-->
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!-- rollover daily 文件名称 -->
<fileNamePattern>${DEV_FILE_PATH}/output-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<maxHistory>${myMaxHistory}</maxHistory>
<maxFileSize>${myFileSize}</maxFileSize>
<totalSizeCap>${myTotalSizeCap}</totalSizeCap>
</rollingPolicy>
</appender>
<appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<fileNamePattern>${DEV_FILE_PATH}/log_info_%d{yyyy-MM-dd_HH}.%i.txt</fileNamePattern>
<!-- 当文件总大小超过2GB先删除30天内最早的文件。不会删除30天外的文件。 -->
<maxHistory>${myMaxHistory}</maxHistory>
<maxFileSize>${myFileSize}</maxFileSize>
<totalSizeCap>${myTotalSizeCap}</totalSizeCap>
</rollingPolicy>
<append>true</append>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<pattern>${PATTERN}</pattern>
<charset>utf-8</charset>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>INFO</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<fileNamePattern>${DEV_FILE_PATH}/log_error_%d{yyyy-MM-dd_HH}.%i.txt</fileNamePattern>
<!-- 当文件总大小超过1GB先删除10天内最早的文件。不会删除10天外的文件。 -->
<maxHistory>${myMaxHistory}</maxHistory>
<maxFileSize>${myFileSize}</maxFileSize>
<totalSizeCap>${myTotalSizeCap}</totalSizeCap>
</rollingPolicy>
<append>true</append>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<pattern>${PATTERN}</pattern>
<charset>utf-8</charset>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<!-- <appender name="WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">-->
<!-- <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">-->
<!-- <fileNamePattern>${DEV_FILE_PATH}/log_warn_%d{yyyy-MM-dd_H}.%i.txt</fileNamePattern>-->
<!-- &lt;!&ndash; 每产生一个日志文件该日志文件的保存期限为10天 &ndash;&gt;-->
<!-- <maxHistory>10</maxHistory>-->
<!-- <maxFileSize>20MB</maxFileSize>-->
<!-- <totalSizeCap>500MB</totalSizeCap>-->
<!-- </rollingPolicy>-->
<!-- <append>true</append>-->
<!-- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
<!-- <pattern>${PATTERN}</pattern>-->
<!-- <charset>utf-8</charset>-->
<!-- </encoder>-->
<!-- <filter class="ch.qos.logback.classic.filter.LevelFilter">-->
<!-- <level>WARN</level>-->
<!-- <onMatch>ACCEPT</onMatch>-->
<!-- <onMismatch>DENY</onMismatch>-->
<!-- </filter>-->
<!-- </appender>-->
<!-- <appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">-->
<!-- <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">-->
<!-- <fileNamePattern>${DEV_FILE_PATH}/log_debug_%d{yyyy-MM-dd_H}.%i.txt</fileNamePattern>-->
<!-- &lt;!&ndash; 当文件总大小超过1GB先删除10天内最早的文件。不会删除10天外的文件。 &ndash;&gt;-->
<!-- <maxHistory>${myMaxHistory}</maxHistory>-->
<!-- <maxFileSize>${myFileSize}</maxFileSize>-->
<!-- <totalSizeCap>${myTotalSizeCap}</totalSizeCap>-->
<!-- </rollingPolicy>-->
<!-- <append>true</append>-->
<!-- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
<!-- <pattern>${PATTERN}</pattern>-->
<!-- <charset>utf-8</charset>-->
<!-- </encoder>-->
<!-- <filter class="ch.qos.logback.classic.filter.LevelFilter">-->
<!-- <level>DEBUG</level>-->
<!-- <onMatch>ACCEPT</onMatch>-->
<!-- <onMismatch>DENY</onMismatch>-->
<!-- </filter>-->
<!-- </appender>-->
<!-- <appender name="SQL" class="ch.qos.logback.core.rolling.RollingFileAppender">-->
<!-- <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">-->
<!-- <fileNamePattern>${DEV_FILE_PATH}/log-sql-%d{yyyy-MM-dd_H}.%i.txt</fileNamePattern>-->
<!-- &lt;!&ndash; 每产生一个日志文件该日志文件的保存期限为3天 &ndash;&gt;-->
<!-- <maxHistory>${myMaxHistory}</maxHistory>-->
<!-- <maxFileSize>${myFileSize}</maxFileSize>-->
<!-- <totalSizeCap>${myTotalSizeCap}</totalSizeCap>-->
<!-- </rollingPolicy>-->
<!-- <append>true</append>-->
<!-- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
<!-- <pattern>${PATTERN}</pattern>-->
<!-- <charset>utf-8</charset>-->
<!-- </encoder>-->
<!-- <filter class="ch.qos.logback.classic.filter.LevelFilter">-->
<!-- <level>DEBUG</level>-->
<!-- <onMatch>ACCEPT</onMatch>-->
<!-- <onMismatch>DENY</onMismatch>-->
<!-- </filter>-->
<!-- </appender>-->
<!--异步输出-->
<!-- <appender name="DEBUG_ASYNC_LOG" class="ch.qos.logback.classic.AsyncAppender">-->
<!-- &lt;!&ndash; 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 &ndash;&gt;-->
<!-- <discardingThreshold>0</discardingThreshold>-->
<!-- &lt;!&ndash; 更改默认的队列的深度,该值会影响性能.默认值为256 &ndash;&gt;-->
<!-- <queueSize>2048</queueSize>-->
<!-- <includeCallerData>true</includeCallerData>-->
<!-- &lt;!&ndash; 添加附加的appender,最多只能添加一个 &ndash;&gt;-->
<!-- <appender-ref ref="DEBUG"/>-->
<!-- </appender>-->
<!--异步输出-->
<appender name="ERROR_ASYNC_LOG" class="ch.qos.logback.classic.AsyncAppender">
<!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
<discardingThreshold>0</discardingThreshold>
<!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
<queueSize>1024</queueSize>
<includeCallerData>true</includeCallerData>
<!-- 添加附加的appender,最多只能添加一个 -->
<appender-ref ref="ERROR"/>
</appender>
<!--异步输出-->
<!-- <appender name="WARN_ASYNC_LOG" class="ch.qos.logback.classic.AsyncAppender">-->
<!-- &lt;!&ndash; 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 &ndash;&gt;-->
<!-- <discardingThreshold>0</discardingThreshold>-->
<!-- &lt;!&ndash; 更改默认的队列的深度,该值会影响性能.默认值为256 &ndash;&gt;-->
<!-- <queueSize>1024</queueSize>-->
<!-- <includeCallerData>true</includeCallerData>-->
<!-- &lt;!&ndash; 添加附加的appender,最多只能添加一个 &ndash;&gt;-->
<!-- <appender-ref ref="WARN"/>-->
<!-- </appender>-->
<!--异步输出-->
<appender name="INFO_ASYNC_LOG" class="ch.qos.logback.classic.AsyncAppender">
<!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
<discardingThreshold>0</discardingThreshold>
<!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
<queueSize>2048</queueSize>
<includeCallerData>true</includeCallerData>
<!-- 添加附加的appender,最多只能添加一个 -->
<appender-ref ref="INFO"/>
</appender>
<!--异步输出-->
<!-- <appender name="SQL_ASYNC_LOG" class="ch.qos.logback.classic.AsyncAppender">-->
<!-- &lt;!&ndash; 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 &ndash;&gt;-->
<!-- <discardingThreshold>0</discardingThreshold>-->
<!-- &lt;!&ndash; 更改默认的队列的深度,该值会影响性能.默认值为256 &ndash;&gt;-->
<!-- <queueSize>2048</queueSize>-->
<!-- <includeCallerData>true</includeCallerData>-->
<!-- &lt;!&ndash; 添加附加的appender,最多只能添加一个 &ndash;&gt;-->
<!-- <appender-ref ref="SQL"/>-->
<!-- </appender>-->
<!--
<logger>用来设置某一个包或者具体的某一个类的日志打印级别、
以及指定<appender><logger>仅有一个name属性
一个可选的level和一个可选的addtivity属性。
name:用来指定受此logger约束的某一个包或者具体的某一个类。
level:用来设置打印级别大小写无关TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF
还有一个特俗值INHERITED或者同义词NULL代表强制执行上级的级别。
如果未设置此属性那么当前logger将会继承上级的级别。
addtivity:是否向上级logger传递打印信息。默认是true。
-->
<!-- <logger name="dao" level="ERROR">-->
<!-- <appender-ref ref="SQL"/>-->
<!-- <appender-ref ref="STDOUT"/>-->
<!-- </logger>-->
<root level="${logLevel}">
<appender-ref ref="STDOUT"/>
<appender-ref ref="fileAppender"/>
<appender-ref ref="INFO_ASYNC_LOG"/>
<!-- <appender-ref ref="WARN_ASYNC_LOG"/>-->
<appender-ref ref="ERROR_ASYNC_LOG"/>
<!-- <appender-ref ref="DEBUG_ASYNC_LOG"/>-->
<!-- <appender-ref ref="SQL_ASYNC_LOG"/>-->
</root>
</configuration>

@ -0,0 +1,52 @@
#\u65E5\u5FD7\u9ED8\u8BA4\u914D\u7F6E
spring.logback.appName=WhiteListManageSys
spring.logback.level=INFO
spring.logback.myMaxHistory=30
spring.logback.myFileSize=10MB
spring.logback.myTotalSizeCap=2GB
#\u7F16\u7801\u8BBE\u7F6E
server.servlet.encoding.charset=UTF-8
server.servlet.encoding.enabled=true
server.servlet.encoding.force=true
spring.messages.encoding=UTF-8
spring.profiles.active=dev
# \u8FDE\u63A5\u6C60\u914D\u7F6E
spring.datasource.hikari.maximum-pool-size=25
spring.datasource.hikari.auto-commit=true
spring.datasource.hikari.idle-timeout=0
spring.datasource.hikari.pool-name=DatebookHikariCP
spring.datasource.hikari.max-lifetime=600000
spring.datasource.hikari.connection-timeout=3600000
spring.datasource.hikari.minimum-idle=1
spring.datasource.hikari.allow-pool-suspension=true
spring.datasource.hikari.register-mbeans=true
spring.datasource.hikari.leak-detection-threshold=600000
spring.devtools.restart.enabled=true
spring.devtools.restart.additional-paths=src/main
spring.session.store-type=none
#spring-session
spring.session.timeout=PT30M
spring.sql.init.mode=always
#\u89E3\u9664\u6587\u4EF6\u4E0A\u4F20\u5927\u5C0F\u9650\u5236
spring.servlet.multipart.enabled=true
spring.servlet.multipart.max-file-size=-1
spring.servlet.multipart.max-request-size=-1
server.tomcat.max-swallow-size=-1
server.tomcat.max-threads=1000
#mybatis-plus\u6253\u5370SQL\u8BED\u53E5
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
logging.level.com.nmgs.ssmpback.mapper=debug
logging.level.com.baomidou.mybatisplus.core.mapper=ERROR
#\u81EA\u5B9A\u4E49\u9ED8\u8BA4\u914D\u7F6E
sqlClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver
sqlvalidationQuery=SELECT 1
OracleClassName=oracle.jdbc.driver.OracleDriver
OraclevalidationQuery=SELECT 1 FROM DUAL
DMClassName=dm.jdbc.driver.DmDriver
DMvalidationQuery=SELECT 1
#MySQLClassName=com.mysql.jdbc.Driver
MySQLClassName=com.goldendb.jdbc.Driver
MySQLvalidationQuery=SELECT 1
MySQLGOADENDBClassName=com.goldendb.jdbc.Driver
MySQLGOADENDBvalidationQuery=SELECT 1
spring.web.resources.static-locations= classpath:/static/View/
Loading…
Cancel
Save