Skip to content

N
nnjcy-data-model
Commit aca8fc24 by 梁家彪
Options

加入公共包模块

parent 0e42b30b
Showing with 4878 additions and 0 deletions
common-client/pom.xml 0 → 100644
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.zq</groupId>
<artifactId>nnjcy-data-model</artifactId>
<version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>common-client</artifactId>
<name>common-client</name>
<description>Spring Cloud common-client</description>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
<!--mybatis-plus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis.plus.version}</version>
</dependency>
<!--pagehelper-->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-core</artifactId>
<version>2.4.2</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-sms</artifactId>
<version>3.0.0-rc1</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<!--<scope>provided</scope>-->
</dependency>
<!--spring boot 集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.15</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.8.0</version>
</dependency>
<!--工具包-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>${hutool.version}</version>
</dependency>
<!-- jwt -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>${jjwt.version}</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/com.belerweb/pinyin4j -->
<dependency>
<groupId>com.belerweb</groupId>
<artifactId>pinyin4j</artifactId>
<version>2.5.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.66</version>
</dependency>
<dependency>
<groupId>com.jfinal</groupId>
<artifactId>jfinal-weixin</artifactId>
<version>2.8</version>
</dependency>
<dependency>
<groupId>com.jfinal</groupId>
<artifactId>jfinal-ext3</artifactId>
<version>4.0.3</version>
</dependency>
</dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!--被依赖的公共模块必须加上这个，打包之后启动，选择后面带EXE的启动，依赖该模块的其他模块就不会因为找不到依赖而打包出错-->
<!--<classifier>exe</classifier>-->
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
common-client/src/main/java/com/zq/common/annotation/AnonymousAccess.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author jacky
* 用于标记匿名访问方法
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnonymousAccess {
String name() default "";
}
common-client/src/main/java/com/zq/common/annotation/DataPermission.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* <p>
* 用于判断是否过滤数据权限
* 1、如果没有用到 @OneToOne 这种关联关系，只需要填写 fieldName [参考：DeptQueryCriteria.class]
* 2、如果用到了 @OneToOne ，fieldName 和 joinName 都需要填写，拿UserQueryCriteria.class举例:
* 应该是 @DataPermission(joinName = "dept", fieldName = "id")
* </p>
*
* @author Zheng Jie
* @website https://docs.auauz.net
* @date 2020-05-07
**/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataPermission {
/**
* Entity 中的字段名称
*/
String fieldName() default "";
/**
* Entity 中与部门关联的字段名称
*/
String joinName() default "";
}
common-client/src/main/java/com/zq/common/annotation/Limit.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.annotation;
import com.zq.common.base.LimitType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author jacky
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Limit {
// 资源名称，用于描述接口功能
String name() default "";
// 资源 key
String key() default "";
// key prefix
String prefix() default "";
// 时间的，单位秒
int period();
// 限制访问次数
int count();
// 限制类型
LimitType limitType() default LimitType.CUSTOMER;
}
common-client/src/main/java/com/zq/common/annotation/Log.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Zheng Jie
* @date 2018-11-24
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
String value() default "";
}
common-client/src/main/java/com/zq/common/annotation/Query.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Zheng Jie
* @date 2019-6-4 13:52:30
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Query {
// Dong ZhaoYang 2017/8/7 基本对象的属性名
String propName() default "";
// Dong ZhaoYang 2017/8/7 查询方式
Type type() default Type.EQUAL;
/**
* 连接查询的属性名，如User类中的dept
*/
String joinName() default "";
/**
* 默认左连接
*/
Join join() default Join.LEFT;
/**
* 多字段模糊搜索，仅支持String类型字段，多个用逗号隔开, 如@Query(blurry = "email,username")
*/
String blurry() default "";
enum Type {
// jie 2019/6/4 相等
EQUAL
// Dong ZhaoYang 2017/8/7 大于等于
, GREATER_THAN
// Dong ZhaoYang 2017/8/7 小于等于
, LESS_THAN
// Dong ZhaoYang 2017/8/7 中模糊查询
, INNER_LIKE
// Dong ZhaoYang 2017/8/7 左模糊查询
, LEFT_LIKE
// Dong ZhaoYang 2017/8/7 右模糊查询
, RIGHT_LIKE
// Dong ZhaoYang 2017/8/7 小于
, LESS_THAN_NQ
// jie 2019/6/4 包含
, IN
// 不等于
, NOT_EQUAL
// between
, BETWEEN
// 不为空
, NOT_NULL
// 为空
, IS_NULL
}
/**
* @author Zheng Jie
* 适用于简单连接查询，复杂的请自定义该注解，或者使用sql查询
*/
enum Join {
/**
* jie 2019-6-4 13:18:30 左右连接
*/
LEFT, RIGHT
}
}
common-client/src/main/java/com/zq/common/base/LimitType.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.base;
/**
* 限流枚举
*
* @author /
*/
public enum LimitType {
CUSTOMER,
IP,
USER_ID
}
common-client/src/main/java/com/zq/common/base/Paginator.java 0 → 100644
/**
* Copyright 2015-2025 .
* <p>
* Licensed 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
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* 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.
*/
package com.zq.common.base;
public class Paginator {
final int DEFAULT_PAGE_SIZE = 15;
private int pageNo;
private int pageSize;
private int totalRecords;
public Paginator() {
this.pageNo = 1;
this.pageSize = DEFAULT_PAGE_SIZE;
}
public Paginator(int pageNo, int pageSize) {
this.pageNo = pageNo;
this.pageSize = pageSize;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getTotalRecords() {
return totalRecords;
}
public void setTotalRecords(int totalRecords) {
this.totalRecords = totalRecords;
}
public int getFirstResult() {
if (pageNo <= 0) {
return 0;
}
return (pageNo - 1) * pageSize;
}
public int getMaxResults() {
return pageSize;
}
}
common-client/src/main/java/com/zq/common/base/SecurityProperties.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.base;
import lombok.Data;
/**
* Jwt参数配置
*
* @author Zheng Jie
* @date 2019年11月28日
*/
@Data
public class SecurityProperties {
/**
* Request Headers ： Authorization
*/
public static String HEADER = "Authorization";
/**
* 令牌前缀，最后留个空格 Bearer
*/
public static String TOKENSTARTWITH = "Bearer";
/**
* 必须使用最少88位的Base64对该令牌进行编码
*/
public static String BASE64SECRET = "ZmQ0ZGI5NjQ0MDQwY2I4MjMxY2Y3ZmI3MjdhN2ZmMjNhODViOTg1ZGE0NTBjMGM4NDA5NzYxMjdjOWMwYWRmZTBlZjlhNGY3ZTg4Y2U3YTE1ODVkZDU5Y2Y3OGYwZWE1NzUzNWQ2YjFjZDc0NGMxZWU2MmQ3MjY1NzJmNTE0MzI=";
/**
* 令牌过期时间 此处单位/毫秒
*/
public static Long TOKENVALIDITYINSECONDS = 14400000L;
/**
* 在线用户 key，根据 key 查询 redis 中在线用户的数据
*/
public static String ONLINEKEY = "online-token-";
/**
* 验证码 key
*/
public static String CODEKEY = "code-key-";
/**
* token 续期检查
*/
public static Long DETECT = 1800000L;
/**
* 续期时间
*/
public static Long RENEW = 3600000L;
public static String getTokenStartWith() {
return TOKENSTARTWITH + " ";
}
}
common-client/src/main/java/com/zq/common/config/base/AsyncConfig.java 0 → 100644
package com.zq.common.config.base;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
/**
* 异步执行配置
*
* @author
* @since 2018-01-19
*/
@Configuration
@ConditionalOnProperty(value = "async.pool.enable", havingValue = "true")
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
private static final Logger log = LoggerFactory.getLogger(AsyncConfig.class);
@Value("${async.pool.core-pool-size:5}")
private int corePoolSize;
@Value("${async.pool.queue-capacity:10}")
private int maxPoolSize;
@Value("${async.pool.max-pool-size:25}")
private int queueCapacity;
@Value("${async.pool.keepalive-seconds:10}")
private int threadTimeout;
@Override
public Executor getAsyncExecutor() {
log.debug(">> 初始化spring线程池...");
ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
// 当一个任务通过execute(Runnable)方法欲添加到线程池时：
// - 若线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也创建新的线程来处理被添加的任务。
// - 若线程池中的数量等于corePoolSize，但缓冲队列workQueue未满，则任务被放入缓冲队列。
// - 若线程池中的数量大于corePoolSize，缓冲队列workQueue满，且线程池中的数量小于maximumPoolSize，则创建新线程来处理被添加的任务。
// - 若线程池中的数量大于corePoolSize，缓冲队列workQueue满，且线程池中的数量等于maximumPoolSize，则通过handler所指定的策略来处理此任务。
// 即：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize，若三者都满，则使用handler处理被拒绝的任务。
// - 若线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。
// 线程池维护线程的最少数量
threadPoolTaskExecutor.setCorePoolSize(corePoolSize);
// 线程池维护线程的最大数量
threadPoolTaskExecutor.setMaxPoolSize(maxPoolSize);
// 线程池所使用的缓冲队列
threadPoolTaskExecutor.setQueueCapacity(queueCapacity);
// 线程池维护线程所允许的空闲时间
threadPoolTaskExecutor.setKeepAliveSeconds(threadTimeout);
// don't forget to initialize the thread pool
threadPoolTaskExecutor.initialize();
return threadPoolTaskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return (throwable, method, params) -> {
String methodName = method.getDeclaringClass().getName() + method.getName();
log.error(">> 异步执行错误: {}({})", methodName, params, throwable);
};
}
}
common-client/src/main/java/com/zq/common/config/base/MybatisConfig.java 0 → 100644
package com.zq.common.config.base;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.github.pagehelper.PageInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Properties;
@Configuration
public class MybatisConfig {
/**
* MybatisPlus分页插件
*/
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
return interceptor;
}
/**
* 官方原话
* MybatisPlus新的分页插件,一缓和二缓遵循mybatis的规则,
* 需要设置 MybatisConfiguration#useDeprecatedExecutor = false
* 避免缓存出现问题(该属性会在旧插件移除后一同移除)
*/
@SuppressWarnings(value = {"deprecation"})
@Bean
public ConfigurationCustomizer configurationCustomizer() {
return configuration -> configuration.setUseDeprecatedExecutor(false);
}
// pagehelper分页插件
@Bean
public PageInterceptor pageInterceptor() {
PageInterceptor pageInterceptor = new PageInterceptor();
Properties properties = new Properties();
properties.put("helperDialect", "mysql");
pageInterceptor.setProperties(properties);
return pageInterceptor;
}
}
common-client/src/main/java/com/zq/common/config/base/SpringContextHolder.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.config.base;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.NonNull;
/**
* @author
* @date 2019-01-07
*/
@Slf4j
@Configuration
public class SpringContextHolder implements ApplicationContextAware, DisposableBean {
private static ApplicationContext applicationContext = null;
/**
* 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
assertContextInjected();
return (T) applicationContext.getBean(name);
}
/**
* 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
public static <T> T getBean(Class<T> requiredType) {
assertContextInjected();
return applicationContext.getBean(requiredType);
}
/**
* 检查ApplicationContext不为空.
*/
private static void assertContextInjected() {
if (applicationContext == null) {
throw new IllegalStateException("applicaitonContext属性未注入, 请在applicationContext" +
".xml中定义SpringContextHolder或在SpringBoot启动类中注册SpringContextHolder.");
}
}
/**
* 清除SpringContextHolder中的ApplicationContext为Null.
*/
private static void clearHolder() {
log.debug("清除SpringContextHolder中的ApplicationContext:"
+ applicationContext);
applicationContext = null;
}
@Override
public void destroy() {
SpringContextHolder.clearHolder();
}
@Override
public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException {
if (SpringContextHolder.applicationContext != null) {
log.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
}
SpringContextHolder.applicationContext = applicationContext;
}
}
common-client/src/main/java/com/zq/common/config/base/UnifiedExceptionHandler.java 0 → 100644
package com.zq.common.config.base;
import com.zq.common.exception.BusinessException;
import com.zq.common.utils.RequestUtils;
import com.zq.common.vo.ResultVo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.multipart.support.MissingServletRequestPartException;
import javax.servlet.http.HttpServletRequest;
/**
* API接口统一异常处理类
* <p>
* &#64;RestControllerAdvice = &#64;ControllerAdvice + &#64;ResponseBody
* </p>
*
* @author wilmiam
* @since 2017-12-21
*/
@ResponseStatus(HttpStatus.OK)
@RestControllerAdvice
public class UnifiedExceptionHandler {
private static final Logger log = LoggerFactory.getLogger(UnifiedExceptionHandler.class);
@ExceptionHandler(BusinessException.class)
public ResultVo handleBusinessException(BusinessException ex, HttpServletRequest request) {
log.info(">> business exception: {}, {}, {}", request.getRequestURI(), ex.getCode(), ex.getMessage());
String errMessage = ex.getMessage();
// 防止空的错误信息
if (StringUtils.isBlank(errMessage)) {
errMessage = "服务器繁忙";
log.warn(">> 空的业务错误信息", ex);
}
return ResultVo.fail(ex.getCode(), errMessage);
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResultVo handleArgumentNotValidException(MethodArgumentNotValidException ex, HttpServletRequest request) {
log.info(">> argument not valid error: {} {}", request.getRequestURI(), ex.getMessage());
return ResultVo.fail(HttpStatus.BAD_REQUEST.value(), "无效的请求参数" + ex.getParameter().getParameterName());
}
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public ResultVo handleMethodNotSupportedException(HttpRequestMethodNotSupportedException ex, HttpServletRequest request) {
log.info(">> method not supported error: {} {}, expected: {}",
ex.getMethod(), request.getRequestURI(), ex.getSupportedHttpMethods());
return ResultVo.fail(HttpStatus.METHOD_NOT_ALLOWED.value(), "不支持此" + ex.getMethod() + "请求");
}
@ExceptionHandler(HttpMediaTypeNotSupportedException.class)
public ResultVo handleMediaTypeNotSupportedException(HttpMediaTypeNotSupportedException ex, HttpServletRequest request) {
String detail = ex.getClass().getName();
if (ex.getSupportedMediaTypes() != null && !ex.getSupportedMediaTypes().isEmpty()) {
detail = MediaType.toString(ex.getSupportedMediaTypes());
detail = "支持的content-type: " + detail;
}
log.info(">> http media type not supported error: {} {}, expected: {}",
request.getContentType(), request.getRequestURI(), detail);
return ResultVo.fail(HttpStatus.UNSUPPORTED_MEDIA_TYPE.value(), "不支持的Content-Type: " + request.getContentType());
}
@ExceptionHandler(HttpMessageConversionException.class)
public ResultVo handleMessageConversionException(HttpMessageConversionException ex, HttpServletRequest request) {
log.info(">> message conversion error: {} {}", request.getRequestURI(), ex.getMessage());
return ResultVo.fail(HttpStatus.BAD_REQUEST.value(), "无法解析请求消息");
}
@ExceptionHandler({MissingServletRequestPartException.class, MissingServletRequestParameterException.class})
public ResultVo handleMissingServletRequestPartException(Exception ex, HttpServletRequest request) {
log.info(">> missing servlet request part/param error: {} {}", request.getRequestURI(), ex.getMessage());
String paranmName = "";
if (ex instanceof MissingServletRequestPartException) {
paranmName = ((MissingServletRequestPartException) ex).getRequestPartName();
} else if (ex instanceof MissingServletRequestParameterException) {
paranmName = ((MissingServletRequestParameterException) ex).getParameterName();
}
return ResultVo.fail(HttpStatus.BAD_REQUEST.value(), "缺少请求参数" + paranmName);
}
@ExceptionHandler(DataAccessException.class)
public ResultVo handleDataAccessException(DataAccessException ex, HttpServletRequest request) {
log.error(">> 访问数据失败 " + request.getRequestURI(), ex);
log.info(">> 访问参数QueryString：" + request.getQueryString());
log.info(">> 访问参数body：" + RequestUtils.getBodyParams(request));
return ResultVo.fail(HttpStatus.INTERNAL_SERVER_ERROR.value(), "服务器繁忙");
}
@ExceptionHandler(value = Exception.class)
public ResultVo defaultErrorHandler(Exception ex, HttpServletRequest request) {
log.error(">> 服务器内部错误 " + request.getRequestURI(), ex);
return ResultVo.fail(HttpStatus.INTERNAL_SERVER_ERROR.value(), "服务器繁忙");
}
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/config/interceptor/UserInfoInterceptor.java 0 → 100644
package com.zq.common.config.interceptor;
import com.zq.common.config.redis.CacheKeys;
import com.zq.common.config.redis.RedisUtils;
import com.zq.common.utils.TokenUtils;
import com.zq.common.vo.AppTokenVo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Slf4j
@Component
@RequiredArgsConstructor
public class UserInfoInterceptor extends HandlerInterceptorAdapter {
private final RedisUtils redisUtils;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (request.getRequestURI().startsWith("/app")) {
String token = TokenUtils.getToken(request);
log.info(">> [UserInfo token] {}", token);
AppTokenVo tokenVo = redisUtils.getObj(CacheKeys.appTokenKey(token), AppTokenVo.class);
TokenUtils.setUserContext(tokenVo);
}
return true;
}
}
common-client/src/main/java/com/zq/common/config/limit/LimitAspect.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.config.limit;
import com.zq.common.annotation.Limit;
import com.zq.common.base.LimitType;
import com.zq.common.utils.AssertUtils;
import com.zq.common.utils.RequestUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
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.util.Collections;
import java.util.List;
import java.util.Objects;
/**
* @author /
*/
@Aspect
@Component
public class LimitAspect {
private final StringRedisTemplate stringRedisTemplate;
private static final Logger logger = LoggerFactory.getLogger(LimitAspect.class);
public LimitAspect(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
@Pointcut("@annotation(com.zq.common.annotation.Limit)")
public void pointcut() {
}
@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method signatureMethod = signature.getMethod();
Limit limit = signatureMethod.getAnnotation(Limit.class);
LimitType limitType = limit.limitType();
String key = limit.key();
if (StringUtils.isBlank(key)) {
if (limitType == LimitType.IP) {
key = RequestUtils.getIp(request);
} else {
key = signatureMethod.getName();
if ("sendCode".equals(key)) {
key = (String) joinPoint.getArgs()[0];
}
}
}
key = StringUtils.join(limit.prefix(), "_", key, "_", signatureMethod.getName());
/*String obj = stringRedisTemplate.opsForValue().get(key);
int currentLimit = 0;
if (obj != null) {
currentLimit = Integer.parseInt(obj);
}
if (currentLimit + 1 > limit.count()) {
throw new BusinessException("访问次数受限制");
}
stringRedisTemplate.opsForValue().set(key, (currentLimit + 1) + "");
stringRedisTemplate.expire(key, limit.period(), TimeUnit.SECONDS);
logger.info("第{}次访问key为 {}，描述为 [{}] 的接口", currentLimit + 1, key, limit.name());
return joinPoint.proceed();*/
List<String> keys = Collections.singletonList(key);
String luaScript = buildLuaScript();
RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
Long count = stringRedisTemplate.execute(redisScript, keys, String.valueOf(limit.count()), String.valueOf(limit.period()));
AssertUtils.isTrue(count != null && count != 0, "访问次数受限制");
logger.info("第{}次访问key为 {}，描述为 [{}] 的接口", count, keys, limit.name());
return joinPoint.proceed();
}
/**
* 限流脚本
*/
private String buildLuaScript() {
return "-- lua 下标从 1 开始" +
"\n-- 限流 key" +
"\nlocal key = KEYS[1]" +
"\n-- 限流大小" +
"\nlocal limit = tonumber(ARGV[1])" +
"\nlocal perSeconds = tonumber(ARGV[2])" +
"\n" +
"\n-- 获取当前流量大小" +
"\nlocal currentLimit = tonumber(redis.call('get', key) or 0)" +
"\n" +
"\nif currentLimit + 1 > limit then" +
"\n -- 达到限流大小 返回" +
"\n return 0;" +
"\nelse" +
"\n -- 没有达到阈值 value + 1" +
"\n redis.call('INCRBY', key, 1)" +
"\n -- EXPIRE的单位是秒" +
"\n redis.call('EXPIRE', key, perSeconds)" +
"\n return currentLimit + 1" +
"\nend";
}
}
common-client/src/main/java/com/zq/common/config/redis/CacheKeys.java 0 → 100644
package com.zq.common.config.redis;
public abstract class CacheKeys {
public static final String PREFIX = "drug.";
private static final String APP_TOKEN = PREFIX + "app-token.";
/**
* 构建app端用户token的缓存key
*
* @param token app登陆后的token
* @return
*/
public static String appTokenKey(String token) {
return APP_TOKEN + token;
}
}
common-client/src/main/java/com/zq/common/config/redis/RedisConfig.java 0 → 100644
/*
* Copyright 2019-2020 Zheng Jie
*
* Licensed 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
*
* http://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.
*/
package com.zq.common.config.redis;
import cn.hutool.core.lang.Assert;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.Cache;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
/**
* @author Zheng Jie
* @date 2018-11-24
*/
@Slf4j
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfig extends CachingConfigurerSupport {
/**
* 设置 redis 数据默认过期时间，默认2小时
* 设置@cacheable 序列化方式
*/
@Bean
public RedisCacheConfiguration redisCacheConfiguration() {
FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig();
configuration = configuration.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(fastJsonRedisSerializer)).entryTtl(Duration.ofHours(2));
return configuration;
}
@SuppressWarnings("all")
@Bean(name = "redisTemplate")
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
//序列化
FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
// value值的序列化采用fastJsonRedisSerializer
template.setValueSerializer(fastJsonRedisSerializer);
template.setHashValueSerializer(fastJsonRedisSerializer);
// 全局开启AutoType，这里方便开发，使用全局的方式
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
// 建议使用这种方式，小范围指定白名单
// ParserConfig.getGlobalInstance().addAccept("me.zhengjie.domain");
// key的序列化采用StringRedisSerializer
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
template.setConnectionFactory(redisConnectionFactory);
return template;
}
/**
* 自定义缓存key生成策略，默认将使用该策略
*/
@Bean
@Override
public KeyGenerator keyGenerator() {
return (target, method, params) -> {
Map<String, Object> container = new HashMap<>(3);
Class<?> targetClassClass = target.getClass();
// 类地址
container.put("class", targetClassClass.toGenericString());
// 方法名称
container.put("methodName", method.getName());
// 包名称
container.put("package", targetClassClass.getPackage());
// 参数列表
for (int i = 0; i < params.length; i++) {
container.put(String.valueOf(i), params[i]);
}
// 转为JSON字符串
String jsonString = JSON.toJSONString(container);
// 做SHA256 Hash计算，得到一个SHA256摘要作为Key
return DigestUtils.sha256Hex(jsonString);
};
}
@Bean
@Override
public CacheErrorHandler errorHandler() {
// 异常处理，当Redis发生异常时，打印日志，但是程序正常走
log.info("初始化 -> [{}]", "Redis CacheErrorHandler");
return new CacheErrorHandler() {
@Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
log.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
}
@Override
public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
log.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
}
@Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
log.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
}
@Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
log.error("Redis occur handleCacheClearError：", e);
}
};
}
}
/**
* Value 序列化
*
* @param <T>
* @author /
*/
class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
private final Class<T> clazz;
FastJsonRedisSerializer(Class<T> clazz) {
super();
this.clazz = clazz;
}
@Override
public byte[] serialize(T t) {
if (t == null) {
return new byte[0];
}
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(StandardCharsets.UTF_8);
}
@Override
public T deserialize(byte[] bytes) {
if (bytes == null || bytes.length <= 0) {
return null;
}
String str = new String(bytes, StandardCharsets.UTF_8);
return JSON.parseObject(str, clazz);
}
}
/**
* 重写序列化器
*
* @author /
*/
class StringRedisSerializer implements RedisSerializer<Object> {
private final Charset charset;
StringRedisSerializer() {
this(StandardCharsets.UTF_8);
}
private StringRedisSerializer(Charset charset) {
Assert.notNull(charset, "Charset must not be null!");
this.charset = charset;
}
@Override
public String deserialize(byte[] bytes) {
return (bytes == null ? null : new String(bytes, charset));
}
@Override
public byte[] serialize(Object object) {
String string = JSON.toJSONString(object);
if (StringUtils.isBlank(string)) {
return null;
}
string = string.replace("\"", "");
return string.getBytes(charset);
}
}
common-client/src/main/java/com/zq/common/constant/AssetsBizTypeEnum.java 0 → 100644
package com.zq.common.constant;
/**
* Assets明细类别枚举
*
* @author wilmiam
* @since 2019-07-01
*/
public enum AssetsBizTypeEnum {
RECHARGE(1, "充值"),
WITHDRAW(2, "提现"),
PRAISE_ONE(3, "1星评价"),
PRAISE_TWO(4, "2星评价"),
PRAISE_THREE(5, "3星评价"),
PRAISE_FOUR(6, "4星好评"),
PRAISE_FIVE(7, "5星好评"),
RECOMMEND(8, "推荐住院"),
CARD_CONSUME_SHARE(9, "卡消费分成"),
;
private int value;
private String label;
AssetsBizTypeEnum(int value, String label) {
this.value = value;
this.label = label;
}
/**
* 获取指定值得枚举对象
*
* @param value 枚举值
* @return 未找到匹配值则返回{@code null}
*/
public static AssetsBizTypeEnum ofValue(int value) {
AssetsBizTypeEnum result = null;
for (AssetsBizTypeEnum item : values()) {
if (item.value == value) {
result = item;
break;
}
}
return result;
}
public int value() {
return this.value;
}
public String label() {
return this.label;
}
}
common-client/src/main/java/com/zq/common/constant/EducationalLevelEnum.java 0 → 100644
package com.zq.common.constant;
/**
* 教育程度枚举
* @author Hmb
* @since 2022-07-10 15:08
*/
public enum EducationalLevelEnum {
/** 教育程度枚举 */
DOCTOR(1, "博士"),
MASTER(2, "硕士"),
UNDERGRADUATE(3, "本科"),
COLLEGE(4, "大专"),
SPECIALIST(5, "专科"),
TECHNICAL_SECONDARY_SCHOOL(6, "中专"),
HIGHER_VOCATIONAL(6, "高职"),
HIGH_SCHOOL(7, "高中"),
JUNIOR_HIGH_SCHOOL(8, "初中"),
PRIMARY_SCHOOL(9, "小学"),
ILLITERACY(10, "文盲"),
UNKNOWN(11, "不详");
private final int value;
private final String label;
EducationalLevelEnum(int value, String label) {
this.value = value;
this.label = label;
}
/**
* 获取指定值得枚举对象
*
* @param value 枚举值
* @return 未找到匹配值则返回{@code null}
*/
public static EducationalLevelEnum ofValue(int value) {
EducationalLevelEnum result = null;
for (EducationalLevelEnum item : values()) {
if (item.value == value) {
result = item;
break;
}
}
return result;
}
public int value() {
return this.value;
}
public String label() {
return this.label;
}
}
common-client/src/main/java/com/zq/common/constant/OrderBizTypeEnum.java 0 → 100644
package com.zq.common.constant;
/**
* Assets明细类别枚举
*
* @author wilmiam
* @since 2019-07-01
*/
public enum OrderBizTypeEnum {
IMAGE_CARD(1, "图文卡"),
PHONE_CARD(2, "语音卡"),
VIDEO_CARD(3, "视频卡"),
ONE_MONTH(4, "30天VIP"),
HALF_YEAR(5, "半年VIP"),
ONE_YEAR(6, "一年VIP"),
;
private int value;
private String label;
OrderBizTypeEnum(int value, String label) {
this.value = value;
this.label = label;
}
/**
* 获取指定值得枚举对象
*
* @param value 枚举值
* @return 未找到匹配值则返回{@code null}
*/
public static OrderBizTypeEnum ofValue(int value) {
OrderBizTypeEnum result = null;
for (OrderBizTypeEnum item : values()) {
if (item.value == value) {
result = item;
break;
}
}
return result;
}
public int value() {
return this.value;
}
public String label() {
return this.label;
}
}
common-client/src/main/java/com/zq/common/constant/PlatformBizTypeEnum.java 0 → 100644
package com.zq.common.constant;
/**
* Assets明细类别枚举
*
* @author wilmiam
* @since 2019-07-01
*/
public enum PlatformBizTypeEnum {
CONSULTATION_CARD(1, true, "咨询卡"),
RECHARGE_VIP(2, true, "充值VIP"),
WITHDRAW(3, false, "提现");
private int value;
private Boolean income;
private String label;
PlatformBizTypeEnum(int value, Boolean income, String label) {
this.value = value;
this.income = income;
this.label = label;
}
/**
* 获取指定值得枚举对象
*
* @param value 枚举值
* @return 未找到匹配值则返回{@code null}
*/
public static PlatformBizTypeEnum ofValue(int value) {
PlatformBizTypeEnum result = null;
for (PlatformBizTypeEnum item : values()) {
if (item.value == value) {
result = item;
break;
}
}
return result;
}
public int value() {
return this.value;
}
public Boolean income() {
return this.income;
}
public String label() {
return this.label;
}
}
common-client/src/main/java/com/zq/common/constant/SystemName.java 0 → 100644
package com.zq.common.constant;
public class SystemName {
public static String DRUG = "drug";
public static String BBS = "bbs";
}
common-client/src/main/java/com/zq/common/context/ThreadContext.java 0 → 100644
package com.zq.common.context;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.Map;
/**
* 基于ThreadLocal的线程相关上下文帮助类, 用于在同一线程下传递变量.
*
* @date 2017-12-18
*/
public class ThreadContext {
private static final Logger log = LoggerFactory.getLogger(ThreadContext.class);
private static ThreadLocal<Map<String, Object>> threadLocalMap = ThreadLocal.withInitial(HashMap::new);
/**
* Don't let anyone instantiate this class
*/
private ThreadContext() {
}
/**
* 根据指定的key获取当前线程相关的变量值
*
* @param key 变量的key
* @param <T> 变量值的具体类型
* @return 若无此key对应的变量值, 则返回{@code null}
* @throws ClassCastException 若接收此返回值的变量类型与上下文保存的值的实际类型不匹配, 则抛出异常
*/
@SuppressWarnings("unchecked")
public static <T> T get(String key) {
return (T) threadLocalMap.get().get(key);
}
/**
* 根据指定的key获取当前线程相关的变量值, 若为{@code null}则返回指定的默认值
*
* @param key 变量的key
* @param defaultValue 默认值
* @param <T> 变量值的具体类型
* @return 若无此key对应的变量值, 则返回defaultValue
* @throws ClassCastException 若接收此返回值的变量类型与上下文保存的值的实际类型不匹配, 则抛出异常
*/
@SuppressWarnings("unchecked")
public static <T> T get(String key, T defaultValue) {
T value = get(key);
return value == null ? defaultValue : value;
}
/**
* 设置线程相关上下文的变量值
*
* @param key 变量的key
* @param value 变量值
*/
public static void set(String key, Object value) {
threadLocalMap.get().put(key, value);
}
/**
* 删除指定key的变量
*
* @param key 变量的key
*/
public static void remove(String key) {
threadLocalMap.get().remove(key);
}
/**
* 清除当前线程相关的上下文
*/
public static void close() {
threadLocalMap.remove();
}
}
common-client/src/main/java/com/zq/common/encrypt/AesCbcUtil.java 0 → 100644
package com.zq.common.encrypt;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.AlgorithmParameters;
import java.security.Security;
import java.util.Arrays;
@Slf4j
public class AesCbcUtil {
/**
* AES解密
*
* @param encryptedData // 密文，被加密的数据
* @param sessionKey // 秘钥
* @param ivData // 偏移量
* @return
*/
public static String decrypt(String encryptedData, String sessionKey, String ivData) {
// 被加密的数据
byte[] dataByte = Base64.decodeBase64(encryptedData);
// 加密秘钥
byte[] keyByte = Base64.decodeBase64(sessionKey);
// 偏移量
byte[] ivByte = Base64.decodeBase64(ivData);
// 如果密钥不足16位，那么就补足. 这个if 中的内容很重要
int base = 16;
if (keyByte.length % base != 0) {
int groups = keyByte.length / base + 1;
byte[] temp = new byte[groups * base];
Arrays.fill(temp, (byte) 0);
System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
keyByte = temp;
}
try {
// 初始化
Security.addProvider(new BouncyCastleProvider());
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
// Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC");
SecretKeySpec spec = new SecretKeySpec(keyByte, "AES");
AlgorithmParameters parameters = AlgorithmParameters.getInstance("AES");
parameters.init(new IvParameterSpec(ivByte));
cipher.init(Cipher.DECRYPT_MODE, spec, parameters);// 初始化
byte[] resultByte = cipher.doFinal(dataByte);
if (null != resultByte && resultByte.length > 0) {
return new String(resultByte, StandardCharsets.UTF_8);
}
} catch (Exception e) {
log.error(">> encryptedData解密失败：{}", e.getMessage());
}
return null;
}
}
common-client/src/main/java/com/zq/common/entity/AppAccount.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 小程序账号详细信息(TAppAccount)实体类
*
* @author wilmiam
* @since 2020-10-21 14:24:31
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_app_account")
public class AppAccount {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 开放平台app id
*/
@ApiModelProperty("开放平台app id")
private String componentAppId;
/**
* 微信公众号id
*/
@ApiModelProperty("微信公众号id")
private String appId;
/**
* appSecret
*/
private String appSecret;
/**
* 公众号/小程序的原始id
*/
@ApiModelProperty(" 公众号/小程序的原始id")
private String appOriginalId;
/**
* 小程序名称
*/
@ApiModelProperty("小程序名称")
private String appName;
/**
* 小程序Logo
*/
@ApiModelProperty("小程序Logo")
private String appLogo;
/**
* 描述（主要用户发放红包备注）
*/
@ApiModelProperty("描述（主要用户发放红包备注）")
private String appDesc;
/**
* 小程序二维码、小程序码
*/
@ApiModelProperty("小程序二维码、小程序码")
private String qrcodeUrl;
/**
* 微信商户id
*/
@ApiModelProperty("微信商户id")
private String payMchId;
/**
* 微信商户api密钥
*/
@ApiModelProperty("微信商户api密钥")
private String paySecretKey;
/**
* 证书文件
*/
@ApiModelProperty("证书文件")
private byte[] certFile;
/**
* sdkAppId
*/
@ApiModelProperty("sdkAppId")
private String sdkAppId;
/**
* TRTC秘钥ID
*/
@ApiModelProperty("TRTC秘钥ID")
private String cloudSecretId;
/**
* TRTC秘钥key
*/
@ApiModelProperty("TRTC秘钥key")
private String cloudSecretKey;
/**
* 状态 1正常 2停用
*/
@ApiModelProperty("状态 1正常 2停用")
private Integer status;
/**
* 授权token
*/
@ApiModelProperty("授权token")
private String authorizerAccessToken;
/**
* 刷新token
*/
@ApiModelProperty("刷新token")
private String authorizerRefreshToken;
/**
* token过期时长
*/
@ApiModelProperty("token过期时长")
private Integer expiresIn;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/AppVersion.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* (TAppVersion)实体类
*
* @author wilmiam
* @since 2021-03-02 09:44:35
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_app_version")
public class AppVersion {
/**
* ID
*/
@ApiModelProperty("ID")
@TableId(type = IdType.AUTO)
private Long id;
/**
* 版本号
*/
@ApiModelProperty("版本号")
private String version;
/**
* App名称
*/
@ApiModelProperty("App名称")
private String appName;
/**
* 安卓下载链接
*/
@ApiModelProperty("安卓下载链接")
private String androidUrl;
/**
* iOS下载链接
*/
@ApiModelProperty("iOS下载链接")
private String iosUrl;
/**
* 更新内容
*/
@ApiModelProperty("更新内容")
private String content;
/**
* 是否当前版本
*/
@ApiModelProperty("是否当前版本")
private Boolean isCurrentVersion;
/**
* 更新时间
*/
@ApiModelProperty("更新时间")
private Date createTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/ApproveLog.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "approve_log")
public class ApproveLog {
/**
*
*/
@ApiModelProperty(value = "ID")
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 审批人id
*/
@ApiModelProperty(value = "审批人id")
private Integer approveUserId;
/**
* 审批意见
*/
private String approveOpinion;
/**
* 当前审批状态
*/
private Integer currStatus;
/**
* 案件id
*/
@ApiModelProperty(value = "案件id")
private Integer casId;
/**
* 审批id
*/
@ApiModelProperty(value = "审批人id")
private Integer approveId;
/**
* 审批信息
*/
@ApiModelProperty(value = "审批信息")
private String info;
/**
*
*/
@ApiModelProperty(value = "")
private Date createTime;
/**
*
*/
@ApiModelProperty(value = "")
private Date updateTime;
}
common-client/src/main/java/com/zq/common/entity/Article.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 资讯文章和帖子(TArticle)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:15
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_article")
public class Article {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 发布者ID
*/
@ApiModelProperty("发布者ID")
private Long memberId;
/**
* 封面图
*/
@ApiModelProperty("封面图")
private String coverImageUrl;
/**
* 标题
*/
@ApiModelProperty("标题")
private String title;
/**
* 出处
*/
@ApiModelProperty("出处")
private String source;
/**
* 内容
*/
@ApiModelProperty("内容")
private String content;
/**
* 图片链接地址数组字符串
*/
@ApiModelProperty("图片链接地址数组字符串")
private String imageUrlList;
/**
* 文章跳转链接
*/
@ApiModelProperty("文章跳转链接")
private String jumpHref;
/**
* 状态：0待审核 1审核不通过 2审核通过
*/
@ApiModelProperty("状态：0待审核 1审核不通过 2审核通过")
private Integer approveStatus;
/**
* 审核用户ID
*/
@ApiModelProperty("审核用户ID")
private Long approveUserId;
/**
* 审核用户名
*/
@ApiModelProperty("审核用户名")
private String approveUserName;
/**
* 审核备注
*/
@ApiModelProperty("审核备注")
private String approveRemarks;
/**
* 状态：1显示 2 隐藏 3删除
*/
@ApiModelProperty("状态：1显示 2隐藏 3删除")
private Integer status;
/**
* 是否推荐
*/
@ApiModelProperty("是否推荐")
private Boolean isRecommend;
/**
* 是否加精
*/
@ApiModelProperty("是否加精")
private Boolean isFinePaste;
/**
* 是否匿名
*/
@ApiModelProperty("是否匿名")
private Boolean isAnonymous;
/**
* 是否允许评论
*/
@ApiModelProperty("是否允许评论")
private Boolean isAllowComment;
/**
* 分享数量
*/
@ApiModelProperty("分享数量")
private Integer shareNum;
/**
* 评论数量
*/
@ApiModelProperty("评论数量")
private Integer commentNum;
/**
* 点赞数量
*/
@ApiModelProperty("点赞数量")
private Integer likeNum;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/ArticleCollect.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 文章收藏(TArticleCollect)实体类
*
* @author wilmiam
* @since 2020-11-09 16:49:09
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_article_collect")
public class ArticleCollect {
/**
* id
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("收藏记录ID")
private Long id;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 文章ID
*/
@ApiModelProperty("文章ID")
private Long articleId;
/**
* createTime
*/
private Date createTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/ArticleComment.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 文章评论表(TArticleComment)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:15
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_article_comment")
public class ArticleComment {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 文章ID
*/
@ApiModelProperty("文章ID")
private Long articleId;
/**
* 上级ID
*/
@ApiModelProperty("上级ID")
private Long pid;
/**
* 所有上级
*/
@ApiModelProperty("所有上级")
private String pids;
/**
* 内容
*/
@ApiModelProperty("内容")
private String content;
/**
* 点赞数量
*/
@ApiModelProperty("点赞数量")
private Integer likeNum;
/**
* 评论数量
*/
@ApiModelProperty("评论数量")
private Integer commentNum;
/**
* 回复级别
*/
@ApiModelProperty("回复级别")
private Integer replyLevel;
/**
* 是否是楼主
*/
@ApiModelProperty("是否是楼主")
private Boolean isLandlord;
/**
* 是否匿名
*/
@ApiModelProperty("是否匿名")
private Boolean isAnonymous;
/**
* 是否删除
*/
@ApiModelProperty("是否删除")
private Boolean isDel;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/ArticleLike.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 文章足迹 收藏(TArticleLike)实体类
*
* @author wilmiam
* @since 2020-11-05 10:30:38
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_article_like")
public class ArticleLike {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 文章ID 或 评论ID
*/
@ApiModelProperty("文章ID 或 评论ID")
private Long targetId;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 1.文章点赞 2.评论点赞
*/
@ApiModelProperty("1.文章点赞 2.评论点赞")
private Integer type;
/**
* createTime
*/
private Date createTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/ArticleTrace.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 文章足迹 收藏(TArticleTrace)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_article_trace")
public class ArticleTrace {
/**
* id
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("浏览记录ID")
private Long id;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 文章ID
*/
@ApiModelProperty("文章ID")
private Long articleId;
/**
* createTime
*/
private Date createTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/Assets.java 0 → 100644
package com.zq.common.entity;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
/**
* (TAssets)实体类
*
* @author wilmiam
* @since 2020-11-07 11:36:45
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_assets")
public class Assets {
/**
* 资产ID
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("资产ID")
private Long id;
/**
* 用户ID
*/
@ApiModelProperty("用户ID")
private Long memberId;
/**
* 可用余额
*/
@ApiModelProperty("可用余额")
private BigDecimal available;
/**
* 冻结余额
*/
@ApiModelProperty("冻结余额")
private BigDecimal frozen;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/AssetsFlow.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.util.Date;
/**
* 资产记录表(TAssetsRecord)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_assets_flow")
public class AssetsFlow {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 商户订单编号
*/
@ApiModelProperty("商户订单编号")
private String tradeNo;
/**
* 金额
*/
@ApiModelProperty("金额")
private BigDecimal amount;
/**
* 变动前余额
*/
@ApiModelProperty("变动前余额")
private BigDecimal amountBefore;
/**
* 变动后余额
*/
@ApiModelProperty("变动后余额")
private BigDecimal amountAfter;
/**
* 0-支出 1-收入
*/
@ApiModelProperty("0-支出 1-收入")
private Boolean income;
/**
* 变动类别
*/
@ApiModelProperty("变动类别")
private Integer category;
/**
* 说明
*/
@ApiModelProperty("说明")
private String note;
/**
* 备注
*/
@ApiModelProperty("备注")
private String remarks;
/**
* createTime
*/
private Date createTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/BankCard.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 银行卡信息(TBankCard)实体类
*
* @author wilmiam
* @since 2020-10-22 09:55:21
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_bank_card")
public class BankCard {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 持卡人
*/
@ApiModelProperty("持卡人")
private String cardholder;
/**
* 身份证号
*/
@ApiModelProperty("身份证号")
private String idCard;
/**
* 开卡行
*/
@ApiModelProperty("开卡行")
private String cardIssuingBank;
/**
* 银行卡号
*/
@ApiModelProperty("银行卡号")
private String cardNo;
/**
* 预留手机号
*/
@ApiModelProperty("预留手机号")
private String reservePhone;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/BjCall.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zheng qing
* @date 2023/6/8
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "bj_call")
public class BjCall {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
@ApiModelProperty(value = "报警人")
private String person;
@ApiModelProperty(value = "报警时间")
private String callTime;
@ApiModelProperty(value = "内容")
private String content;
@ApiModelProperty(value = "涉及人")
private String involvePerson;
@ApiModelProperty(value = "备注")
private String note;
}
common-client/src/main/java/com/zq/common/entity/BjCase.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zheng qing
* @date 2023/6/8
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "bj_case")
public class BjCase {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
@ApiModelProperty(value = "当事人")
private String person;
@ApiModelProperty(value = "报警时间")
private String callTime;
@ApiModelProperty(value = "内容")
private String content;
@ApiModelProperty(value = "涉及人")
private String involvePerson;
@ApiModelProperty(value = "备注")
private String note;
}
common-client/src/main/java/com/zq/common/entity/CalcPenalty.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 实际量刑计算主表
* @author Hmb
* @since 2022/7/4 16:35
*/
@ApiModel(value = "实际量刑计算主表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "calc_penalty")
public class CalcPenalty {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value = "案件id")
private Integer caseInfoId;
/**
* 主刑基础刑罚信息id
*/
@TableField(value = "penalty_base_id")
@ApiModelProperty(value = "主刑基础刑罚信息id")
private Integer penaltyBaseId;
/**
* 基础刑罚天数，量刑起点
*/
@TableField(value = "penalty_base_days")
@ApiModelProperty(value = "基础刑罚天数，量刑起点")
private Integer penaltyBaseDays;
/**
* 总的刑罚天数
*/
@TableField(value = "total_penalty_days")
@ApiModelProperty(value = "总的刑罚天数")
private Integer totalPenaltyDays;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value = "")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value = "")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CalcPenaltyAdd.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 实际量刑计算增加刑罚量表
* @author Hmb
* @since 2022/7/4 16:35
*/
@ApiModel(value = "实际量刑计算增加刑罚量表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "calc_penalty_add")
public class CalcPenaltyAdd {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value = "案件id")
private Integer caseInfoId;
/**
* 主刑增加刑罚信息id
*/
@TableField(value = "penalty_add_id")
@ApiModelProperty(value = "主刑增加刑罚信息id")
private Integer penaltyAddId;
/**
* 增加刑罚天数
*/
@TableField(value = "penalty_add_days")
@ApiModelProperty(value = "增加刑罚天数")
private Integer penaltyAddDays;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value = "")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value = "")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CalcPenaltyAddX.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 实际量刑计算增加基准刑表
* @author Hmb
* @since 2022/7/4 16:35
*/
@ApiModel(value = "实际量刑计算增加基准刑表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "calc_penalty_add_x")
public class CalcPenaltyAddX {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value = "案件id")
private Integer caseInfoId;
/**
* 增加刑罚比例X信息id
*/
@TableField(value = "penalty_add_x_id")
@ApiModelProperty(value = "增加刑罚比例X信息id")
private Integer penaltyAddXId;
/**
* 增加刑罚X比例
*/
@TableField(value = "penalty_add_x_percent")
@ApiModelProperty(value = "增加刑罚X比例")
private Integer penaltyAddXPercent;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value = "")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value = "")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CalcPenaltyCash.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author Hmb
* @since 2022-07-13 21:51
*/
/**
* 实际罚金表
*/
@ApiModel(value="实际罚金表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "calc_penalty_cash")
public class CalcPenaltyCash {
/**
* 自增长id
*/
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value="自增长id")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value="案件id")
private Integer caseInfoId;
/**
* 主刑基础刑罚信息id
*/
@TableField(value = "penalty_base_id")
@ApiModelProperty(value="主刑基础刑罚信息id")
private Integer penaltyBaseId;
/**
* 总的刑罚天数
*/
@TableField(value = "total_penalty_days")
@ApiModelProperty(value="总的刑罚天数")
private Integer totalPenaltyDays;
/**
* 罚金规范id
*/
@TableField(value = "penalty_cash_rule_id")
@ApiModelProperty(value="罚金规范id")
private Integer penaltyCashRuleId;
/**
* 实际罚金多少钱
*/
@TableField(value = "penalty_cash")
@ApiModelProperty(value="实际罚金多少钱")
private Integer penaltyCash;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value="")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value="")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CalcPenaltyReduceDiscretionary.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 酌定情节实际减少基准刑表
* @author Hmb
* @since 2022-08-07 14:30
*/
@ApiModel(value="酌定情节实际减少基准刑表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "calc_penalty_reduce_discretionary")
public class CalcPenaltyReduceDiscretionary {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value="")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value="案件id")
private Integer caseInfoId;
/**
* 酌定情节减少比例信息id
*/
@TableField(value = "reduce_discretionary_id")
@ApiModelProperty(value="酌定情节减少比例信息id")
private Integer reduceDiscretionaryId;
/**
* 酌定情节减少比例
*/
@TableField(value = "reduce_discretionary_percent")
@ApiModelProperty(value="酌定情节减少比例")
private Integer reduceDiscretionaryPercent;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value="")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value="")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CalcPenaltyReduceY.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 实际量刑计算减少基准刑表
* @author Hmb
* @since 2022/7/4 16:35
*/
@ApiModel(value = "实际量刑计算减少基准刑表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "calc_penalty_reduce_y")
public class CalcPenaltyReduceY {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value = "案件id")
private Integer caseInfoId;
/**
* 减少刑罚比例Y信息id
*/
@TableField(value = "penalty_reduce_y_id")
@ApiModelProperty(value = "减少刑罚比例Y信息id")
private Integer penaltyReduceYId;
/**
* 减少刑罚Y比例
*/
@TableField(value = "penalty_reduce_y_percent")
@ApiModelProperty(value = "减少刑罚Y比例")
private Integer penaltyReduceYPercent;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value = "")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value = "")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CardBag.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.util.Date;
/**
* 卡包表(TCardBag)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_card_bag")
public class CardBag {
/**
* 卡包ID
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("卡包ID")
private Long id;
/**
* 用户ID
*/
@ApiModelProperty("用户ID")
private Long memberId;
/**
* 咨询的医生ID
*/
@ApiModelProperty("咨询的医生ID")
private Long doctorId;
/**
* 卡类型 0开会员赠送 1图文 2语音 3视频
*/
@ApiModelProperty("卡类型 0开会员赠送 1图文 2语音 3视频")
private Integer type;
/**
* 金额
*/
@ApiModelProperty("金额")
private BigDecimal amount;
/**
* 剩余时间
*/
@ApiModelProperty("剩余时间")
private String surplusTime;
/**
* 到期时间
*/
@ApiModelProperty("到期时间")
private Date dueTime;
/**
* 商户订单编号
*/
@ApiModelProperty("商户订单编号")
private String tradeNo;
/**
* 支付返回的交易号
*/
@ApiModelProperty("支付返回的交易号")
private String transactionId;
/**
* 状态 1未使用 2使用中 3已使用
*/
@ApiModelProperty("状态 0未支付 1未使用 2使用中 3已使用 4已失效")
private Integer status;
/**
* 支付类型 1支付宝 2微信
*/
@ApiModelProperty("支付类型 1支付宝 2微信")
private Integer payType;
/**
* 支付时间
*/
@ApiModelProperty("支付时间")
private Date payTime;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CasInfo.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "cas_info")
public class CasInfo {
/**
* 案件信息id
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("案件信息id")
private Integer id;
/**
* 审批环节信息(1审批中 99完成)
*/
// TODO: 2022/6/13 审批需求新增字段
@ApiModelProperty("审批环节信息 (1审批中 99完成)")
private Integer currStep;
/**
* 上传人
*/
@ApiModelProperty("上传案件人")
private Integer uploadUserId;
/**
* 案件类型
*/
@ApiModelProperty("案件类型")
private Integer casType;
/**
* 是否起诉
*/
@ApiModelProperty("0不起诉 1起诉")
private boolean toSue;
/**
* 酒精含量
*/
@ApiModelProperty("酒精含量")
private float alcoholContent;
/**
* 酒精含量第二次
*/
@ApiModelProperty("酒精含量2")
private float alcoholContent2;
/**
* 乙醇浓度
*/
@ApiModelProperty("乙醇浓度")
private float EthanolConcentration;
/**
* 起诉意见书文号
*/
@ApiModelProperty("起诉意见书文号")
private String docNoIndictment;
/**
* 乙醇检验鉴定书文号
*/
@ApiModelProperty("乙醇检验鉴定书文号")
private String docNoAppraisal;
/**
* 抽血验血医疗机构id
*/
@ApiModelProperty("抽血验血医疗机构id")
private Integer appraisalHospitalId;
/**
* 辩护人情形
*/
@ApiModelProperty("1无 2值班律师 3辩护人")
private Integer counselStatus;
/**
* 侦、调查机关
*/
@ApiModelProperty("侦、调查机关")
private String investigator;
/**
* 人民法院
*/
@ApiModelProperty("人民法院")
private String court;
/**
* 是否有被害人
*/
@ApiModelProperty("是否有被害人 1有 2无")
private Integer hasVictim;
/**
* 案件状态
*/
@ApiModelProperty("1正常 2删除")
private Integer status;
/**
* 修改时间
*/
@ApiModelProperty("更新时间")
private Date updateTime;
/**
* createTime
*/
@ApiModelProperty("创建时间")
private Date createTime;
}
common-client/src/main/java/com/zq/common/entity/CasPersonInvolved.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "cas_person_involved")
public class CasPersonInvolved {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 案件id，绑定案件
*/
@ApiModelProperty("案件id，绑定案件")
private Integer casInfoId;
/**
*涉案人员姓名
*/
@ApiModelProperty("涉案人员姓名")
private String personName;
/**
*涉案人员身份证
*/
@ApiModelProperty("涉案人员身份证")
private String personId;
/**
* 是否认罪认罚
*/
@ApiModelProperty("是否认罪认罚 1是，0否")
private Integer isPlead;
/**
*民族
*/
@TableField(updateStrategy = FieldStrategy.IGNORED)
@ApiModelProperty("民族")
private Long nation;
/**
*受教育程度
*/
@ApiModelProperty("受教育程度")
private Long educationalLevel;
/**
*身份/单位性质
*/
@ApiModelProperty("身份/单位性质")
private Long workType;
/**
*驾照类型
*/
@ApiModelProperty("驾照类型")
private Long drivingLicenseType;
/**
*户籍详细地址
*/
@ApiModelProperty("户籍详细地址")
private String permanentAddress;
/**
*住所详细地址
*/
@ApiModelProperty("住所详细地址")
private String houseAddress;
/**
*是否共产党员
*/
@ApiModelProperty("是否共产党员")
private Integer isCommunistMember;
/**
*是否有前科劣迹
*/
@ApiModelProperty("是否有前科劣迹")
private Integer hasCriminalRecord;
/**
*创建时间
*/
@ApiModelProperty("创建时间")
private Date createTime;
/**
*更新时间
*/
@ApiModelProperty("更新时间")
private Date updateTime;
}
common-client/src/main/java/com/zq/common/entity/CasSentence.java 0 → 100644
package com.zq.common.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 io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "cas_sentence")
public class CasSentence {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 案件id，绑定案件
*/
@ApiModelProperty("案件id，绑定案件")
private Integer casInfoId;
/**
*庭审程序
*/
@ApiModelProperty("庭审程序")
private Long trialProcedureType;
/**
*刑拘时长
*/
@ApiModelProperty("刑拘时长")
private String detentionDuration;
/**
* 是否缓刑 true是 false否
*/
@ApiModelProperty("是否缓刑 true是 false否")
private boolean probation;
/**
*缓刑时长，仅当勾选缓刑选项且输入时长时才有值
*/
@ApiModelProperty("缓刑时长，仅当勾选缓刑选项且输入时长时才有值")
private String probationDuration;
/**
*罚金
*/
@ApiModelProperty("罚金")
private String fineMoney;
/**
*创建时间
*/
@ApiModelProperty("创建时间")
private Date createTime;
/**
*更新时间
*/
@ApiModelProperty("更新时间")
private Date updateTime;
}
common-client/src/main/java/com/zq/common/entity/CasTrial.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "cas_trial")
public class CasTrial {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 案件id，绑定案件
*/
@ApiModelProperty("案件id，绑定案件")
private Integer casInfoId;
/**
*强制（处罚）类型
*/
@ApiModelProperty("强制（处罚）类型 1刑事拘留取保候审 2 直接取保候审 3 刑拘直诉")
private Integer punishmentType;
/**
* 刑事拘留日期
*/
@ApiModelProperty("刑事拘留日期")
private Date detentionDate;
/**
* 取保日期
*/
@ApiModelProperty("取保日期")
private Date bailDate;
/**
*到案过程
*/
@ApiModelProperty("到案过程")
private String catchDesc;
/**
*供述和辩解
*/
@ApiModelProperty("供述和辩解")
private String declaration;
/**
* 嫌疑人供述证明
*/
@ApiModelProperty("嫌疑人供述和证明")
private String declarationProve;
/**
*侦查查明的事实
*/
@ApiModelProperty("侦查查明的事实")
private String investigation;
/**
*审查查明的事实
*/
@ApiModelProperty("审查查明的事实")
private String reviewFact;
/**
*创建时间
*/
@ApiModelProperty("户籍详细地址")
private Date createTime;
/**
*更新时间
*/
@ApiModelProperty("住所详细地址")
private Date updateTime;
}
common-client/src/main/java/com/zq/common/entity/CaseApprove.java 0 → 100644
package com.zq.common.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 io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 审批流程信息表
* @author Hmb
* @date 2022/4/21 11:55
*/
@TableName(value ="cas_approve")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CaseApprove {
/**
* 主键
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("id")
private Integer id;
/**
* 提交人id
*/
@ApiModelProperty("提交审批人id")
private Integer submitUserId;
/**
* 案子信息id
*/
@ApiModelProperty("案子id")
private Integer caseInfoId;
/**
* 审批人id
*/
@ApiModelProperty("审批人id")
private Integer approveUserId;
/**
* 审批环节
1审批中 99完成
*/
@ApiModelProperty("审批环节 1审批中 99完成")
private Integer currStep;
/**
* 审批状态
0等待审批 1通过 2拒绝
*/
@ApiModelProperty("审批状态 0等待审批 1通过 2拒绝")
@TableField("approve_status")
private Integer approveStatus;
/**
* 审批意见
*/
@ApiModelProperty("审批意见")
private String approveOpinion;
/**
* 创建时间
*/
@ApiModelProperty("创建时间")
private Date createTime;
/**
* 更新时间
*/
@ApiModelProperty("更新时间")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CaseBase.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author Hmb
* @since 2022/7/29 17:12
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "case_base")
public class CaseBase {
/**
* 自增id
*/
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**
* 地域
*/
@TableField(value = "area")
@ApiModelProperty(value="地域")
private String area;
/**
* 案件类型(0刑事案件 1民事案件 2行政案件 3赔偿案件 4执行案件)
*/
@TableField(value = "case_type")
@ApiModelProperty(value="案件类型(0刑事案件 1民事案件 2行政案件 3赔偿案件 4执行案件)")
private Integer caseType;
/**
* 罪名
*/
@TableField(value = "charge")
@ApiModelProperty(value="罪名")
private String charge;
/**
* 酒精含量
*/
@TableField(value = "alcohol_content")
@ApiModelProperty(value="酒精含量")
private String alcoholContent;
/**
* (0普通二轮摩托车 1小型轿车 2小型客车 3小型汽车)
*/
@TableField(value = "vehicle_type")
@ApiModelProperty(value="车辆类型(0普通二轮摩托车 1小型轿车 2小型客车 3小型汽车)")
private Integer vehicleType;
/**
* 是否发生事故(0无事故 1有事故全部责任 2有事故主要责任 3有事故同等责任 4有事故次要责任 5有事故无责任)
*/
@TableField(value = "is_accident")
@ApiModelProperty(value="是否发生事故(0无事故 1有事故全部责任 2有事故主要责任 3有事故同等责任 4有事故次要责任 5有事故无责任)")
private Integer isAccident;
/**
* 是否有前科(0无前科 1曾因酒驾被行政处罚 2曾因酒驾被不起诉 3曾因酒驾被判刑 4有其他犯罪前科)
*/
@TableField(value = "is_criminal_record")
@ApiModelProperty(value="是否有前科(0无前科 1曾因酒驾被行政处罚 2曾因酒驾被不起诉 3曾因酒驾被判刑 4有其他犯罪前科)")
private Integer isCriminalRecord;
/**
* 是否有驾驶资格(0有驾驶资格 1无驾驶资格)
*/
@TableField(value = "is_driving_qualification")
@ApiModelProperty(value="是否有驾驶资格(0有驾驶资格 1无驾驶资格)")
private Integer isDrivingQualification;
/**
* 是否驾驶检验不合格的机动车(0是 1否)
*/
@TableField(value = "is_unqualified_motor_vehicles")
@ApiModelProperty(value="是否驾驶检验不合格的机动车(0是 1否)")
private Integer isUnqualifiedMotorVehicles;
/**
* 文件路径
*/
@TableField(value = "file_path")
@ApiModelProperty(value="文件路径")
private String filePath;
/**
* 文件名称
*/
@TableField(value = "file_name")
@ApiModelProperty(value="文件名称")
private String fileName;
/**
* 文件内容
*/
@TableField(value = "file_content")
@ApiModelProperty(value="文件内容")
private String fileContent;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value="创建时间")
private Date createTime;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value="更新时间")
private Date updateTime;
}
common-client/src/main/java/com/zq/common/entity/CaseType.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("case_type")
public class CaseType implements Serializable {
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**
* 案件类型名称
*/
private String typeName;
/**
* 上级案件类型id
*/
private Integer parentId;
/**
* 状态：1正常，2不可用
*/
private Integer status;
private Date createTime;
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CaseUnite.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("case_unite")
public class CaseUnite implements Serializable {
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
private String caseName;
private Integer caseTypeId;
private Date createTime;
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CaseVictim.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 案件被害人信息
* @author Hmb
* @since 2022/7/26 12:27
*/
@ApiModel(value="案件被害人信息")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "case_victim")
public class CaseVictim {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value="")
private Integer id;
/**
* 案件id
*/
@TableField(value = "cas_info_id")
@ApiModelProperty(value="案件id")
private Integer casInfoId;
/**
* 被害人姓名
*/
@TableField(value = "victim_name")
@ApiModelProperty(value="被害人姓名")
private String victimName;
/**
* 被害人电话
*/
@TableField(value = "victim_phone")
@ApiModelProperty(value="被害人电话")
private String victimPhone;
/**
* 被害人陈述摘录
*/
@TableField(value = "victim_excerpt")
@ApiModelProperty(value="被害人陈述摘录")
private String victimExcerpt;
/**
* 被害人身份证
*/
@TableField(value = "victim_id_card")
@ApiModelProperty(value="被害人身份证")
private String victimIdCard;
/**
* 被害人户籍
*/
@TableField(value = "victim_household_address")
@ApiModelProperty(value="被害人户籍")
private String victimHouseholdAddress;
/**
* 被害人现住址
*/
@TableField(value = "victim_current_address")
@ApiModelProperty(value="被害人现住址")
private String victimCurrentAddress;
/**
* 证明内容
*/
@TableField(value = "victim_prove")
@ApiModelProperty(value="证明内容")
private String victimProve;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value="")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value="")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/CaseWitness.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 案件证人证言
* @author Hmb
* @since 2022/7/26 12:27
*/
@ApiModel(value="案件证人证言")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "case_witness")
public class CaseWitness {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value="")
private Integer id;
/**
* 案件id
*/
@TableField(value = "cas_info_id")
@ApiModelProperty(value="案件id")
private Integer casInfoId;
/**
* 询问证人的姓名
*/
@TableField(value = "witness_name")
@ApiModelProperty(value="询问证人的姓名")
private String witnessName;
/**
* 证人人电话
*/
@TableField(value = "witness_phone")
@ApiModelProperty(value="证人电话")
private String witnessPhone;
/**
* 证人身份证
*/
@TableField(value = "witness_id_card")
@ApiModelProperty(value="被害人身份证")
private String witnessIdCard;
/**
* 证人户籍
*/
@TableField(value = "witness_household_address")
@ApiModelProperty(value="证人户籍")
private String witnessHouseholdAddress;
/**
* 证人现住址
*/
@TableField(value = "witness_current_address")
@ApiModelProperty(value="证人现住址")
private String witnessCurrentAddress;
/**
* 询问证人的供述
*/
@TableField(value = "witness_excerpt")
@ApiModelProperty(value="询问证人的供述")
private String witnessExcerpt;
/**
* 证明
*/
@TableField(value = "witness_prove")
@ApiModelProperty(value="证明")
private String witnessProve;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value="")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value="")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/ConsultRecord.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.util.Date;
/**
* 咨询记录(TConsultRecord)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_consult_record")
public class ConsultRecord {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 医生ID
*/
@ApiModelProperty("医生ID")
private Long doctorId;
/**
* 卡包ID
*/
@ApiModelProperty("卡包ID")
private Long cardId;
/**
* 咨询类型1图文 2语音 3视频
*/
@ApiModelProperty("咨询类型 1图文 2语音 3视频")
private Integer consultType;
/**
* 音视频房间ID
*/
@ApiModelProperty("音视频房间ID")
private String roomId;
/**
* 是否结束音视频
*/
@ApiModelProperty("是否结束音视频")
private Boolean isFinished;
/**
* 开始时间
*/
@ApiModelProperty("开始时间")
private Date startTime;
/**
* 结束时间
*/
@ApiModelProperty("结束时间")
private Date endTime;
/**
* 时长
*/
@ApiModelProperty("时长")
private String duration;
/**
* 消费金额
*/
@ApiModelProperty("消费金额")
private BigDecimal consumeAmount;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
/**
* 服务等级打分
*/
@ApiModelProperty("服务等级打分")
private Integer evaluationServerLevel;
/**
* 评价内容
*/
@ApiModelProperty("评价内容")
private String evaluationContent;
/**
* 评价时间
*/
@ApiModelProperty("评价时间")
private Date evaluationTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/DocTemplate.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "doc_template")
public class DocTemplate {
/**
* 文书模板id
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("案件信息id")
private Integer id;
/**
* 模板名称
*/
@ApiModelProperty("模板名称")
private String tplName;
/**
* 模板路径
*/
@ApiModelProperty("模板路径")
private String tplFile;
/**
* 检察院id
*/
@ApiModelProperty("检察院id")
private Integer deptId;
/**
* 案件类型
*/
@ApiModelProperty("案件类型")
private String casType;
/**
* 模板状态 2正常 3废弃
*/
@ApiModelProperty("模板状态")
private Integer status;
/**
* 1普通程序 2 速裁程序 3简易程序
*/
@ApiModelProperty("庭审程序：1普通程序 2 速裁程序 3简易程序")
private Integer procType;
/**
* 修改时间
*/
@ApiModelProperty("更新时间")
private Date updateTime;
/**
* createTime
*/
@ApiModelProperty("创建时间")
private Date createTime;
/**
* 用户id
*/
@ApiModelProperty("用户id")
private Integer userId;
}
common-client/src/main/java/com/zq/common/entity/DoctorDetail.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.util.Date;
/**
* 医生详细表(TDoctorDetail)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_doctor_detail")
public class DoctorDetail {
/**
* id
*/
@ApiModelProperty("医生ID")
private Long id;
/**
* 名字
*/
@ApiModelProperty("名字")
private String name;
/**
* 身份证号
*/
@ApiModelProperty("身份证号")
private String idCard;
/**
* 是否在线
*/
@ApiModelProperty("是否在线")
private Boolean isOnline;
/**
* 工牌照
*/
@ApiModelProperty("工牌照")
private String workLicenseUrl;
/**
* 资格证
*/
@ApiModelProperty("资格证")
private String certificateUrl;
/**
* 医生等级 1知名专家 2科室专家
*/
@ApiModelProperty("医生等级 1知名专家 2科室专家")
private Integer level;
/**
* 职称
*/
@ApiModelProperty("职称")
private String title;
/**
* 医院ID
*/
@ApiModelProperty("医院ID")
private Long hospitalId;
/**
* 科室ID
*/
@ApiModelProperty("科室ID")
private Long deptId;
/**
* 介绍
*/
@ApiModelProperty("介绍")
private String introduce;
/**
* 邀请码
*/
@ApiModelProperty("邀请码")
private String invitation;
/**
* 认证状态 1.审核中 2.审核不通过 3.认证成功 4.禁用
*/
@ApiModelProperty("认证状态 1.审核中 2.审核不通过 3.认证成功 4.禁用")
private Integer authStatus;
/**
* 审核用户
*/
@ApiModelProperty("审核用户")
private Long approveUserId;
/**
* 审核用户名
*/
@ApiModelProperty("审核用户名")
private String approveUserName;
/**
* 图文咨询
*/
@ApiModelProperty("图文咨询")
private Boolean imageConsult;
/**
* 图文咨询价格
*/
@ApiModelProperty("图文咨询价格")
private BigDecimal imageConsultPrice;
/**
* 电话咨询
*/
@ApiModelProperty("电话咨询")
private Boolean phoneConsult;
/**
* 电话咨询价格
*/
@ApiModelProperty("电话咨询价格")
private BigDecimal phoneConsultPrice;
/**
* 视频咨询
*/
@ApiModelProperty("视频咨询")
private Boolean videoConsult;
/**
* 视频咨询价格
*/
@ApiModelProperty("视频咨询价格")
private BigDecimal videoConsultPrice;
/**
* 是否推荐
*/
@ApiModelProperty("是否推荐")
private Boolean isRecommend;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/DocumentaryEvidence.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 证据（书证）信息表
* @author Hmb
* @since 2022/7/26 12:27
*/
@ApiModel(value = "证据（书证）信息表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "documentary_evidence")
public class DocumentaryEvidence {
@TableId(value = "id", type = IdType.AUTO)
@ApiModelProperty(value = "")
private Integer id;
/**
* 案件id
*/
@TableField(value = "case_info_id")
@ApiModelProperty(value = "案件id")
private Integer caseInfoId;
/**
* 证据（书证）
*/
@TableField(value = "documentary_evidence")
@ApiModelProperty(value = "证据（书证）")
private String documentaryEvidence;
/**
* 书证证明
*/
@TableField(value = "documentary_prove")
@ApiModelProperty(value = "书证证明")
private String documentaryProve;
@TableField(value = "create_time", fill = FieldFill.INSERT)
@ApiModelProperty(value = "")
private Date createTime;
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value = "")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/Friends.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 我的患者表(Friends)实体类
*
* @author wilmiam
* @since 2020-11-06 14:33:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_friends")
public class Friends {
/**
* 我的患者记录ID
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty("医患关系表ID")
private Long id;
/**
* 医生ID
*/
@ApiModelProperty("医生ID")
private Long doctorId;
/**
* 患者ID
*/
@ApiModelProperty("患者ID")
private Long memberId;
/**
* 备注
*/
@ApiModelProperty("备注")
private String remarks;
/**
* 最后一条消息
*/
@ApiModelProperty("最后一条消息")
private String lastMsg;
/**
* 消息类型 1文字 2图片 3语音 4视频 5卡片
*/
@ApiModelProperty("消息类型 1文字 2图片 3语音 4视频 5卡片")
private Integer lastMsgType;
/**
* 患者未读消息数
*/
@ApiModelProperty("患者未读消息数")
private Integer memberUnread;
/**
* 医生未读消息数
*/
@ApiModelProperty("医生未读消息数")
private Integer doctorUnread;
/**
* 关系码
*/
@ApiModelProperty("关系码")
private String relationCode;
/**
* 创建时间
*/
@ApiModelProperty("创建时间")
private Date createTime;
/**
* 更新时间
*/
@ApiModelProperty("更新时间")
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/Hospital.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 医院信息表(THospital)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_hospital")
public class Hospital {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 名称
*/
@ApiModelProperty("名称")
private String name;
/**
* 级别
*/
@ApiModelProperty("级别")
private String level;
/**
* 地址
*/
@ApiModelProperty("地址")
private String address;
/**
* 电话
*/
@ApiModelProperty("电话")
private String tel;
/**
* 封面图
*/
@ApiModelProperty("封面图")
private String coverImageUrl;
/**
* 介绍
*/
@ApiModelProperty("介绍")
private String introduce;
/**
* 是否推荐
*/
@ApiModelProperty("是否推荐")
private Boolean isRecommend;
/**
* 是否上线
*/
@ApiModelProperty("是否上线")
private Boolean isOnline;
/**
* 是否给医生推荐
*/
@ApiModelProperty("是否给医生推荐")
private Boolean isHospitalized;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/HospitalDept.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* 医院科室表(THospitalDept)实体类
*
* @author wilmiam
* @since 2020-10-20 12:05:16
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_hospital_dept")
public class HospitalDept {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 医院ID
*/
@ApiModelProperty("医院ID")
private Long hospitalId;
/**
* 名称
*/
@ApiModelProperty("名称")
private String name;
/**
* 介绍
*/
@ApiModelProperty("介绍")
private String introduce;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
common-client/src/main/java/com/zq/common/entity/HospitalRecord.java 0 → 100644
package com.zq.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.util.Date;
/**
* 推荐住院记录(THospitalRecord)实体类
*
* @author wilmiam
* @since 2020-11-19 10:22:21
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "t_hospital_record")
public class HospitalRecord {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 医生ID
*/
@ApiModelProperty("医生ID")
private Long doctorId;
/**
* 会员ID
*/
@ApiModelProperty("会员ID")
private Long memberId;
/**
* 推荐医院ID
*/
@ApiModelProperty("推荐医院ID")
private Long hospitalId;
/**
* 开始时间
*/
@ApiModelProperty("开始时间")
private Date startTime;
/**
* 结束时间
*/
@ApiModelProperty("结束时间")
private Date endTime;
/**
* 时长
*/
@ApiModelProperty("时长")
private String duration;
/**
* 消费金额
*/
@ApiModelProperty("消费金额")
private BigDecimal consumeAmount;
/**
* 状态：0待审核 1审核不通过 2审核通过
*/
@ApiModelProperty("状态：0待审核 1审核不通过 2审核通过")
private Integer approveStatus;
/**
* 审核用户ID
*/
@ApiModelProperty("审核用户ID")
private Long approveUserId;
/**
* 审核用户名
*/
@ApiModelProperty("审核用户名")
private String approveUserName;
/**
* createTime
*/
private Date createTime;
/**
* updateTime
*/
private Date updateTime;
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment