pengjunjie/JeecgBoot
1
0
Fork 1
mirror of https://github.com/jeecgboot/JeecgBoot.git synced 2025-12-08 17:12:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

JeecgBoot 2.3 里程碑版本发布，支持微服务和单体自由切换、提供新行编辑表格JVXETable

Browse Source
This commit is contained in:
zhangdaiscott
2020-09-13 18:23:23 +08:00
parent 65d1e6a879
commit 7f30a186df
533 changed files with 187550 additions and 36942 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
jeecg-boot/jeecg-boot-module-system/Dockerfile
View File

@ -10,6 +10,6 @@ WORKDIR /jeecg-boot
EXPOSE 8080
ADD ./target/jeecg-boot-module-system-2.2.1.jar ./
ADD ./target/jeecg-boot-module-system-2.3.0.jar ./
CMD sleep 60;java -Djava.security.egd=file:/dev/./urandom -jar jeecg-boot-module-system-2.2.1.jar
CMD sleep 60;java -Djava.security.egd=file:/dev/./urandom -jar jeecg-boot-module-system-2.3.0.jar

19
jeecg-boot/jeecg-boot-module-system/pom.xml
View File

@ -1,14 +1,14 @@
<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">
<modelVersion>4.0.0</modelVersion>
<artifactId>jeecg-boot-module-system</artifactId>
<parent>
<groupId>org.jeecgframework.boot</groupId>
<artifactId>jeecg-boot-parent</artifactId>
<version>2.2.1</version>
<version>2.3.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>jeecg-boot-module-system</artifactId>
<repositories>
<repository>
@ -28,12 +28,19 @@
</snapshots>
</repository>
</repositories>
<dependencies>
<!-- jeecg base api -->
<dependency>
<groupId>org.jeecgframework.boot</groupId>
<artifactId>jeecg-boot-base-common</artifactId>
<artifactId>jeecg-system-local-api</artifactId>
</dependency>
<dependency>
<groupId>org.jeecgframework.boot</groupId>
<artifactId>jeecg-boot-module-demo</artifactId>
<version>${jeecgboot.version}</version>
</dependency>
</dependencies>
<build>

12
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/JeecgApplication.java → jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/JeecgSystemApplication.java
View File

@ -3,6 +3,7 @@ package org.jeecg;
import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.Context;
import org.apache.tomcat.util.scan.StandardJarScanner;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
@ -17,26 +18,27 @@ import java.net.UnknownHostException;
@Slf4j
@SpringBootApplication
public class JeecgApplication extends SpringBootServletInitializer {
public class JeecgSystemApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(JeecgApplication.class);
return application.sources(JeecgSystemApplication.class);
}
public static void main(String[] args) throws UnknownHostException {
//System.setProperty("spring.devtools.restart.enabled", "true");
ConfigurableApplicationContext application = SpringApplication.run(JeecgApplication.class, args);
ConfigurableApplicationContext application = SpringApplication.run(JeecgSystemApplication.class, args);
Environment env = application.getEnvironment();
String ip = InetAddress.getLocalHost().getHostAddress();
String port = env.getProperty("server.port");
String path = env.getProperty("server.servlet.context-path");
String path = oConvertUtils.getString(env.getProperty("server.servlet.context-path"));
log.info("\n----------------------------------------------------------\n\t" +
"Application Jeecg-Boot is running! Access URLs:\n\t" +
"Local: \t\thttp://localhost:" + port + path + "/\n\t" +
"External: \thttp://" + ip + ":" + port + path + "/\n\t" +
"Swagger文档: \thttp://" + ip + ":" + port + path + "/doc.html\n" +
"Swagger-ui: \thttp://" + ip + ":" + port + path + "/swagger-ui.html\n\t" +
"Doc文档: \thttp://" + ip + ":" + port + path + "/doc.html\n" +
"----------------------------------------------------------");
}

28
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/AutoPoiConfig.java
View File

@ -1,28 +0,0 @@
package org.jeecg.config;
import org.jeecgframework.core.util.ApplicationContextUtil;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @Author: Scott
* @Date: 2018/2/7
* @description: autopoi 配置类
*/
@Configuration
public class AutoPoiConfig {
/**
* excel注解字典参数支持(导入导出字典值，自动翻译)
* 举例： @Excel(name = "性别", width = 15, dicCode = "sex")
* 1、导出的时候会根据字典配置，把值1,2翻译成：男、女;
* 2、导入的时候，会把男、女翻译成1,2存进数据库;
* @return
*/
@Bean
public ApplicationContextUtil applicationContextUtil() {
return new org.jeecgframework.core.util.ApplicationContextUtil();
}
}

38
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/MinioConfig.java
View File

@ -1,38 +0,0 @@
package org.jeecg.config;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.util.MinioUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Minio文件上传配置文件
*/
@Slf4j
@Configuration
public class MinioConfig {
@Value(value = "${jeecg.minio.minio_url}")
private String minioUrl;
@Value(value = "${jeecg.minio.minio_name}")
private String minioName;
@Value(value = "${jeecg.minio.minio_pass}")
private String minioPass;
@Value(value = "${jeecg.minio.bucketName}")
private String bucketName;
@Bean
public void initMinio(){
if(!minioUrl.startsWith("http")){
minioUrl = "http://" + minioUrl;
}
if(!minioUrl.endsWith("/")){
minioUrl = minioUrl.concat("/");
}
MinioUtil.setMinioUrl(minioUrl);
MinioUtil.setMinioName(minioName);
MinioUtil.setMinioPass(minioPass);
MinioUtil.setBucketName(bucketName);
}
}

120
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/MybatisPlusConfig.java
View File

@ -1,120 +0,0 @@
package org.jeecg.config;
import com.baomidou.mybatisplus.core.parser.ISqlParser;
import com.baomidou.mybatisplus.core.parser.ISqlParserFilter;
import com.baomidou.mybatisplus.core.parser.SqlParserHelper;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantHandler;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantSqlParser;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.schema.Column;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.reflection.MetaObject;
import org.jeecg.config.mybatis.JeecgTenantParser;
import org.jeecg.modules.system.util.TenantContext;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
/**
* 单数据源配置（jeecg.datasource.open = false时生效）
* @Author zhoujf
*
*/
@Configuration
@MapperScan(value={"org.jeecg.modules.**.mapper*"})
public class MybatisPlusConfig {
/**
* tenant_id 字段名
*/
public static final String tenant_field = "tenant_id";
/**
* 有哪些表需要做多租户 这些表需要添加一个字段 ，字段名和tenant_field对应的值一样
*/
private static final List<String> tenantTable = new ArrayList<String>();
static {
tenantTable.add("jee_bug_danbiao");
}
/**
* 多租户属于 SQL 解析部分，依赖 MP 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor().setLimit(-1);
/*
* 【测试多租户】 SQL 解析处理拦截器<br>
* 这里固定写成住户 1 实际情况你可以从cookie读取，因此数据看不到 【 麻花藤 】 这条记录（ 注意观察 SQL ）<br>
*/
List<ISqlParser> sqlParserList = new ArrayList<>();
TenantSqlParser tenantSqlParser = new JeecgTenantParser();
tenantSqlParser.setTenantHandler(new TenantHandler() {
@Override
public Expression getTenantId(boolean select) {
String tenant_id = TenantContext.getTenant();
return new LongValue(tenant_id);
}
@Override
public String getTenantIdColumn() {
return tenant_field;
}
@Override
public boolean doTableFilter(String tableName) {
//true则不加租户条件查询 false则加
// return excludeTable.contains(tableName);
if(tenantTable.contains(tableName)){
return false;
}
return true;
}
private Expression in(String ids){
final InExpression inExpression = new InExpression();
inExpression.setLeftExpression(new Column(getTenantIdColumn()));
final ExpressionList itemsList = new ExpressionList();
final List<Expression> inValues = new ArrayList<>(2);
for(String id:ids.split(",")){
inValues.add(new LongValue(id));
}
itemsList.setExpressions(inValues);
inExpression.setRightItemsList(itemsList);
return inExpression;
}
});
sqlParserList.add(tenantSqlParser);
paginationInterceptor.setSqlParserList(sqlParserList);
paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
@Override
public boolean doFilter(MetaObject metaObject) {
MappedStatement ms = SqlParserHelper.getMappedStatement(metaObject);
// 过滤自定义查询此时无租户信息约束【 麻花藤 】出现
if ("com.baomidou.springboot.mapper.UserMapper.selectListBySQL".equals(ms.getId())) {
return true;
}
return false;
}
});
return paginationInterceptor;
}
// /**
// * mybatis-plus SQL执行效率插件【生产环境可以关闭】
// */
// @Bean
// public PerformanceInterceptor performanceInterceptor() {
// return new PerformanceInterceptor();
// }
}

111
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/RedisConfig.java
View File

@ -1,111 +0,0 @@
package org.jeecg.config;
import java.lang.reflect.Method;
import java.time.Duration;
import java.util.Arrays;
import javax.annotation.Resource;
import org.jeecg.common.constant.CacheConstant;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;
import static java.util.Collections.singletonMap;
@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig extends CachingConfigurerSupport {
@Resource
private LettuceConnectionFactory lettuceConnectionFactory;
// /**
// * @description 自定义的缓存key的生成策略 若想使用这个key
// * 只需要讲注解上keyGenerator的值设置为keyGenerator即可</br>
// * @return 自定义策略生成的key
// */
// @Override
// @Bean
// public KeyGenerator keyGenerator() {
// return new KeyGenerator() {
// @Override
// public Object generate(Object target, Method method, Object... params) {
// StringBuilder sb = new StringBuilder();
// sb.append(target.getClass().getName());
// sb.append(method.getDeclaringClass().getName());
// Arrays.stream(params).map(Object::toString).forEach(sb::append);
// return sb.toString();
// }
// };
// }
/**
* RedisTemplate配置
*
* @param lettuceConnectionFactory
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
// 设置序列化
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
om.enableDefaultTyping(DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置redisTemplate
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(lettuceConnectionFactory);
RedisSerializer<?> stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer);// key序列化
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 缓存配置管理器
*
* @param factory
* @return
*/
@Bean
public CacheManager cacheManager(LettuceConnectionFactory factory) {
// 配置序列化（缓存默认有效期 6小时）
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(6));
RedisCacheConfiguration redisCacheConfiguration = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
// 以锁写入的方式创建RedisCacheWriter对象
//RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
// 创建默认缓存配置对象
/* 默认配置，设置缓存有效期 1小时*/
//RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1));
/* 自定义配置test:demo 的超时时间为 5分钟*/
RedisCacheManager cacheManager = RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter(factory)).cacheDefaults(redisCacheConfiguration)
.withInitialCacheConfigurations(singletonMap(CacheConstant.TEST_DEMO_CACHE, RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(5)).disableCachingNullValues()))
.transactionAware().build();
return cacheManager;
}
}

24
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/RestTemplateConfig.java
View File

@ -1,24 +0,0 @@
package org.jeecg.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
return new RestTemplate(factory);
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setReadTimeout(5000);//ms
factory.setConnectTimeout(15000);//ms
return factory;
}
}

242
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/ShiroConfig.java
View File

@ -1,242 +0,0 @@
package org.jeecg.config;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.crazycake.shiro.IRedisManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisClusterManager;
import org.crazycake.shiro.RedisManager;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.shiro.authc.ShiroRealm;
import org.jeecg.modules.shiro.authc.aop.JwtFilter;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.util.StringUtils;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import javax.annotation.Resource;
import javax.servlet.Filter;
import java.util.*;
/**
* @author: Scott
* @date: 2018/2/7
* @description: shiro 配置类
*/
@Slf4j
@Configuration
public class ShiroConfig {
@Value("${jeecg.shiro.excludeUrls}")
private String excludeUrls;
@Resource
LettuceConnectionFactory lettuceConnectionFactory;
/**
* Filter Chain定义说明
*
* 1、一个URL可以配置多个Filter，使用逗号分隔
* 2、当设置多个过滤器时，全部验证通过，才视为通过
* 3、部分过滤器可指定参数，如perms，roles
*/
@Bean("shiroFilter")
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
// 拦截器
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
if(oConvertUtils.isNotEmpty(excludeUrls)){
String[] permissionUrl = excludeUrls.split(",");
for(String url : permissionUrl){
filterChainDefinitionMap.put(url,"anon");
}
}
//cas验证登录
filterChainDefinitionMap.put("/cas/client/validateLogin", "anon");
// 配置不会被拦截的链接 顺序判断
filterChainDefinitionMap.put("/sys/randomImage/**", "anon"); //登录验证码接口排除
filterChainDefinitionMap.put("/sys/checkCaptcha", "anon"); //登录验证码接口排除
filterChainDefinitionMap.put("/sys/login", "anon"); //登录接口排除
filterChainDefinitionMap.put("/sys/mLogin", "anon"); //登录接口排除
filterChainDefinitionMap.put("/sys/logout", "anon"); //登出接口排除
filterChainDefinitionMap.put("/thirdLogin/**", "anon"); //第三方登录
filterChainDefinitionMap.put("/sys/getEncryptedString", "anon"); //获取加密串
filterChainDefinitionMap.put("/sys/sms", "anon");//短信验证码
filterChainDefinitionMap.put("/sys/phoneLogin", "anon");//手机登录
filterChainDefinitionMap.put("/sys/user/checkOnlyUser", "anon");//校验用户是否存在
filterChainDefinitionMap.put("/sys/user/register", "anon");//用户注册
filterChainDefinitionMap.put("/sys/user/querySysUser", "anon");//根据手机号获取用户信息
filterChainDefinitionMap.put("/sys/user/phoneVerification", "anon");//用户忘记密码验证手机号
filterChainDefinitionMap.put("/sys/user/passwordChange", "anon");//用户更改密码
filterChainDefinitionMap.put("/auth/2step-code", "anon");//登录验证码
filterChainDefinitionMap.put("/sys/common/static/**", "anon");//图片预览 &下载文件不限制token
filterChainDefinitionMap.put("/sys/common/pdf/**", "anon");//pdf预览
filterChainDefinitionMap.put("/generic/**", "anon");//pdf预览需要文件
filterChainDefinitionMap.put("/", "anon");
filterChainDefinitionMap.put("/doc.html", "anon");
filterChainDefinitionMap.put("/**/*.js", "anon");
filterChainDefinitionMap.put("/**/*.css", "anon");
filterChainDefinitionMap.put("/**/*.html", "anon");
filterChainDefinitionMap.put("/**/*.svg", "anon");
filterChainDefinitionMap.put("/**/*.pdf", "anon");
filterChainDefinitionMap.put("/**/*.jpg", "anon");
filterChainDefinitionMap.put("/**/*.png", "anon");
filterChainDefinitionMap.put("/**/*.ico", "anon");
// update-begin--Author:sunjianlei Date:20190813 for：排除字体格式的后缀
filterChainDefinitionMap.put("/**/*.ttf", "anon");
filterChainDefinitionMap.put("/**/*.woff", "anon");
filterChainDefinitionMap.put("/**/*.woff2", "anon");
// update-begin--Author:sunjianlei Date:20190813 for：排除字体格式的后缀
filterChainDefinitionMap.put("/druid/**", "anon");
filterChainDefinitionMap.put("/swagger-ui.html", "anon");
filterChainDefinitionMap.put("/swagger**/**", "anon");
filterChainDefinitionMap.put("/webjars/**", "anon");
filterChainDefinitionMap.put("/v2/**", "anon");
//性能监控
filterChainDefinitionMap.put("/actuator/metrics/**", "anon");
filterChainDefinitionMap.put("/actuator/httptrace/**", "anon");
filterChainDefinitionMap.put("/actuator/redis/**", "anon");
//测试示例
filterChainDefinitionMap.put("/test/jeecgDemo/html", "anon"); //模板页面
filterChainDefinitionMap.put("/test/jeecgDemo/redis/**", "anon"); //redis测试
filterChainDefinitionMap.put("/big/screen/**", "anon");
filterChainDefinitionMap.put("/bigscreen/**", "anon");
//排除Online请求
filterChainDefinitionMap.put("/auto/cgform/**", "anon");
//websocket排除
filterChainDefinitionMap.put("/websocket/**", "anon");
filterChainDefinitionMap.put("/newsWebsocket/**", "anon");
// 添加自己的过滤器并且取名为jwt
Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
filterMap.put("jwt", new JwtFilter());
shiroFilterFactoryBean.setFilters(filterMap);
// <!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边
filterChainDefinitionMap.put("/**", "jwt");
// 未授权界面返回JSON
shiroFilterFactoryBean.setUnauthorizedUrl("/sys/common/403");
shiroFilterFactoryBean.setLoginUrl("/sys/common/403");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilterFactoryBean;
}
@Bean("securityManager")
public DefaultWebSecurityManager securityManager(ShiroRealm myRealm) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(myRealm);
/*
* 关闭shiro自带的session，详情见文档
* http://shiro.apache.org/session-management.html#SessionManagement-
* StatelessApplications%28Sessionless%29
*/
DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
securityManager.setSubjectDAO(subjectDAO);
//自定义缓存实现,使用redis
securityManager.setCacheManager(redisCacheManager());
return securityManager;
}
/**
* 下面的代码是添加注解支持
* @return
*/
@Bean
@DependsOn("lifecycleBeanPostProcessor")
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
/**
* 解决重复代理问题 github#994
* 添加前缀判断 不匹配 任何Advisor
*/
defaultAdvisorAutoProxyCreator.setUsePrefix(true);
defaultAdvisorAutoProxyCreator.setAdvisorBeanNamePrefix("_no_advisor");
return defaultAdvisorAutoProxyCreator;
}
@Bean
public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
}
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
/**
* cacheManager 缓存 redis实现
* 使用的是shiro-redis开源插件
*
* @return
*/
public RedisCacheManager redisCacheManager() {
log.info("===============(1)创建缓存管理器RedisCacheManager");
RedisCacheManager redisCacheManager = new RedisCacheManager();
redisCacheManager.setRedisManager(redisManager());
//redis中针对不同用户缓存(此处的id需要对应user实体中的id字段,用于唯一标识)
redisCacheManager.setPrincipalIdFieldName("id");
//用户权限信息缓存时间
redisCacheManager.setExpire(200000);
return redisCacheManager;
}
/**
* 配置shiro redisManager
* 使用的是shiro-redis开源插件
*
* @return
*/
@Bean
public IRedisManager redisManager() {
log.info("===============(2)创建RedisManager,连接Redis..");
IRedisManager manager;
// redis 单机支持，在集群为空，或者集群无机器时候使用 add by jzyadmin@163.com
if (lettuceConnectionFactory.getClusterConfiguration() == null || lettuceConnectionFactory.getClusterConfiguration().getClusterNodes().isEmpty()) {
RedisManager redisManager = new RedisManager();
redisManager.setHost(lettuceConnectionFactory.getHostName());
redisManager.setPort(lettuceConnectionFactory.getPort());
redisManager.setTimeout(0);
if (!StringUtils.isEmpty(lettuceConnectionFactory.getPassword())) {
redisManager.setPassword(lettuceConnectionFactory.getPassword());
}
manager = redisManager;
}else{
// redis 集群支持，优先使用集群配置 add by jzyadmin@163.com
RedisClusterManager redisManager = new RedisClusterManager();
Set<HostAndPort> portSet = new HashSet<>();
lettuceConnectionFactory.getClusterConfiguration().getClusterNodes().forEach(node -> portSet.add(new HostAndPort(node.getHost() , node.getPort())));
JedisCluster jedisCluster = new JedisCluster(portSet);
redisManager.setJedisCluster(jedisCluster);
manager = redisManager;
}
return manager;
}
}

31
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/StaticConfig.java
View File

@ -1,31 +0,0 @@
package org.jeecg.config;
import org.jeecg.common.util.DySmsHelper;
import org.jeecg.modules.message.handle.impl.EmailSendMsgHandle;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 设置静态参数初始化
*/
@Configuration
public class StaticConfig {
@Value("${jeecg.sms.accessKeyId}")
private String accessKeyId;
@Value("${jeecg.sms.accessKeySecret}")
private String accessKeySecret;
@Value(value = "${spring.mail.username}")
private String emailFrom;
@Bean
public void initStatic() {
DySmsHelper.setAccessKeyId(accessKeyId);
DySmsHelper.setAccessKeySecret(accessKeySecret);
EmailSendMsgHandle.setEmailFrom(emailFrom);
}
}

115
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/Swagger2Config.java
View File

@ -1,115 +0,0 @@
package org.jeecg.config;
import com.github.xiaoymin.swaggerbootstrapui.annotations.EnableSwaggerBootstrapUI;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.modules.shiro.vo.DefContants;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.ApiKey;
import springfox.documentation.service.Parameter;
import springfox.documentation.service.SecurityScheme;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @Author scott
*/
@Slf4j
@Configuration
@EnableSwagger2
@EnableSwaggerBootstrapUI
@ConditionalOnProperty(name = "swagger.enable", havingValue = "true")
public class Swagger2Config implements WebMvcConfigurer {
/**
*
* 显示swagger-ui.html文档展示页，还必须注入swagger资源：
*
* @param registry
*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}
/**
* swagger2的配置文件，这里可以配置swagger2的一些基本的内容，比如扫描的包等等
*
* @return Docket
*/
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
//此包路径下的类，才生成接口文档
.apis(RequestHandlerSelectors.basePackage("org.jeecg.modules"))
//加了ApiOperation注解的类，才生成接口文档
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
.paths(PathSelectors.any())
.build()
.securitySchemes(Collections.singletonList(securityScheme()));
//.globalOperationParameters(setHeaderToken());
}
/***
* oauth2配置
* 需要增加swagger授权回调地址
* http://localhost:8888/webjars/springfox-swagger-ui/o2c.html
* @return
*/
@Bean
SecurityScheme securityScheme() {
return new ApiKey(DefContants.X_ACCESS_TOKEN, DefContants.X_ACCESS_TOKEN, "header");
}
/**
* JWT token
* @return
*/
private List<Parameter> setHeaderToken() {
ParameterBuilder tokenPar = new ParameterBuilder();
List<Parameter> pars = new ArrayList<>();
tokenPar.name(DefContants.X_ACCESS_TOKEN).description("token").modelRef(new ModelRef("string")).parameterType("header").required(false).build();
pars.add(tokenPar.build());
return pars;
}
/**
* api文档的详细信息函数,注意这里的注解引用的是哪个
*
* @return
*/
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
// //大标题
.title("Jeecg-Boot 后台服务API接口文档")
// 版本号
.version("1.0")
// .termsOfServiceUrl("NO terms of service")
// 描述
.description("后台API接口")
// 作者
.contact("JEECG团队")
.license("The Apache License, Version 2.0")
.licenseUrl("http://www.apache.org/licenses/LICENSE-2.0.html")
.build();
}
}

76
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/WebMvcConfiguration.java
View File

@ -1,76 +0,0 @@
package org.jeecg.config;
import org.jeecg.modules.shiro.authc.interceptor.OnlineInterceptor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* Spring Boot 2.0 解决跨域问题
*
* @Author qinfeng
*
*/
@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {
@Value("${jeecg.path.upload}")
private String upLoadPath;
@Value("${jeecg.path.webapp}")
private String webAppPath;
@Value("${spring.resource.static-locations}")
private String staticLocations;
@Bean
public OnlineInterceptor onlineInterceptor(){
return new OnlineInterceptor();
}
@Bean
public CorsFilter corsFilter() {
final UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
final CorsConfiguration corsConfiguration = new CorsConfiguration();
/* 是否允许请求带有验证信息 */
corsConfiguration.setAllowCredentials(true);
/* 允许访问的客户端域名 */
corsConfiguration.addAllowedOrigin("*");
/* 允许服务端访问的客户端请求头 */
corsConfiguration.addAllowedHeader("*");
/* 允许访问的方法名,GET POST等 */
corsConfiguration.addAllowedMethod("*");
urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
return new CorsFilter(urlBasedCorsConfigurationSource);
}
/**
* 静态资源的配置 - 使得可以从磁盘中读取 Html、图片、视频、音频等
*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("file:" + upLoadPath + "//", "file:" + webAppPath + "//")
.addResourceLocations(staticLocations.split(","));
}
/**
* 方案一： 默认访问根路径跳转 doc.html页面 （swagger文档页面）
* 方案二： 访问根路径改成跳转 index.html页面 （简化部署方案： 可以把前端打包直接放到项目的 webapp，上面的配置）
*/
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("doc.html");
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
String [] exculudes = new String[]{"/*.html","/html/**","/js/**","/css/**","/images/**"};
registry.addInterceptor(onlineInterceptor()).excludePathPatterns(exculudes).addPathPatterns("/online/cgform/api/**");
}
}

18
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/WebSocketConfig.java
View File

@ -1,18 +0,0 @@
package org.jeecg.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
@Configuration
public class WebSocketConfig {
/**
* 注入ServerEndpointExporter，
* 这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint
*/
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}

130
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/mybatis/JeecgTenantParser.java
View File

@ -1,130 +0,0 @@
package org.jeecg.config.mybatis;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantSqlParser;
import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.*;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.select.*;
import java.util.List;
/**
* 复写租户条件
*/
public class JeecgTenantParser extends TenantSqlParser {
/**
* @param expression
* @param table
* @return
*/
protected Expression processTableAlias(Expression expression, Table table) {
String tableAliasName;
if (table.getAlias() == null) {
tableAliasName = table.getName();
} else {
tableAliasName = table.getAlias().getName();
}
// in
if (expression instanceof InExpression) {
InExpression in = (InExpression) expression;
if (in.getLeftExpression() instanceof Column) {
setTableAliasNameForColumn((Column) in.getLeftExpression(), tableAliasName);
}
// 比较操作
} else if (expression instanceof BinaryExpression) {
BinaryExpression compare = (BinaryExpression) expression;
if (compare.getLeftExpression() instanceof Column) {
setTableAliasNameForColumn((Column) compare.getLeftExpression(), tableAliasName);
} else if (compare.getRightExpression() instanceof Column) {
setTableAliasNameForColumn((Column) compare.getRightExpression(), tableAliasName);
}
// between
} else if (expression instanceof Between) {
Between between = (Between) expression;
if (between.getLeftExpression() instanceof Column) {
setTableAliasNameForColumn((Column) between.getLeftExpression(), tableAliasName);
}
}
return expression;
}
private void setTableAliasNameForColumn(Column column, String tableAliasName) {
column.setColumnName(tableAliasName + "." + column.getColumnName());
}
/**
* 默认是按 tenant_id=1 按等于条件追加
*
* @param currentExpression 现有的条件：比如你原来的sql查询条件
* @param table
* @return
*/
@Override
protected Expression builderExpression(Expression currentExpression, Table table) {
final Expression tenantExpression = this.getTenantHandler().getTenantId(true);
Expression appendExpression;
if (!(tenantExpression instanceof SupportsOldOracleJoinSyntax)) {
appendExpression = new EqualsTo();
((EqualsTo) appendExpression).setLeftExpression(this.getAliasColumn(table));
((EqualsTo) appendExpression).setRightExpression(tenantExpression);
} else {
appendExpression = processTableAlias(tenantExpression, table);
}
if (currentExpression == null) {
return appendExpression;
}
if (currentExpression instanceof BinaryExpression) {
BinaryExpression binaryExpression = (BinaryExpression) currentExpression;
if (binaryExpression.getLeftExpression() instanceof FromItem) {
processFromItem((FromItem) binaryExpression.getLeftExpression());
}
if (binaryExpression.getRightExpression() instanceof FromItem) {
processFromItem((FromItem) binaryExpression.getRightExpression());
}
} else if (currentExpression instanceof InExpression) {
InExpression inExp = (InExpression) currentExpression;
ItemsList rightItems = inExp.getRightItemsList();
if (rightItems instanceof SubSelect) {
processSelectBody(((SubSelect) rightItems).getSelectBody());
}
}
if (currentExpression instanceof OrExpression) {
return new AndExpression(new Parenthesis(currentExpression), appendExpression);
} else {
return new AndExpression(currentExpression, appendExpression);
}
}
@Override
protected void processPlainSelect(PlainSelect plainSelect, boolean addColumn) {
FromItem fromItem = plainSelect.getFromItem();
if (fromItem instanceof Table) {
Table fromTable = (Table) fromItem;
if (!this.getTenantHandler().doTableFilter(fromTable.getName())) {
plainSelect.setWhere(builderExpression(plainSelect.getWhere(), fromTable));
if (addColumn) {
plainSelect.getSelectItems().add(new SelectExpressionItem(new Column(this.getTenantHandler().getTenantIdColumn())));
}
}
} else {
processFromItem(fromItem);
}
List<Join> joins = plainSelect.getJoins();
if (joins != null && joins.size() > 0) {
joins.forEach(j -> {
processJoin(j);
processFromItem(j.getRightItem());
});
}
}
}

167
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/mybatis/MybatisInterceptor.java
View File

@ -1,167 +0,0 @@
package org.jeecg.config.mybatis;
import java.lang.reflect.Field;
import java.util.Date;
import java.util.Properties;
import org.apache.ibatis.binding.MapperMethod.ParamMap;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysUser;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
/**
* mybatis拦截器，自动注入创建人、创建时间、修改人、修改时间
* @Author scott
* @Date 2019-01-19
*
*/
@Slf4j
@Component
@Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }) })
public class MybatisInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
String sqlId = mappedStatement.getId();
log.debug("------sqlId------" + sqlId);
SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
Object parameter = invocation.getArgs()[1];
log.debug("------sqlCommandType------" + sqlCommandType);
if (parameter == null) {
return invocation.proceed();
}
if (SqlCommandType.INSERT == sqlCommandType) {
LoginUser sysUser = this.getLoginUser();
Field[] fields = oConvertUtils.getAllFields(parameter);
for (Field field : fields) {
log.debug("------field.name------" + field.getName());
try {
if ("createBy".equals(field.getName())) {
field.setAccessible(true);
Object local_createBy = field.get(parameter);
field.setAccessible(false);
if (local_createBy == null || local_createBy.equals("")) {
if (sysUser != null) {
// 登录人账号
field.setAccessible(true);
field.set(parameter, sysUser.getUsername());
field.setAccessible(false);
}
}
}
// 注入创建时间
if ("createTime".equals(field.getName())) {
field.setAccessible(true);
Object local_createDate = field.get(parameter);
field.setAccessible(false);
if (local_createDate == null || local_createDate.equals("")) {
field.setAccessible(true);
field.set(parameter, new Date());
field.setAccessible(false);
}
}
//注入部门编码
if ("sysOrgCode".equals(field.getName())) {
field.setAccessible(true);
Object local_sysOrgCode = field.get(parameter);
field.setAccessible(false);
if (local_sysOrgCode == null || local_sysOrgCode.equals("")) {
// 获取登录用户信息
if (sysUser != null) {
field.setAccessible(true);
field.set(parameter, sysUser.getOrgCode());
field.setAccessible(false);
}
}
}
} catch (Exception e) {
}
}
}
if (SqlCommandType.UPDATE == sqlCommandType) {
LoginUser sysUser = this.getLoginUser();
Field[] fields = null;
if (parameter instanceof ParamMap) {
ParamMap<?> p = (ParamMap<?>) parameter;
//update-begin-author:scott date:20190729 for:批量更新报错issues/IZA3Q--
if (p.containsKey("et")) {
parameter = p.get("et");
} else {
parameter = p.get("param1");
}
//update-end-author:scott date:20190729 for:批量更新报错issues/IZA3Q-
//update-begin-author:scott date:20190729 for:更新指定字段时报错 issues/#516-
if (parameter == null) {
return invocation.proceed();
}
//update-end-author:scott date:20190729 for:更新指定字段时报错 issues/#516-
fields = oConvertUtils.getAllFields(parameter);
} else {
fields = oConvertUtils.getAllFields(parameter);
}
for (Field field : fields) {
log.debug("------field.name------" + field.getName());
try {
if ("updateBy".equals(field.getName())) {
//获取登录用户信息
if (sysUser != null) {
// 登录账号
field.setAccessible(true);
field.set(parameter, sysUser.getUsername());
field.setAccessible(false);
}
}
if ("updateTime".equals(field.getName())) {
field.setAccessible(true);
field.set(parameter, new Date());
field.setAccessible(false);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
// TODO Auto-generated method stub
}
//update-begin--Author:scott Date:20191213 for：关于使用Quzrtz 开启线程任务， #465
private LoginUser getLoginUser() {
LoginUser sysUser = null;
try {
sysUser = SecurityUtils.getSubject().getPrincipal() != null ? (LoginUser) SecurityUtils.getSubject().getPrincipal() : null;
} catch (Exception e) {
//e.printStackTrace();
sysUser = null;
}
return sysUser;
}
//update-end--Author:scott Date:20191213 for：关于使用Quzrtz 开启线程任务， #465
}

31
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/config/oss/OssBootConfiguration.java
View File

@ -1,31 +0,0 @@
package org.jeecg.config.oss;
import org.jeecg.common.util.oss.OssBootUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class OssBootConfiguration {
@Value("${jeecg.oss.endpoint}")
private String endpoint;
@Value("${jeecg.oss.accessKey}")
private String accessKeyId;
@Value("${jeecg.oss.secretKey}")
private String accessKeySecret;
@Value("${jeecg.oss.bucketName}")
private String bucketName;
@Value("${jeecg.oss.staticDomain}")
private String staticDomain;
@Bean
public void initOssBootConfiguration() {
OssBootUtil.setEndPoint(endpoint);
OssBootUtil.setAccessKeyId(accessKeyId);
OssBootUtil.setAccessKeySecret(accessKeySecret);
OssBootUtil.setBucketName(bucketName);
OssBootUtil.setStaticDomain(staticDomain);
}
}

493
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/api/controller/SystemAPIController.java Normal file
View File

@ -0,0 +1,493 @@
package org.jeecg.modules.api.controller;
import com.alibaba.fastjson.JSONObject;
import org.jeecg.common.api.dto.message.*;
import org.jeecg.common.api.dto.OnlineAuthDTO;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.vo.*;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Set;
/**
* 服务化 system模块 对外接口请求类
*/
@RestController
@RequestMapping("/sys/api")
public class SystemAPIController {
@Autowired
private ISysBaseAPI sysBaseAPI;
@Autowired
private ISysUserService sysUserService;
/**
* 发送系统消息
* @param message 使用构造器赋值参数 如果不设置category(消息类型)则默认为2 发送系统消息
*/
@PostMapping("/sendSysAnnouncement")
public void sendSysAnnouncement(@RequestBody MessageDTO message){
sysBaseAPI.sendSysAnnouncement(message);
}
/**
* 发送消息 附带业务参数
* @param message 使用构造器赋值参数
*/
@PostMapping("/sendBusAnnouncement")
public void sendBusAnnouncement(@RequestBody BusMessageDTO message){
sysBaseAPI.sendBusAnnouncement(message);
}
/**
* 通过模板发送消息
* @param message 使用构造器赋值参数
*/
@PostMapping("/sendTemplateAnnouncement")
public void sendTemplateAnnouncement(@RequestBody TemplateMessageDTO message){
sysBaseAPI.sendTemplateAnnouncement(message);
}
/**
* 通过模板发送消息 附带业务参数
* @param message 使用构造器赋值参数
*/
@PostMapping("/sendBusTemplateAnnouncement")
public void sendBusTemplateAnnouncement(@RequestBody BusTemplateMessageDTO message){
sysBaseAPI.sendBusTemplateAnnouncement(message);
}
/**
* 通过消息中心模板，生成推送内容
* @param templateDTO 使用构造器赋值参数
* @return
*/
@PostMapping("/parseTemplateByCode")
public String parseTemplateByCode(@RequestBody TemplateDTO templateDTO){
return sysBaseAPI.parseTemplateByCode(templateDTO);
}
/**
* 根据业务类型busType及业务busId修改消息已读
*/
@GetMapping("/updateSysAnnounReadFlag")
public void updateSysAnnounReadFlag(@RequestParam("busType") String busType, @RequestParam("busId")String busId){
sysBaseAPI.updateSysAnnounReadFlag(busType, busId);
}
/**
* 根据用户账号查询用户信息
* @param username
* @return
*/
@GetMapping("/getUserByName")
public LoginUser getUserByName(@RequestParam("username") String username){
return sysBaseAPI.getUserByName(username);
}
/**
* 根据用户id查询用户信息
* @param id
* @return
*/
@GetMapping("/getUserById")
LoginUser getUserById(@RequestParam("id") String id){
return sysBaseAPI.getUserById(id);
}
/**
* 通过用户账号查询角色集合
* @param username
* @return
*/
@GetMapping("/getRolesByUsername")
List<String> getRolesByUsername(@RequestParam("username") String username){
return sysBaseAPI.getRolesByUsername(username);
}
/**
* 通过用户账号查询部门集合
* @param username
* @return 部门 id
*/
@GetMapping("/getDepartIdsByUsername")
List<String> getDepartIdsByUsername(@RequestParam("username") String username){
return sysBaseAPI.getDepartIdsByUsername(username);
}
/**
* 通过用户账号查询部门 name
* @param username
* @return 部门 name
*/
@GetMapping("/getDepartNamesByUsername")
List<String> getDepartNamesByUsername(@RequestParam("username") String username){
return sysBaseAPI.getDepartNamesByUsername(username);
}
/**
* 获取数据字典
* @param code
* @return
*/
@GetMapping("/queryDictItemsByCode")
List<DictModel> queryDictItemsByCode(@RequestParam("code") String code){
return sysBaseAPI.queryDictItemsByCode(code);
}
/** 查询所有的父级字典，按照create_time排序 */
@GetMapping("/queryAllDict")
List<DictModel> queryAllDict(){
return sysBaseAPI.queryAllDict();
}
/**
* 查询所有分类字典
* @return
*/
@GetMapping("/queryAllDSysCategory")
List<SysCategoryModel> queryAllDSysCategory(){
return sysBaseAPI.queryAllDSysCategory();
}
/**
* 获取表数据字典
* @param table
* @param text
* @param code
* @return
*/
@GetMapping("/queryTableDictItemsByCode")
List<DictModel> queryTableDictItemsByCode(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code){
return sysBaseAPI.queryTableDictItemsByCode(table, text, code);
}
/**
* 查询所有部门 作为字典信息 id -->value,departName -->text
* @return
*/
@GetMapping("/queryAllDepartBackDictModel")
List<DictModel> queryAllDepartBackDictModel(){
return sysBaseAPI.queryAllDepartBackDictModel();
}
/**
* 查询表字典 支持过滤数据
* @param table
* @param text
* @param code
* @param filterSql
* @return
*/
@GetMapping("/queryFilterTableDictInfo")
List<DictModel> queryFilterTableDictInfo(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("filterSql") String filterSql){
return sysBaseAPI.queryFilterTableDictInfo(table, text, code, filterSql);
}
/**
* 查询指定table的 text code 获取字典，包含text和value
* @param table
* @param text
* @param code
* @param keyArray
* @return
*/
@Deprecated
@GetMapping("/queryTableDictByKeys")
public List<String> queryTableDictByKeys(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("keyArray") String[] keyArray){
return sysBaseAPI.queryTableDictByKeys(table, text, code, keyArray);
}
/**
* 获取所有角色 带参
* roleIds 默认选中角色
* @return
*/
@GetMapping("/queryAllRole")
public List<ComboModel> queryAllRole(@RequestParam(name = "roleIds",required = false)String[] roleIds){
if(roleIds==null || roleIds.length==0){
return sysBaseAPI.queryAllRole();
}else{
return sysBaseAPI.queryAllRole(roleIds);
}
}
/**
* 通过用户账号查询角色Id集合
* @param username
* @return
*/
@GetMapping("/getRoleIdsByUsername")
public List<String> getRoleIdsByUsername(@RequestParam("username")String username){
return sysBaseAPI.getRoleIdsByUsername(username);
}
/**
* 通过部门编号查询部门id
* @param orgCode
* @return
*/
@GetMapping("/getDepartIdsByOrgCode")
public String getDepartIdsByOrgCode(@RequestParam("orgCode")String orgCode){
return sysBaseAPI.getDepartIdsByOrgCode(orgCode);
}
/**
* 查询所有部门
* @return
*/
@GetMapping("/getAllSysDepart")
public List<SysDepartModel> getAllSysDepart(){
return sysBaseAPI.getAllSysDepart();
}
/**
* 根据 id 查询数据库中存储的 DynamicDataSourceModel
*
* @param dbSourceId
* @return
*/
@GetMapping("/getDynamicDbSourceById")
DynamicDataSourceModel getDynamicDbSourceById(@RequestParam("dbSourceId")String dbSourceId){
return sysBaseAPI.getDynamicDbSourceById(dbSourceId);
}
/**
* 根据部门Id获取部门负责人
* @param deptId
* @return
*/
@GetMapping("/getDeptHeadByDepId")
public List<String> getDeptHeadByDepId(@RequestParam("deptId") String deptId){
return sysBaseAPI.getDeptHeadByDepId(deptId);
}
/**
* 查找父级部门
* @param departId
* @return
*/
@GetMapping("/getParentDepartId")
public DictModel getParentDepartId(@RequestParam("departId")String departId){
return sysBaseAPI.getParentDepartId(departId);
}
/**
* 根据 code 查询数据库中存储的 DynamicDataSourceModel
*
* @param dbSourceCode
* @return
*/
@GetMapping("/getDynamicDbSourceByCode")
public DynamicDataSourceModel getDynamicDbSourceByCode(@RequestParam("dbSourceCode") String dbSourceCode){
return sysBaseAPI.getDynamicDbSourceByCode(dbSourceCode);
}
/**
* 给指定用户发消息
* @param userIds
* @param cmd
*/
@GetMapping("/sendWebSocketMsg")
public void sendWebSocketMsg(String[] userIds, String cmd){
sysBaseAPI.sendWebSocketMsg(userIds, cmd);
}
/**
* 根据id获取所有参与用户
* userIds
* @return
*/
@GetMapping("/queryAllUserByIds")
public List<LoginUser> queryAllUserByIds(@RequestParam("userIds") String[] userIds){
return sysBaseAPI.queryAllUserByIds(userIds);
}
/**
* 查询所有用户 返回ComboModel
* @return
*/
@GetMapping("/queryAllUserBackCombo")
public List<ComboModel> queryAllUserBackCombo(){
return sysBaseAPI.queryAllUserBackCombo();
}
/**
* 分页查询用户 返回JSONObject
* @return
*/
@GetMapping("/queryAllUser")
public JSONObject queryAllUser(@RequestParam(name="userIds",required=false)String userIds, @RequestParam(name="pageNo",required=false) Integer pageNo,@RequestParam(name="pageSize",required=false) int pageSize){
return sysBaseAPI.queryAllUser(userIds, pageNo, pageSize);
}
/**
* 将会议签到信息推动到预览
* userIds
* @return
* @param userId
*/
@GetMapping("/meetingSignWebsocket")
public void meetingSignWebsocket(@RequestParam("userId")String userId){
sysBaseAPI.meetingSignWebsocket(userId);
}
/**
* 根据name获取所有参与用户
* userNames
* @return
*/
@GetMapping("/queryUserByNames")
public List<LoginUser> queryUserByNames(@RequestParam("userNames")String[] userNames){
return sysBaseAPI.queryUserByNames(userNames);
}
/**
* 获取用户的角色集合
* @param username
* @return
*/
@GetMapping("/getUserRoleSet")
public Set<String> getUserRoleSet(@RequestParam("username")String username){
return sysBaseAPI.getUserRoleSet(username);
}
/**
* 获取用户的权限集合
* @param username
* @return
*/
@GetMapping("/getUserPermissionSet")
public Set<String> getUserPermissionSet(@RequestParam("username") String username){
return sysBaseAPI.getUserPermissionSet(username);
}
//-----
/**
* 判断是否有online访问的权限
* @param onlineAuthDTO
* @return
*/
@PostMapping("/hasOnlineAuth")
public boolean hasOnlineAuth(@RequestBody OnlineAuthDTO onlineAuthDTO){
return sysBaseAPI.hasOnlineAuth(onlineAuthDTO);
}
/**
* 查询用户角色信息
* @param username
* @return
*/
@GetMapping("/queryUserRoles")
public Set<String> queryUserRoles(@RequestParam("username") String username){
return sysUserService.getUserRolesSet(username);
}
/**
* 查询用户权限信息
* @param username
* @return
*/
@GetMapping("/queryUserAuths")
public Set<String> queryUserAuths(@RequestParam("username") String username){
return sysUserService.getUserPermissionsSet(username);
}
/**
* 通过部门id获取部门全部信息
*/
@GetMapping("/selectAllById")
public SysDepartModel selectAllById(@RequestParam("id") String id){
return sysBaseAPI.selectAllById(id);
}
/**
* 根据用户id查询用户所属公司下所有用户ids
* @param userId
* @return
*/
@GetMapping("/queryDeptUsersByUserId")
public List<String> queryDeptUsersByUserId(@RequestParam("userId") String userId){
return sysBaseAPI.queryDeptUsersByUserId(userId);
}
/**
* 查询数据权限
* @return
*/
@GetMapping("/queryPermissionDataRule")
public List<SysPermissionDataRuleModel> queryPermissionDataRule(@RequestParam("component") String component, @RequestParam("requestPath")String requestPath, @RequestParam("username") String username){
return sysBaseAPI.queryPermissionDataRule(component, requestPath, username);
}
/**
* 查询用户信息
* @param username
* @return
*/
@GetMapping("/getCacheUser")
public SysUserCacheInfo getCacheUser(@RequestParam("username") String username){
return sysBaseAPI.getCacheUser(username);
}
/**
* 字典表的 翻译
* @param table
* @param text
* @param code
* @param key
* @return
*/
@GetMapping("/translateDictFromTable")
public String translateDictFromTable(@RequestParam("table") String table, @RequestParam("text") String text, @RequestParam("code") String code, @RequestParam("key") String key){
return sysBaseAPI.translateDictFromTable(table, text, code, key);
}
/**
* 普通字典的翻译
* @param code
* @param key
* @return
*/
@GetMapping("/translateDict")
public String translateDict(@RequestParam("code") String code, @RequestParam("key") String key){
return sysBaseAPI.translateDict(code, key);
}
/**
* 36根据多个用户账号(逗号分隔)，查询返回多个用户信息
* @param usernames
* @return
*/
@GetMapping("/queryUsersByUsernames")
List<JSONObject> queryUsersByUsernames(String usernames){
return this.sysBaseAPI.queryUsersByUsernames(usernames);
}
/**
* 37根据多个部门编码(逗号分隔)，查询返回多个部门信息
* @param orgCodes
* @return
*/
@GetMapping("/queryDepartsByOrgcodes")
List<JSONObject> queryDepartsByOrgcodes(String orgCodes){
return this.sysBaseAPI.queryDepartsByOrgcodes(orgCodes);
}
}

15
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/cas/controller/CasClientController.java
View File

@ -5,10 +5,13 @@ import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.hutool.crypto.SecureUtil;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.cas.util.CASServiceUtil;
import org.jeecg.modules.cas.util.XmlUtils;
@ -16,6 +19,7 @@ import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
@ -82,7 +86,16 @@ public class CasClientController {
// 设置超时时间
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME*2 / 1000);
//获取用户部门信息
//update-begin-author:taoyan date:20200812 for:登录缓存用户信息
LoginUser vo = new LoginUser();
BeanUtils.copyProperties(sysUser,vo);
vo.setPassword(SecureUtil.md5(sysUser.getPassword()));
redisUtil.set(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, vo);
redisUtil.expire(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, JwtUtil.EXPIRE_TIME*2 / 1000);
//update-end-author:taoyan date:20200812 for:登录缓存用户信息
//获取用户部门信息
JSONObject obj = new JSONObject();
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
obj.put("departs", departs);

204
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/MockController.java
View File

@ -1,204 +0,0 @@
package org.jeecg.modules.demo.mock;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.swing.filechooser.FileSystemView;
import org.apache.commons.io.IOUtils;
import org.jeecg.common.api.vo.Result;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import lombok.extern.slf4j.Slf4j;
@RestController
@RequestMapping("/api")
@Slf4j
public class MockController {
private final String JSON_PATH = "classpath:org/jeecg/modules/demo/mock/json";
/**
* 通用json访问接口
* 格式： http://localhost:8080/jeecg-boot/api/json/{filename}
* @param filename
* @return
*/
@RequestMapping(value = "/json/{filename}", method = RequestMethod.GET)
public String getJsonData(@PathVariable String filename) {
String jsonpath = "classpath:org/jeecg/modules/demo/mock/json/"+filename+".json";
return readJson(jsonpath);
}
@GetMapping(value = "/asynTreeList")
public String asynTreeList(String id) {
return readJson(JSON_PATH + "/asyn_tree_list_" + id + ".json");
}
@GetMapping(value = "/user")
public String user() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/user.json");
}
/**
* 老的登录获取用户信息接口
* @return
*/
@GetMapping(value = "/user/info")
public String userInfo() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/user_info.json");
}
@GetMapping(value = "/role")
public String role() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/role.json");
}
@GetMapping(value = "/service")
public String service() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/service.json");
}
@GetMapping(value = "/permission")
public String permission() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/permission.json");
}
@GetMapping(value = "/permission/no-pager")
public String permission_no_page() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/permission_no_page.json");
}
/**
* 省市县
*/
@GetMapping(value = "/area")
public String area() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/area.json");
}
/**
* 测试报表数据
*/
@GetMapping(value = "/report/getYearCountInfo")
public String getYearCountInfo() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/getCntrNoCountInfo.json");
}
@GetMapping(value = "/report/getMonthCountInfo")
public String getMonthCountInfo() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/getCntrNoCountInfo.json");
}
@GetMapping(value = "/report/getCntrNoCountInfo")
public String getCntrNoCountInfo() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/getCntrNoCountInfo.json");
}
@GetMapping(value = "/report/getCabinetCountInfo")
public String getCabinetCountInfo() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/getCntrNoCountInfo.json");
}
/**
* 实时磁盘监控
* @param request
* @param response
* @return
*/
@GetMapping("/queryDiskInfo")
public Result<List<Map<String,Object>>> queryDiskInfo(HttpServletRequest request, HttpServletResponse response){
Result<List<Map<String,Object>>> res = new Result<>();
try {
// 当前文件系统类
FileSystemView fsv = FileSystemView.getFileSystemView();
// 列出所有windows 磁盘
File[] fs = File.listRoots();
log.info("查询磁盘信息:"+fs.length+"个");
List<Map<String,Object>> list = new ArrayList<>();
for (int i = 0; i < fs.length; i++) {
if(fs[i].getTotalSpace()==0) {
continue;
}
Map<String,Object> map = new HashMap<>();
map.put("name", fsv.getSystemDisplayName(fs[i]));
map.put("max", fs[i].getTotalSpace());
map.put("rest", fs[i].getFreeSpace());
map.put("restPPT", fs[i].getFreeSpace()*100/fs[i].getTotalSpace());
list.add(map);
log.info(map.toString());
}
res.setResult(list);
res.success("查询成功");
} catch (Exception e) {
res.error500("查询失败"+e.getMessage());
}
return res;
}
//-------------------------------------------------------------------------------------------
/**
* 工作台首页的数据
* @return
*/
@GetMapping(value = "/list/search/projects")
public String projects() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/workplace_projects.json");
}
@GetMapping(value = "/workplace/activity")
public String activity() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/workplace_activity.json");
}
@GetMapping(value = "/workplace/teams")
public String teams() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/workplace_teams.json");
}
@GetMapping(value = "/workplace/radar")
public String radar() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/workplace_radar.json");
}
@GetMapping(value = "/task/process")
public String taskProcess() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/task_process.json");
}
//-------------------------------------------------------------------------------------------
//author:lvdandan-----date：20190315---for:添加数据日志json----
public String sysDataLogJson() {
return readJson("classpath:org/jeecg/modules/demo/mock/json/sysdatalog.json");
}
//author:lvdandan-----date：20190315---for:添加数据日志json----
/**
* 读取json格式文件
* @param jsonSrc
* @return
*/
private String readJson(String jsonSrc) {
String json = "";
try {
//File jsonFile = ResourceUtils.getFile(jsonSrc);
//json = FileUtils.re.readFileToString(jsonFile);
//换个写法，解决springboot读取jar包中文件的问题
InputStream stream = getClass().getClassLoader().getResourceAsStream(jsonSrc.replace("classpath:", ""));
json = IOUtils.toString(stream,"UTF-8");
} catch (IOException e) {
log.error(e.getMessage(),e);
}
return json;
}
}

13551
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/area.json
View File

File diff suppressed because it is too large Load Diff

1
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/area_mini.json
View File

File diff suppressed because one or more lines are too long

36
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/area_options.json
View File

@ -1,36 +0,0 @@
[
{"value": "110000", "label": "北京市"},
{"value": "120000", "label": "天津市"},
{"value": "130000", "label": "河北省"},
{"value": "140000", "label": "山西省"},
{"value": "150000", "label": "内蒙古自治区"},
{"value": "210000", "label": "辽宁省"},
{"value": "220000", "label": "吉林省"},
{"value": "230000", "label": "黑龙江省"},
{"value": "310000", "label": "上海市"},
{"value": "320000", "label": "江苏省"},
{"value": "330000", "label": "浙江省"},
{"value": "340000", "label": "安徽省"},
{"value": "350000", "label": "福建省"},
{"value": "360000", "label": "江西省"},
{"value": "370000", "label": "山东省"},
{"value": "410000", "label": "河南省"},
{"value": "420000", "label": "湖北省"},
{"value": "430000", "label": "湖南省"},
{"value": "440000", "label": "广东省"},
{"value": "450000", "label": "广西壮族自治区"},
{"value": "460000", "label": "海南省"},
{"value": "500000", "label": "重庆市"},
{"value": "510000", "label": "四川省"},
{"value": "520000", "label": "贵州省"},
{"value": "530000", "label": "云南省"},
{"value": "540000", "label": "西藏自治区"},
{"value": "610000", "label": "陕西省"},
{"value": "620000", "label": "甘肃省"},
{"value": "630000", "label": "青海省"},
{"value": "640000", "label": "宁夏回族自治区"},
{"value": "650000", "label": "新疆维吾尔自治区"},
{"value": "710000", "label": "台湾省"},
{"value": "810000", "label": "香港特别行政区"},
{"value": "820000", "label": "澳门特别行政区"}
]

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/asyn_tree_list_0.json
View File

@ -1,29 +0,0 @@
{
"status": 200,
"success": true,
"message": "ok",
"result": [
{
"id": 1,
"name": "首页",
"component": "dashboard/Analysis",
"orderNum": 1,
"hasChildren": false
},
{
"id": 2,
"name": "常见案例",
"component": "layouts/RouteView",
"orderNum": 2,
"hasChildren": true
},
{
"id": 3,
"name": "系统监控",
"component": "layouts/RouteView",
"orderNum": 3,
"hasChildren": true
}
],
"timestamp": 1554950583837
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/asyn_tree_list_1.json
View File

@ -1,29 +0,0 @@
{
"status": 200,
"success": true,
"message": "ok",
"result": [
{
"id": 11,
"name": "首页",
"component": "dashboard/Analysis",
"orderNum": 1,
"hasChildren": false
},
{
"id": 12,
"name": "系统管理",
"component": "layouts/RouteView",
"orderNum": 2,
"hasChildren": true
},
{
"id": 13,
"name": "常见案例",
"component": "layouts/RouteView",
"orderNum": 3,
"hasChildren": true
}
],
"timestamp": 1554950583837
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/asyn_tree_list_2.json
View File

@ -1,29 +0,0 @@
{
"status": 200,
"success": true,
"message": "ok",
"result": [
{
"id": 21,
"name": "弹框选择Demo",
"component": "jeecg/SelectDemo",
"orderNum": 1,
"hasChildren": false
},
{
"id": 22,
"name": "单表模型示例",
"component": "jeecg/JeecgDemoList",
"orderNum": 2,
"hasChildren": false
},
{
"id": 23,
"name": "一对多Tab示例",
"component": "jeecg/tablist/JeecgOrderDMainList",
"orderNum": 3,
"hasChildren": false
}
],
"timestamp": 1554950583837
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/asyn_tree_list_3.json
View File

@ -1,29 +0,0 @@
{
"status": 200,
"success": true,
"message": "ok",
"result": [
{
"id": 31,
"name": "性能监控",
"component": "layouts/RouteView",
"orderNum": 1,
"hasChildren": true
},
{
"id": 32,
"name": "在线文档",
"component": "layouts/IframePageView",
"orderNum": 2,
"hasChildren": false
},
{
"id": 33,
"name": "工作台",
"component": "dashboard/Workplace",
"orderNum": 3,
"hasChildren": false
}
],
"timestamp": 1554950583837
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/asyn_tree_list_31.json
View File

@ -1,29 +0,0 @@
{
"status": 200,
"success": true,
"message": "ok",
"result": [
{
"id": 311,
"name": "Redis监控",
"component": "modules/monitor/RedisInfo",
"orderNum": 1,
"hasChildren": false
},
{
"id": 312,
"name": "JVM信息",
"component": "modules/monitor/JvmInfo",
"orderNum": 2,
"hasChildren": false
},
{
"id": 313,
"name": "Tomcat信息",
"component": "modules/monitor/TomcatInfo",
"orderNum": 3,
"hasChildren": false
}
],
"timestamp": 1554950583837
}

63
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/getCntrNoCountInfo.json
View File

@ -1,63 +0,0 @@
{
"success": true,
"message": "查询成功",
"code": null,
"result": [
{
"resultIndex": 0,
"yearcount": 623,
"year": 2016,
"month": "四月",
"monthcount": 3255,
"classifyname": "证明类",
"cntrnocount": 24,
"cabinetname": "一号柜",
"cabinetcocunt": 12
},
{
"resultIndex": 1,
"yearcount": 243,
"year": 2017,
"month": "五月",
"monthcount": 5673,
"classifyname": "产权类",
"cntrnocount": 52,
"cabinetname": "二号柜",
"cabinetcocunt": 52
},
{
"resultIndex": 2,
"yearcount": 345,
"year": 2018,
"month": "六月",
"monthcount": 2673,
"classifyname": "知识类",
"cntrnocount": 85,
"cabinetname": "三号柜",
"cabinetcocunt": 24
},
{
"resultIndex": 3,
"yearcount": 452,
"year": 2019,
"month": "七月",
"monthcount": 2341,
"classifyname": "技术类",
"cntrnocount": 67,
"cabinetname": "四号柜",
"cabinetcocunt": 45
},
{
"resultIndex": 4,
"yearcount": 645,
"year": 2020,
"month": "八月",
"monthcount": 7473,
"classifyname": "工具类",
"cntrnocount": 93,
"cabinetname": "五号柜",
"cabinetcocunt": 94
}
],
"timestamp": 1554285003594
}

50
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/graphreport_chart.json
View File

@ -1,50 +0,0 @@
{
"status": 200,
"success": true,
"message": "ok",
"result": {
"data": [
{
"id": 0,
"x": "1",
"y": 889
},
{
"id": 1,
"x": "2",
"y": 341
},
{
"id": 2,
"x": "3",
"y": 1028
},
{
"id": 3,
"x": "4",
"y": 1168
},
{
"id": 4,
"x": "5",
"y": 653
},
{
"id": 5,
"x": "6",
"y": 863
},
{
"id": 6,
"x": "7",
"y": 421
},
{
"id": 7,
"x": "8",
"y": 1320
}
]
},
"timestamp": 1554950583837
}

156
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/permission.json
View File

@ -1,156 +0,0 @@
{
"message": "",
"result": {
"data": [
{
"id": "marketing",
"name": "营销管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": null,
"parents": null,
"type": null,
"deleted": 0,
"actions": [
"add",
"query",
"get",
"update",
"delete"
]
},
{
"id": "member",
"name": "会员管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"query",
"get",
"update",
"delete"
]
},
{
"id": "menu",
"name": "菜单管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"import",
"get",
"update"
]
},
{
"id": "order",
"name": "订单管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"query",
"get",
"update",
"delete"
]
},
{
"id": "permission",
"name": "权限管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get",
"update",
"delete"
]
},
{
"id": "role",
"name": "角色管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get",
"update",
"delete"
]
},
{
"id": "test",
"name": "测试权限",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get"
]
},
{
"id": "user",
"name": "用户管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"describe\":\"新增\",\"defaultCheck\":false},{\"action\":\"get\",\"describe\":\"查询\",\"defaultCheck\":false}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get"
]
}
],
"pageSize": 10,
"pageNo": 0,
"totalPage": 1,
"totalCount": 5
},
"status": 200,
"timestamp": 1537082021471
}

150
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/permission_no_page.json
View File

@ -1,150 +0,0 @@
{
"message": "",
"result": [
{
"id": "marketing",
"name": "营销管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": null,
"parents": null,
"type": null,
"deleted": 0,
"actions": [
"add",
"query",
"get",
"update",
"delete"
]
},
{
"id": "member",
"name": "会员管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"query",
"get",
"update",
"delete"
]
},
{
"id": "menu",
"name": "菜单管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"import",
"get",
"update"
]
},
{
"id": "order",
"name": "订单管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"query",
"get",
"update",
"delete"
]
},
{
"id": "permission",
"name": "权限管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get",
"update",
"delete"
]
},
{
"id": "role",
"name": "角色管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get",
"update",
"delete"
]
},
{
"id": "test",
"name": "测试权限",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get"
]
},
{
"id": "user",
"name": "用户管理",
"describe": null,
"status": 1,
"actionData": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"export\",\"defaultCheck\":false,\"describe\":\"导出\"}]",
"sptDaTypes": null,
"optionalFields": "[]",
"parents": null,
"type": "default",
"deleted": 0,
"actions": [
"add",
"get"
]
}
],
"status": 200,
"timestamp": 1537082021471
}

608
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/role.json
View File

@ -1,608 +0,0 @@
{
"message": "",
"result": {
"data": [
{
"id": "admin",
"name": "管理员",
"describe": "拥有所有权限",
"status": 1,
"creatorId": "system",
"createTime": 1497160610259,
"deleted": 0,
"permissions": [
{
"roleId": "admin",
"permissionId": "comment",
"permissionName": "评论管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "member",
"permissionName": "会员管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "menu",
"permissionName": "菜单管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "import",
"describe": "导入",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "order",
"permissionName": "订单管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "permission",
"permissionName": "权限管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "role",
"permissionName": "角色管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "test",
"permissionName": "测试权限",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "user",
"permissionName": "用户管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"},{\"action\":\"export\",\"defaultCheck\":false,\"describe\":\"导出\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "import",
"describe": "导入",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
},
{
"action": "export",
"describe": "导出",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
}
]
},
{
"id": "svip",
"name": "SVIP",
"describe": "超级会员",
"status": 1,
"creatorId": "system",
"createTime": 1532417744846,
"deleted": 0,
"permissions": [
{
"roleId": "admin",
"permissionId": "comment",
"permissionName": "评论管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "member",
"permissionName": "会员管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "menu",
"permissionName": "菜单管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "import",
"describe": "导入",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "order",
"permissionName": "订单管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "permission",
"permissionName": "权限管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "role",
"permissionName": "角色管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "test",
"permissionName": "测试权限",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "user",
"permissionName": "用户管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"},{\"action\":\"export\",\"defaultCheck\":false,\"describe\":\"导出\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "import",
"describe": "导入",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
}
]
},
{
"id": "user",
"name": "普通会员",
"describe": "普通用户，只能查询",
"status": 1,
"creatorId": "system",
"createTime": 1497160610259,
"deleted": 0,
"permissions": [
{
"roleId": "user",
"permissionId": "comment",
"permissionName": "评论管理",
"actions": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"}]",
"actionEntitySet": [
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "marketing",
"permissionName": "营销管理",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "member",
"permissionName": "会员管理",
"actions": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"}]",
"actionEntitySet": [
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "menu",
"permissionName": "菜单管理",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "order",
"permissionName": "订单管理",
"actions": "[{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"}]",
"actionEntitySet": [
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "permission",
"permissionName": "权限管理",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "role",
"permissionName": "角色管理",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "test",
"permissionName": "测试权限",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
},
{
"roleId": "user",
"permissionId": "user",
"permissionName": "用户管理",
"actions": "[]",
"actionEntitySet": [],
"actionList": null,
"dataAccess": null
}
]
}
],
"pageSize": 10,
"pageNo": 0,
"totalPage": 1,
"totalCount": 5
},
"status": 200,
"timestamp": 1537079497645
}

103
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/service.json
View File

@ -1,103 +0,0 @@
{
"message": "",
"result": {
"pageSize": 10,
"pageNo": 0,
"totalCount": 57,
"totalPage": 6,
"data": [
{
"key": 1,
"no": "No 1",
"description": "这是一段描述",
"callNo": 127,
"status": 2,
"updatedAt": "1970-06-24 11:51:20",
"editable": false
},
{
"key": 2,
"no": "No 2",
"description": "这是一段描述",
"callNo": 573,
"status": 2,
"updatedAt": "1994-12-11 00:37:35",
"editable": false
},
{
"key": 3,
"no": "No 3",
"description": "这是一段描述",
"callNo": 869,
"status": 2,
"updatedAt": "2013-11-11 08:04:03",
"editable": false
},
{
"key": 4,
"no": "No 4",
"description": "这是一段描述",
"callNo": 26,
"status": 2,
"updatedAt": "1990-11-04 15:41:42",
"editable": false
},
{
"key": 5,
"no": "No 5",
"description": "这是一段描述",
"callNo": 20,
"status": 2,
"updatedAt": "1970-01-05 11:04:56",
"editable": false
},
{
"key": 6,
"no": "No 6",
"description": "这是一段描述",
"callNo": 675,
"status": 2,
"updatedAt": "1983-06-06 04:09:04",
"editable": false
},
{
"key": 7,
"no": "No 7",
"description": "这是一段描述",
"callNo": 512,
"status": 3,
"updatedAt": "1996-08-26 21:47:44",
"editable": false
},
{
"key": 8,
"no": "No 8",
"description": "这是一段描述",
"callNo": 962,
"status": 2,
"updatedAt": "2004-08-15 23:15:22",
"editable": false
},
{
"key": 9,
"no": "No 9",
"description": "这是一段描述",
"callNo": 318,
"status": 3,
"updatedAt": "1988-08-10 14:36:35",
"editable": false
},
{
"key": 10,
"no": "No 10",
"description": "这是一段描述",
"callNo": 789,
"status": 0,
"updatedAt": "1988-12-27 23:39:41",
"editable": false
}
]
},
"status": 200,
"timestamp": 1534955098193
}

12
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/sysdatalog.json
View File

@ -1,12 +0,0 @@
{
"mobilePhone":"1872222222",
"officePhone":"1222222",
"email":"",
"createDate":"Jun 23, 2016 12:00:00 PM",
"sex":"1",
"depId":"402880e447e99cf10147e9a03b320003",
"userName":"9001",
"status":"1",
"content":"111",
"id":"4028ef81550c1a7901550c1cd6e70001"
}

55
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/task_process.json
View File

@ -1,55 +0,0 @@
{
"success": true,
"message": "操作成功！",
"code": 0,
"result": {
"records": [
{
"taskId": "48701",
"name": "start",
"taskBeginTime": "2019-03-07 09:33:04",
"taskEndTime": "2019-03-08 04:03:01",
"principal": "测试体验账号",
"result": "已完成"
},
{
"taskId": "48702",
"name": "部门领导审批",
"taskBeginTime": "2019-03-07 09:33:04",
"taskEndTime": "2019-03-08 04:03:01",
"principal": "测试体验账号",
"result": "已完成"
},
{
"taskId": "48703",
"name": "调整申请",
"taskBeginTime": "2019-03-07 09:33:04",
"taskEndTime": "2019-03-08 04:03:01",
"principal": "测试体验账号",
"result": "已完成"
},
{
"taskId": "48704",
"name": "人事审批",
"taskBeginTime": "2019-03-07 09:33:04",
"taskEndTime": "2019-03-08 04:03:01",
"principal": "测试体验账号",
"result": "已完成"
},
{
"taskId": "48705",
"name": "end",
"taskBeginTime": "2019-03-07 09:33:04",
"taskEndTime": "2019-03-08 04:03:01",
"principal": "测试体验账号",
"result": "已完成"
}
],
"total": 0,
"size": 10,
"current": 1,
"searchCount": true,
"pages": 0
},
"timestamp": 1551922394641
}

2388
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/user.json
View File

File diff suppressed because it is too large Load Diff

407
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/user_info.json
View File

@ -1,407 +0,0 @@
{
"message": "",
"result": {
"id": "4291d7da9005377ec9aec4a71ea837f",
"name": "天野远子",
"username": "admin",
"password": "",
"avatar": "/avatar2.jpg",
"status": 1,
"telephone": "",
"lastLoginIp": "27.154.74.117",
"lastLoginTime": 1534837621348,
"creatorId": "admin",
"createTime": 1497160610259,
"merchantCode": "TLif2btpzg079h15bk",
"deleted": 0,
"roleId": "admin",
"role": {
"id": "admin",
"name": "管理员",
"describe": "拥有所有权限",
"status": 1,
"creatorId": "system",
"createTime": 1497160610259,
"deleted": 0,
"permissions": [
{
"roleId": "admin",
"permissionId": "dashboard",
"permissionName": "仪表盘",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "exception",
"permissionName": "异常页面权限",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "result",
"permissionName": "结果权限",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "profile",
"permissionName": "详细页权限",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "table",
"permissionName": "表格权限",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "import",
"describe": "导入",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "form",
"permissionName": "表单权限",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "order",
"permissionName": "订单管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "permission",
"permissionName": "权限管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "role",
"permissionName": "角色管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "table",
"permissionName": "桌子管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"query\",\"defaultCheck\":false,\"describe\":\"查询\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "query",
"describe": "查询",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
},
{
"roleId": "admin",
"permissionId": "user",
"permissionName": "用户管理",
"actions": "[{\"action\":\"add\",\"defaultCheck\":false,\"describe\":\"新增\"},{\"action\":\"import\",\"defaultCheck\":false,\"describe\":\"导入\"},{\"action\":\"get\",\"defaultCheck\":false,\"describe\":\"详情\"},{\"action\":\"update\",\"defaultCheck\":false,\"describe\":\"修改\"},{\"action\":\"delete\",\"defaultCheck\":false,\"describe\":\"删除\"},{\"action\":\"export\",\"defaultCheck\":false,\"describe\":\"导出\"}]",
"actionEntitySet": [
{
"action": "add",
"describe": "新增",
"defaultCheck": false
},
{
"action": "import",
"describe": "导入",
"defaultCheck": false
},
{
"action": "get",
"describe": "详情",
"defaultCheck": false
},
{
"action": "update",
"describe": "修改",
"defaultCheck": false
},
{
"action": "delete",
"describe": "删除",
"defaultCheck": false
},
{
"action": "export",
"describe": "导出",
"defaultCheck": false
}
],
"actionList": null,
"dataAccess": null
}
]
}
},
"status": 200,
"timestamp": 1534844188679
}

85
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/workplace_activity.json
View File

@ -1,85 +0,0 @@
{
"message": "",
"result": [
{
"id": 1,
"user": {
"nickname": "Barbara Lee",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/BiazfanxmamNRoxxVxka.png"
},
"project": {
"name": "白鹭酱油开发组",
"action": "更新",
"event": "番组计划"
},
"time": "2018-08-23 14:47:00"
},
{
"id": 1,
"user": {
"nickname": "蓝莓酱",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/jZUIxmJycoymBprLOUbT.png"
},
"project": {
"name": "白鹭酱油开发组",
"action": "更新",
"event": "番组计划"
},
"time": "2018-08-23 09:35:37"
},
{
"id": 1,
"user": {
"nickname": "Brian Young",
"avatar": "http://dummyimage.com/64x64"
},
"project": {
"name": "白鹭酱油开发组",
"action": "创建",
"event": "番组计划"
},
"time": "2017-05-27 00:00:00"
},
{
"id": 1,
"user": {
"nickname": "曲丽丽",
"avatar": "http://dummyimage.com/64x64"
},
"project": {
"name": "高逼格设计天团",
"action": "更新",
"event": "六月迭代"
},
"time": "2018-08-23 14:47:00"
},
{
"id": 1,
"user": {
"nickname": "Dorothy Thompson",
"avatar": "http://dummyimage.com/64x64"
},
"project": {
"name": "高逼格设计天团",
"action": "created",
"event": "六月迭代"
},
"time": "2018-08-23 14:47:00"
},
{
"id": 1,
"user": {
"nickname": "曲丽丽",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/BiazfanxmamNRoxxVxka.png"
},
"project": {
"name": "高逼格设计天团",
"action": "created",
"event": "六月迭代"
},
"time": "2018-08-23 14:47:00"
}
],
"status": 200,
"timestamp": 0
}

61
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/workplace_projects.json
View File

@ -1,61 +0,0 @@
{
"message": "",
"result": {
"data": [
{
"id": 1,
"cover": "https://gw.alipayobjects.com/zos/rmsportal/WdGqmHpayyMjiEhcKoVE.png",
"title": "Alipay",
"description": "那是一种内在的东西， 他们到达不了，也无法触及的",
"status": 1,
"updatedAt": "2018-07-26 00:00:00"
},
{
"id": 2,
"cover": "https://gw.alipayobjects.com/zos/rmsportal/zOsKZmFRdUtvpqCImOVY.png",
"title": "Angular",
"description": "希望是一个好东西，也许是最好的，好东西是不会消亡的",
"status": 1,
"updatedAt": "2018-07-26 00:00:00"
},
{
"id": 3,
"cover": "https://gw.alipayobjects.com/zos/rmsportal/dURIMkkrRFpPgTuzkwnB.png",
"title": "Ant Design",
"description": "城镇中有那么多的酒馆，她却偏偏走进了我的酒馆",
"status": 1,
"updatedAt": "2018-07-26 00:00:00"
},
{
"id": 4,
"cover": "https://gw.alipayobjects.com/zos/rmsportal/sfjbOqnsXXJgNCjCzDBL.png",
"title": "Ant Design Pro",
"description": "那时候我只会想自己想要什么，从不想自己拥有什么",
"status": 1,
"updatedAt": "2018-07-26 00:00:00"
},
{
"id": 5,
"cover": "https://gw.alipayobjects.com/zos/rmsportal/siCrBXXhmvTQGWPNLBow.png",
"title": "Bootstrap",
"description": "凛冬将至",
"status": 1,
"updatedAt": "2018-07-26 00:00:00"
},
{
"id": 6,
"cover": "https://gw.alipayobjects.com/zos/rmsportal/ComBAopevLwENQdKWiIn.png",
"title": "Vue",
"description": "生命就像一盒巧克力，结果往往出人意料",
"status": 1,
"updatedAt": "2018-07-26 00:00:00"
}
],
"pageSize": 10,
"pageNo": 1,
"totalPage": 6,
"totalCount": 57
},
"status": 200,
"timestamp": 1534955098193
}

43
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/workplace_radar.json
View File

@ -1,43 +0,0 @@
{
"message": "",
"result": [
{
"item": "引用",
"个人": 70,
"团队": 30,
"部门": 40
},
{
"item": "口碑",
"个人": 60,
"团队": 70,
"部门": 40
},
{
"item": "产量",
"个人": 50,
"团队": 60,
"部门": 40
},
{
"item": "贡献",
"个人": 40,
"团队": 50,
"部门": 40
},
{
"item": "热度",
"个人": 60,
"团队": 70,
"部门": 40
},
{
"item": "引用",
"个人": 70,
"团队": 50,
"部门": 40
}
],
"status": 200,
"timestamp": 1534955098193
}

32
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/mock/json/workplace_teams.json
View File

@ -1,32 +0,0 @@
{
"message": "",
"result": [
{
"id": 1,
"name": "科学搬砖组",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/BiazfanxmamNRoxxVxka.png"
},
{
"id": 2,
"name": "程序员日常",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/cnrhVkzwxjPwAaCfPbdc.png"
},
{
"id": 1,
"name": "设计天团",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/gaOngJwsRYRaVAuXXcmB.png"
},
{
"id": 1,
"name": "中二少女团",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/ubnKSIfAJTxIgXOKlciN.png"
},
{
"id": 1,
"name": "骗你学计算机",
"avatar": "https://gw.alipayobjects.com/zos/rmsportal/WhxKECPNujWoWEFNdnJE.png"
}
],
"status": 200,
"timestamp": 0
}

63
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/controller/BigScreenTemplatController.java
View File

@ -1,63 +0,0 @@
package org.jeecg.modules.demo.test.controller;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.modules.demo.test.entity.JeecgDemo;
import org.jeecg.modules.demo.test.service.IJeecgDemoService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import java.util.ArrayList;
import java.util.List;
/**
* @Description: 大屏预览入口
* @Author: scott
* @Date:2019-12-12
* @Version:V1.0
*/
@Slf4j
@Controller
@RequestMapping("/big/screen/templat")
public class BigScreenTemplatController extends JeecgController<JeecgDemo, IJeecgDemoService> {
/**
* @param modelAndView
* @return
*/
@RequestMapping("/html")
public ModelAndView ftl(ModelAndView modelAndView) {
modelAndView.setViewName("demo3");
List<String> userList = new ArrayList<String>();
userList.add("admin");
userList.add("user1");
userList.add("user2");
log.info("--------------test--------------");
modelAndView.addObject("userList", userList);
return modelAndView;
}
/**
* 生产销售监控模版
* @param modelAndView
* @return
*/
@RequestMapping("/index1")
public ModelAndView index1(ModelAndView modelAndView) {
modelAndView.setViewName("/bigscreen/template1/index");
return modelAndView;
}
/**
* 智慧物流监控模版
* @param modelAndView
* @return
*/
@RequestMapping("/index2")
public ModelAndView index2(ModelAndView modelAndView) {
modelAndView.setViewName("/bigscreen/template2/index");
return modelAndView;
}
}

295
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/controller/JeecgDemoController.java
View File

@ -1,295 +0,0 @@
package org.jeecg.modules.demo.test.controller;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.aspect.annotation.PermissionData;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.demo.test.entity.JeecgDemo;
import org.jeecg.modules.demo.test.service.IJeecgDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 单表示例
* @Author: jeecg-boot
* @Date:2018-12-29
* @Version:V2.0
*/
@Slf4j
@Api(tags = "单表DEMO")
@RestController
@RequestMapping("/test/jeecgDemo")
public class JeecgDemoController extends JeecgController<JeecgDemo, IJeecgDemoService> {
@Autowired
private IJeecgDemoService jeecgDemoService;
@Autowired
private RedisUtil redisUtil;
/**
* 分页列表查询
*
* @param jeecgDemo
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@ApiOperation(value = "获取Demo数据列表", notes = "获取所有Demo数据列表")
@GetMapping(value = "/list")
@PermissionData(pageComponent = "jeecg/JeecgDemoList")
public Result<?> list(JeecgDemo jeecgDemo, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<JeecgDemo> queryWrapper = QueryGenerator.initQueryWrapper(jeecgDemo, req.getParameterMap());
Page<JeecgDemo> page = new Page<JeecgDemo>(pageNo, pageSize);
IPage<JeecgDemo> pageList = jeecgDemoService.page(page, queryWrapper);
log.info("查询当前页：" + pageList.getCurrent());
log.info("查询当前页数量：" + pageList.getSize());
log.info("查询结果数量：" + pageList.getRecords().size());
log.info("数据总数：" + pageList.getTotal());
return Result.ok(pageList);
}
/**
* 添加
*
* @param jeecgDemo
* @return
*/
@PostMapping(value = "/add")
@AutoLog(value = "添加测试DEMO")
@ApiOperation(value = "添加DEMO", notes = "添加DEMO")
public Result<?> add(@RequestBody JeecgDemo jeecgDemo) {
jeecgDemoService.save(jeecgDemo);
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param jeecgDemo
* @return
*/
@PutMapping(value = "/edit")
@ApiOperation(value = "编辑DEMO", notes = "编辑DEMO")
@AutoLog(value = "编辑DEMO", operateType = CommonConstant.OPERATE_TYPE_3)
public Result<?> edit(@RequestBody JeecgDemo jeecgDemo) {
jeecgDemoService.updateById(jeecgDemo);
return Result.ok("更新成功！");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@AutoLog(value = "删除测试DEMO")
@DeleteMapping(value = "/delete")
@ApiOperation(value = "通过ID删除DEMO", notes = "通过ID删除DEMO")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
jeecgDemoService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
@ApiOperation(value = "批量删除DEMO", notes = "批量删除DEMO")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.jeecgDemoService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功！");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@GetMapping(value = "/queryById")
@ApiOperation(value = "通过ID查询DEMO", notes = "通过ID查询DEMO")
public Result<?> queryById(@ApiParam(name = "id", value = "示例id", required = true) @RequestParam(name = "id", required = true) String id) {
JeecgDemo jeecgDemo = jeecgDemoService.getById(id);
return Result.ok(jeecgDemo);
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
@PermissionData(pageComponent = "jeecg/JeecgDemoList")
public ModelAndView exportXls(HttpServletRequest request, JeecgDemo jeecgDemo) {
return super.exportXls(request, jeecgDemo, JeecgDemo.class, "单表模型");
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
return super.importExcel(request, response, JeecgDemo.class);
}
// =====Redis 示例===============================================================================================
/**
* redis操作 -- set
*/
@GetMapping(value = "/redisSet")
public void redisSet() {
redisUtil.set("name", "张三" + DateUtils.now());
}
/**
* redis操作 -- get
*/
@GetMapping(value = "/redisGet")
public String redisGet() {
return (String) redisUtil.get("name");
}
/**
* redis操作 -- setObj
*/
@GetMapping(value = "/redisSetObj")
public void redisSetObj() {
JeecgDemo p = new JeecgDemo();
p.setAge(10);
p.setBirthday(new Date());
p.setContent("hello");
p.setName("张三");
p.setSex("男");
redisUtil.set("user-zdh", p);
}
/**
* redis操作 -- setObj
*/
@GetMapping(value = "/redisGetObj")
public Object redisGetObj() {
return redisUtil.get("user-zdh");
}
/**
* redis操作 -- get
*/
@GetMapping(value = "/redis/{id}")
public JeecgDemo redisGetJeecgDemo(@PathVariable("id") String id) {
JeecgDemo t = jeecgDemoService.getByIdCacheable(id);
log.info(t.toString());
return t;
}
// ===Freemaker示例================================================================================
/**
* freemaker方式 【页面路径： src/main/resources/templates】
*
* @param modelAndView
* @return
*/
@RequestMapping("/html")
public ModelAndView ftl(ModelAndView modelAndView) {
modelAndView.setViewName("demo3");
List<String> userList = new ArrayList<String>();
userList.add("admin");
userList.add("user1");
userList.add("user2");
log.info("--------------test--------------");
modelAndView.addObject("userList", userList);
return modelAndView;
}
// ==========================================动态表单 JSON接收测试===========================================
@PostMapping(value = "/testOnlineAdd")
public Result<?> testOnlineAdd(@RequestBody JSONObject json) {
log.info(json.toJSONString());
return Result.ok("添加成功！");
}
/*----------------------------------------外部获取权限示例------------------------------------*/
/**
* 【数据权限示例 - 编程】mybatisPlus java类方式加载权限
*
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/mpList")
@PermissionData(pageComponent = "jeecg/JeecgDemoList")
public Result<?> loadMpPermissonList(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<JeecgDemo> queryWrapper = new QueryWrapper<JeecgDemo>();
//编程方式，给queryWrapper装载数据权限规则
QueryGenerator.installAuthMplus(queryWrapper, JeecgDemo.class);
Page<JeecgDemo> page = new Page<JeecgDemo>(pageNo, pageSize);
IPage<JeecgDemo> pageList = jeecgDemoService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 【数据权限示例 - 编程】mybatis xml方式加载权限
*
* @param jeecgDemo
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/sqlList")
@PermissionData(pageComponent = "jeecg/JeecgDemoList")
public Result<?> loadSqlPermissonList(JeecgDemo jeecgDemo, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
IPage<JeecgDemo> pageList = jeecgDemoService.queryListWithPermission(pageSize, pageNo);
return Result.ok(pageList);
}
/*----------------------------------------外部获取权限示例------------------------------------*/
}

254
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/controller/JeecgOrderMainController.java
View File

@ -1,254 +0,0 @@
package org.jeecg.modules.demo.test.controller;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.demo.test.entity.JeecgDemo;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import org.jeecg.modules.demo.test.entity.JeecgOrderMain;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import org.jeecg.modules.demo.test.service.IJeecgDemoService;
import org.jeecg.modules.demo.test.service.IJeecgOrderCustomerService;
import org.jeecg.modules.demo.test.service.IJeecgOrderMainService;
import org.jeecg.modules.demo.test.service.IJeecgOrderTicketService;
import org.jeecg.modules.demo.test.vo.JeecgOrderMainPage;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 一对多示例（JEditableTable行编辑）
* @Author: jeecg-boot
* @Date:2019-02-15
* @Version: V2.0
*/
@RestController
@RequestMapping("/test/jeecgOrderMain")
@Slf4j
public class JeecgOrderMainController extends JeecgController<JeecgOrderMain, IJeecgOrderMainService> {
@Autowired
private IJeecgOrderMainService jeecgOrderMainService;
@Autowired
private IJeecgOrderCustomerService jeecgOrderCustomerService;
@Autowired
private IJeecgOrderTicketService jeecgOrderTicketService;
/**
* 分页列表查询
*
* @param jeecgOrderMain
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/list")
public Result<?> queryPageList(JeecgOrderMain jeecgOrderMain, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) {
QueryWrapper<JeecgOrderMain> queryWrapper = QueryGenerator.initQueryWrapper(jeecgOrderMain, req.getParameterMap());
Page<JeecgOrderMain> page = new Page<JeecgOrderMain>(pageNo, pageSize);
IPage<JeecgOrderMain> pageList = jeecgOrderMainService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 添加
*
* @param jeecgOrderMainPage
* @return
*/
@PostMapping(value = "/add")
public Result<?> add(@RequestBody JeecgOrderMainPage jeecgOrderMainPage) {
JeecgOrderMain jeecgOrderMain = new JeecgOrderMain();
BeanUtils.copyProperties(jeecgOrderMainPage, jeecgOrderMain);
jeecgOrderMainService.saveMain(jeecgOrderMain, jeecgOrderMainPage.getJeecgOrderCustomerList(), jeecgOrderMainPage.getJeecgOrderTicketList());
return Result.ok("添加成功！");
}
/**
* 编辑
*
* @param jeecgOrderMainPage
* @return
*/
@PutMapping(value = "/edit")
public Result<?> eidt(@RequestBody JeecgOrderMainPage jeecgOrderMainPage) {
JeecgOrderMain jeecgOrderMain = new JeecgOrderMain();
BeanUtils.copyProperties(jeecgOrderMainPage, jeecgOrderMain);
jeecgOrderMainService.updateMain(jeecgOrderMain, jeecgOrderMainPage.getJeecgOrderCustomerList(), jeecgOrderMainPage.getJeecgOrderTicketList());
return Result.ok("编辑成功！");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
jeecgOrderMainService.delMain(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.jeecgOrderMainService.delBatchMain(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
JeecgOrderMain jeecgOrderMain = jeecgOrderMainService.getById(id);
return Result.ok(jeecgOrderMain);
}
/**
* 通过id查询
*
* @param id
* @return
*/
@GetMapping(value = "/queryOrderCustomerListByMainId")
public Result<?> queryOrderCustomerListByMainId(@RequestParam(name = "id", required = true) String id) {
List<JeecgOrderCustomer> jeecgOrderCustomerList = jeecgOrderCustomerService.selectCustomersByMainId(id);
return Result.ok(jeecgOrderCustomerList);
}
/**
* 通过id查询
*
* @param id
* @return
*/
@GetMapping(value = "/queryOrderTicketListByMainId")
public Result<?> queryOrderTicketListByMainId(@RequestParam(name = "id", required = true) String id) {
List<JeecgOrderTicket> jeecgOrderTicketList = jeecgOrderTicketService.selectTicketsByMainId(id);
return Result.ok(jeecgOrderTicketList);
}
/**
* 导出excel
*
* @param request
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, JeecgOrderMain jeecgOrderMain) {
// Step.1 组装查询条件
QueryWrapper<JeecgOrderMain> queryWrapper = QueryGenerator.initQueryWrapper(jeecgOrderMain, request.getParameterMap());
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
//获取当前用户
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
List<JeecgOrderMainPage> pageList = new ArrayList<JeecgOrderMainPage>();
List<JeecgOrderMain> jeecgOrderMainList = jeecgOrderMainService.list(queryWrapper);
for (JeecgOrderMain orderMain : jeecgOrderMainList) {
JeecgOrderMainPage vo = new JeecgOrderMainPage();
BeanUtils.copyProperties(orderMain, vo);
// 查询机票
List<JeecgOrderTicket> jeecgOrderTicketList = jeecgOrderTicketService.selectTicketsByMainId(orderMain.getId());
vo.setJeecgOrderTicketList(jeecgOrderTicketList);
// 查询客户
List<JeecgOrderCustomer> jeecgOrderCustomerList = jeecgOrderCustomerService.selectCustomersByMainId(orderMain.getId());
vo.setJeecgOrderCustomerList(jeecgOrderCustomerList);
pageList.add(vo);
}
// 导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "一对多订单示例");
// 注解对象Class
mv.addObject(NormalExcelConstants.CLASS, JeecgOrderMainPage.class);
// 自定义表格参数
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("自定义导出Excel内容标题", "导出人:" + sysUser.getRealname(), "自定义Sheet名字"));
// 导出数据列表
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(2);
params.setNeedSave(true);
try {
List<JeecgOrderMainPage> list = ExcelImportUtil.importExcel(file.getInputStream(), JeecgOrderMainPage.class, params);
for (JeecgOrderMainPage page : list) {
JeecgOrderMain po = new JeecgOrderMain();
BeanUtils.copyProperties(page, po);
jeecgOrderMainService.saveMain(po, page.getJeecgOrderCustomerList(), page.getJeecgOrderTicketList());
}
return Result.ok("文件导入成功！");
} catch (Exception e) {
log.error(e.getMessage(), e);
return Result.error("文件导入失败：" + e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
return Result.error("文件导入失败！");
}
}

267
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/controller/JeecgOrderTabMainController.java
View File

@ -1,267 +0,0 @@
package org.jeecg.modules.demo.test.controller;
import java.util.Arrays;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import org.jeecg.modules.demo.test.entity.JeecgOrderMain;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import org.jeecg.modules.demo.test.service.IJeecgOrderCustomerService;
import org.jeecg.modules.demo.test.service.IJeecgOrderMainService;
import org.jeecg.modules.demo.test.service.IJeecgOrderTicketService;
import org.jeecg.modules.demo.test.vo.JeecgOrderMainPage;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 一对多示例（ERP TAB风格）
* @Author: ZhiLin
* @Date: 2019-02-20
* @Version: v2.0
*/
@Slf4j
@RestController
@RequestMapping("/test/order")
public class JeecgOrderTabMainController {
@Autowired
private IJeecgOrderMainService jeecgOrderMainService;
@Autowired
private IJeecgOrderCustomerService jeecgOrderCustomerService;
@Autowired
private IJeecgOrderTicketService jeecgOrderTicketService;
/**
* 分页列表查询
*
* @param jeecgOrderMain
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/orderList")
public Result<?> respondePagedData(JeecgOrderMain jeecgOrderMain,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<JeecgOrderMain> queryWrapper = QueryGenerator.initQueryWrapper(jeecgOrderMain, req.getParameterMap());
Page<JeecgOrderMain> page = new Page<JeecgOrderMain>(pageNo, pageSize);
IPage<JeecgOrderMain> pageList = jeecgOrderMainService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 添加
*
* @param jeecgOrderMainPage
* @return
*/
@PostMapping(value = "/add")
public Result<?> add(@RequestBody JeecgOrderMainPage jeecgOrderMainPage) {
JeecgOrderMain jeecgOrderMain = new JeecgOrderMain();
BeanUtils.copyProperties(jeecgOrderMainPage, jeecgOrderMain);
jeecgOrderMainService.save(jeecgOrderMain);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param jeecgOrderMainPage
* @return
*/
@PutMapping("/edit")
public Result<?> edit(@RequestBody JeecgOrderMainPage jeecgOrderMainPage) {
JeecgOrderMain jeecgOrderMain = new JeecgOrderMain();
BeanUtils.copyProperties(jeecgOrderMainPage, jeecgOrderMain);
jeecgOrderMainService.updateById(jeecgOrderMain);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@DeleteMapping(value = "/delete")
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
jeecgOrderMainService.delMain(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
this.jeecgOrderMainService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 通过id查询
*
* @param id
* @return
*/
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
JeecgOrderMain jeecgOrderMain = jeecgOrderMainService.getById(id);
return Result.ok(jeecgOrderMain);
}
/**
* 通过id查询
*
* @param jeecgOrderCustomer
* @return
*/
@GetMapping(value = "/listOrderCustomerByMainId")
public Result<?> queryOrderCustomerListByMainId(JeecgOrderCustomer jeecgOrderCustomer,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<JeecgOrderCustomer> queryWrapper = QueryGenerator.initQueryWrapper(jeecgOrderCustomer, req.getParameterMap());
Page<JeecgOrderCustomer> page = new Page<JeecgOrderCustomer>(pageNo, pageSize);
IPage<JeecgOrderCustomer> pageList = jeecgOrderCustomerService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 通过id查询
*
* @param jeecgOrderTicket
* @return
*/
@GetMapping(value = "/listOrderTicketByMainId")
public Result<?> queryOrderTicketListByMainId(JeecgOrderTicket jeecgOrderTicket,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<JeecgOrderTicket> queryWrapper = QueryGenerator.initQueryWrapper(jeecgOrderTicket, req.getParameterMap());
Page<JeecgOrderTicket> page = new Page<JeecgOrderTicket>(pageNo, pageSize);
IPage<JeecgOrderTicket> pageList = jeecgOrderTicketService.page(page, queryWrapper);
return Result.ok(pageList);
}
/**
* 添加
*
* @param jeecgOrderCustomer
* @return
*/
@PostMapping(value = "/addCustomer")
public Result<?> addCustomer(@RequestBody JeecgOrderCustomer jeecgOrderCustomer) {
jeecgOrderCustomerService.save(jeecgOrderCustomer);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param jeecgOrderCustomer
* @return
*/
@PutMapping("/editCustomer")
public Result<?> editCustomer(@RequestBody JeecgOrderCustomer jeecgOrderCustomer) {
jeecgOrderCustomerService.updateById(jeecgOrderCustomer);
return Result.ok("添加成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@DeleteMapping(value = "/deleteCustomer")
public Result<?> deleteCustomer(@RequestParam(name = "id", required = true) String id) {
jeecgOrderCustomerService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatchCustomer")
public Result<?> deleteBatchCustomer(@RequestParam(name = "ids", required = true) String ids) {
this.jeecgOrderCustomerService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
/**
* 添加
*
* @param jeecgOrderTicket
* @return
*/
@PostMapping(value = "/addTicket")
public Result<?> addTicket(@RequestBody JeecgOrderTicket jeecgOrderTicket) {
jeecgOrderTicketService.save(jeecgOrderTicket);
return Result.ok("添加成功!");
}
/**
* 编辑
*
* @param jeecgOrderTicket
* @return
*/
@PutMapping("/editTicket")
public Result<?> editTicket(@RequestBody JeecgOrderTicket jeecgOrderTicket) {
jeecgOrderTicketService.updateById(jeecgOrderTicket);
return Result.ok("编辑成功!");
}
/**
* 通过id删除
*
* @param id
* @return
*/
@DeleteMapping(value = "/deleteTicket")
public Result<?> deleteTicket(@RequestParam(name = "id", required = true) String id) {
jeecgOrderTicketService.removeById(id);
return Result.ok("删除成功!");
}
/**
* 批量删除
*
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatchTicket")
public Result<?> deleteBatchTicket(@RequestParam(name = "ids", required = true) String ids) {
this.jeecgOrderTicketService.removeByIds(Arrays.asList(ids.split(",")));
return Result.ok("批量删除成功!");
}
}

244
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/controller/JoaDemoController.java
View File

@ -1,244 +0,0 @@
package org.jeecg.modules.demo.test.controller;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.demo.test.entity.JoaDemo;
import org.jeecg.modules.demo.test.service.IJoaDemoService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 流程测试
* @Author: jeecg-boot
* @Date: 2019-05-14
* @Version: V1.0
*/
@RestController
@RequestMapping("/test/joaDemo")
@Slf4j
public class JoaDemoController {
@Autowired
private IJoaDemoService joaDemoService;
/**
* 分页列表查询
* @param joaDemo
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@GetMapping(value = "/list")
public Result<IPage<JoaDemo>> queryPageList(JoaDemo joaDemo,
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
HttpServletRequest req) {
Result<IPage<JoaDemo>> result = new Result<IPage<JoaDemo>>();
QueryWrapper<JoaDemo> queryWrapper = QueryGenerator.initQueryWrapper(joaDemo, req.getParameterMap());
Page<JoaDemo> page = new Page<JoaDemo>(pageNo, pageSize);
IPage<JoaDemo> pageList = joaDemoService.page(page, queryWrapper);
result.setSuccess(true);
result.setResult(pageList);
return result;
}
/**
* 添加
* @param joaDemo
* @return
*/
@PostMapping(value = "/add")
public Result<JoaDemo> add(@RequestBody JoaDemo joaDemo) {
Result<JoaDemo> result = new Result<JoaDemo>();
try {
joaDemoService.save(joaDemo);
result.success("添加成功！");
} catch (Exception e) {
log.error(e.getMessage(),e);
result.error500("操作失败");
}
return result;
}
/**
* 编辑
* @param joaDemo
* @return
*/
@PutMapping(value = "/edit")
public Result<JoaDemo> edit(@RequestBody JoaDemo joaDemo) {
Result<JoaDemo> result = new Result<JoaDemo>();
JoaDemo joaDemoEntity = joaDemoService.getById(joaDemo.getId());
if(joaDemoEntity==null) {
result.error500("未找到对应实体");
}else {
boolean ok = joaDemoService.updateById(joaDemo);
//TODO 返回false说明什么？
if(ok) {
result.success("修改成功!");
}
}
return result;
}
/**
* 通过id删除
* @param id
* @return
*/
@DeleteMapping(value = "/delete")
public Result<JoaDemo> delete(@RequestParam(name="id",required=true) String id) {
Result<JoaDemo> result = new Result<JoaDemo>();
JoaDemo joaDemo = joaDemoService.getById(id);
if(joaDemo==null) {
result.error500("未找到对应实体");
}else {
boolean ok = joaDemoService.removeById(id);
if(ok) {
result.success("删除成功!");
}
}
return result;
}
/**
* 批量删除
* @param ids
* @return
*/
@DeleteMapping(value = "/deleteBatch")
public Result<JoaDemo> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<JoaDemo> result = new Result<JoaDemo>();
if(ids==null || "".equals(ids.trim())) {
result.error500("参数不识别！");
}else {
this.joaDemoService.removeByIds(Arrays.asList(ids.split(",")));
result.success("删除成功!");
}
return result;
}
/**
* 通过id查询
* @param id
* @return
*/
@GetMapping(value = "/queryById")
public Result<JoaDemo> queryById(@RequestParam(name="id",required=true) String id) {
Result<JoaDemo> result = new Result<JoaDemo>();
JoaDemo joaDemo = joaDemoService.getById(id);
if(joaDemo==null) {
result.error500("未找到对应实体");
}else {
result.setResult(joaDemo);
result.setSuccess(true);
}
return result;
}
/**
* 导出excel
*
* @param request
* @param response
*/
@RequestMapping(value = "/exportXls")
public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
// Step.1 组装查询条件
QueryWrapper<JoaDemo> queryWrapper = null;
try {
String paramsStr = request.getParameter("paramsStr");
if (oConvertUtils.isNotEmpty(paramsStr)) {
String deString = URLDecoder.decode(paramsStr, "UTF-8");
JoaDemo joaDemo = JSON.parseObject(deString, JoaDemo.class);
queryWrapper = QueryGenerator.initQueryWrapper(joaDemo, request.getParameterMap());
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
//Step.2 AutoPoi 导出Excel
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
List<JoaDemo> pageList = joaDemoService.list(queryWrapper);
//导出文件名称
mv.addObject(NormalExcelConstants.FILE_NAME, "流程测试列表");
mv.addObject(NormalExcelConstants.CLASS, JoaDemo.class);
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("流程测试列表数据", "导出人:Jeecg", "导出信息"));
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
return mv;
}
/**
* 通过excel导入数据
*
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile file = entity.getValue();// 获取上传文件对象
ImportParams params = new ImportParams();
params.setTitleRows(2);
params.setHeadRows(1);
params.setNeedSave(true);
try {
List<JoaDemo> listJoaDemos = ExcelImportUtil.importExcel(file.getInputStream(), JoaDemo.class, params);
for (JoaDemo joaDemoExcel : listJoaDemos) {
joaDemoService.save(joaDemoExcel);
}
return Result.ok("文件导入成功！数据行数:" + listJoaDemos.size());
} catch (Exception e) {
log.error(e.getMessage(),e);
return Result.error("文件导入失败:"+e.getMessage());
} finally {
try {
file.getInputStream().close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Result.ok("文件导入失败！");
}
}

78
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/entity/JeecgDemo.java
View File

@ -1,78 +0,0 @@
package org.jeecg.modules.demo.test.entity;
import java.io.Serializable;
import org.jeecg.common.system.base.entity.JeecgEntity;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* @Description: jeecg 测试demo
* @Author: jeecg-boot
* @Date: 2018-12-29
* @Version:V1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="测试DEMO对象", description="测试DEMO")
@TableName("demo")
public class JeecgDemo extends JeecgEntity implements Serializable {
private static final long serialVersionUID = 1L;
/** 部门编码 */
@Excel(name="部门编码",width=25)
@ApiModelProperty(value = "部门编码")
private java.lang.String sysOrgCode;
/** 姓名 */
@Excel(name="姓名",width=25)
@ApiModelProperty(value = "姓名")
private java.lang.String name;
/** 关键词 */
@ApiModelProperty(value = "关键词")
@Excel(name="关键词",width=15)
private java.lang.String keyWord;
/** 打卡时间 */
@ApiModelProperty(value = "打卡时间")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Excel(name="打卡时间",width=20,format="yyyy-MM-dd HH:mm:ss")
private java.util.Date punchTime;
/** 工资 */
@ApiModelProperty(value = "工资",example = "0")
@Excel(name="工资",width=15)
private java.math.BigDecimal salaryMoney;
/** 奖金 */
@ApiModelProperty(value = "奖金",example = "0")
@Excel(name="奖金",width=15)
private java.lang.Double bonusMoney;
/** 性别 {男:1,女:2} */
@ApiModelProperty(value = "性别")
@Excel(name = "性别", width = 15, dicCode = "sex")
private java.lang.String sex;
/** 年龄 */
@ApiModelProperty(value = "年龄",example = "0")
@Excel(name="年龄",width=15)
private java.lang.Integer age;
/** 生日 */
@ApiModelProperty(value = "生日")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@Excel(name="生日",format="yyyy-MM-dd")
private java.util.Date birthday;
/** 邮箱 */
@ApiModelProperty(value = "邮箱")
@Excel(name="邮箱",width=30)
private java.lang.String email;
/** 个人简介 */
@ApiModelProperty(value = "个人简介")
private java.lang.String content;
}

54
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/entity/JeecgOrderCustomer.java
View File

@ -1,54 +0,0 @@
package org.jeecg.modules.demo.test.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 订单客户
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
@Data
@TableName("jeecg_order_customer")
public class JeecgOrderCustomer implements Serializable {
private static final long serialVersionUID = 1L;
/**主键*/
@TableId(type = IdType.ID_WORKER_STR)
private java.lang.String id;
/**客户名*/
@Excel(name="客户名字",width=15)
private java.lang.String name;
/**性别*/
private java.lang.String sex;
/**身份证号码*/
@Excel(name="身份证号码",width=15)
private java.lang.String idcard;
/**身份证扫描件*/
private java.lang.String idcardPic;
/**电话1*/
@Excel(name="电话",width=15)
private java.lang.String telphone;
/**外键*/
private java.lang.String orderId;
/**创建人*/
private java.lang.String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**修改人*/
private java.lang.String updateBy;
/**修改时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
}

50
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/entity/JeecgOrderMain.java
View File

@ -1,50 +0,0 @@
package org.jeecg.modules.demo.test.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 订单
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
@Data
@TableName("jeecg_order_main")
public class JeecgOrderMain implements Serializable {
private static final long serialVersionUID = 1L;
/**主键*/
@TableId(type = IdType.ID_WORKER_STR)
private java.lang.String id;
/**订单号*/
private java.lang.String orderCode;
/**订单类型*/
private java.lang.String ctype;
/**订单日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date orderDate;
/**订单金额*/
private java.lang.Double orderMoney;
/**订单备注*/
private java.lang.String content;
/**创建人*/
private java.lang.String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**修改人*/
private java.lang.String updateBy;
/**修改时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
}

48
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/entity/JeecgOrderTicket.java
View File

@ -1,48 +0,0 @@
package org.jeecg.modules.demo.test.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 订单机票
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
@Data
@TableName("jeecg_order_ticket")
public class JeecgOrderTicket implements Serializable {
private static final long serialVersionUID = 1L;
/**主键*/
@TableId(type = IdType.ID_WORKER_STR)
private java.lang.String id;
/**航班号*/
@Excel(name="航班号",width=15)
private java.lang.String ticketCode;
/**航班时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@Excel(name="航班时间",width=15,format = "yyyy-MM-dd")
private java.util.Date tickectDate;
/**外键*/
private java.lang.String orderId;
/**创建人*/
private java.lang.String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**修改人*/
private java.lang.String updateBy;
/**修改时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
}

67
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/entity/JoaDemo.java
View File

@ -1,67 +0,0 @@
package org.jeecg.modules.demo.test.entity;
import java.io.Serializable;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
/**
* @Description: 流程测试
* @Author: jeecg-boot
* @Date: 2019-05-14
* @Version: V1.0
*/
@Data
@TableName("joa_demo")
public class JoaDemo implements Serializable {
private static final long serialVersionUID = 1L;
/**ID*/
@TableId(type = IdType.ID_WORKER_STR)
private java.lang.String id;
/**请假人*/
@Excel(name = "请假人", width = 15)
private java.lang.String name;
/**请假天数*/
@Excel(name = "请假天数", width = 15)
private java.lang.Integer days;
/**开始时间*/
@Excel(name = "开始时间", width = 20, format = "yyyy-MM-dd")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
private java.util.Date beginDate;
/**请假结束时间*/
@Excel(name = "请假结束时间", width = 20, format = "yyyy-MM-dd")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
private java.util.Date endDate;
/**请假原因*/
@Excel(name = "请假原因", width = 15)
private java.lang.String reason;
/**流程状态*/
@Excel(name = "流程状态", width = 15)
private java.lang.String bpmStatus;
/**创建人id*/
@Excel(name = "创建人id", width = 15)
private java.lang.String createBy;
/**创建时间*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**修改时间*/
@Excel(name = "修改时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
/**修改人id*/
@Excel(name = "修改人id", width = 15)
private java.lang.String updateBy;
}

30
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/JeecgDemoMapper.java
View File

@ -1,30 +0,0 @@
package org.jeecg.modules.demo.test.mapper;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.demo.test.entity.JeecgDemo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* @Description: jeecg 测试demo
* @Author: jeecg-boot
* @Date: 2018-12-29
* @Version: V1.0
*/
public interface JeecgDemoMapper extends BaseMapper<JeecgDemo> {
public List<JeecgDemo> getDemoByName(@Param("name") String name);
/**
* 查询列表数据 直接传数据权限的sql进行数据过滤
* @param page
* @param permissionSql
* @return
*/
public IPage<JeecgDemo> queryListWithPermission(Page<JeecgDemo> page,@Param("permissionSql")String permissionSql);
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/JeecgOrderCustomerMapper.java
View File

@ -1,29 +0,0 @@
package org.jeecg.modules.demo.test.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Select;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 订单客户
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
public interface JeecgOrderCustomerMapper extends BaseMapper<JeecgOrderCustomer> {
/**
* 通过主表外键批量删除客户
* @param mainId
* @return
*/
@Delete("DELETE FROM JEECG_ORDER_CUSTOMER WHERE ORDER_ID = #{mainId}")
public boolean deleteCustomersByMainId(String mainId);
@Select("SELECT * FROM JEECG_ORDER_CUSTOMER WHERE ORDER_ID = #{mainId}")
public List<JeecgOrderCustomer> selectCustomersByMainId(String mainId);
}

17
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/JeecgOrderMainMapper.java
View File

@ -1,17 +0,0 @@
package org.jeecg.modules.demo.test.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.demo.test.entity.JeecgOrderMain;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 订单
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
public interface JeecgOrderMainMapper extends BaseMapper<JeecgOrderMain> {
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/JeecgOrderTicketMapper.java
View File

@ -1,29 +0,0 @@
package org.jeecg.modules.demo.test.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Select;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 订单机票
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
public interface JeecgOrderTicketMapper extends BaseMapper<JeecgOrderTicket> {
/**
* 通过主表外键批量删除客户
* @param mainId
* @return
*/
@Delete("DELETE FROM JEECG_ORDER_TICKET WHERE ORDER_ID = #{mainId}")
public boolean deleteTicketsByMainId(String mainId);
@Select("SELECT * FROM JEECG_ORDER_TICKET WHERE ORDER_ID = #{mainId}")
public List<JeecgOrderTicket> selectTicketsByMainId(String mainId);
}

15
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/JoaDemoMapper.java
View File

@ -1,15 +0,0 @@
package org.jeecg.modules.demo.test.mapper;
import org.jeecg.modules.demo.test.entity.JoaDemo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 流程测试
* @Author: jeecg-boot
* @Date: 2019-05-14
* @Version: V1.0
*/
public interface JoaDemoMapper extends BaseMapper<JoaDemo> {
}

14
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/xml/JeecgDemoMapper.xml
View File

@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.jeecg.modules.demo.test.mapper.JeecgDemoMapper">
<!-- 根据用户名查询 -->
<select id="getDemoByName" resultType="org.jeecg.modules.demo.test.entity.JeecgDemo">
select * from demo where name = #{name}
</select>
<!-- 根据权限sql查询数据集 -->
<select id="queryListWithPermission" parameterType="Object" resultType="org.jeecg.modules.demo.test.entity.JeecgDemo">
select * from demo where 1=1 ${permissionSql}
</select>
</mapper>

5
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/mapper/xml/JeecgOrderMainMapper.xml
View File

@ -1,5 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.jeecg.modules.demo.test.mapper.JeecgOrderMainMapper">
</mapper>

27
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/IJeecgDemoService.java
View File

@ -1,27 +0,0 @@
package org.jeecg.modules.demo.test.service;
import org.jeecg.common.system.base.service.JeecgService;
import org.jeecg.modules.demo.test.entity.JeecgDemo;
import com.baomidou.mybatisplus.core.metadata.IPage;
/**
* @Description: jeecg 测试demo
* @Author: jeecg-boot
* @Date: 2018-12-29
* @Version: V1.0
*/
public interface IJeecgDemoService extends JeecgService<JeecgDemo> {
public void testTran();
public JeecgDemo getByIdCacheable(String id);
/**
* 查询列表数据 在service中获取数据权限sql信息
* @param pageSize
* @param pageNo
* @return
*/
IPage<JeecgDemo> queryListWithPermission(int pageSize,int pageNo);
}

18
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/IJeecgOrderCustomerService.java
View File

@ -1,18 +0,0 @@
package org.jeecg.modules.demo.test.service;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 订单客户
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
public interface IJeecgOrderCustomerService extends IService<JeecgOrderCustomer> {
public List<JeecgOrderCustomer> selectCustomersByMainId(String mainId);
}

44
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/IJeecgOrderMainService.java
View File

@ -1,44 +0,0 @@
package org.jeecg.modules.demo.test.service;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import org.jeecg.modules.demo.test.entity.JeecgOrderMain;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 订单
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
public interface IJeecgOrderMainService extends IService<JeecgOrderMain> {
/**
* 添加一对多
*
*/
public void saveMain(JeecgOrderMain jeecgOrderMain,List<JeecgOrderCustomer> jeecgOrderCustomerList,List<JeecgOrderTicket> jeecgOrderTicketList) ;
/**
* 修改一对多
*
*/
public void updateMain(JeecgOrderMain jeecgOrderMain,List<JeecgOrderCustomer> jeecgOrderCustomerList,List<JeecgOrderTicket> jeecgOrderTicketList);
/**
* 删除一对多
* @param jformOrderMain
*/
public void delMain (String id);
/**
* 批量删除一对多
* @param jformOrderMain
*/
public void delBatchMain (Collection<? extends Serializable> idList);
}

18
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/IJeecgOrderTicketService.java
View File

@ -1,18 +0,0 @@
package org.jeecg.modules.demo.test.service;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 订单机票
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
public interface IJeecgOrderTicketService extends IService<JeecgOrderTicket> {
public List<JeecgOrderTicket> selectTicketsByMainId(String mainId);
}

15
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/IJoaDemoService.java
View File

@ -1,15 +0,0 @@
package org.jeecg.modules.demo.test.service;
import org.jeecg.modules.demo.test.entity.JoaDemo;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 流程测试
* @Author: jeecg-boot
* @Date: 2019-05-14
* @Version: V1.0
*/
public interface IJoaDemoService extends IService<JoaDemo> {
}

75
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/impl/JeecgDemoServiceImpl.java
View File

@ -1,75 +0,0 @@
package org.jeecg.modules.demo.test.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.demo.test.entity.JeecgDemo;
import org.jeecg.modules.demo.test.mapper.JeecgDemoMapper;
import org.jeecg.modules.demo.test.service.IJeecgDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* @Description: jeecg 测试demo
* @Author: jeecg-boot
* @Date: 2018-12-29
* @Version: V1.0
*/
@Service
public class JeecgDemoServiceImpl extends ServiceImpl<JeecgDemoMapper, JeecgDemo> implements IJeecgDemoService {
@Autowired
JeecgDemoMapper jeecgDemoMapper;
/**
* 事务控制在service层面
* 加上注解：@Transactional，声明的方法就是一个独立的事务（有异常DB操作全部回滚）
*/
@Override
@Transactional
public void testTran() {
JeecgDemo pp = new JeecgDemo();
pp.setAge(1111);
pp.setName("测试事务 小白兔 1");
jeecgDemoMapper.insert(pp);
JeecgDemo pp2 = new JeecgDemo();
pp2.setAge(2222);
pp2.setName("测试事务 小白兔 2");
jeecgDemoMapper.insert(pp2);
Integer.parseInt("hello");//自定义异常
JeecgDemo pp3 = new JeecgDemo();
pp3.setAge(3333);
pp3.setName("测试事务 小白兔 3");
jeecgDemoMapper.insert(pp3);
return ;
}
/**
* 缓存注解测试： redis
*/
@Override
@Cacheable(cacheNames = CacheConstant.TEST_DEMO_CACHE, key = "#id")
public JeecgDemo getByIdCacheable(String id) {
JeecgDemo t = jeecgDemoMapper.selectById(id);
System.err.println("---未读缓存，读取数据库---");
System.err.println(t);
return t;
}
@Override
public IPage<JeecgDemo> queryListWithPermission(int pageSize,int pageNo) {
Page<JeecgDemo> page = new Page<>(pageNo, pageSize);
//编程方式，获取当前请求的数据权限规则SQL片段
String sql = QueryGenerator.installAuthJdbc(JeecgDemo.class);
return this.baseMapper.queryListWithPermission(page, sql);
}
}

30
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/impl/JeecgOrderCustomerServiceImpl.java
View File

@ -1,30 +0,0 @@
package org.jeecg.modules.demo.test.service.impl;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import org.jeecg.modules.demo.test.mapper.JeecgOrderCustomerMapper;
import org.jeecg.modules.demo.test.service.IJeecgOrderCustomerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 订单客户
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
@Service
public class JeecgOrderCustomerServiceImpl extends ServiceImpl<JeecgOrderCustomerMapper, JeecgOrderCustomer> implements IJeecgOrderCustomerService {
@Autowired
private JeecgOrderCustomerMapper jeecgOrderCustomerMapper;
@Override
public List<JeecgOrderCustomer> selectCustomersByMainId(String mainId) {
return jeecgOrderCustomerMapper.selectCustomersByMainId(mainId);
}
}

96
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/impl/JeecgOrderMainServiceImpl.java
View File

@ -1,96 +0,0 @@
package org.jeecg.modules.demo.test.service.impl;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import org.jeecg.modules.demo.test.entity.JeecgOrderMain;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import org.jeecg.modules.demo.test.mapper.JeecgOrderCustomerMapper;
import org.jeecg.modules.demo.test.mapper.JeecgOrderMainMapper;
import org.jeecg.modules.demo.test.mapper.JeecgOrderTicketMapper;
import org.jeecg.modules.demo.test.service.IJeecgOrderMainService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 订单
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
@Service
public class JeecgOrderMainServiceImpl extends ServiceImpl<JeecgOrderMainMapper, JeecgOrderMain> implements IJeecgOrderMainService {
@Autowired
private JeecgOrderMainMapper jeecgOrderMainMapper;
@Autowired
private JeecgOrderCustomerMapper jeecgOrderCustomerMapper;
@Autowired
private JeecgOrderTicketMapper jeecgOrderTicketMapper;
@Override
@Transactional
public void saveMain(JeecgOrderMain jeecgOrderMain, List<JeecgOrderCustomer> jeecgOrderCustomerList, List<JeecgOrderTicket> jeecgOrderTicketList) {
jeecgOrderMainMapper.insert(jeecgOrderMain);
if (jeecgOrderCustomerList != null) {
for (JeecgOrderCustomer entity : jeecgOrderCustomerList) {
entity.setOrderId(jeecgOrderMain.getId());
jeecgOrderCustomerMapper.insert(entity);
}
}
if (jeecgOrderTicketList != null) {
for (JeecgOrderTicket entity : jeecgOrderTicketList) {
entity.setOrderId(jeecgOrderMain.getId());
jeecgOrderTicketMapper.insert(entity);
}
}
}
@Override
@Transactional
public void updateMain(JeecgOrderMain jeecgOrderMain, List<JeecgOrderCustomer> jeecgOrderCustomerList, List<JeecgOrderTicket> jeecgOrderTicketList) {
jeecgOrderMainMapper.updateById(jeecgOrderMain);
//1.先删除子表数据
jeecgOrderTicketMapper.deleteTicketsByMainId(jeecgOrderMain.getId());
jeecgOrderCustomerMapper.deleteCustomersByMainId(jeecgOrderMain.getId());
//2.子表数据重新插入
if (jeecgOrderCustomerList != null) {
for (JeecgOrderCustomer entity : jeecgOrderCustomerList) {
entity.setOrderId(jeecgOrderMain.getId());
jeecgOrderCustomerMapper.insert(entity);
}
}
if (jeecgOrderTicketList != null) {
for (JeecgOrderTicket entity : jeecgOrderTicketList) {
entity.setOrderId(jeecgOrderMain.getId());
jeecgOrderTicketMapper.insert(entity);
}
}
}
@Override
@Transactional
public void delMain(String id) {
jeecgOrderMainMapper.deleteById(id);
jeecgOrderTicketMapper.deleteTicketsByMainId(id);
jeecgOrderCustomerMapper.deleteCustomersByMainId(id);
}
@Override
@Transactional
public void delBatchMain(Collection<? extends Serializable> idList) {
for(Serializable id:idList) {
jeecgOrderMainMapper.deleteById(id);
jeecgOrderTicketMapper.deleteTicketsByMainId(id.toString());
jeecgOrderCustomerMapper.deleteCustomersByMainId(id.toString());
}
}
}

29
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/impl/JeecgOrderTicketServiceImpl.java
View File

@ -1,29 +0,0 @@
package org.jeecg.modules.demo.test.service.impl;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import org.jeecg.modules.demo.test.mapper.JeecgOrderTicketMapper;
import org.jeecg.modules.demo.test.service.IJeecgOrderTicketService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 订单机票
* @Author: jeecg-boot
* @Date: 2019-02-15
* @Version: V1.0
*/
@Service
public class JeecgOrderTicketServiceImpl extends ServiceImpl<JeecgOrderTicketMapper, JeecgOrderTicket> implements IJeecgOrderTicketService {
@Autowired
private JeecgOrderTicketMapper jeecgOrderTicketMapper;
@Override
public List<JeecgOrderTicket> selectTicketsByMainId(String mainId) {
return jeecgOrderTicketMapper.selectTicketsByMainId(mainId);
}
}

19
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/service/impl/JoaDemoServiceImpl.java
View File

@ -1,19 +0,0 @@
package org.jeecg.modules.demo.test.service.impl;
import org.jeecg.modules.demo.test.entity.JoaDemo;
import org.jeecg.modules.demo.test.mapper.JoaDemoMapper;
import org.jeecg.modules.demo.test.service.IJoaDemoService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 流程测试
* @Author: jeecg-boot
* @Date: 2019-05-14
* @Version: V1.0
*/
@Service
public class JoaDemoServiceImpl extends ServiceImpl<JoaDemoMapper, JoaDemo> implements IJoaDemoService {
}

44
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/demo/test/vo/JeecgOrderMainPage.java
View File

@ -1,44 +0,0 @@
package org.jeecg.modules.demo.test.vo;
import java.util.List;
import org.jeecg.modules.demo.test.entity.JeecgOrderCustomer;
import org.jeecg.modules.demo.test.entity.JeecgOrderTicket;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecgframework.poi.excel.annotation.ExcelCollection;
import lombok.Data;
@Data
public class JeecgOrderMainPage {
/**主键*/
private java.lang.String id;
/**订单号*/
@Excel(name="订单号",width=15)
private java.lang.String orderCode;
/**订单类型*/
private java.lang.String ctype;
/**订单日期*/
@Excel(name="订单日期",width=15,format = "yyyy-MM-dd")
private java.util.Date orderDate;
/**订单金额*/
@Excel(name="订单金额",width=15)
private java.lang.Double orderMoney;
/**订单备注*/
private java.lang.String content;
/**创建人*/
private java.lang.String createBy;
/**创建时间*/
private java.util.Date createTime;
/**修改人*/
private java.lang.String updateBy;
/**修改时间*/
private java.util.Date updateTime;
@ExcelCollection(name="客户")
private List<JeecgOrderCustomer> jeecgOrderCustomerList;
@ExcelCollection(name="机票")
private List<JeecgOrderTicket> jeecgOrderTicketList;
}

8
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/message/handle/impl/EmailSendMsgHandle.java
View File

@ -1,6 +1,8 @@
package org.jeecg.modules.message.handle.impl;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.StaticConfig;
import org.jeecg.modules.message.handle.ISendMsgHandle;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
@ -21,6 +23,12 @@ public class EmailSendMsgHandle implements ISendMsgHandle {
JavaMailSender mailSender = (JavaMailSender) SpringContextUtils.getBean("mailSender");
MimeMessage message = mailSender.createMimeMessage();
MimeMessageHelper helper = null;
//update-begin-author：taoyan date:20200811 for:配置类数据获取
if(oConvertUtils.isEmpty(emailFrom)){
StaticConfig staticConfig = SpringContextUtils.getBean(StaticConfig.class);
setEmailFrom(staticConfig.getEmailFrom());
}
//update-end-author：taoyan date:20200811 for:配置类数据获取
try {
helper = new MimeMessageHelper(message, true);
// 设置发送方邮箱地址

26
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/message/util/PushMsgUtil.java
View File

@ -1,5 +1,8 @@
package org.jeecg.modules.message.util;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import org.jeecg.modules.message.entity.SysMessage;
import org.jeecg.modules.message.entity.SysMessageTemplate;
import org.jeecg.modules.message.handle.enums.SendMsgStatusEnum;
@ -10,6 +13,8 @@ import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Date;
import java.util.List;
import java.util.Map;
@ -27,6 +32,8 @@ public class PushMsgUtil {
@Autowired
private ISysMessageTemplateService sysMessageTemplateService;
@Autowired
private Configuration freemarkerConfig;
/**
* @param msgType 消息类型 1短信 2邮件 3微信
* @param templateCode 消息模板码
@ -44,13 +51,19 @@ public class PushMsgUtil {
String title = sysSmsTemplate.getTemplateName();
//模板内容
String content = sysSmsTemplate.getTemplateContent();
if(map!=null) {
for (Map.Entry<String, String> entry : map.entrySet()) {
String str = "${" + entry.getKey() + "}";
title = title.replace(str, entry.getValue());
content = content.replace(str, entry.getValue());
}
StringWriter stringWriter = new StringWriter();
Template template = null;
try {
template = new Template("SysMessageTemplate", content, freemarkerConfig);
template.process(map, stringWriter);
} catch (IOException e) {
e.printStackTrace();
return false;
} catch (TemplateException e) {
e.printStackTrace();
return false;
}
content = stringWriter.toString();
sysMessage.setEsTitle(title);
sysMessage.setEsContent(content);
sysMessage.setEsParam(JSONObject.toJSONString(map));
@ -63,4 +76,5 @@ public class PushMsgUtil {
}
return false;
}
}

2
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/quartz/entity/QuartzJob.java
View File

@ -26,7 +26,7 @@ public class QuartzJob implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ID_WORKER_STR)
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**创建人*/
private java.lang.String createBy;

28
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/authc/JwtToken.java
View File

@ -1,28 +0,0 @@
package org.jeecg.modules.shiro.authc;
import org.apache.shiro.authc.AuthenticationToken;
/**
* @Author Scott
* @create 2018-07-12 15:19
* @desc
**/
public class JwtToken implements AuthenticationToken {
private static final long serialVersionUID = 1L;
private String token;
public JwtToken(String token) {
this.token = token;
}
@Override
public Object getPrincipal() {
return token;
}
@Override
public Object getCredentials() {
return token;
}
}

181
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/authc/ShiroRealm.java
View File

@ -1,181 +0,0 @@
package org.jeecg.modules.shiro.authc;
import java.util.Set;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 用户登录鉴权和获取用户授权
* @Author: Scott
* @Date: 2019-4-23 8:13
* @Version: 1.1
*/
@Component
@Slf4j
public class ShiroRealm extends AuthorizingRealm {
@Autowired
@Lazy
private ISysUserService sysUserService;
@Autowired
@Lazy
private ISysBaseAPI sysBaseAPI;
@Autowired
@Lazy
private RedisUtil redisUtil;
/**
* 必须重写此方法，不然Shiro会报错
*/
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof JwtToken;
}
/**
* 权限信息认证(包括角色以及权限)是用户访问controller的时候才进行验证(redis存储的此处权限信息)
* 触发检测用户权限时才会调用此方法，例如checkRole,checkPermission
*
* @param principals 身份信息
* @return AuthorizationInfo 权限信息
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
log.info("===============Shiro权限认证开始============ [ roles、permissions]==========");
String username = null;
if (principals != null) {
LoginUser sysUser = (LoginUser) principals.getPrimaryPrincipal();
username = sysUser.getUsername();
}
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
// 设置用户拥有的角色集合，比如“admin,test”
Set<String> roleSet = sysUserService.getUserRolesSet(username);
info.setRoles(roleSet);
// 设置用户拥有的权限集合，比如“sys:role:add,sys:user:add”
Set<String> permissionSet = sysUserService.getUserPermissionsSet(username);
info.addStringPermissions(permissionSet);
log.info("===============Shiro权限认证成功==============");
return info;
}
/**
* 用户信息认证是在用户进行登录的时候进行验证(不存redis)
* 也就是说验证用户输入的账号和密码是否正确，错误抛出异常
*
* @param auth 用户登录的账号密码信息
* @return 返回封装了用户信息的 AuthenticationInfo 实例
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
String token = (String) auth.getCredentials();
if (token == null) {
log.info("————————身份认证失败——————————IP地址: "+ oConvertUtils.getIpAddrByRequest(SpringContextUtils.getHttpServletRequest()));
throw new AuthenticationException("token为空!");
}
// 校验token有效性
LoginUser loginUser = this.checkUserTokenIsEffect(token);
return new SimpleAuthenticationInfo(loginUser, token, getName());
}
/**
* 校验token的有效性
*
* @param token
*/
public LoginUser checkUserTokenIsEffect(String token) throws AuthenticationException {
// 解密获得username，用于和数据库进行对比
String username = JwtUtil.getUsername(token);
if (username == null) {
throw new AuthenticationException("token非法无效!");
}
// 查询用户信息
log.debug("———校验token是否有效————checkUserTokenIsEffect——————— "+ token);
LoginUser loginUser = sysBaseAPI.getUserByName(username);
if (loginUser == null) {
throw new AuthenticationException("用户不存在!");
}
// 判断用户状态
if (loginUser.getStatus() != 1) {
throw new AuthenticationException("账号已被锁定,请联系管理员!");
}
// 校验token是否超时失效 & 或者账号密码是否错误
if (!jwtTokenRefresh(token, username, loginUser.getPassword())) {
throw new AuthenticationException("Token失效，请重新登录!");
}
return loginUser;
}
/**
* JWTToken刷新生命周期 （实现： 用户在线操作不掉线功能）
* 1、登录成功后将用户的JWT生成的Token作为k、v存储到cache缓存里面(这时候k、v值一样)，缓存有效期设置为Jwt有效时间的2倍
* 2、当该用户再次请求时，通过JWTFilter层层校验之后会进入到doGetAuthenticationInfo进行身份验证
* 3、当该用户这次请求jwt生成的token值已经超时，但该token对应cache中的k还是存在，则表示该用户一直在操作只是JWT的token失效了，程序会给token对应的k映射的v值重新生成JWTToken并覆盖v值，该缓存生命周期重新计算
* 4、当该用户这次请求jwt在生成的token值已经超时，并在cache中不存在对应的k，则表示该用户账户空闲超时，返回用户信息已失效，请重新登录。
* 注意： 前端请求Header中设置Authorization保持不变，校验有效性以缓存中的token为准。
* 用户过期时间 = Jwt有效时间 * 2。
*
* @param userName
* @param passWord
* @return
*/
public boolean jwtTokenRefresh(String token, String userName, String passWord) {
String cacheToken = String.valueOf(redisUtil.get(CommonConstant.PREFIX_USER_TOKEN + token));
if (oConvertUtils.isNotEmpty(cacheToken)) {
// 校验token有效性
if (!JwtUtil.verify(cacheToken, userName, passWord)) {
String newAuthorization = JwtUtil.sign(userName, passWord);
// 设置超时时间
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, newAuthorization);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME *2 / 1000);
log.info("——————————用户在线操作，更新token保证不掉线—————————jwtTokenRefresh——————— "+ token);
}
//update-begin--Author:scott Date:20191005 for：解决每次请求，都重写redis中 token缓存问题
// else {
// // 设置超时时间
// redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, cacheToken);
// redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME / 1000);
// }
//update-end--Author:scott Date:20191005 for：解决每次请求，都重写redis中 token缓存问题
return true;
}
return false;
}
/**
* 清除当前用户的权限认证缓存
*
* @param principals 权限信息
*/
@Override
public void clearCache(PrincipalCollection principals) {
super.clearCache(principals);
}
}

78
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/authc/aop/JwtFilter.java
View File

@ -1,78 +0,0 @@
package org.jeecg.modules.shiro.authc.aop;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.jeecg.modules.shiro.authc.JwtToken;
import org.jeecg.modules.shiro.vo.DefContants;
import org.jeecg.modules.system.util.TenantContext;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 鉴权登录拦截器
* @Author: Scott
* @Date: 2018/10/7
**/
@Slf4j
public class JwtFilter extends BasicHttpAuthenticationFilter {
/**
* 执行登录认证
*
* @param request
* @param response
* @param mappedValue
* @return
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
try {
executeLogin(request, response);
return true;
} catch (Exception e) {
throw new AuthenticationException("Token失效，请重新登录", e);
}
}
/**
*
*/
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader(DefContants.X_ACCESS_TOKEN);
JwtToken jwtToken = new JwtToken(token);
// 提交给realm进行登入，如果错误他会抛出异常并被捕获
getSubject(request, response).login(jwtToken);
// 如果没有抛出异常则代表登入成功，返回true
return true;
}
/**
* 对跨域提供支持
*/
@Override
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
HttpServletResponse httpServletResponse = (HttpServletResponse) response;
httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
// 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
httpServletResponse.setStatus(HttpStatus.OK.value());
return false;
}
//update-begin-author:taoyan date:20200708 for:多租户用到
String tenant_id = httpServletRequest.getHeader(DefContants.TENANT_ID);
TenantContext.setTenant(tenant_id);
//update-end-author:taoyan date:20200708 for:多租户用到
return super.preHandle(request, response);
}
}

69
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/authc/aop/ResourceCheckFilter.java
View File

@ -1,69 +0,0 @@
package org.jeecg.modules.shiro.authc.aop;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.AccessControlFilter;
import lombok.extern.slf4j.Slf4j;
/**
* @Author Scott
* @create 2019-02-01 15:56
* @desc 鉴权请求URL访问权限拦截器
*/
@Slf4j
public class ResourceCheckFilter extends AccessControlFilter {
private String errorUrl;
public String getErrorUrl() {
return errorUrl;
}
public void setErrorUrl(String errorUrl) {
this.errorUrl = errorUrl;
}
/**
* 表示是否允许访问 ，如果允许访问返回true，否则false；
*
* @param servletRequest
* @param servletResponse
* @param o 表示写在拦截器中括号里面的字符串 mappedValue 就是 [urls] 配置中拦截器参数部分
* @return
* @throws Exception
*/
@Override
protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
Subject subject = getSubject(servletRequest, servletResponse);
String url = getPathWithinApplication(servletRequest);
log.info("当前用户正在访问的 url => " + url);
return subject.isPermitted(url);
}
/**
* onAccessDenied：表示当访问拒绝时是否已经处理了； 如果返回 true 表示需要继续处理； 如果返回 false
* 表示该拦截器实例已经处理了，将直接返回即可。
*
* @param servletRequest
* @param servletResponse
* @return
* @throws Exception
*/
@Override
protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
log.info("当 isAccessAllowed 返回 false 的时候，才会执行 method onAccessDenied ");
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse) servletResponse;
response.sendRedirect(request.getContextPath() + this.errorUrl);
// 返回 false 表示已经处理，例如页面跳转啥的，表示不在走以下的拦截器了（如果还有配置的话）
return false;
}
}

141
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/authc/interceptor/OnlineInterceptor.java
View File

@ -1,141 +0,0 @@
package org.jeecg.modules.shiro.authc.interceptor;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.OnlineAuth;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.service.ISysPermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
/**
* Online 自定义请求拦截器
*
* @author: taoyan
* @date: 2020年03月20日
*/
@Slf4j
public class OnlineInterceptor implements HandlerInterceptor {
@Autowired
private ISysPermissionService sysPermissionService;
/**
* online表单菜单地址
*/
private static final String ONLINE_FORM = "/online/cgform";
/**
* online功能测试地址 前缀
*/
private static final String[] ONLINE_TEST_PRE = {"/online/cgformErpList", "/online/cgformList", "/online/cgformTreeList"};
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 请求的方法是否有注解
boolean anno = handler.getClass().isAssignableFrom(HandlerMethod.class);
if (anno) {
OnlineAuth onlineAuth = ((HandlerMethod) handler).getMethodAnnotation(OnlineAuth.class);
if (onlineAuth != null) {
String requestPath = request.getRequestURI().substring(request.getContextPath().length());
requestPath = filterUrl(requestPath);
//1.通过前端请求地址得到code
String authKey = onlineAuth.value();
String code = requestPath.substring(requestPath.lastIndexOf(authKey) + authKey.length());
log.info("拦截请求(" + request.getMethod() + ")：" + requestPath + ",");
if ("form".equals(authKey) && "DELETE".equals(request.getMethod())) {
code = code.substring(0, code.lastIndexOf("/"));
}
List<String> possibleUrl = new ArrayList<>();
//获取可能的表单地址
for (String pre : ONLINE_TEST_PRE) {
possibleUrl.add(pre + code);
}
//查询菜单
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag, 0);
query.in(SysPermission::getUrl, possibleUrl);
List<SysPermission> permissionList = sysPermissionService.list(query);
String username = JwtUtil.getUserNameByToken(request);
if (permissionList == null || permissionList.size() == 0) {
//没有配置菜单 找online表单菜单地址
boolean hasPermission = sysPermissionService.hasPermission(username, ONLINE_FORM);
if (!hasPermission) {
backError(response, authKey);
return false;
}
} else {
//找到菜单了
boolean has = false;
for (SysPermission p : permissionList) {
has = has || sysPermissionService.hasPermission(username, p);
}
if (!has) {
backError(response, authKey);
return false;
}
}
}
}
return true;
}
/**
* 地址过滤
*
* @param requestPath
* @return
*/
private String filterUrl(String requestPath) {
String url = "";
if (oConvertUtils.isNotEmpty(requestPath)) {
url = requestPath.replace("\\", "/");
url = requestPath.replace("//", "/");
if (url.indexOf("//") >= 0) {
url = filterUrl(url);
}
}
return url;
}
/**
* 返回一个错误信息
*
* @param response
* @param authKey
*/
private void backError(HttpServletResponse response, String authKey) {
PrintWriter writer = null;
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
response.setHeader("auth", "fail");
try {
writer = response.getWriter();
if ("exportXls".equals(authKey)) {
writer.print("");
} else {
Result<?> result = Result.error("无权限访问(操作)");
writer.print(JSON.toJSON(result));
}
} catch (IOException e) {
log.error(e.getMessage());
} finally {
if (writer != null) {
writer.close();
}
}
}
}

12
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/vo/DefContants.java
View File

@ -1,12 +0,0 @@
package org.jeecg.modules.shiro.vo;
public class DefContants {
public final static String X_ACCESS_TOKEN = "X-Access-Token";
/**
* 多租户 请求头
*/
public final static String TENANT_ID = "tenant_id";
}

42
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/vo/ResponseBean.java
View File

@ -1,42 +0,0 @@
package org.jeecg.modules.shiro.vo;
public class ResponseBean {
// http 状态码
private int code;
// 返回信息
private String msg;
// 返回的数据
private Object data;
public ResponseBean(int code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}

13
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/vo/UserBean.java
View File

@ -1,13 +0,0 @@
package org.jeecg.modules.shiro.vo;
import java.util.HashSet;
import java.util.Set;
import lombok.Data;
@Data
public class UserBean {
private String username;
private String password;
private Set<String> roles = new HashSet<>(); //用户所有角色值，用于shiro做角色权限的判断
private Set<String> perms = new HashSet<>(); //用户所有权限值，用于shiro做资源权限的判断
}

82
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/shiro/web/TestWebController.java
View File

@ -1,82 +0,0 @@
package org.jeecg.modules.shiro.web;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.shiro.authz.annotation.Logical;
import org.apache.shiro.authz.annotation.RequiresAuthentication;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.modules.shiro.vo.ResponseBean;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestWebController {
private ISysUserService userService;
@Autowired
public void setService(ISysUserService userService) {
this.userService = userService;
}
@PostMapping("/login")
public ResponseBean login(@RequestParam("username") String username,
@RequestParam("password") String password) {
SysUser user = userService.getUserByName(username);
if(user==null) {
return new ResponseBean(200, "用户不存在！", JwtUtil.sign(username, user.getPassword()));
}
String passwordEncode = PasswordUtil.encrypt(username, password, user.getSalt());
if (passwordEncode.equals(user.getPassword())) {
return new ResponseBean(200, "Login success", JwtUtil.sign(username, user.getPassword()));
} else {
throw new UnauthorizedException();
}
}
@GetMapping("/article")
public ResponseBean article() {
Subject subject = SecurityUtils.getSubject();
if (subject.isAuthenticated()) {
return new ResponseBean(200, "You are already logged in", null);
} else {
return new ResponseBean(200, "You are guest", null);
}
}
@GetMapping("/require_auth")
@RequiresAuthentication
public ResponseBean requireAuth() {
return new ResponseBean(200, "You are authenticated", null);
}
@GetMapping("/require_role")
@RequiresRoles("admin")
public ResponseBean requireRole() {
return new ResponseBean(200, "You are visiting require_role", null);
}
@GetMapping("/require_permission")
@RequiresPermissions(logical = Logical.AND, value = {"view", "edit"})
public ResponseBean requirePermission() {
return new ResponseBean(200, "You are visiting permission require edit,view", null);
}
@RequestMapping(path = "/401")
@ResponseStatus(HttpStatus.UNAUTHORIZED)
public ResponseBean unauthorized() {
return new ResponseBean(401, "Unauthorized", null);
}
}

179
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/aspect/AutoLogAspect.java
View File

@ -1,179 +0,0 @@
package org.jeecg.modules.system.aspect;
import java.lang.reflect.Method;
import java.util.Date;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.IPUtils;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.modules.system.entity.SysLog;
import org.jeecg.modules.system.service.ISysLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import org.springframework.web.multipart.MultipartFile;
/**
* 系统日志，切面处理类
*
* @Author scott
* @email jeecgos@163.com
* @Date 2018年1月14日
*/
@Aspect
@Component
public class AutoLogAspect {
@Autowired
private ISysLogService sysLogService;
@Pointcut("@annotation(org.jeecg.common.aspect.annotation.AutoLog)")
public void logPointCut() {
}
@Around("logPointCut()")
public Object around(ProceedingJoinPoint point) throws Throwable {
long beginTime = System.currentTimeMillis();
//执行方法
Object result = point.proceed();
//执行时长(毫秒)
long time = System.currentTimeMillis() - beginTime;
//保存日志
saveSysLog(point, time);
return result;
}
private void saveSysLog(ProceedingJoinPoint joinPoint, long time) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
SysLog sysLog = new SysLog();
AutoLog syslog = method.getAnnotation(AutoLog.class);
if(syslog != null){
//注解上的描述,操作日志内容
sysLog.setLogContent(syslog.value());
sysLog.setLogType(syslog.logType());
}
//请求的方法名
String className = joinPoint.getTarget().getClass().getName();
String methodName = signature.getName();
sysLog.setMethod(className + "." + methodName + "()");
//设置操作类型
if (sysLog.getLogType() == CommonConstant.LOG_TYPE_2) {
sysLog.setOperateType(getOperateType(methodName, syslog.operateType()));
}
//获取request
HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
//请求的参数
sysLog.setRequestParam(getReqestParams(request,joinPoint));
//设置IP地址
sysLog.setIp(IPUtils.getIpAddr(request));
//获取登录用户信息
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
if(sysUser!=null){
sysLog.setUserid(sysUser.getUsername());
sysLog.setUsername(sysUser.getRealname());
}
//耗时
sysLog.setCostTime(time);
sysLog.setCreateTime(new Date());
//保存系统日志
sysLogService.save(sysLog);
}
/**
* 获取操作类型
*/
private int getOperateType(String methodName,int operateType) {
if (operateType > 0) {
return operateType;
}
if (methodName.startsWith("list")) {
return CommonConstant.OPERATE_TYPE_1;
}
if (methodName.startsWith("add")) {
return CommonConstant.OPERATE_TYPE_2;
}
if (methodName.startsWith("edit")) {
return CommonConstant.OPERATE_TYPE_3;
}
if (methodName.startsWith("delete")) {
return CommonConstant.OPERATE_TYPE_4;
}
if (methodName.startsWith("import")) {
return CommonConstant.OPERATE_TYPE_5;
}
if (methodName.startsWith("export")) {
return CommonConstant.OPERATE_TYPE_6;
}
return CommonConstant.OPERATE_TYPE_1;
}
/**
* @Description: 获取请求参数
* @author: scott
* @date: 2020/4/16 0:10
* @param request: request
* @param joinPoint: joinPoint
* @Return: java.lang.String
*/
private String getReqestParams(HttpServletRequest request, JoinPoint joinPoint) {
String httpMethod = request.getMethod();
String params = "";
if ("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod)) {
Object[] paramsArray = joinPoint.getArgs();
// java.lang.IllegalStateException: It is illegal to call this method if the current request is not in asynchronous mode (i.e. isAsyncStarted() returns false)
// https://my.oschina.net/mengzhang6/blog/2395893
Object[] arguments = new Object[paramsArray.length];
for (int i = 0; i < paramsArray.length; i++) {
if (paramsArray[i] instanceof ServletRequest || paramsArray[i] instanceof ServletResponse || paramsArray[i] instanceof MultipartFile) {
//ServletRequest不能序列化，从入参里排除，否则报异常：java.lang.IllegalStateException: It is illegal to call this method if the current request is not in asynchronous mode (i.e. isAsyncStarted() returns false)
//ServletResponse不能序列化 从入参里排除，否则报异常：java.lang.IllegalStateException: getOutputStream() has already been called for this response
continue;
}
arguments[i] = paramsArray[i];
}
params = JSONObject.toJSONString(arguments);
} else {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
// 请求的方法参数值
Object[] args = joinPoint.getArgs();
// 请求的方法参数名称
LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
String[] paramNames = u.getParameterNames(method);
if (args != null && paramNames != null) {
for (int i = 0; i < args.length; i++) {
params += " " + paramNames[i] + ": " + args[i];
}
}
}
return params;
}
}

165
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/aspect/DictAspect.java
View File

@ -1,165 +0,0 @@
package org.jeecg.modules.system.aspect;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
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.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.service.ISysDictService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
/**
* @Description: 字典aop类
* @Author: dangzhenghui
* @Date: 2019-3-17 21:50
* @Version: 1.0
*/
@Aspect
@Component
@Slf4j
public class DictAspect {
@Autowired
private ISysDictService dictService;
// 定义切点Pointcut
@Pointcut("execution(public * org.jeecg.modules..*.*Controller.*(..))")
public void excudeService() {
}
@Around("excudeService()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
long time1=System.currentTimeMillis();
Object result = pjp.proceed();
long time2=System.currentTimeMillis();
log.debug("获取JSON数据 耗时："+(time2-time1)+"ms");
long start=System.currentTimeMillis();
this.parseDictText(result);
long end=System.currentTimeMillis();
log.debug("解析注入JSON数据 耗时"+(end-start)+"ms");
return result;
}
/**
* 本方法针对返回对象为Result 的IPage的分页列表数据进行动态字典注入
* 字典注入实现 通过对实体类添加注解@dict 来标识需要的字典内容,字典分为单字典code即可 ，table字典 code table text配合使用与原来jeecg的用法相同
* 示例为SysUser 字段为sex 添加了注解@Dict(dicCode = "sex") 会在字典服务立马查出来对应的text 然后在请求list的时候将这个字典text，已字段名称加_dictText形式返回到前端
* 例输入当前返回值的就会多出一个sex_dictText字段
* {
* sex:1,
* sex_dictText:"男"
* }
* 前端直接取值sext_dictText在table里面无需再进行前端的字典转换了
* customRender:function (text) {
* if(text==1){
* return "男";
* }else if(text==2){
* return "女";
* }else{
* return text;
* }
* }
* 目前vue是这么进行字典渲染到table上的多了就很麻烦了 这个直接在服务端渲染完成前端可以直接用
* @param result
*/
private void parseDictText(Object result) {
if (result instanceof Result) {
if (((Result) result).getResult() instanceof IPage) {
List<JSONObject> items = new ArrayList<>();
for (Object record : ((IPage) ((Result) result).getResult()).getRecords()) {
ObjectMapper mapper = new ObjectMapper();
String json="{}";
try {
//解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
json = mapper.writeValueAsString(record);
} catch (JsonProcessingException e) {
log.error("json解析失败"+e.getMessage(),e);
}
JSONObject item = JSONObject.parseObject(json);
//update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
//for (Field field : record.getClass().getDeclaredFields()) {
for (Field field : oConvertUtils.getAllFields(record)) {
//update-end--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
if (field.getAnnotation(Dict.class) != null) {
String code = field.getAnnotation(Dict.class).dicCode();
String text = field.getAnnotation(Dict.class).dicText();
String table = field.getAnnotation(Dict.class).dictTable();
String key = String.valueOf(item.get(field.getName()));
//翻译字典值对应的txt
String textValue = translateDictValue(code, text, table, key);
log.debug(" 字典Val : "+ textValue);
log.debug(" __翻译字典字段__ "+field.getName() + CommonConstant.DICT_TEXT_SUFFIX+"： "+ textValue);
item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
}
//date类型默认转换string格式化日期
if (field.getType().getName().equals("java.util.Date")&&field.getAnnotation(JsonFormat.class)==null&&item.get(field.getName())!=null){
SimpleDateFormat aDate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
}
}
items.add(item);
}
((IPage) ((Result) result).getResult()).setRecords(items);
}
}
}
/**
* 翻译字典文本
* @param code
* @param text
* @param table
* @param key
* @return
*/
private String translateDictValue(String code, String text, String table, String key) {
if(oConvertUtils.isEmpty(key)) {
return null;
}
StringBuffer textValue=new StringBuffer();
String[] keys = key.split(",");
for (String k : keys) {
String tmpValue = null;
log.debug(" 字典 key : "+ k);
if (k.trim().length() == 0) {
continue; //跳过循环
}
if (!StringUtils.isEmpty(table)){
log.debug("--DictAspect------dicTable="+ table+" ,dicText= "+text+" ,dicCode="+code);
tmpValue= dictService.queryTableDictTextByKey(table,text,code,k.trim());
}else {
tmpValue = dictService.queryDictTextByKey(code, k.trim());
}
if (tmpValue != null) {
if (!"".equals(textValue.toString())) {
textValue.append(",");
}
textValue.append(tmpValue);
}
}
return textValue.toString();
}
}

196
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/aspect/PermissionDataAspect.java
View File

@ -1,196 +0,0 @@
package org.jeecg.modules.system.aspect;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.jeecg.common.aspect.annotation.PermissionData;
import org.jeecg.common.system.util.JeecgDataAutorUtils;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.SysPermissionDataRuleModel;
import org.jeecg.common.system.vo.SysUserCacheInfo;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import org.jeecg.modules.system.service.ISysPermissionDataRuleService;
import org.jeecg.modules.system.service.ISysPermissionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
/**
* 数据权限切面处理类
* 当被请求的方法有注解PermissionData时,会在往当前request中写入数据权限信息
* @Date 2019年4月10日
* @Version: 1.0
*/
@Aspect
@Component
@Slf4j
public class PermissionDataAspect {
@Autowired
private ISysPermissionService sysPermissionService;
@Autowired
private ISysPermissionDataRuleService sysPermissionDataRuleService;
@Autowired
private ISysUserService sysUserService;
@Pointcut("@annotation(org.jeecg.common.aspect.annotation.PermissionData)")
public void pointCut() {
}
@Around("pointCut()")
public Object arround(ProceedingJoinPoint point) throws Throwable{
HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
PermissionData pd = method.getAnnotation(PermissionData.class);
String component = pd.pageComponent();
List<SysPermission> currentSyspermission = null;
if(oConvertUtils.isNotEmpty(component)) {
//1.通过注解属性pageComponent 获取菜单
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag,0);
query.eq(SysPermission::getComponent, component);
currentSyspermission = sysPermissionService.list(query);
}else {
String requestMethod = request.getMethod();
String requestPath = request.getRequestURI().substring(request.getContextPath().length());
requestPath = filterUrl(requestPath);
log.info("拦截请求 >> "+requestPath+";请求类型 >> "+requestMethod);
//1.直接通过前端请求地址查询菜单
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getMenuType,2);
query.eq(SysPermission::getDelFlag,0);
query.eq(SysPermission::getUrl, requestPath);
currentSyspermission = sysPermissionService.list(query);
//2.未找到 再通过自定义匹配URL 获取菜单
if(currentSyspermission==null || currentSyspermission.size()==0) {
//通过自定义URL匹配规则 获取菜单（实现通过菜单配置数据权限规则，实际上针对获取数据接口进行数据规则控制）
String userMatchUrl = UrlMatchEnum.getMatchResultByUrl(requestPath);
LambdaQueryWrapper<SysPermission> queryQserMatch = new LambdaQueryWrapper<SysPermission>();
queryQserMatch.eq(SysPermission::getMenuType, 1);
queryQserMatch.eq(SysPermission::getDelFlag, 0);
queryQserMatch.eq(SysPermission::getUrl, userMatchUrl);
if(oConvertUtils.isNotEmpty(userMatchUrl)){
currentSyspermission = sysPermissionService.list(queryQserMatch);
}
}
//3.未找到 再通过正则匹配获取菜单
if(currentSyspermission==null || currentSyspermission.size()==0) {
//通过正则匹配权限配置
String regUrl = getRegexpUrl(requestPath);
if(regUrl!=null) {
currentSyspermission = sysPermissionService.list(new LambdaQueryWrapper<SysPermission>().eq(SysPermission::getMenuType,2).eq(SysPermission::getUrl, regUrl).eq(SysPermission::getDelFlag,0));
}
}
}
//3.通过用户名+菜单ID 找到权限配置信息 放到request中去
if(currentSyspermission!=null && currentSyspermission.size()>0) {
String username = JwtUtil.getUserNameByToken(request);
List<SysPermissionDataRuleModel> dataRules = new ArrayList<SysPermissionDataRuleModel>();
for (SysPermission sysPermission : currentSyspermission) {
// update-begin--Author:scott Date:20191119 for：数据权限规则编码不规范，项目存在相同包名和类名 #722
List<SysPermissionDataRule> temp = sysPermissionDataRuleService.queryPermissionDataRules(username, sysPermission.getId());
if(temp!=null && temp.size()>0) {
//dataRules.addAll(temp);
dataRules = oConvertUtils.entityListToModelList(temp,SysPermissionDataRuleModel.class);
}
// update-end--Author:scott Date:20191119 for：数据权限规则编码不规范，项目存在相同包名和类名 #722
}
if(dataRules!=null && dataRules.size()>0) {
JeecgDataAutorUtils.installDataSearchConditon(request, dataRules);
SysUserCacheInfo userinfo = sysUserService.getCacheUser(username);
JeecgDataAutorUtils.installUserInfo(request, userinfo);
}
}
return point.proceed();
}
private String filterUrl(String requestPath){
String url = "";
if(oConvertUtils.isNotEmpty(requestPath)){
url = requestPath.replace("\\", "/");
url = requestPath.replace("//", "/");
if(url.indexOf("//")>=0){
url = filterUrl(url);
}
/*if(url.startsWith("/")){
url=url.substring(1);
}*/
}
return url;
}
/**
* 获取请求地址
* @param request
* @return
*/
private String getJgAuthRequsetPath(HttpServletRequest request) {
String queryString = request.getQueryString();
String requestPath = request.getRequestURI();
if(oConvertUtils.isNotEmpty(queryString)){
requestPath += "?" + queryString;
}
if (requestPath.indexOf("&") > -1) {// 去掉其他参数(保留一个参数) 例如：loginController.do?login
requestPath = requestPath.substring(0, requestPath.indexOf("&"));
}
if(requestPath.indexOf("=")!=-1){
if(requestPath.indexOf(".do")!=-1){
requestPath = requestPath.substring(0,requestPath.indexOf(".do")+3);
}else{
requestPath = requestPath.substring(0,requestPath.indexOf("?"));
}
}
requestPath = requestPath.substring(request.getContextPath().length() + 1);// 去掉项目路径
return filterUrl(requestPath);
}
private boolean moHuContain(List<String> list,String key){
for(String str : list){
if(key.contains(str)){
return true;
}
}
return false;
}
/**
* 匹配前端传过来的地址 匹配成功返回正则地址
* AntPathMatcher匹配地址
*()* 匹配0个或多个字符
*()**匹配0个或多个目录
*/
private String getRegexpUrl(String url) {
List<String> list = sysPermissionService.queryPermissionUrlWithStar();
if(list!=null && list.size()>0) {
for (String p : list) {
PathMatcher matcher = new AntPathMatcher();
if(matcher.match(p, url)) {
return p;
}
}
}
return null;
}
}

58
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/aspect/UrlMatchEnum.java
View File

@ -1,58 +0,0 @@
package org.jeecg.modules.system.aspect;
/**
* @Author scott
* @Date 2020/1/14 13:36
* @Description: 请求URL与菜单路由URL转换规则（方便于采用菜单路由URL来配置数据权限规则）
*/
public enum UrlMatchEnum {
CGFORM_DATA("/online/cgform/api/getData/", "/online/cgformList/"),
CGFORM_EXCEL_DATA("/online/cgform/api/exportXls/", "/online/cgformList/"),
CGFORM_TREE_DATA("/online/cgform/api/getTreeData/", "/online/cgformList/"),
CGREPORT_DATA("/online/cgreport/api/getColumnsAndData/", "/online/cgreport/"),
CGREPORT_EXCEL_DATA("/online/cgreport/api/exportXls/", "/online/cgreport/");
UrlMatchEnum(String url, String match_url) {
this.url = url;
this.match_url = match_url;
}
/**
* Request 请求 URL前缀
*/
private String url;
/**
* 菜单路由 URL前缀 (对应菜单路径)
*/
private String match_url;
/**
* 根据req url 获取到菜单配置路径（前端页面路由URL）
*
* @param url
* @return
*/
public static String getMatchResultByUrl(String url) {
//获取到枚举
UrlMatchEnum[] values = UrlMatchEnum.values();
//加强for循环进行遍历操作
for (UrlMatchEnum lr : values) {
//如果遍历获取的type和参数type一致
if (url.indexOf(lr.url) != -1) {
//返回type对象的desc
return url.replace(lr.url, lr.match_url);
}
}
return null;
}
public static void main(String[] args) {
/**
* 比如request真实请求URL: /online/cgform/api/getData/81fcf7d8922d45069b0d5ba983612d3a
* 转换匹配路由URL后（对应配置的菜单路径）:/online/cgformList/81fcf7d8922d45069b0d5ba983612d3a
*/
System.out.println(UrlMatchEnum.getMatchResultByUrl("/online/cgform/api/getData/81fcf7d8922d45069b0d5ba983612d3a"));
}
}

382
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/CommonController.java Normal file
View File

@ -0,0 +1,382 @@
package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.RestUtil;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLDecoder;
/**
* <p>
* 用户表 前端控制器
* </p>
*
* @Author scott
* @since 2018-12-20
*/
@Slf4j
@RestController
@RequestMapping("/sys/common")
public class CommonController {
@Autowired
private ISysBaseAPI sysBaseAPI;
@Value(value = "${jeecg.path.upload}")
private String uploadpath;
/**
* 本地：local minio：minio 阿里：alioss
*/
@Value(value="${jeecg.uploadType}")
private String uploadType;
/**
* @Author 政辉
* @return
*/
@GetMapping("/403")
public Result<?> noauth() {
return Result.error("没有权限，请联系管理员授权");
}
/**
* 文件上传统一方法
* @param request
* @param response
* @return
*/
@PostMapping(value = "/upload")
public Result<?> upload(HttpServletRequest request, HttpServletResponse response) {
Result<?> result = new Result<>();
String savePath = "";
String bizPath = request.getParameter("biz");
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("file");// 获取上传文件对象
if(oConvertUtils.isEmpty(bizPath)){
if(CommonConstant.UPLOAD_TYPE_OSS.equals(uploadType)){
//未指定目录，则用阿里云默认目录 upload
bizPath = "upload";
//result.setMessage("使用阿里云文件上传时，必须添加目录！");
//result.setSuccess(false);
//return result;
}else{
bizPath = "";
}
}
if(CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)){
//针对jeditor编辑器如何使 lcaol模式，采用 base64格式存储
String jeditor = request.getParameter("jeditor");
if(oConvertUtils.isNotEmpty(jeditor)){
result.setMessage(CommonConstant.UPLOAD_TYPE_LOCAL);
result.setSuccess(true);
return result;
}else{
savePath = this.uploadLocal(file,bizPath);
}
}else{
//update-begin-author:taoyan date:20200814 for:文件上传改造
savePath = CommonUtils.upload(file, bizPath, uploadType);
//update-end-author:taoyan date:20200814 for:文件上传改造
}
if(oConvertUtils.isNotEmpty(savePath)){
result.setMessage(savePath);
result.setSuccess(true);
}else {
result.setMessage("上传失败！");
result.setSuccess(false);
}
return result;
}
/**
* 本地文件上传
* @param mf 文件
* @param bizPath 自定义路径
* @return
*/
private String uploadLocal(MultipartFile mf,String bizPath){
try {
String ctxPath = uploadpath;
String fileName = null;
File file = new File(ctxPath + File.separator + bizPath + File.separator );
if (!file.exists()) {
file.mkdirs();// 创建文件根目录
}
String orgName = mf.getOriginalFilename();// 获取文件名
orgName = CommonUtils.getFileName(orgName);
if(orgName.indexOf(".")!=-1){
fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.indexOf("."));
}else{
fileName = orgName+ "_" + System.currentTimeMillis();
}
String savePath = file.getPath() + File.separator + fileName;
File savefile = new File(savePath);
FileCopyUtils.copy(mf.getBytes(), savefile);
String dbpath = null;
if(oConvertUtils.isNotEmpty(bizPath)){
dbpath = bizPath + File.separator + fileName;
}else{
dbpath = fileName;
}
if (dbpath.contains("\\")) {
dbpath = dbpath.replace("\\", "/");
}
return dbpath;
} catch (IOException e) {
log.error(e.getMessage(), e);
}
return "";
}
// @PostMapping(value = "/upload2")
// public Result<?> upload2(HttpServletRequest request, HttpServletResponse response) {
// Result<?> result = new Result<>();
// try {
// String ctxPath = uploadpath;
// String fileName = null;
// String bizPath = "files";
// String tempBizPath = request.getParameter("biz");
// if(oConvertUtils.isNotEmpty(tempBizPath)){
// bizPath = tempBizPath;
// }
// String nowday = new SimpleDateFormat("yyyyMMdd").format(new Date());
// File file = new File(ctxPath + File.separator + bizPath + File.separator + nowday);
// if (!file.exists()) {
// file.mkdirs();// 创建文件根目录
// }
// MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
// MultipartFile mf = multipartRequest.getFile("file");// 获取上传文件对象
// String orgName = mf.getOriginalFilename();// 获取文件名
// fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.indexOf("."));
// String savePath = file.getPath() + File.separator + fileName;
// File savefile = new File(savePath);
// FileCopyUtils.copy(mf.getBytes(), savefile);
// String dbpath = bizPath + File.separator + nowday + File.separator + fileName;
// if (dbpath.contains("\\")) {
// dbpath = dbpath.replace("\\", "/");
// }
// result.setMessage(dbpath);
// result.setSuccess(true);
// } catch (IOException e) {
// result.setSuccess(false);
// result.setMessage(e.getMessage());
// log.error(e.getMessage(), e);
// }
// return result;
// }
/**
* 预览图片&下载文件
* 请求地址：http://localhost:8080/common/static/{user/20190119/e1fe9925bc315c60addea1b98eb1cb1349547719_1547866868179.jpg}
*
* @param request
* @param response
*/
@GetMapping(value = "/static/**")
public void view(HttpServletRequest request, HttpServletResponse response) {
// ISO-8859-1 ==> UTF-8 进行编码转换
String imgPath = extractPathFromPattern(request);
if(oConvertUtils.isEmpty(imgPath) || imgPath=="null"){
return;
}
// 其余处理略
InputStream inputStream = null;
OutputStream outputStream = null;
try {
imgPath = imgPath.replace("..", "");
if (imgPath.endsWith(",")) {
imgPath = imgPath.substring(0, imgPath.length() - 1);
}
String filePath = uploadpath + File.separator + imgPath;
File file = new File(filePath);
if(!file.exists()){
response.setStatus(404);
throw new RuntimeException("文件不存在..");
}
response.setContentType("application/force-download");// 设置强制下载不打开
response.addHeader("Content-Disposition", "attachment;fileName=" + new String(file.getName().getBytes("UTF-8"),"iso-8859-1"));
inputStream = new BufferedInputStream(new FileInputStream(filePath));
outputStream = response.getOutputStream();
byte[] buf = new byte[1024];
int len;
while ((len = inputStream.read(buf)) > 0) {
outputStream.write(buf, 0, len);
}
response.flushBuffer();
} catch (IOException e) {
log.error("预览文件失败" + e.getMessage());
response.setStatus(404);
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
}
}
// /**
// * 下载文件
// * 请求地址：http://localhost:8080/common/download/{user/20190119/e1fe9925bc315c60addea1b98eb1cb1349547719_1547866868179.jpg}
// *
// * @param request
// * @param response
// * @throws Exception
// */
// @GetMapping(value = "/download/**")
// public void download(HttpServletRequest request, HttpServletResponse response) throws Exception {
// // ISO-8859-1 ==> UTF-8 进行编码转换
// String filePath = extractPathFromPattern(request);
// // 其余处理略
// InputStream inputStream = null;
// OutputStream outputStream = null;
// try {
// filePath = filePath.replace("..", "");
// if (filePath.endsWith(",")) {
// filePath = filePath.substring(0, filePath.length() - 1);
// }
// String localPath = uploadpath;
// String downloadFilePath = localPath + File.separator + filePath;
// File file = new File(downloadFilePath);
// if (file.exists()) {
// response.setContentType("application/force-download");// 设置强制下载不打开            
// response.addHeader("Content-Disposition", "attachment;fileName=" + new String(file.getName().getBytes("UTF-8"),"iso-8859-1"));
// inputStream = new BufferedInputStream(new FileInputStream(file));
// outputStream = response.getOutputStream();
// byte[] buf = new byte[1024];
// int len;
// while ((len = inputStream.read(buf)) > 0) {
// outputStream.write(buf, 0, len);
// }
// response.flushBuffer();
// }
//
// } catch (Exception e) {
// log.info("文件下载失败" + e.getMessage());
// // e.printStackTrace();
// } finally {
// if (inputStream != null) {
// try {
// inputStream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// if (outputStream != null) {
// try {
// outputStream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// }
//
// }
/**
* @功能：pdf预览Iframe
* @param modelAndView
* @return
*/
@RequestMapping("/pdf/pdfPreviewIframe")
public ModelAndView pdfPreviewIframe(ModelAndView modelAndView) {
modelAndView.setViewName("pdfPreviewIframe");
return modelAndView;
}
/**
* 把指定URL后的字符串全部截断当成参数
* 这么做是为了防止URL中包含中文或者特殊字符（/等）时，匹配不了的问题
* @param request
* @return
*/
private static String extractPathFromPattern(final HttpServletRequest request) {
String path = (String) request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
String bestMatchPattern = (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
return new AntPathMatcher().extractPathWithinPattern(bestMatchPattern, path);
}
/**
* 中转HTTP请求，解决跨域问题
*
* @param url 必填：请求地址
* @return
*/
@RequestMapping("/transitRESTful")
public Result transitRESTful(@RequestParam("url") String url, HttpServletRequest request) {
try {
ServletServerHttpRequest httpRequest = new ServletServerHttpRequest(request);
// 中转请求method、body
HttpMethod method = httpRequest.getMethod();
JSONObject params;
try {
params = JSON.parseObject(JSON.toJSONString(httpRequest.getBody()));
} catch (Exception e) {
params = new JSONObject();
}
// 中转请求问号参数
JSONObject variables = JSON.parseObject(JSON.toJSONString(request.getParameterMap()));
variables.remove("url");
// 在 headers 里传递Token
String token = TokenUtils.getTokenByRequest(request);
HttpHeaders headers = new HttpHeaders();
headers.set("X-Access-Token", token);
// 发送请求
String httpURL = URLDecoder.decode(url, "UTF-8");
ResponseEntity<String> response = RestUtil.request(httpURL, method, headers , variables, params, String.class);
// 封装返回结果
Result<Object> result = new Result<>();
int statusCode = response.getStatusCodeValue();
result.setCode(statusCode);
result.setSuccess(statusCode == 200);
String responseBody = response.getBody();
try {
// 尝试将返回结果转为JSON
Object json = JSON.parse(responseBody);
result.setResult(json);
} catch (Exception e) {
// 转成JSON失败，直接返回原始数据
result.setResult(responseBody);
}
return result;
} catch (Exception e) {
log.debug("中转HTTP请求失败", e);
return Result.error(e.getMessage());
}
}
}

51
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/LoginController.java
View File

@ -1,6 +1,7 @@
package org.jeecg.modules.system.controller;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.SecureUtil;
import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.exceptions.ClientException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@ -8,16 +9,15 @@ import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.*;
import org.jeecg.common.util.encryption.EncryptedString;
import org.jeecg.modules.shiro.vo.DefContants;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.model.SysLoginModel;
@ -26,9 +26,11 @@ import org.jeecg.modules.system.service.ISysDictService;
import org.jeecg.modules.system.service.ISysLogService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.util.RandImageUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
@ -54,6 +56,8 @@ public class LoginController {
private ISysDepartService sysDepartService;
@Autowired
private ISysDictService sysDictService;
@Resource
private BaseCommonService baseCommonService;
private static final String BASE_CHECK_CODES = "qwertyuiplkjhgfdsazxcvbnmQWERTYUPLKJHGFDSAZXCVBNM1234567890";
@ -104,8 +108,11 @@ public class LoginController {
//用户登录信息
userInfo(sysUser, result);
sysBaseAPI.addLog("用户名: " + username + ",登录成功！", CommonConstant.LOG_TYPE_1, null);
//update-begin--Author:wangshuai Date:20200714 for：登录日志没有记录人员
LoginUser loginUser = new LoginUser();
BeanUtils.copyProperties(sysUser, loginUser);
baseCommonService.addLog("用户名: " + username + ",登录成功！", CommonConstant.LOG_TYPE_1, null,loginUser);
//update-end--Author:wangshuai Date:20200714 for：登录日志没有记录人员
return result;
}
@ -118,14 +125,16 @@ public class LoginController {
@RequestMapping(value = "/logout")
public Result<Object> logout(HttpServletRequest request,HttpServletResponse response) {
//用户退出逻辑
String token = request.getHeader(DefContants.X_ACCESS_TOKEN);
String token = request.getHeader(CommonConstant.X_ACCESS_TOKEN);
if(oConvertUtils.isEmpty(token)) {
return Result.error("退出登录失败！");
}
String username = JwtUtil.getUsername(token);
LoginUser sysUser = sysBaseAPI.getUserByName(username);
if(sysUser!=null) {
sysBaseAPI.addLog("用户名: "+sysUser.getRealname()+",退出成功！", CommonConstant.LOG_TYPE_1, null);
//update-begin--Author:wangshuai Date:20200714 for：登出日志没有记录人员
baseCommonService.addLog("用户名: "+sysUser.getRealname()+",退出成功！", CommonConstant.LOG_TYPE_1, null,sysUser);
//update-end--Author:wangshuai Date:20200714 for：登出日志没有记录人员
log.info(" 用户名: "+sysUser.getRealname()+",退出成功！ ");
//清空用户登录Token缓存
redisUtil.del(CommonConstant.PREFIX_USER_TOKEN + token);
@ -252,7 +261,7 @@ public class LoginController {
SysUser sysUser = sysUserService.getUserByPhone(mobile);
if(sysUser!=null) {
result.error500(" 手机号已经注册，请直接登录！");
sysBaseAPI.addLog("手机号已经注册，请直接登录！", CommonConstant.LOG_TYPE_1, null);
baseCommonService.addLog("手机号已经注册，请直接登录！", CommonConstant.LOG_TYPE_1, null);
return result;
}
b = DySmsHelper.sendSms(mobile, obj, DySmsEnum.REGISTER_TEMPLATE_CODE);
@ -329,7 +338,7 @@ public class LoginController {
//用户信息
userInfo(sysUser, result);
//添加日志
sysBaseAPI.addLog("用户名: " + sysUser.getUsername() + ",登录成功！", CommonConstant.LOG_TYPE_1, null);
baseCommonService.addLog("用户名: " + sysUser.getUsername() + ",登录成功！", CommonConstant.LOG_TYPE_1, null);
return result;
}
@ -351,6 +360,14 @@ public class LoginController {
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME*2 / 1000);
//update-begin-author:taoyan date:20200812 for:登录缓存用户信息
LoginUser vo = new LoginUser();
BeanUtils.copyProperties(sysUser,vo);
vo.setPassword(SecureUtil.md5(sysUser.getPassword()));
redisUtil.set(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, vo);
redisUtil.expire(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, JwtUtil.EXPIRE_TIME*2 / 1000);
//update-end-author:taoyan date:20200812 for:登录缓存用户信息
// 获取用户部门信息
JSONObject obj = new JSONObject();
List<SysDepart> departs = sysDepartService.queryUserDeparts(sysUser.getId());
@ -361,6 +378,13 @@ public class LoginController {
sysUserService.updateUserDepart(username, departs.get(0).getOrgCode());
obj.put("multi_depart", 1);
} else {
//查询当前是否有登录部门
// update-begin--Author:wangshuai Date:20200805 for：如果用戶为选择部门，数据库为存在上一次登录部门，则取一条存进去
SysUser sysUserById = sysUserService.getById(sysUser.getId());
if(oConvertUtils.isEmpty(sysUserById.getOrgCode())){
sysUserService.updateUserDepart(username, departs.get(0).getOrgCode());
}
// update-end--Author:wangshuai Date:20200805 for：如果用戶为选择部门，数据库为存在上一次登录部门，则取一条存进去
obj.put("multi_depart", 2);
}
obj.put("token", token);
@ -457,12 +481,21 @@ public class LoginController {
// 设置超时时间
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME*2 / 1000);
//update-begin-author:taoyan date:20200812 for:登录缓存用户信息
LoginUser vo = new LoginUser();
BeanUtils.copyProperties(sysUser,vo);
vo.setPassword(SecureUtil.md5(sysUser.getPassword()));
redisUtil.set(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, vo);
redisUtil.expire(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, JwtUtil.EXPIRE_TIME*2 / 1000);
//update-end-author:taoyan date:20200812 for:登录缓存用户信息
//token 信息
obj.put("token", token);
result.setResult(obj);
result.setSuccess(true);
result.setCode(200);
sysBaseAPI.addLog("用户名: " + username + ",登录成功[移动端]！", CommonConstant.LOG_TYPE_1, null);
baseCommonService.addLog("用户名: " + username + ",登录成功[移动端]！", CommonConstant.LOG_TYPE_1, null);
return result;
}

9
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysAnnouncementController.java
View File

@ -297,11 +297,20 @@ public class SysAnnouncementController {
List<SysAnnouncement> announcements = sysAnnouncementService.list(querySaWrapper);
if(announcements.size()>0) {
for(int i=0;i<announcements.size();i++) {
//update-begin--Author:wangshuai Date:20200803 for： 通知公告消息重复LOWCOD-759--------------------
//因为websocket没有判断是否存在这个用户，要是判断会出现问题，故在此判断逻辑
LambdaQueryWrapper<SysAnnouncementSend> query = new LambdaQueryWrapper<>();
query.eq(SysAnnouncementSend::getAnntId,announcements.get(i).getId());
query.eq(SysAnnouncementSend::getUserId,userId);
SysAnnouncementSend one = sysAnnouncementSendService.getOne(query);
if(null==one){
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(announcements.get(i).getId());
announcementSend.setUserId(userId);
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
sysAnnouncementSendService.save(announcementSend);
}
//update-end--Author:wangshuai Date:20200803 for： 通知公告消息重复LOWCOD-759------------
}
}
// 2.查询用户未读的系统消息

25
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysDepartController.java
View File

@ -23,6 +23,7 @@ import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysPositionService;
import org.jeecg.modules.system.service.ISysUserDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.util.FindsDepartsChildrenUtil;
import org.jeecgframework.poi.excel.ExcelImportUtil;
@ -62,6 +63,8 @@ public class SysDepartController {
public RedisTemplate<String, Object> redisTemplate;
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysUserDepartService sysUserDepartService;
/**
* 查询数据 查出我的部门,并以树结构数据格式响应给前端
*
@ -116,6 +119,7 @@ public class SysDepartController {
* @param sysDepart
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/add", method = RequestMethod.POST)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> add(@RequestBody SysDepart sysDepart, HttpServletRequest request) {
@ -141,6 +145,7 @@ public class SysDepartController {
* @param sysDepart
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> edit(@RequestBody SysDepart sysDepart, HttpServletRequest request) {
@ -168,6 +173,7 @@ public class SysDepartController {
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> delete(@RequestParam(name="id",required=true) String id) {
@ -195,6 +201,7 @@ public class SysDepartController {
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<SysDepart> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
@ -309,6 +316,7 @@ public class SysDepartController {
* @param response
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
@CacheEvict(value= {CacheConstant.SYS_DEPARTS_CACHE,CacheConstant.SYS_DEPART_IDS_CACHE}, allEntries=true)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
@ -410,7 +418,7 @@ public class SysDepartController {
List<SysDepartTreeModel> list = sysDepartService.queryTreeByKeyWord(keyWord);
//根据keyWord获取用户信息
LambdaQueryWrapper<SysUser> queryUser = new LambdaQueryWrapper<SysUser>();
queryUser.eq(SysUser::getDelFlag,0);
queryUser.eq(SysUser::getDelFlag,CommonConstant.DEL_FLAG_0);
queryUser.and(i -> i.like(SysUser::getUsername, keyWord).or().like(SysUser::getRealname, keyWord));
List<SysUser> sysUsers = this.sysUserService.list(queryUser);
map.put("userList",sysUsers);
@ -439,4 +447,19 @@ public class SysDepartController {
result.setResult(sysDepart);
return result;
}
/**
* 根据部门id获取用户信息
*
* @param id
* @return
*/
@GetMapping("/getUsersByDepartId")
public Result<List<SysUser>> getUsersByDepartId(@RequestParam(name = "id") String id) {
Result<List<SysUser>> result = new Result<>();
List<SysUser> sysUsers = sysUserDepartService.queryUserByDepId(id);
result.setSuccess(true);
result.setResult(sysUsers);
return result;
}
}

5
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysDepartRoleController.java
View File

@ -98,6 +98,7 @@ public class SysDepartRoleController extends JeecgController<SysDepartRole, ISys
* @param sysDepartRole
* @return
*/
//@RequiresRoles({"admin"})
@ApiOperation(value="部门角色-添加", notes="部门角色-添加")
@PostMapping(value = "/add")
public Result<?> add(@RequestBody SysDepartRole sysDepartRole) {
@ -111,6 +112,7 @@ public class SysDepartRoleController extends JeecgController<SysDepartRole, ISys
* @param sysDepartRole
* @return
*/
//@RequiresRoles({"admin"})
@ApiOperation(value="部门角色-编辑", notes="部门角色-编辑")
@PutMapping(value = "/edit")
public Result<?> edit(@RequestBody SysDepartRole sysDepartRole) {
@ -124,6 +126,7 @@ public class SysDepartRoleController extends JeecgController<SysDepartRole, ISys
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@AutoLog(value = "部门角色-通过id删除")
@ApiOperation(value="部门角色-通过id删除", notes="部门角色-通过id删除")
@DeleteMapping(value = "/delete")
@ -138,6 +141,7 @@ public class SysDepartRoleController extends JeecgController<SysDepartRole, ISys
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@AutoLog(value = "部门角色-批量删除")
@ApiOperation(value="部门角色-批量删除", notes="部门角色-批量删除")
@DeleteMapping(value = "/deleteBatch")
@ -179,6 +183,7 @@ public class SysDepartRoleController extends JeecgController<SysDepartRole, ISys
* @param json
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deptRoleUserAdd", method = RequestMethod.POST)
public Result<?> deptRoleAdd(@RequestBody JSONObject json) {
String newRoleId = json.getString("newRoleId");

33
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysDictController.java
View File

@ -1,29 +1,24 @@
package org.jeecg.modules.system.controller;
import java.io.InputStream;
import java.util.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.hutool.crypto.SecureUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.DictQuery;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.ImportExcelUtil;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.SqlInjectionUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.shiro.vo.DefContants;
import org.jeecg.modules.system.entity.SysDict;
import org.jeecg.modules.system.entity.SysDictItem;
import org.jeecg.modules.system.model.SysDictTree;
@ -44,15 +39,9 @@ import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
/**
* <p>
@ -319,6 +308,7 @@ public class SysDictController {
* @param sysDict
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysDict> add(@RequestBody SysDict sysDict) {
Result<SysDict> result = new Result<SysDict>();
@ -339,6 +329,7 @@ public class SysDictController {
* @param sysDict
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysDict> edit(@RequestBody SysDict sysDict) {
Result<SysDict> result = new Result<SysDict>();
@ -360,6 +351,7 @@ public class SysDictController {
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDict> delete(@RequestParam(name="id",required=true) String id) {
@ -378,6 +370,7 @@ public class SysDictController {
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value= CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDict> deleteBatch(@RequestParam(name="ids",required=true) String ids) {

4
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysDictItemController.java
View File

@ -68,6 +68,7 @@ public class SysDictItemController {
* @功能：新增
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/add", method = RequestMethod.POST)
@CacheEvict(value= CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> add(@RequestBody SysDictItem sysDictItem) {
@ -88,6 +89,7 @@ public class SysDictItemController {
* @param sysDictItem
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> edit(@RequestBody SysDictItem sysDictItem) {
@ -111,6 +113,7 @@ public class SysDictItemController {
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> delete(@RequestParam(name="id",required=true) String id) {
@ -132,6 +135,7 @@ public class SysDictItemController {
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
@CacheEvict(value=CacheConstant.SYS_DICT_CACHE, allEntries=true)
public Result<SysDictItem> deleteBatch(@RequestParam(name="ids",required=true) String ids) {

67
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysGatewayRouteController.java Normal file
View File

@ -0,0 +1,67 @@
package org.jeecg.modules.system.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysGatewayRoute;
import org.jeecg.modules.system.service.ISysGatewayRouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* @Description: gateway路由管理
* @Author: jeecg-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
@Api(tags="gateway路由管理")
@RestController
@RequestMapping("/sys/gatewayRoute")
@Slf4j
public class SysGatewayRouteController extends JeecgController<SysGatewayRoute, ISysGatewayRouteService> {
@Autowired
private ISysGatewayRouteService sysGatewayRouteService;
@PostMapping(value = "/updateAll")
public Result<?> updateAll(@RequestBody JSONObject json) {
String text = json.getString("routes");
JSONArray array = JSON.parseArray(text);
sysGatewayRouteService.updateAll(array);
return Result.ok("操作成功！");
}
@GetMapping(value = "/list")
public Result<?> queryPageList(SysGatewayRoute sysGatewayRoute) {
LambdaQueryWrapper<SysGatewayRoute> query = new LambdaQueryWrapper<>();
query.eq(SysGatewayRoute::getStatus,1);
List<SysGatewayRoute> ls = sysGatewayRouteService.list(query);
JSONArray array = new JSONArray();
for(SysGatewayRoute rt: ls){
JSONObject obj = (JSONObject) JSONObject.toJSON(rt);
if(oConvertUtils.isNotEmpty(rt.getPredicates())){
obj.put("predicates", JSONArray.parseArray(rt.getPredicates()));
}
if(oConvertUtils.isNotEmpty(rt.getFilters())){
obj.put("filters", JSONArray.parseArray(rt.getFilters()));
}
array.add(obj);
}
return Result.ok(array);
}
@GetMapping(value = "/clearRedis")
public Result<?> clearRedis() {
sysGatewayRouteService.clearRedis();
return Result.ok("清除成功！");
}
}

22
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysPositionController.java
View File

@ -255,4 +255,26 @@ public class SysPositionController {
return ImportExcelUtil.imporReturnRes(errorLines,successLines,errorMessage);
}
/**
* 通过code查询
*
* @param code
* @return
*/
@AutoLog(value = "职务表-通过code查询")
@ApiOperation(value = "职务表-通过code查询", notes = "职务表-通过code查询")
@GetMapping(value = "/queryByCode")
public Result<SysPosition> queryByCode(@RequestParam(name = "code", required = true) String code) {
Result<SysPosition> result = new Result<SysPosition>();
QueryWrapper<SysPosition> queryWrapper = new QueryWrapper<SysPosition>();
queryWrapper.eq("code",code);
SysPosition sysPosition = sysPositionService.getOne(queryWrapper);
if (sysPosition == null) {
result.error500("未找到对应实体");
} else {
result.setResult(sysPosition);
result.setSuccess(true);
}
return result;
}
}

4
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysRoleController.java
View File

@ -109,6 +109,7 @@ public class SysRoleController {
* @return
*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
//@RequiresRoles({"admin"})
public Result<SysRole> add(@RequestBody SysRole role) {
Result<SysRole> result = new Result<SysRole>();
try {
@ -127,6 +128,7 @@ public class SysRoleController {
* @param role
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysRole> edit(@RequestBody SysRole role) {
Result<SysRole> result = new Result<SysRole>();
@ -150,6 +152,7 @@ public class SysRoleController {
* @param id
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysRoleService.deleteRole(id);
@ -161,6 +164,7 @@ public class SysRoleController {
* @param ids
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysRole> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
Result<SysRole> result = new Result<SysRole>();

4
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysTenantController.java
View File

@ -152,9 +152,7 @@ public class SysTenantController {
if(oConvertUtils.isNotEmpty(ids)){
query.in(SysTenant::getId, ids.split(","));
}
Date now = new Date();
query.ge(SysTenant::getEndDate, now);
query.le(SysTenant::getBeginDate, now);
//此处查询忽略时间条件
List<SysTenant> ls = sysTenantService.list(query);
result.setSuccess(true);
result.setResult(ls);

138
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/SysUserController.java
View File

@ -19,6 +19,7 @@ import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.PermissionData;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
@ -41,9 +42,9 @@ import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
@ -90,6 +91,9 @@ public class SysUserController {
@Value("${jeecg.path.upload}")
private String upLoadPath;
@Resource
private BaseCommonService baseCommonService;
/**
* 获取用户列表数据
* @param user
@ -125,6 +129,8 @@ public class SysUserController {
return result;
}
//@RequiresRoles({"admin"})
@RequiresPermissions("user:add")
@RequestMapping(value = "/add", method = RequestMethod.POST)
public Result<SysUser> add(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
@ -149,12 +155,14 @@ public class SysUserController {
return result;
}
//@RequiresRoles({"admin"})
@RequiresPermissions("user:edit")
@RequestMapping(value = "/edit", method = RequestMethod.PUT)
public Result<SysUser> edit(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
try {
SysUser sysUser = sysUserService.getById(jsonObject.getString("id"));
sysBaseAPI.addLog("编辑用户，id： " +jsonObject.getString("id") ,CommonConstant.LOG_TYPE_2, 2);
baseCommonService.addLog("编辑用户，id： " +jsonObject.getString("id") ,CommonConstant.LOG_TYPE_2, 2);
if(sysUser==null) {
result.error500("未找到对应实体");
}else {
@ -179,9 +187,10 @@ public class SysUserController {
/**
* 删除用户
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
public Result<?> delete(@RequestParam(name="id",required=true) String id) {
sysBaseAPI.addLog("删除用户，id： " +id ,CommonConstant.LOG_TYPE_2, 3);
baseCommonService.addLog("删除用户，id： " +id ,CommonConstant.LOG_TYPE_2, 3);
this.sysUserService.deleteUser(id);
return Result.ok("删除用户成功");
}
@ -189,9 +198,10 @@ public class SysUserController {
/**
* 批量删除用户
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<?> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
sysBaseAPI.addLog("批量删除用户， ids： " +ids ,CommonConstant.LOG_TYPE_2, 3);
baseCommonService.addLog("批量删除用户， ids： " +ids ,CommonConstant.LOG_TYPE_2, 3);
this.sysUserService.deleteBatchUsers(ids);
return Result.ok("批量删除用户成功");
}
@ -201,6 +211,7 @@ public class SysUserController {
* @param jsonObject
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/frozenBatch", method = RequestMethod.PUT)
public Result<SysUser> frozenBatch(@RequestBody JSONObject jsonObject) {
Result<SysUser> result = new Result<SysUser>();
@ -287,6 +298,7 @@ public class SysUserController {
/**
* 修改密码
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/changePassword", method = RequestMethod.PUT)
public Result<?> changePassword(@RequestBody SysUser sysUser) {
SysUser u = this.sysUserService.getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUsername, sysUser.getUsername()));
@ -415,6 +427,8 @@ public class SysUserController {
* @param response
* @return
*/
//@RequiresRoles({"admin"})
@RequiresPermissions("user:import")
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response)throws IOException {
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
@ -508,6 +522,7 @@ public class SysUserController {
/**
* 首页用户重置密码
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/updatePassword", method = RequestMethod.PUT)
public Result<?> changPassword(@RequestBody JSONObject json) {
String username = json.getString("username");
@ -540,6 +555,7 @@ public class SysUserController {
* @param
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/addSysUserRole", method = RequestMethod.POST)
public Result<String> addSysUserRole(@RequestBody SysUserRoleVO sysUserRoleVO) {
Result<String> result = new Result<String>();
@ -570,6 +586,7 @@ public class SysUserController {
* @param
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteUserRole", method = RequestMethod.DELETE)
public Result<SysUserRole> deleteUserRole(@RequestParam(name="roleId") String roleId,
@RequestParam(name="userId",required=true) String userId
@ -593,6 +610,7 @@ public class SysUserController {
* @param
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteUserRoleBatch", method = RequestMethod.DELETE)
public Result<SysUserRole> deleteUserRoleBatch(
@RequestParam(name="roleId") String roleId,
@ -719,6 +737,7 @@ public class SysUserController {
/**
* 给指定部门添加对应的用户
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/editSysDepartWithUser", method = RequestMethod.POST)
public Result<String> editSysDepartWithUser(@RequestBody SysDepartUsersVO sysDepartUsersVO) {
Result<String> result = new Result<String>();
@ -747,6 +766,7 @@ public class SysUserController {
/**
* 删除指定机构的用户关系
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteUserInDepart", method = RequestMethod.DELETE)
public Result<SysUserDepart> deleteUserInDepart(@RequestParam(name="depId") String depId,
@RequestParam(name="userId",required=true) String userId
@ -778,6 +798,7 @@ public class SysUserController {
/**
* 批量删除指定机构的用户关系
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteUserInDepartBatch", method = RequestMethod.DELETE)
public Result<SysUserDepart> deleteUserInDepartBatch(
@RequestParam(name="depId") String depId,
@ -1057,9 +1078,9 @@ public class SysUserController {
//TODO 从查询效率上将不要用mp的封装的page分页查询 建议自己写分页语句
LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<SysUser>();
if(oConvertUtils.isNotEmpty(syncFlow)){
query.eq(SysUser::getActivitiSync, "1");
query.eq(SysUser::getActivitiSync, CommonConstant.ACT_SYNC_1);
}
query.eq(SysUser::getDelFlag,"0");
query.eq(SysUser::getDelFlag,CommonConstant.DEL_FLAG_0);
if(oConvertUtils.isNotEmpty(username)){
if(username.contains(",")){
query.in(SysUser::getUsername,username.split(","));
@ -1122,6 +1143,7 @@ public class SysUserController {
* @param userIds 被删除的用户ID，多个id用半角逗号分割
* @return
*/
//@RequiresRoles({"admin"})
@RequestMapping(value = "/deleteRecycleBin", method = RequestMethod.DELETE)
public Result deleteRecycleBin(@RequestParam("userIds") String userIds) {
if (StringUtils.isNotBlank(userIds)) {
@ -1142,23 +1164,39 @@ public class SysUserController {
try {
String username = JwtUtil.getUserNameByToken(request);
SysUser sysUser = sysUserService.getUserByName(username);
sysBaseAPI.addLog("移动端编辑用户，id： " +jsonObject.getString("id") ,CommonConstant.LOG_TYPE_2, 2);
baseCommonService.addLog("移动端编辑用户，id： " +jsonObject.getString("id") ,CommonConstant.LOG_TYPE_2, 2);
String realname=jsonObject.getString("realname");
String avatar=jsonObject.getString("avatar");
String sex=jsonObject.getString("sex");
String phone=jsonObject.getString("phone");
String email=jsonObject.getString("email");
// Date birthday=jsonObject.getDate("birthday");
SysUser userPhone = sysUserService.getUserByPhone(phone);
if(sysUser==null) {
result.error500("未找到对应用户!");
}else {
String realname=jsonObject.getString("realname");
String avatar=jsonObject.getString("avatar");
String sex=jsonObject.getString("sex");
String phone=jsonObject.getString("phone");
String email=jsonObject.getString("email");
Date birthday=jsonObject.getDate("birthday");
sysUser.setRealname(realname);
sysUser.setAvatar(avatar);
sysUser.setSex(Integer.parseInt(sex));
sysUser.setBirthday(birthday);
sysUser.setPhone(phone);
sysUser.setEmail(email);
if(userPhone!=null){
String userPhonename = userPhone.getUsername();
if(!userPhonename.equals(username)){
result.error500("手机号已存在!");
return result;
}
}
if(StringUtils.isNotBlank(realname)){
sysUser.setRealname(realname);
}
if(StringUtils.isNotBlank(avatar)){
sysUser.setAvatar(avatar);
}
if(StringUtils.isNotBlank(sex)){
sysUser.setSex(Integer.parseInt(sex));
}
if(StringUtils.isNotBlank(phone)){
sysUser.setPhone(phone);
}
if(StringUtils.isNotBlank(email)){
sysUser.setEmail(email);
}
sysUser.setUpdateTime(new Date());
sysUserService.updateById(sysUser);
}
@ -1168,6 +1206,29 @@ public class SysUserController {
}
return result;
}
/**
* 移动端保存设备信息
* @param clientId
* @return
*/
@RequestMapping(value = "/saveClientId", method = RequestMethod.GET)
public Result<SysUser> saveClientId(HttpServletRequest request,@RequestParam("clientId")String clientId) {
Result<SysUser> result = new Result<SysUser>();
try {
String username = JwtUtil.getUserNameByToken(request);
SysUser sysUser = sysUserService.getUserByName(username);
if(sysUser==null) {
result.error500("未找到对应用户!");
}else {
sysUser.setClientId(clientId);
sysUserService.updateById(sysUser);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
result.error500("操作失败!");
}
return result;
}
/**
* 根据userid获取用户信息和部门员工信息
*
@ -1234,4 +1295,41 @@ public class SysUserController {
result.setResult(list);
return result;
}
/**
* 根据用户名修改手机号
* @param json
* @return
*/
@RequestMapping(value = "/updateMobile", method = RequestMethod.PUT)
public Result<?> changMobile(@RequestBody JSONObject json,HttpServletRequest request) {
String smscode = json.getString("smscode");
String phone = json.getString("phone");
Result<SysUser> result = new Result<SysUser>();
//获取登录用户名
String username = JwtUtil.getUserNameByToken(request);
if(oConvertUtils.isEmpty(username) || oConvertUtils.isEmpty(smscode) || oConvertUtils.isEmpty(phone)) {
result.setMessage("修改手机号失败！");
result.setSuccess(false);
return result;
}
Object object= redisUtil.get(phone);
if(null==object) {
result.setMessage("短信验证码失效！");
result.setSuccess(false);
return result;
}
if(!smscode.equals(object)) {
result.setMessage("短信验证码不匹配！");
result.setSuccess(false);
return result;
}
SysUser user = sysUserService.getUserByName(username);
if(user==null) {
return Result.error("用户不存在！");
}
user.setPhone(phone);
sysUserService.updateById(user);
return Result.ok("手机号设置成功!");
}
}

26
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/controller/ThirdLoginController.java
View File

@ -1,5 +1,6 @@
package org.jeecg.modules.system.controller;
import cn.hutool.crypto.SecureUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xkcoding.justauth.AuthRequestFactory;
@ -9,14 +10,17 @@ import me.zhyd.oauth.model.AuthResponse;
import me.zhyd.oauth.request.AuthRequest;
import me.zhyd.oauth.utils.AuthStateUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
@ -41,7 +45,7 @@ public class ThirdLoginController {
private ISysUserService sysUserService;
@Autowired
private ISysBaseAPI sysBaseAPI;
private BaseCommonService baseCommonService;
@Autowired
private RedisUtil redisUtil;
@Autowired
@ -104,9 +108,21 @@ public class ThirdLoginController {
redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, token);
// 设置超时时间
redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME / 1000);
//update-begin-author:taoyan date:20200812 for:登录缓存用户信息
LoginUser redisUser = new LoginUser();
BeanUtils.copyProperties(user, redisUser);
redisUser.setPassword(SecureUtil.md5(user.getPassword()));
redisUtil.set(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, redisUser);
redisUtil.expire(CacheConstant.SYS_USERS_CACHE_JWT +":" +token, JwtUtil.EXPIRE_TIME*2 / 1000);
//update-end-author:taoyan date:20200812 for:登录缓存用户信息
modelMap.addAttribute("token", token);
}
//update-begin--Author:wangshuai Date:20200729 for：接口在签名校验失败时返回失败的标识码 issues#1441--------------------
}else{
modelMap.addAttribute("token", "登录失败");
}
//update-end--Author:wangshuai Date:20200729 for：接口在签名校验失败时返回失败的标识码 issues#1441--------------------
result.setSuccess(false);
result.setMessage("第三方登录异常,请联系管理员");
return "thirdLogin";
@ -133,7 +149,7 @@ public class ThirdLoginController {
result.setResult(obj);
result.setSuccess(true);
result.setCode(200);
sysBaseAPI.addLog("用户名: " + username + ",登录成功[第三方用户]！", CommonConstant.LOG_TYPE_1, null);
baseCommonService.addLog("用户名: " + username + ",登录成功[第三方用户]！", CommonConstant.LOG_TYPE_1, null);
return result;
}

2
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/entity/SysAnnouncement.java
View File

@ -26,7 +26,7 @@ public class SysAnnouncement implements Serializable {
/**
* id
*/
@TableId(type = IdType.ID_WORKER_STR)
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**
* 标题

2
jeecg-boot/jeecg-boot-module-system/src/main/java/org/jeecg/modules/system/entity/SysAnnouncementSend.java
View File

@ -21,7 +21,7 @@ public class SysAnnouncementSend implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ID_WORKER_STR)
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**通告id*/
private java.lang.String anntId;

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