在线演示(VUE3beta版)

JeecgBoot低代码平台 3.0版本发布—新里程牌开始，迎接VUE3到来！！
JeecgBoot低代码平台 3.0版本发布—新里程牌开始，迎接VUE3版本到来！！
2025-12-08 17:12:28 +08:00 · 2021-10-29 09:40:25 +08:00 · 2021-10-27 14:33:50 +08:00 · 2021-10-27 11:48:19 +08:00 · 2021-10-27 11:33:09 +08:00 · 2021-10-27 10:55:52 +08:00
941 changed files with 461995 additions and 28157 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -2,3 +2,4 @@
 *.css linguist-language=Java
 *.html linguist-language=Java
 *.vue linguist-language=Java
+*.sql linguist-language=Java
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -9,4 +9,9 @@



-友情提示： 未按格式要求发帖，会直接删掉。
+#### 友情提示（为了提高issue处理效率）：
+  - 未按格式要求发帖，会被直接删掉;
+  - 请自己初判问题描述是否清楚，是否方便我们调查处理；
+  - 针对问题请说明是Online在线功能(需说明用的主题模板)，还是生成的代码功能；
+  - 描述过于简单或模糊，导致无法处理的，会被直接删掉；
+  
--- a/README.md
+++ b/README.md
@ -1,18 +1,19 @@


-![JEECG](https://static.oschina.net/uploads/img/201905/24164523_XDhg.png "JeecgBoot低代码开发平台")
+![JEECG](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/site/jeecgfengm.png "JeecgBoot低代码开发平台")



 JEECG BOOT 低代码开发平台（前后端分离版本）
 ===============

-当前最新版本： 2.3（发布日期：2020-09-14）
+当前最新版本： 3.0（发布日期：2021-11-01）


 [![AUR](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/zhangdaiscott/jeecg-boot/blob/master/LICENSE)
 [![](https://img.shields.io/badge/Author-北京国炬软件-orange.svg)](http://www.jeecg.com)
-[![](https://img.shields.io/badge/version-2.3-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
+[![](https://img.shields.io/badge/Blog-官方博客-blue.svg)](https://jeecg.blog.csdn.net)
+[![](https://img.shields.io/badge/version-3.0-brightgreen.svg)](https://github.com/zhangdaiscott/jeecg-boot)
 [![GitHub stars](https://img.shields.io/github/stars/zhangdaiscott/jeecg-boot.svg?style=social&label=Stars)](https://github.com/zhangdaiscott/jeecg-boot)
 [![GitHub forks](https://img.shields.io/github/forks/zhangdaiscott/jeecg-boot.svg?style=social&label=Fork)](https://github.com/zhangdaiscott/jeecg-boot)

@ -23,11 +24,14 @@ JEECG BOOT 低代码开发平台（前后端分离版本）

 <h3 align="center">Java Low Code Platform for Enterprise web applications</h3>

-JeecgBoot 是一款基于代码生成器的`低代码`开发平台，零代码开发！采用前后端分离架构：SpringBoot2.x，Ant Design&Vue，Mybatis-plus，Shiro，JWT。强大的代码生成器让前后端代码一键生成，无需写任何代码! JeecgBoot引领新的开发模式(Online Coding模式-> 代码生成器模式-> 手工MERGE智能开发)， 帮助解决Java项目70%的重复工作，让开发更多关注业务逻辑。既能快速提高开发效率，帮助公司节省成本，同时又不失灵活性！JeecgBoot还独创在线开发模式（No代码概念）：在线表单配置（表单设计器）、移动配置能力、工作流配置（在线设计流程）、报表配置能力、在线图表配置、插件能力（可插拔）等等！
+JeecgBoot 是一款基于代码生成器的`低代码平台`！前后端分离架构 SpringBoot2.x，SpringCloud，Ant Design&Vue，Mybatis-plus，Shiro，JWT，支持微服务。强大的代码生成器让前后端代码一键生成，实现低代码开发!  JeecgBoot 引领新的低代码开发模式(OnlineCoding-> 代码生成器-> 手工MERGE)， 帮助解决Java项目70%的重复工作，让开发更多关注业务。既能快速提高效率，节省研发成本，同时又不失灵活性！
+
+JeecgBoot 提供了一系列`低代码模块`，实现在线开发`真正的零代码`：Online表单开发、Online报表、报表配置能力、在线图表设计、大屏设计、移动配置能力、表单设计器、在线设计流程、流程自动化配置、插件能力（可插拔）等等！


-`JEECG宗旨是:` 简单功能由Online Coding配置实现既`零代码开发`（在线配置表单、在线配置报表、在线图表设计、在线设计流程、在线设计表单），复杂功能由代码生成器生成进行手工Merge，既保证了`智能`又兼顾了`灵活`; 
-业务流程采用工作流来实现、扩展出任务接口，供开发编写业务逻辑，表单提供多种解决方案： 表单设计器、online配置表单、编码表单。同时实现了流程与表单的分离设计（松耦合）、并支持任务节点灵活配置，既保证了公司流程的保密性，又减少了开发人员的工作量。
+`JEECG宗旨是:` 简单功能由OnlineCoding配置实现，做到`零代码开发`；复杂功能由代码生成器生成进行手工Merge 实现`低代码开发`，既保证了`智能`又兼顾`灵活`；实现了低代码开发的同时又支持灵活编码，解决了当前低代码产品普遍不灵活的弊端！
+
+`JEECG业务流程:` 采用工作流来实现、扩展出任务接口，供开发编写业务逻辑，表单提供多种解决方案： 表单设计器、online配置表单、编码表单。同时实现了流程与表单的分离设计（松耦合）、并支持任务节点灵活配置，既保证了公司流程的保密性，又减少了开发人员的工作量。


 适用项目
@ -41,13 +45,17 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，

 - 技术官网：  [http://www.jeecg.com](http://www.jeecg.com)

- 开发文档：  [http://doc.jeecg.com](http://doc.jeecg.com/1273753)
-
 - 在线演示 ： [http://boot.jeecg.com](http://boot.jeecg.com)

- 视频教程  ：[JeecgBoot入门视频教程](http://www.jeecg.com/doc/video)
+- 在线演示(VUE3beta版)：[http://boot3.jeecg.com](http://boot3.jeecg.com)

- 常见问题：  [入门常见问题大全](http://bbs.jeecg.com/forum.php?mod=viewthread&tid=7816&extra=page%3D1)
+- 开发文档：  [http://doc.jeecg.com](http://doc.jeecg.com)
+
+- 视频教程  ：[JeecgBoot入门视频](http://www.jeecg.com/doc/video)
+
+- 微服务启动：  [单体升级为微服务启动文档2.4+](http://doc.jeecg.com/2043906)
+
+- 常见问题：  [入门常见问题Q&A](http://jeecg.com/doc/qa)

 - 更新日志：  [版本日志](http://www.jeecg.com/doc/log)

@ -56,19 +64,19 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
 交流互动
 -----------------------------------

- QQ交流群 ：  ③816531124、②769925425（满）、①284271917（满）
+- QQ交流群 ： ⑤860162132、④774126647(满)、③816531124(满)、②769925425(满)、①284271917(满)

 - 反馈问题：  [反馈问题，请按格式发Issues](https://github.com/zhangdaiscott/jeecg-boot/issues/new)

 - 参与开源：  [欢迎加入JEECG开源团队，共同进步！！](http://www.jeecg.com/doc/join)

- Online一分钟：  [1分钟快速学习](https://jeecg.blog.csdn.net/article/details/106078912)
+- Online一分钟：  [1分钟快速学习](https://my.oschina.net/jeecg/blog/3083313)


 为什么选择JEECG-BOOT?
 -----------------------------------
 * 1.采用最新主流前后分离框架（Springboot+Mybatis+antd），容易上手; 代码生成器依赖性低,灵活的扩展能力，可快速实现二次开发;
-* 2.支持微服务SpringCloud Alibaba(Nacos、Gateway、Sentinel、Skywarking)，提供切换机制支持单体和微服务自由切换
+* 2.支持微服务SpringCloud Alibaba(Nacos、Gateway、Sentinel、Skywalking)，提供切换机制支持单体和微服务自由切换
 * 3.开发效率高,采用代码生成器，单表、树列表、一对多、一对一等数据模型，增删改查功能一键生成，菜单配置直接使用；
 * 4.代码生成器提供强大模板机制，支持自定义模板，目前提供四套风格模板（单表两套、树模型一套、一对多三套）
 * 5.代码生成器非常智能，在线业务建模、在线配置、所见即所得支持23种类控件，一键生成前后端代码，大幅度提升开发效率，不再为重复工作发愁。
@ -85,7 +93,7 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
 * 16.页面校验自动生成(必须输入、数字校验、金额校验、时间空间等);
 * 17.支持SAAS服务模式，提供SaaS多租户架构方案。
 * 18.分布式文件服务，集成minio、阿里OSS等优秀的第三方，提供便捷的文件上传与管理，同时也支持本地存储。
-* 19.主流数据库兼容，一套代码完全兼容Mysql、Postgresql、Oracle三大主流数据库。
+* 19.主流数据库兼容，一套代码完全兼容Mysql、Postgresql、Oracle、Sqlserver、MariaDB、达梦等主流数据库。
 * 20.集成工作流activiti，并实现了只需在页面配置流程转向，可极大的简化bpm工作流的开发；用bpm的流程设计器画出了流程走向，一个工作流基本就完成了，只需写很少量的java代码；
 * 21.低代码能力：在线流程设计，采用开源Activiti流程引擎，实现在线画流程,自定义表单,表单挂靠,业务流转
 * 22.多数据源：及其简易的使用方式，在线配置数据源配置，便捷的从其他数据抓取数据；
@ -124,21 +132,39 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，

 - 依赖管理：Maven

- 数据库：MySQL5.7+  &  Oracle 11g & Sqlserver2017
-
 - 缓存：Redis

+- 数据库脚本：MySQL5.7+  &  Oracle 11g & Sqlserver2017（默认只提供这三个库脚本，其他库需要自己转）
+
+|  数据库   |  支持   |
+| --- | --- |
+|   MySQL   |  √   |
+|  Oracle11g   |  √   |
+|  Sqlserver2017   |  √   |
+|   PostgreSQL   |  √   |
+|   DB2、Informix   |  √   |
+|   MariaDB   |  √   |
+|  SQLite、Hsqldb、Derby、H2   |  √   |
+|   达梦、人大金仓、神通   |  √   |
+|   华为高斯、虚谷、瀚高数据库   |  √   |
+|   阿里云PolarDB、PPAS、HerdDB   |  √   |
+|  Hive、HBase、CouchBase   |  √   |
+

 #### 后端
- 基础框架：Spring Boot 2.1.3.RELEASE \ Spring Cloud Alibaba 2.1.0.RELEASE
+- 基础框架：Spring Boot 2.3.5.RELEASE

- 持久层框架：Mybatis-plus_3.1.2
+- 微服务框架： Spring Cloud Alibaba 2.2.3.RELEASE

- 安全框架：Apache Shiro 1.4.0，Jwt_3.7.0
+- 持久层框架：Mybatis-plus 3.4.3.1、Minidao 

- 微服务技术：Spring Cloud Alibaba、Nacos、Gateway、Sentinel、Skywarking
+- 报表工具： jimureport 1.3.78

- 数据库连接池：阿里巴巴Druid 1.1.10
+- 安全框架：Apache Shiro 1.7.0，Jwt 3.11.0
+
+- 微服务技术栈：Spring Cloud Alibaba、Nacos、Gateway、Sentinel、Skywalking
+
+- 数据库连接池：阿里巴巴Druid 1.1.22

 - 缓存框架：redis

@ -182,7 +208,7 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
 ├─消息中心
 │  ├─消息管理
 │  ├─模板管理
-├─智能化功能
+├─代码生成器(低代码)
 │  ├─代码生成器功能（一键生成前后端代码，生成后无需修改直接用，绝对是后端开发福音）
 │  ├─代码生成器模板（提供4套模板，分别支持单表和一对多模型，不同风格选择）
 │  ├─代码生成器模板（生成代码，自带excel导入导出）
@ -271,14 +297,19 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
 │  ├─提供单点登录CAS集成方案
 │  ├─提供APP发布方案
 │  ├─集成Websocket消息通知机制
-├─Online在线低代码开发(暂未开源)
+├─Online在线开发(低代码)
 │  ├─Online在线表单 - 功能已开放
-│  ├─在线代码生成器 - 功能已开放
+│  ├─Online代码生成器 - 功能已开放
 │  ├─Online在线报表 - 功能已开放
-│  ├─多数据源管理
-│  ├─Online在线图表
-│  ├─Online图表模板配置
-│  ├─高级表单设计器
+│  ├─Online在线图表(暂不开源)
+│  ├─Online图表模板配置(暂不开源)
+│  ├─Online布局设计(暂不开源)
+│  ├─多数据源管理 - 功能已开放
+├─积木报表设计器(低代码)
+│  ├─打印设计器
+│  ├─数据报表设计
+│  ├─图形报表设计（支持echart）
+│  ├─大屏设计器(暂不开源)
 │─流程模块功能 (暂不开源)
 │  ├─流程设计器
 │  ├─在线表单设计
@ -297,14 +328,14 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
   
 ```

-## 微服务整体解决方案(2.3+版本)
+## 微服务整体解决方案(2.4+版本)


 1、服务注册和发现 Nacos √

 2、统一配置中心 Nacos  √

-3、路由网关 gateway √
+3、路由网关 gateway(三种加载方式) √

 4、分布式 http feign √

@ -314,27 +345,30 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，

 7、统一权限控制 JWT + Shiro √

-8、服务监控 SpringBootAdmin  [参考文档](https://www.kancloud.cn/zhangdaiscott/jeecgcloud/1761865)
+8、服务监控 SpringBootAdmin√

-9、链路跟踪 Skywarking  [参考文档](https://www.kancloud.cn/zhangdaiscott/jeecgcloud/1771670)
+9、链路跟踪 Skywalking   [参考文档](https://www.kancloud.cn/zhangdaiscott/jeecgcloud/1771670)

-10、消息中间件 SpringCloudStream+RabbitMQ  [参考文档](https://www.kancloud.cn/zhangdaiscott/jeecgcloud/1744409)
+10、消息中间件 RabbitMQ  √

-11、分布式任务 xxl-job  [参考文档](https://www.kancloud.cn/zhangdaiscott/jeecgcloud/1801263)
+11、分布式任务 xxl-job  √ 

 12、分布式事务 Seata

-13、分布式日志 elk + kafa
+13、分布式日志 elk + kafka

 14、支持 docker-compose、k8s、jenkins

 15、CAS 单点登录   √
+
+16、路由限流   √
+
   
 #### 微服务架构图
 ![微服务架构图](https://jeecgos.oss-cn-beijing.aliyuncs.com/files/jeecgboot-weifuwu-cloud.png "在这里输入图片标题")

 ### Jeecg Boot 产品功能蓝图
-![功能蓝图](https://static.jeecg.com/upload/test/Jeecg-Boot-lantu202005_1590912449914.jpg "在这里输入图片标题")
+![功能蓝图](https://jeecgos.oss-cn-beijing.aliyuncs.com/upload/test/Jeecg-Boot-lantu202005_1590912449914.jpg "在这里输入图片标题")


 后台开发环境和依赖
@ -344,7 +378,7 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
 - jdk8
 - mysql
 - redis
- 数据库脚本：jeecg-boot\docs\jeecg-boot-mysql.sql
+- 数据库脚本：jeecg-boot/db/jeecgboot-mysql-5.7.sql
 - 默认登录账号： admin/123456


@ -367,11 +401,11 @@ Jeecg-Boot低代码开发平台，可以应用在任何J2EE项目的开发中，
 - 拉取项目代码
 ```bash
 git clone https://github.com/zhangdaiscott/jeecg-boot.git
-cd  jeecg-boot/ant-design-jeecg-vue
+cd  jeecg-boot/ant-design-vue-jeecg
 ```

 1. 安装node.js
-2. 切换到ant-design-jeecg-vue文件夹下
+2. 切换到ant-design-vue-jeecg文件夹下
 ```
 # 安装yarn
 npm install -g yarn
@ -472,9 +506,9 @@ yarn run lint

 - [Vue](https://cn.vuejs.org/v2/guide)

- [路由/菜单说明](https://gitee.com/jeecg/jeecg-boot/tree/v1.1/ant-design-jeecg-vue/src/router/README.md)
+- [路由/菜单说明](https://gitee.com/jeecg/jeecg-boot/tree/v1.1/ant-design-vue-jeecg/src/router/README.md)

- [ANTD 默认配置项](https://gitee.com/jeecg/jeecg-boot/blob/v1.1/ant-design-jeecg-vue/src/defaultSettings.js)
+- [ANTD 默认配置项](https://gitee.com/jeecg/jeecg-boot/blob/v1.1/ant-design-vue-jeecg/src/defaultSettings.js)

 - 其他待补充...

--- a/ant-design-vue-jeecg/.env
+++ b/ant-design-vue-jeecg/.env
@ -0,0 +1,3 @@
+NODE_ENV=production
+VUE_APP_PLATFORM_NAME=JeecgBoot 企业级低代码平台
+VUE_APP_SSO=false
--- a/ant-design-vue-jeecg/.env.development
+++ b/ant-design-vue-jeecg/.env.development
@ -0,0 +1,4 @@
+NODE_ENV=development
+VUE_APP_API_BASE_URL=http://localhost:8080/jeecg-boot
+VUE_APP_CAS_BASE_URL=http://cas.example.org:8443/cas
+VUE_APP_ONLINE_BASE_URL=http://fileview.jeecg.com/onlinePreview
--- a/ant-design-vue-jeecg/.env.production
+++ b/ant-design-vue-jeecg/.env.production
@ -0,0 +1,4 @@
+NODE_ENV=production
+VUE_APP_API_BASE_URL=http://localhost:8080/jeecg-boot
+VUE_APP_CAS_BASE_URL=http://localhost:8888/cas
+VUE_APP_ONLINE_BASE_URL=http://fileview.jeecg.com/onlinePreview
--- a/ant-design-vue-jeecg/.env.test
+++ b/ant-design-vue-jeecg/.env.test
@ -0,0 +1,4 @@
+NODE_ENV=production
+VUE_APP_API_BASE_URL=http://boot.jeecg.com:8080/jeecg-boot
+VUE_APP_CAS_BASE_URL=http://cas.example.org:8443/cas
+VUE_APP_ONLINE_BASE_URL=http://fileview.jeecg.com/onlinePreview
--- a/ant-design-vue-jeecg/README.md
+++ b/ant-design-vue-jeecg/README.md
@ -1,13 +1,13 @@
 Ant Design Jeecg Vue
 ====

-当前最新版本： 2.3.0（发布日期：20200914）
+当前最新版本： 3.0.0（发布日期：2021-11-01）

 Overview
 ----

 基于 [Ant Design of Vue](https://vuecomponent.github.io/ant-design-vue/docs/vue/introduce-cn/) 实现的 Ant Design Pro  Vue 版
-Jeecg-boot 的前段UI框架，采用前后端分离方案，提供强大代码生成器的快速开发平台。
+Jeecg-boot 的前端UI框架，采用前后端分离方案，提供强大代码生成器的低代码平台。
 前端页面代码和后端功能代码一键生成，不需要写任何代码，保持jeecg一贯的强大！！


@ -33,7 +33,7 @@ Jeecg-boot 的前段UI框架，采用前后端分离方案，提供强大代码
 - 拉取项目代码
 ```bash
 git clone https://github.com/zhangdaiscott/jeecg-boot.git
-cd  jeecg-boot/ant-design-jeecg-vue
+cd  jeecg-boot/ant-design-vue-jeecg
 ```

 - 安装依赖
@ -93,9 +93,9 @@ yarn run lint

 - [Vue](https://cn.vuejs.org/v2/guide)

- [路由/菜单说明](https://github.com/zhangdaiscott/jeecg-boot/tree/master/ant-design-jeecg-vue/src/router/README.md)
+- [路由/菜单说明](https://github.com/zhangdaiscott/jeecg-boot/tree/master/ant-design-vue-jeecg/src/router/README.md)

- [ANTD 默认配置项](https://github.com/zhangdaiscott/jeecg-boot/tree/master/ant-design-jeecg-vue/src/defaultSettings.js)
+- [ANTD 默认配置项](https://github.com/zhangdaiscott/jeecg-boot/tree/master/ant-design-vue-jeecg/src/defaultSettings.js)

 - 其他待补充...

@ -111,7 +111,7 @@ Docker 镜像使用

 ``` 
 # 1.修改前端项目的后台域名
-    public/index.html  
+    .env.development
    域名改成： http://jeecg-boot-system:8080/jeecg-boot
   
 # 2.先进入打包前端项目
--- a/ant-design-vue-jeecg/package-lock.json
+++ b/ant-design-vue-jeecg/package-lock.json
--- a/ant-design-vue-jeecg/package.json
+++ b/ant-design-vue-jeecg/package.json
@ -1,16 +1,17 @@
 {
  "name": "vue-antd-jeecg",
-  "version": "2.3.0",
+  "version": "3.0.0",
  "private": true,
  "scripts": {
    "pre": "cnpm install || yarn --registry https://registry.npm.taobao.org || npm install --registry https://registry.npm.taobao.org ",
    "serve": "vue-cli-service serve",
+    "build:test": "vue-cli-service build --mode test",
    "build": "vue-cli-service build",
    "lint": "vue-cli-service lint"
  },
  "dependencies": {
-    "ant-design-vue": "^1.6.3",
-    "@jeecg/antd-online-mini": "2.3.0",
+    "ant-design-vue": "^1.7.2",
+    "@jeecg/antd-online-mini": "3.0.0-beta",
    "@antv/data-set": "^0.11.4",
    "viser-vue": "^2.4.8",
    "axios": "^0.18.0",
@ -38,12 +39,12 @@
    "tinymce": "^5.3.2",
    "@toast-ui/editor": "^2.1.2",
    "vue-area-linkage": "^5.1.0",
-    "area-data": "^5.0.6",
-    "jsoneditor": "^9.0.0",
+    "china-area-data": "^5.0.1",
    "dom-align": "1.12.0",
    "xe-utils": "2.4.8",
    "vxe-table": "2.9.13",
-    "vxe-table-plugin-antd": "1.8.10"
+    "vxe-table-plugin-antd": "1.8.10",
+    "cron-parser": "^2.10.0"
  },
  "devDependencies": {
    "@babel/polyfill": "^7.2.5",
@ -58,8 +59,7 @@
    "less-loader": "^4.1.0",
    "vue-template-compiler": "^2.6.10",
    "html-webpack-plugin": "^4.2.0",
-    "compression-webpack-plugin": "^3.1.0",
-    "babel-plugin-import": "^1.13.0"
+    "compression-webpack-plugin": "^3.1.0"
  },
  "eslintConfig": {
    "root": true,
--- a/ant-design-vue-jeecg/public/cdn/font-icon/font_2316098_umqusozousr.js
+++ b/ant-design-vue-jeecg/public/cdn/font-icon/font_2316098_umqusozousr.js
--- a/ant-design-vue-jeecg/public/color.less
+++ b/ant-design-vue-jeecg/public/color.less
@ -2421,7 +2421,9 @@ a.listItemMetaTitle {
  color: rgba(0, 0, 0, 0.85);
 }
 .main {
-  background-color: #fff;
+  //update-begin---author:liusq   Date:20210108  for：[JT-409]编译主题色，然后退出登录后的首页是这样子------------
+  //background-color: #fff;
+  //update-end---author:liusq     Date:20210108  for：[JT-409]编译主题色，然后退出登录后的首页是这样子------------
 }
 .main .leftmenu {
  border-right: 1px solid #e8e8e8;
@ -7687,9 +7689,6 @@ font.weak {
    color: @primary-color;
  }
 }
-.ant-menu-submenu-selected {
-  color: @primary-color;
-}

 // begin -------- JAreaLinkage 三级联动样式 --------------
 .cascader-menu-list .cascader-menu-option.hover,
--- a/ant-design-vue-jeecg/public/index.html
+++ b/ant-design-vue-jeecg/public/index.html
@ -5,10 +5,9 @@
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width,initial-scale=1.0">
-  <title>Jeecg-Boot 企业级快速开发平台</title>
+  <title>JeecgBoot 企业级低代码平台</title>
  <link rel="icon" href="<%= BASE_URL %>logo.png">
-  <script src="/cdn/babel-polyfill/polyfill_7_2_5.js"></script>
-
+  <script src="<%= BASE_URL %>cdn/babel-polyfill/polyfill_7_2_5.js"></script>
  <style>
    html,
    body,
@ -243,23 +242,16 @@
  <!-- 全局配置 -->
  <script>
    window._CONFIG = {};
-    window._CONFIG['domianURL'] = 'http://127.0.0.1:8080/jeecg-boot';
-    window._CONFIG['casPrefixUrl'] = 'http://cas.example.org:8443/cas';
-    window._CONFIG['onlinePreviewDomainURL'] = 'http://fileview.jeecg.com/onlinePreview'
-    window._CONFIG['staticDomainURL'] = window._CONFIG['domianURL'] + '/sys/common/static';
-    //window._CONFIG['downloadUrl'] = window._CONFIG['domianURL'] + '/sys/common/download';
-    window._CONFIG['pdfDomainURL'] =  window._CONFIG['domianURL'] + '/sys/common/pdf/pdfPreviewIframe';
  </script>
 </head>

 <body>
-<!-- built files will be auto injected -->
 <div id="app">
  <div id="loader-wrapper">
    <div id="loader"></div>
    <div class="loader-section section-left"></div>
    <div class="loader-section section-right"></div>
-    <div class="load_title">正在加载 Jeecg-Boot 快速开发平台,请耐心等待
+    <div class="load_title">正在加载 JeecgBoot 低代码平台,请耐心等待

    </div>
  </div>
--- a/ant-design-vue-jeecg/src/api/api.js
+++ b/ant-design-vue-jeecg/src/api/api.js
@ -2,17 +2,9 @@ import { getAction, deleteAction, putAction, postAction, httpAction } from '@/ap
 import Vue from 'vue'
 import {UI_CACHE_DB_DICT_DATA } from "@/store/mutation-types"

-////根路径
-// const doMian = "/jeecg-boot/";
-////图片预览请求地址
-// const imgView = "http://localhost:8080/jeecg-boot/sys/common/view/";
-
 //角色管理
 const addRole = (params)=>postAction("/sys/role/add",params);
 const editRole = (params)=>putAction("/sys/role/edit",params);
-// const getRoleList = (params)=>getAction("/sys/role/list",params);
-// const deleteRole = (params)=>deleteAction("/sys/role/delete",params);
-// const deleteRoleList = (params)=>deleteAction("/sys/role/deleteBatch",params);
 const checkRoleCode = (params)=>getAction("/sys/role/checkRoleCode",params);
 const queryall = (params)=>getAction("/sys/role/queryall",params);

@ -21,8 +13,6 @@ const addUser = (params)=>postAction("/sys/user/add",params);
 const editUser = (params)=>putAction("/sys/user/edit",params);
 const queryUserRole = (params)=>getAction("/sys/user/queryUserRole",params);
 const getUserList = (params)=>getAction("/sys/user/list",params);
-// const deleteUser = (params)=>deleteAction("/sys/user/delete",params);
-// const deleteUserList = (params)=>deleteAction("/sys/user/deleteBatch",params);
 const frozenBatch = (params)=>putAction("/sys/user/frozenBatch",params);
 //验证用户是否存在
 const checkOnlyUser = (params)=>getAction("/sys/user/checkOnlyUser",params);
@ -33,27 +23,22 @@ const changePassword = (params)=>putAction("/sys/user/changePassword",params);
 const addPermission= (params)=>postAction("/sys/permission/add",params);
 const editPermission= (params)=>putAction("/sys/permission/edit",params);
 const getPermissionList = (params)=>getAction("/sys/permission/list",params);
-/*update_begin author:wuxianquan date:20190908 for:添加查询一级菜单和子菜单查询api */
 const getSystemMenuList = (params)=>getAction("/sys/permission/getSystemMenuList",params);
 const getSystemSubmenu = (params)=>getAction("/sys/permission/getSystemSubmenu",params);
 const getSystemSubmenuBatch = (params) => getAction('/sys/permission/getSystemSubmenuBatch', params)
-/*update_end author:wuxianquan date:20190908 for:添加查询一级菜单和子菜单查询api */
-
-// const deletePermission = (params)=>deleteAction("/sys/permission/delete",params);
-// const deletePermissionList = (params)=>deleteAction("/sys/permission/deleteBatch",params);
 const queryTreeList = (params)=>getAction("/sys/permission/queryTreeList",params);
 const queryTreeListForRole = (params)=>getAction("/sys/role/queryTreeList",params);
 const queryListAsync = (params)=>getAction("/sys/permission/queryListAsync",params);
 const queryRolePermission = (params)=>getAction("/sys/permission/queryRolePermission",params);
 const saveRolePermission = (params)=>postAction("/sys/permission/saveRolePermission",params);
-//const queryPermissionsByUser = (params)=>getAction("/sys/permission/queryByUser",params);
-const queryPermissionsByUser = (params)=>getAction("/sys/permission/getUserPermissionByToken",params);
+const queryPermissionsByUser = ()=>getAction("/sys/permission/getUserPermissionByToken");
 const loadAllRoleIds = (params)=>getAction("/sys/permission/loadAllRoleIds",params);
 const getPermissionRuleList = (params)=>getAction("/sys/permission/getPermRuleListByPermId",params);
 const queryPermissionRule = (params)=>getAction("/sys/permission/queryPermissionRule",params);

 // 部门管理
 const queryDepartTreeList = (params)=>getAction("/sys/sysDepart/queryTreeList",params);
+const queryDepartTreeSync = (params)=>getAction("/sys/sysDepart/queryDepartTreeSync",params);
 const queryIdTree = (params)=>getAction("/sys/sysDepart/queryIdTree",params);
 const queryParentName   = (params)=>getAction("/sys/sysDepart/queryParentName",params);
 const searchByKeywords   = (params)=>getAction("/sys/sysDepart/searchBy",params);
@ -68,21 +53,15 @@ const saveDeptRolePermission = (params)=>postAction("/sys/sysDepartPermission/sa
 const queryMyDepartTreeList = (params)=>getAction("/sys/sysDepart/queryMyDeptTreeList",params);

 //日志管理
-//const getLogList = (params)=>getAction("/sys/log/list",params);
 const deleteLog = (params)=>deleteAction("/sys/log/delete",params);
 const deleteLogList = (params)=>deleteAction("/sys/log/deleteBatch",params);

 //数据字典
 const addDict = (params)=>postAction("/sys/dict/add",params);
 const editDict = (params)=>putAction("/sys/dict/edit",params);
-//const getDictList = (params)=>getAction("/sys/dict/list",params);
 const treeList = (params)=>getAction("/sys/dict/treeList",params);
-// const delDict = (params)=>deleteAction("/sys/dict/delete",params);
-//const getDictItemList = (params)=>getAction("/sys/dictItem/list",params);
 const addDictItem = (params)=>postAction("/sys/dictItem/add",params);
 const editDictItem = (params)=>putAction("/sys/dictItem/edit",params);
-//const delDictItem = (params)=>deleteAction("/sys/dictItem/delete",params);
-//const delDictItemList = (params)=>deleteAction("/sys/dictItem/deleteBatch",params);

 //字典标签专用（通过code获取字典数组）
 export const ajaxGetDictItems = (code, params)=>getAction(`/sys/dict/getDictItems/${code}`,params);
@ -90,7 +69,7 @@ export const ajaxGetDictItems = (code, params)=>getAction(`/sys/dict/getDictItem
 function getDictItemsFromCache(dictCode) {
  if (Vue.ls.get(UI_CACHE_DB_DICT_DATA) && Vue.ls.get(UI_CACHE_DB_DICT_DATA)[dictCode]) {
    let dictItems = Vue.ls.get(UI_CACHE_DB_DICT_DATA)[dictCode];
-    console.log("-----------getDictItemsFromCache----------dictCode="+dictCode+"---- dictItems=",dictItems)
+    //console.log("-----------getDictItemsFromCache----------dictCode="+dictCode+"---- dictItems=",dictItems)
    return dictItems;
  }
 }
@ -101,14 +80,10 @@ const doReovkeData = (params)=>getAction("/sys/annountCement/doReovkeData",param
 //获取系统访问量
 const getLoginfo = (params)=>getAction("/sys/loginfo",params);
 const getVisitInfo = (params)=>getAction("/sys/visitInfo",params);
-//数据日志访问
-// const getDataLogList = (params)=>getAction("/sys/dataLog/list",params);

 // 根据部门主键查询用户信息
 const queryUserByDepId = (params)=>getAction("/sys/user/queryUserByDepId",params);

-// 查询用户角色表里的所有信息
-// const queryUserRoleMap = (params)=>getAction("/sys/user/queryUserRoleMap",params);
 // 重复校验
 const duplicateCheck = (params)=>getAction("/sys/duplicate/check",params);
 // 加载分类字典
@ -151,6 +126,7 @@ export {
  getPermissionRuleList,
  queryPermissionRule,
  queryDepartTreeList,
+  queryDepartTreeSync,
  queryIdTree,
  queryParentName,
  searchByKeywords,
--- a/ant-design-vue-jeecg/src/api/login.js
+++ b/ant-design-vue-jeecg/src/api/login.js
@ -36,15 +36,15 @@ export function getSmsCaptcha(parameter) {
  })
 }

-export function getInfo() {
-  return axios({
-    url: '/api/user/info',
-    method: 'get',
-    headers: {
-      'Content-Type': 'application/json;charset=UTF-8'
-    }
-  })
-}
+// export function getInfo() {
+//   return axios({
+//     url: '/api/user/info',
+//     method: 'get',
+//     headers: {
+//       'Content-Type': 'application/json;charset=UTF-8'
+//     }
+//   })
+// }

 export function logout(logoutToken) {
  return axios({
@ -60,14 +60,28 @@ export function logout(logoutToken) {
 /**
 * 第三方登录
 * @param token
+ * @param thirdType
 * @returns {*}
 */
-export function thirdLogin(token) {
+export function thirdLogin(token,thirdType) {
  return axios({
-    url: `/thirdLogin/getLoginUser/${token}`,
+    url: `/sys/thirdLogin/getLoginUser/${token}/${thirdType}`,
    method: 'get',
    headers: {
      'Content-Type': 'application/json;charset=UTF-8'
    }
  })
+}
+
+/**
+ * 强退其他账号
+ * @param token
+ * @returns {*}
+ */
+export function forceLogout(parameter) {
+  return axios({
+    url: '/sys/online/forceLogout',
+    method: 'post',
+    data: parameter
+  })
 }
--- a/ant-design-vue-jeecg/src/api/manage.js
+++ b/ant-design-vue-jeecg/src/api/manage.js
@ -1,31 +1,42 @@
 import Vue from 'vue'
 import { axios } from '@/utils/request'
+import signMd5Utils from '@/utils/encryption/signMd5Utils'

 const api = {
-  user: '/api/user',
-  role: '/api/role',
-  service: '/api/service',
-  permission: '/api/permission',
-  permissionNoPager: '/api/permission/no-pager'
+  user: '/mock/api/user',
+  role: '/mock/api/role',
+  service: '/mock/api/service',
+  permission: '/mock/api/permission',
+  permissionNoPager: '/mock/api/permission/no-pager'
 }

 export default api

 //post
 export function postAction(url,parameter) {
+  let sign = signMd5Utils.getSign(url, parameter);
+  //将签名和时间戳，添加在请求接口 Header
+  let signHeader = {"X-Sign": sign,"X-TIMESTAMP": signMd5Utils.getDateTimeToString()};
+
  return axios({
    url: url,
    method:'post' ,
-    data: parameter
+    data: parameter,
+    headers: signHeader
  })
 }

 //post method= {post | put}
 export function httpAction(url,parameter,method) {
+  let sign = signMd5Utils.getSign(url, parameter);
+  //将签名和时间戳，添加在请求接口 Header
+  let signHeader = {"X-Sign": sign,"X-TIMESTAMP": signMd5Utils.getDateTimeToString()};
+
  return axios({
    url: url,
    method:method ,
-    data: parameter
+    data: parameter,
+    headers: signHeader
  })
 }

@ -40,10 +51,15 @@ export function putAction(url,parameter) {

 //get
 export function getAction(url,parameter) {
+  let sign = signMd5Utils.getSign(url, parameter);
+  //将签名和时间戳，添加在请求接口 Header
+  let signHeader = {"X-Sign": sign,"X-TIMESTAMP": signMd5Utils.getDateTimeToString()};
+
  return axios({
    url: url,
    method: 'get',
-    params: parameter
+    params: parameter,
+    headers: signHeader
  })
 }

--- a/ant-design-vue-jeecg/src/cas/sso.js
+++ b/ant-design-vue-jeecg/src/cas/sso.js
@ -5,21 +5,25 @@ import store from '@/store'
 * 单点登录
 */
 const init = (callback) => {
-  console.log("-------单点登录开始-------");
-  let token = Vue.ls.get(ACCESS_TOKEN);
-  let st = getUrlParam("ticket");
-  let sevice = "http://"+window.location.host+"/";
-  if(token){
-    loginSuccess(callback);
-  }else{
-    if(st){
-      validateSt(st,sevice,callback);
-    }else{
-      let serviceUrl = encodeURIComponent(sevice);
-      window.location.href = window._CONFIG['casPrefixUrl']+"/login?service="+serviceUrl;
+  if (process.env.VUE_APP_SSO == 'true') {
+    console.log("-------单点登录开始-------");
+    let token = Vue.ls.get(ACCESS_TOKEN);
+    let st = getUrlParam("ticket");
+    let sevice = "http://" + window.location.host + "/";
+    if (token) {
+      loginSuccess(callback);
+    } else {
+      if (st) {
+        validateSt(st, sevice, callback);
+      } else {
+        let serviceUrl = encodeURIComponent(sevice);
+        window.location.href = window._CONFIG['casPrefixUrl'] + "/login?service=" + serviceUrl;
+      }
    }
+    console.log("-------单点登录结束-------");
+  }else{
+    callback && callback()
  }
-  console.log("-------单点登录结束-------");
 };
 const SSO = {
  init: init
--- a/ant-design-vue-jeecg/src/components/JVxeCells/JVxeFileCell.vue
+++ b/ant-design-vue-jeecg/src/components/JVxeCells/JVxeFileCell.vue
@ -12,9 +12,9 @@
          <span style="margin-left:5px">{{ ellipsisFileName }}</span>
        </a-tooltip>

-        <a-tooltip v-else :title="file.name">
-          <a-icon type="paper-clip" style="color:red;"/>
-          <span style="color:red;margin-left:5px">{{ ellipsisFileName }}</span>
+        <a-tooltip v-else :title="file.message||'上传失败'">
+          <a-icon type="exclamation-circle" style="color:red;"/>
+          <span style="margin-left:5px">{{ ellipsisFileName }}</span>
        </a-tooltip>

        <template style="width: 30px">
@ -33,7 +33,7 @@
              <a-menu-item v-if="originColumn.allowRemove !== false" @click="handleClickDeleteFile">
                <span><a-icon type="delete"/>&nbsp;删除</span>
              </a-menu-item>
-              <a-menu-item @click="handleMoreOperation">
+              <a-menu-item @click="handleMoreOperation(originColumn)">
                <span><a-icon type="bars"/> 更多</span>
              </a-menu-item>
            </a-menu>
@ -55,7 +55,7 @@
    >
      <a-button icon="upload">{{originColumn.btnText || '上传文件'}}</a-button>
    </a-upload>
-    <j-file-pop ref="filePop" @ok="handleFileSuccess"/>
+    <j-file-pop ref="filePop" @ok="handleFileSuccess" :number="number"/>
  </div>
 </template>

@ -75,6 +75,7 @@
    data() {
      return {
        innerFile: null,
+        number:0,
      }
    },
    computed: {
@ -137,7 +138,18 @@
    methods: {

      // 点击更多按钮
-      handleMoreOperation() {
+      handleMoreOperation(originColumn) {
+        //update-begin-author:wangshuai date:20201021 for:LOWCOD-969 判断传过来的字段是否存在number，用于控制上传文件
+        if (originColumn.number) {
+          this.number = originColumn.number
+        } else {
+          this.number = 0
+        }
+        //update-end-author:wangshuai date:20201021 for:LOWCOD-969 判断传过来的字段是否存在number，用于控制上传文件
+        if(originColumn && originColumn.fieldExtendJson){
+          let json = JSON.parse(originColumn.fieldExtendJson);
+          this.number = json.uploadnum?json.uploadnum:0;
+        }
        let path = ''
        if (this.innerFile) {
          path = this.innerFile.path
@ -167,8 +179,19 @@
          value['responseName'] = file.response[this.responseName]
        }
        if (file.status === 'done') {
-          value['path'] = file.response[this.responseName]
-          this.handleChangeCommon(value)
+          if (typeof file.response.success === 'boolean') {
+            if (file.response.success) {
+              value['path'] = file.response[this.responseName]
+              this.handleChangeCommon(value)
+            } else {
+              value['status'] = 'error'
+              value['message'] = file.response.message || '未知错误'
+            }
+          } else {
+            // 考虑到如果设置action上传路径为非jeecg-boot后台，可能不会返回 success 属性的情况，就默认为成功
+            value['path'] = file.response[this.responseName]
+            this.handleChangeCommon(value)
+          }
        } else if (file.status === 'error') {
          value['message'] = file.response.message || '未知错误'
        }
@ -202,4 +225,4 @@
 </script>

 <style scoped lang="less">
-</style>
+</style>
--- a/ant-design-vue-jeecg/src/components/JVxeCells/JVxeImageCell.vue
+++ b/ant-design-vue-jeecg/src/components/JVxeCells/JVxeImageCell.vue
@ -10,20 +10,9 @@
        <template v-else-if="file['path']">
          <img class="j-editable-image" :src="imgSrc" alt="无图片" @click="handleMoreOperation"/>
        </template>
-        <template v-else>
-          <a-icon type="exclamation-circle" style="color: red;" @click="handleClickShowImageError"/>
-        </template>
-        <template slot="addonBefore" style="width: 30px">
-          <a-tooltip v-if="file.status==='uploading'" :title="`上传中(${Math.floor(file.percent)}%)`">
-            <a-icon type="loading"/>
-          </a-tooltip>
-          <a-tooltip v-else-if="file.status==='done'" title="上传完成">
-            <a-icon type="check-circle" style="color:#00DB00;"/>
-          </a-tooltip>
-          <a-tooltip v-else title="上传失败">
-            <a-icon type="exclamation-circle" style="color:red;"/>
-          </a-tooltip>
-        </template>
+        <a-tooltip v-else :title="file.message||'上传失败'" @click="handleClickShowImageError">
+          <a-icon type="exclamation-circle" style="color:red;"/>
+        </a-tooltip>

        <template style="width: 30px">
          <a-dropdown :trigger="['click']" placement="bottomRight" style="margin-left: 10px;">
@ -41,7 +30,7 @@
              <a-menu-item v-if="originColumn.allowRemove !== false" @click="handleClickDeleteFile">
                <span><a-icon type="delete"/>&nbsp;删除</span>
              </a-menu-item>
-              <a-menu-item @click="handleMoreOperation">
+              <a-menu-item @click="handleMoreOperation(originColumn)">
                <span><a-icon type="bars"/> 更多</span>
              </a-menu-item>
            </a-menu>
@ -63,7 +52,7 @@
    >
      <a-button icon="upload">{{originColumn.btnText || '上传图片'}}</a-button>
    </a-upload>
-    <j-file-pop ref="filePop" @ok="handleFileSuccess"/>
+    <j-file-pop ref="filePop" @ok="handleFileSuccess" :number="number"/>
  </div>
 </template>

@ -83,6 +72,7 @@
    data() {
      return {
        innerFile: null,
+        number:0
      }
    },
    computed: {
@ -146,7 +136,18 @@
    methods: {

      // 点击更多按钮
-      handleMoreOperation() {
+      handleMoreOperation(originColumn) {
+        //update-begin-author:wangshuai date:20201021 for:LOWCOD-969 判断传过来的字段是否存在number，用于控制上传文件
+        if (originColumn.number) {
+          this.number = originColumn.number
+        } else {
+          this.number = 0
+        }
+        //update-end-author:wangshuai date:20201021 for:LOWCOD-969 判断传过来的字段是否存在number，用于控制上传文件
+        if(originColumn && originColumn.fieldExtendJson){
+          let json = JSON.parse(originColumn.fieldExtendJson);
+          this.number = json.uploadnum?json.uploadnum:0;
+        }
        let path = ''
        if (this.innerFile) {
          path = this.innerFile.path
@ -184,8 +185,19 @@
          value['responseName'] = file.response[this.responseName]
        }
        if (file.status === 'done') {
-          value['path'] = file.response[this.responseName]
-          this.handleChangeCommon(value)
+          if (typeof file.response.success === 'boolean') {
+            if (file.response.success) {
+              value['path'] = file.response[this.responseName]
+              this.handleChangeCommon(value)
+            } else {
+              value['status'] = 'error'
+              value['message'] = file.response.message || '未知错误'
+            }
+          } else {
+            // 考虑到如果设置action上传路径为非jeecg-boot后台，可能不会返回 success 属性的情况，就默认为成功
+            value['path'] = file.response[this.responseName]
+            this.handleChangeCommon(value)
+          }
        } else if (file.status === 'error') {
          value['message'] = file.response.message || '未知错误'
        }
@ -227,4 +239,4 @@
    }

  }
-</style>
+</style>
--- a/ant-design-vue-jeecg/src/components/JVxeCells/JVxePopupCell.vue
+++ b/ant-design-vue-jeecg/src/components/JVxeCells/JVxePopupCell.vue
@ -6,7 +6,7 @@
 </template>

 <script>
-  import JVxeCellMixins, { vModel, dispatchEvent } from '@/components/jeecg/JVxeTable/mixins/JVxeCellMixins'
+  import JVxeCellMixins, { dispatchEvent, vModel } from '@/components/jeecg/JVxeTable/mixins/JVxeCellMixins'

  export default {
    name: 'JVxePopupCell',
@ -22,6 +22,8 @@
          orgFields: col.orgFields,
          destFields: col.destFields,
          groupId: caseId,
+          param: col.param,
+          sorter: col.sorter,
        }
      },
    },
@ -48,7 +50,9 @@
    // 【组件增强】注释详见：JVxeCellMixins.js
    enhanced: {
      aopEvents: {
-        editActived: event => dispatchEvent(event, 'ant-input'),
+        editActived(event) {
+          dispatchEvent.call(this, event, 'ant-input')
+        },
      },
    },
  }
--- a/ant-design-vue-jeecg/src/components/JVxeCells/JVxeSelectDictSearchCell.js
+++ b/ant-design-vue-jeecg/src/components/JVxeCells/JVxeSelectDictSearchCell.js
@ -254,7 +254,9 @@ export const DictSearchInputCell = {
  // 【组件增强】注释详见：JVxeCellMixins.js
  enhanced: {
    aopEvents: {
-      editActived: event => dispatchEvent(event, 'ant-select'),
+      editActived(event) {
+        dispatchEvent.call(this, event, 'ant-select')
+      },
    },
  }
 }
--- a/ant-design-vue-jeecg/src/components/README.md
+++ b/ant-design-vue-jeecg/src/components/README.md
@ -39,5 +39,5 @@ UserMenu.vue:首页右上侧的内容
 ![输入图片说明](https://static.oschina.net/uploads/img/201904/12201226_laQK.png "在这里输入图片标题")
 ####16.trend包 趋势显示组件（如下图）
 ![输入图片说明](https://static.oschina.net/uploads/img/201904/12201600_Wo8K.png "在这里输入图片标题")
-![corn表达式](https://oscimg.oschina.net/oscnet/661f9ac09016395f9f49286143af3241623.jpg)
-![corn控件添加清除按钮](https://oscimg.oschina.net/oscnet/15096e49f2e29bd829e304d56770025d03c.jpg)
+![cron表达式](https://oscimg.oschina.net/oscnet/661f9ac09016395f9f49286143af3241623.jpg)
+![cron控件添加清除按钮](https://oscimg.oschina.net/oscnet/15096e49f2e29bd829e304d56770025d03c.jpg)
--- a/ant-design-vue-jeecg/src/components/_util/Area.js
+++ b/ant-design-vue-jeecg/src/components/_util/Area.js
@ -1,5 +1,4 @@
-import { pcaa } from 'area-data'
-
+import Vue from 'vue'
 /**
 * 省市区
 */
@ -8,18 +7,23 @@ export default class Area {
   * 构造器
   * @param express
   */
-  constructor() {
+  constructor(pcaa) {
+    if(!pcaa){
+      pcaa = Vue.prototype.$Jpcaa;
+    }
    let arr = []
    const province = pcaa['86']
    Object.keys(province).map(key=>{
-      arr.push({id:key, text:province[key], pid:'86'});
+      arr.push({id:key, text:province[key], pid:'86', index:1});
      const city = pcaa[key];
      Object.keys(city).map(key2=>{
-        arr.push({id:key2, text:city[key2], pid:key});
+        arr.push({id:key2, text:city[key2], pid:key, index:2});
        const qu = pcaa[key2];
-        Object.keys(qu).map(key3=>{
-          arr.push({id:key3, text:qu[key3], pid:key2});
-        })
+        if(qu){
+          Object.keys(qu).map(key3=>{
+            arr.push({id:key3, text:qu[key3], pid:key2, index:3});
+          })
+        }
      })
    })
    this.all = arr;
@ -45,33 +49,35 @@ export default class Area {
      return ''
    }
    let arr = []
-    this.getAreaBycode(code,arr);
+    this.getAreaBycode(code, arr, 3);
    return arr.join('/')
  }

  getRealCode(code){
    let arr = []
-    this.getPcode(code, arr)
+    this.getPcode(code, arr, 3)
    return arr;
  }

-  getPcode(id, arr){
+  getPcode(id, arr, index){
    for(let item of this.all){
-      if(item.id === id){
+      if(item.id === id && item.index == index){
        arr.unshift(id)
        if(item.pid != '86'){
-          this.getPcode(item.pid,arr)
+          this.getPcode(item.pid, arr, --index)
        }
      }
    }
  }

-  getAreaBycode(code,arr){
-    //console.log("this.all.length",this.all)
+  getAreaBycode(code, arr, index){
    for(let item of this.all){
-      if(item.id === code){
+      if(item.id === code && item.index == index){
        arr.unshift(item.text);
-        this.getAreaBycode(item.pid,arr)
+        if(item.pid != '86'){
+          this.getAreaBycode(item.pid, arr, --index)
+        }
+
      }
    }
  }
--- a/ant-design-vue-jeecg/src/components/_util/StringUtil.js
+++ b/ant-design-vue-jeecg/src/components/_util/StringUtil.js
@ -32,4 +32,15 @@ export const cutStrByFullLength = (str = '', maxLength) => {
    }
    return pre
  }, '')
+}
+
+// 下划线转换驼峰
+export function underLinetoHump(name) {
+  return name.replace(/\_(\w)/g, function(all, letter){
+    return letter.toUpperCase();
+  });
+}
+// 驼峰转换下划线
+export function humptoUnderLine(name) {
+  return name.replace(/([A-Z])/g,"_$1").toLowerCase();
 }
--- a/ant-design-vue-jeecg/src/components/dict/JDictSelectTag.vue
+++ b/ant-design-vue-jeecg/src/components/dict/JDictSelectTag.vue
@ -25,7 +25,6 @@
    props: {
      dictCode: String,
      placeholder: String,
-      triggerChange: Boolean,
      disabled: Boolean,
      value: [String, Number],
      type: String,
@ -82,19 +81,15 @@
          }
        })
      },
-      handleInput(e) {
+      handleInput(e='') {
        let val;
-        if(this.tagType=="radio"){
+        if(Object.keys(e).includes('target')){
          val = e.target.value
        }else{
          val = e
        }
        console.log(val);
-        if(this.triggerChange){
-          this.$emit('change', val);
-        }else{
-          this.$emit('input', val);
-        }
+        this.$emit('change', val);
      },
      setCurrentDictOptions(dictOptions){
        this.dictOptions = dictOptions
@ -102,6 +97,10 @@
      getCurrentDictOptions(){
        return this.dictOptions
      }
+    },
+    model:{
+      prop: 'value',
+      event: 'change'
    }
  }
 </script>
--- a/ant-design-vue-jeecg/src/components/dict/JMultiSelectTag.vue
+++ b/ant-design-vue-jeecg/src/components/dict/JMultiSelectTag.vue
@ -10,7 +10,9 @@
    :disabled="disabled"
    mode="multiple"
    :placeholder="placeholder"
-    :getPopupContainer="(node) => node.parentNode"
+    :getPopupContainer="getParentContainer"
+    optionFilterProp="children"
+    :filterOption="filterOption"
    allowClear>
    <a-select-option
      v-for="(item,index) in dictOptions"
@ -34,13 +36,23 @@
      disabled: Boolean,
      value: String,
      type: String,
-      options:Array
+      options:Array,
+      spliter:{
+        type: String,
+        required: false,
+        default: ','
+      },
+      popContainer:{
+        type:String,
+        default:'',
+        required:false
+      },
    },
    data() {
      return {
        dictOptions: [],
        tagType:"",
-        arrayValue:!this.value?[]:this.value.split(",")
+        arrayValue:!this.value?[]:this.value.split(this.spliter)
      }
    },
    created() {
@ -66,7 +78,7 @@
        if(!val){
          this.arrayValue = []
        }else{
-          this.arrayValue = this.value.split(",")
+          this.arrayValue = this.value.split(this.spliter)
        }
      }
    },
@ -76,8 +88,9 @@
          this.dictOptions = [...this.options]
        }else{
          //优先从缓存中读取字典配置
-          if(getDictItemsFromCache(this.dictCode)){
-            this.dictOptions = getDictItemsFromCache(this.dictCode);
+          let cacheOption = getDictItemsFromCache(this.dictCode)
+          if(cacheOption && cacheOption.length>0){
+            this.dictOptions = cacheOption
            return
          }
          //根据字典Code, 初始化字典数组
@ -90,14 +103,26 @@

      },
      onChange (selectedValue) {
-        this.$emit('change', selectedValue.join(","));
+        this.$emit('change', selectedValue.join(this.spliter));
      },
      setCurrentDictOptions(dictOptions){
        this.dictOptions = dictOptions
      },
      getCurrentDictOptions(){
        return this.dictOptions
+      },
+      getParentContainer(node){
+        if(!this.popContainer){
+          return node.parentNode
+        }else{
+          return document.querySelector(this.popContainer)
+        }
+      },
+      // update--begin--autor:lvdandan-----date:20201120------for：LOWCOD-1086 下拉多选框,搜索时只字典code进行搜索不能通过字典text搜索
+      filterOption(input, option) {
+        return option.componentOptions.children[0].children[0].text.toLowerCase().indexOf(input.toLowerCase()) >= 0
      }
+      // update--end--autor:lvdandan-----date:20201120------for：LOWCOD-1086 下拉多选框,搜索时只字典code进行搜索不能通过字典text搜索
    },
    model: {
      prop: 'value',
--- a/ant-design-vue-jeecg/src/components/dict/JSearchSelectTag.vue
+++ b/ant-design-vue-jeecg/src/components/dict/JSearchSelectTag.vue
@ -5,7 +5,7 @@
    showSearch
    labelInValue
    :disabled="disabled"
-    :getPopupContainer="(node) => node.parentNode"
+    :getPopupContainer="getParentContainer"
    @search="loadData"
    :placeholder="placeholder"
    v-model="selectedAsyncValue"
@ -21,7 +21,7 @@

  <a-select
    v-else
-    :getPopupContainer="(node) => node.parentNode"
+    :getPopupContainer="getParentContainer"
    showSearch
    :disabled="disabled"
    :placeholder="placeholder"
@ -48,14 +48,32 @@
    props:{
      disabled: Boolean,
      value: [String, Number],
-      dict: String,
      dictOptions: Array,
      async: Boolean,
      placeholder:{
        type:String,
        default:"请选择",
        required:false
-      }
+      },
+      dict:{
+        type: String,
+        default: '',
+        required: false
+      },
+      popContainer:{
+        type:String,
+        default:'',
+        required:false
+      },
+      pageSize:{
+        type: Number,
+        default: 10,
+        required: false
+      },
+      getPopupContainer: {
+        type:Function,
+        default: null
+      },
    },
    data(){
      this.loadData = debounce(this.loadData, 800);//消抖
@ -126,7 +144,7 @@
        this.options = []
        this.loading=true
        // 字典code格式：table,text,code
-        getAction(`/sys/dict/loadDict/${this.dict}`,{keyword:value}).then(res=>{
+        getAction(`/sys/dict/loadDict/${this.dict}`,{keyword:value, pageSize: this.pageSize}).then(res=>{
          this.loading=false
          if(res.success){
            if(currentLoad!=this.lastLoad){
@ -171,6 +189,21 @@
                })
            }
          }
+        }else{
+          if(!this.dict){
+            console.error('搜索组件未配置字典项')
+          }else{
+            //异步一开始也加载一点数据
+            this.loading=true
+            getAction(`/sys/dict/loadDict/${this.dict}`,{pageSize: this.pageSize, keyword:''}).then(res=>{
+              this.loading=false
+              if(res.success){
+                this.options = res.result
+              }else{
+                this.$message.warning(res.message)
+              }
+            })
+          }
        }
      },
      filterOption(input, option) {
@ -182,9 +215,18 @@
        this.callback()
      },
      handleAsyncChange(selectedObj){
-        this.selectedAsyncValue = selectedObj
-        this.selectedValue = selectedObj.key
+        //update-begin-author:scott date:20201222 for:【搜索】搜索查询组件，删除条件，默认下拉还是上次的缓存数据，不好 JT-191
+        if(selectedObj){
+          this.selectedAsyncValue = selectedObj
+          this.selectedValue = selectedObj.key
+        }else{
+          this.selectedAsyncValue = null
+          this.selectedValue = null
+          this.options = null
+          this.loadData("")
+        }
        this.callback()
+        //update-end-author:scott date:20201222 for:【搜索】搜索查询组件，删除条件，默认下拉还是上次的缓存数据，不好 JT-191
      },
      callback(){
        this.$emit('change', this.selectedValue);
@ -194,7 +236,16 @@
      },
      getCurrentDictOptions(){
        return this.options
-      }
+      },
+      getParentContainer(node){
+        if(typeof this.getPopupContainer === 'function'){
+          return this.getPopupContainer(node)
+        } else if(!this.popContainer){
+          return node.parentNode
+        }else{
+          return document.querySelector(this.popContainer)
+        }
+      },

    },
    model: {
--- a/ant-design-vue-jeecg/src/components/dict/index.js
+++ b/ant-design-vue-jeecg/src/components/dict/index.js
@ -1,7 +1,16 @@
-import T from './JDictSelectTag.vue'
-const JDictSelectTag = {
+import JDictSelectTag from './JDictSelectTag.vue'
+import JMultiSelectTag from './JMultiSelectTag.vue'
+import JSearchSelectTag from './JSearchSelectTag.vue'
+import { filterMultiDictText,filterDictText,initDictOptions,filterDictTextByCache } from './JDictSelectUtil'
+
+export default {
  install: function (Vue) {
-    Vue.component('JDictSelectTag',T);
+    Vue.component('JDictSelectTag',JDictSelectTag);
+    Vue.component('JMultiSelectTag',JMultiSelectTag);
+    Vue.component('JSearchSelectTag',JSearchSelectTag);
+    Vue.prototype.$initDictOptions = (dictCode) => initDictOptions(dictCode)
+    Vue.prototype.$filterMultiDictText = (dictOptions, text) => filterMultiDictText(dictOptions, text)
+    Vue.prototype.$filterDictText = (dictOptions, text) => filterDictText(dictOptions, text)
+    Vue.prototype.$filterDictTextByCache = (...param) => filterDictTextByCache(...param)
  }
-}
-export default JDictSelectTag;
+}
--- a/ant-design-vue-jeecg/src/components/jeecg/JAreaLinkage.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JAreaLinkage.vue
@ -29,7 +29,6 @@
 </template>

 <script>
-  import { pcaa } from 'area-data'
  import Area from '@/components/_util/Area'

  export default {
@ -53,7 +52,7 @@
    },
    data() {
      return {
-        pcaa,
+        pcaa: this.$Jpcaa,
        innerValue: [],
        usedListeners: ['change'],
        enums: {
@ -114,7 +113,7 @@
      /** 通过地区code获取子级 */
      loadDataByCode(value) {
        let options = []
-        let data = pcaa[value]
+        let data = this.pcaa[value]
        if (data) {
          for (let key in data) {
            if (data.hasOwnProperty(key)) {
@ -139,7 +138,7 @@
      },
      initAreaData(){
        if(!this.areaData){
-          this.areaData = new Area();
+          this.areaData = new Area(this.$Jpcaa);
        }
      },

--- a/ant-design-vue-jeecg/src/components/jeecg/JCodeEditor.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JCodeEditor.vue
@ -251,6 +251,9 @@
          },
          style: {}
        }
+        if(isIE() || isIE11()){
+          props.style['height'] = '240px'
+        }
        if (this.fullCoder) {
          props.style['z-index'] = this.zIndex
        }
@ -397,6 +400,10 @@
    .null-tip-hidden{
      display: none;
    }
+    /**选中样式偶然出现高度不够的情况*/
+    .CodeMirror-selected{
+      min-height: 19px !important;
+    }
  }

  /* 全屏样式 */
--- a/ant-design-vue-jeecg/src/components/jeecg/JCodeEditor2.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JCodeEditor2.vue
@ -1,282 +0,0 @@
-<template>
-  <div v-bind="fullScreenParentProps">
-    <a-icon v-if="fullScreen" class="full-screen-icon" :type="iconType" @click="()=>fullCoder=!fullCoder"/>
-
-    <div class="code-editor-cust full-screen-child">
-      <a-textarea auto-size v-model="textareaValue" :placeholder="placeholderShow" @change="handleChange" :style="{'max-height': maxHeight+'px','min-height': minHeight+'px'}"></a-textarea>
-    </div>
-  </div>
-</template>
-
-<script type="text/ecmascript-6">
-  export default {
-    name: 'JCodeEditor',
-    props: {
-      value: {
-        type: String,
-        default: ''
-      },
-      placeholder: {
-        type: String,
-        default: null
-      },
-      // 是否显示全屏按钮
-      fullScreen: {
-        type: Boolean,
-        default: false
-      },
-      // 全屏以后的z-index
-      zIndex: {
-        type: [Number, String],
-        default: 999
-      },
-      // 是否自适应高度，可以传String或Boolean
-      // 传 String 类型只能写"!ie" ，
-      // 填写这个字符串，代表其他浏览器自适应高度
-      // 唯独IE下不自适应高度，因为IE下不支持min、max-height样式
-      // 如果填写的不是"!ie"就视为true
-      autoHeight: {
-        type: [String, Boolean],
-        default: true
-      },
-      // 不自适应高度的情况下生效的固定高度
-      height: {
-        type: [String, Number],
-        default: '240px'
-      },
-      language: {
-        type: String,
-        default: ''
-      },
-      minHeight:{
-        type:Number,
-        default: 100,
-        required:false
-      },
-      maxHeight:{
-        type:Number,
-        default: 320,
-        required:false
-      }
-    },
-    data () {
-      return {
-        textareaValue: '',
-        // 内部真实的内容
-        code: '',
-        iconType: 'fullscreen',
-        hasCode:false,
-        // 默认的语法类型
-        mode: 'javascript',
-        // 编辑器实例
-        coder: null,
-        // 默认配置
-        options: {
-          // 缩进格式
-          tabSize: 2,
-          // 主题，对应主题库 JS 需要提前引入
-          theme: 'panda-syntax',
-          line: true,
-          // extraKeys: {'Ctrl': 'autocomplete'},//自定义快捷键
-          hintOptions: {
-            tables: {
-              users: ['name', 'score', 'birthDate'],
-              countries: ['name', 'population', 'size']
-            }
-          },
-        },
-
-        // code 编辑器 是否全屏
-        fullCoder: false
-      }
-    },
-    watch: {
-      fullCoder:{
-        handler(value) {
-          if(value){
-            this.iconType="fullscreen-exit"
-          }else{
-            this.iconType="fullscreen"
-          }
-        }
-      }
-    },
-    computed: {
-      placeholderShow() {
-        if (this.placeholder == null) {
-          return `请在此输入代码`
-        } else {
-          return this.placeholder
-        }
-      },
-      isAutoHeight() {
-        let {autoHeight} = this
-        if (typeof autoHeight === 'string' && autoHeight.toLowerCase().trim() === '!ie') {
-          autoHeight = !(isIE() || isIE11())
-        } else {
-          autoHeight = true
-        }
-        return autoHeight
-      },
-      fullScreenParentProps() {
-        let props = {
-          class: {
-            'full-screen-parent': true,
-            'full-screen': this.fullCoder,
-            'auto-height': this.isAutoHeight
-          },
-          style: {}
-        }
-        if (this.fullCoder) {
-          props.style['z-index'] = this.zIndex
-        }
-        if (!this.isAutoHeight) {
-          props.style['height'] = (typeof this.height === 'number' ? this.height + 'px' : this.height)
-        }
-        return props
-      }
-    },
-    mounted () {
-      // 初始化
-      this._initialize()
-    },
-    methods: {
-      // 初始化
-      _initialize () {
-        this.setCodeContent(this.value)
-      },
-      handleChange(e){
-        this.$emit('input', e.target.value)
-      },
-      getCodeContent(){
-        return this.value
-      },
-      setCodeContent(val){
-        setTimeout(()=>{
-          if(!val){
-            this.textareaValue = ''
-          }else{
-            this.textareaValue = val
-          }
-        },300)
-      },
-      nullTipClick(){
-        this.coder.focus()
-      }
-    }
-  }
-</script>
-
-<style lang="less">
-  .code-editor-cust{
-    flex-grow:1;
-    display:flex;
-    position:relative;
-    height:100%;
-    .CodeMirror{
-      flex-grow:1;
-      z-index:1;
-      .CodeMirror-code{
-        line-height:19px;
-      }
-
-    }
-    .code-mode-select{
-      position:absolute;
-      z-index:2;
-      right:10px;
-      top:10px;
-      max-width:130px;
-    }
-    .CodeMirror{
-      height: auto;
-      min-height:100%;
-    }
-    .null-tip{
-      position: absolute;
-      top: 4px;
-      left: 36px;
-      z-index: 10;
-      color: #ffffffc9;
-      line-height: initial;
-    }
-    .null-tip-hidden{
-      display: none;
-    }
-  }
-
-  /* 全屏样式 */
-  .full-screen-parent {
-    position: relative;
-
-    .full-screen-icon {
-      opacity: 0;
-      color: black;
-      width: 20px;
-      height: 20px;
-      line-height: 24px;
-      background-color: white;
-      position: absolute;
-      top: 2px;
-      right: 2px;
-      z-index: 9;
-      cursor: pointer;
-      transition: opacity 0.3s;
-    }
-
-    &:hover {
-      .full-screen-icon {
-        opacity: 1;
-
-        &:hover {
-          background-color: rgba(255, 255, 255, 0.88);
-        }
-      }
-    }
-
-    &.full-screen {
-      position: fixed;
-      top: 10px;
-      left: 10px;
-      width: calc(100% - 20px);
-      height: calc(100% - 20px);
-      padding: 10px;
-      background-color: #f5f5f5;
-
-      .full-screen-icon {
-        top: 12px;
-        right: 12px;
-      }
-
-      .full-screen-child {
-        height: 100%;
-        max-height: 100%;
-        min-height: 100%;
-      }
-    }
-
-    .full-screen-child {
-      height: 100%;
-    }
-
-    &.auto-height {
-      .full-screen-child {
-        min-height: 120px;
-        max-height: 320px;
-        height: unset;
-        overflow: hidden;
-      }
-
-      &.full-screen .full-screen-child {
-        height: 100%;
-        max-height: 100%;
-        min-height: 100%;
-      }
-    }
-
-  }
-
-  .CodeMirror-cursor{
-    height:18.4px !important;
-  }
-</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JCron.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JCron.vue
@ -1,7 +1,7 @@
 <template>
  <div class="components-input-demo-presuffix">
-    <a-input @click="openModal" placeholder="corn表达式" v-model="cron" @change="handleOK">
-      <a-icon slot="prefix" type="schedule" title="corn控件"/>
+    <a-input @click="openModal" placeholder="cron表达式" v-model="cron" @change="(e)=>handleOK(e.target.value)">
+      <a-icon slot="prefix" type="schedule" title="cron控件"/>
      <a-icon v-if="cron" slot="suffix" type="close-circle" @click="handleEmpty" title="清空"/>
    </a-input>
    <JCronModal ref="innerVueCron" :data="cron" @ok="handleOK"></JCronModal>
--- a/ant-design-vue-jeecg/src/components/jeecg/JDate.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JDate.vue
@ -8,7 +8,7 @@
    :showTime="showTime"
    :format="dateFormat"
    :getCalendarContainer="getCalendarContainer"
-  />
+    v-bind="$attrs"/>
 </template>
 <script>
  import moment from 'moment'
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/EasyCron.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/EasyCron.vue
@ -0,0 +1,281 @@
+<template>
+  <div class="j-easy-cron">
+    <div class="content">
+      <div>
+        <a-tabs size="small" v-model="curtab">
+          <a-tab-pane tab="秒" key="second" v-if="!hideSecond">
+            <second-ui v-model="second" :disabled="disabled"></second-ui>
+          </a-tab-pane>
+          <a-tab-pane tab="分" key="minute">
+            <minute-ui v-model="minute" :disabled="disabled"></minute-ui>
+          </a-tab-pane>
+          <a-tab-pane tab="时" key="hour">
+            <hour-ui v-model="hour" :disabled="disabled"></hour-ui>
+          </a-tab-pane>
+          <a-tab-pane tab="日" key="day">
+            <day-ui v-model="day" :week="week" :disabled="disabled"></day-ui>
+          </a-tab-pane>
+          <a-tab-pane tab="月" key="month">
+            <month-ui v-model="month" :disabled="disabled"></month-ui>
+          </a-tab-pane>
+          <a-tab-pane tab="周" key="week">
+            <week-ui v-model="week" :day="day" :disabled="disabled"></week-ui>
+          </a-tab-pane>
+          <a-tab-pane tab="年" key="year" v-if="!hideYear && !hideSecond">
+            <year-ui v-model="year" :disabled="disabled"></year-ui>
+          </a-tab-pane>
+        </a-tabs>
+      </div>
+      <a-divider/>
+      <!-- 执行时间预览 -->
+      <a-row :gutter="8">
+        <a-col :span="18" style="margin-top: 22px;">
+          <a-row :gutter="8">
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="秒" v-model="inputValues.second" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="分" v-model="inputValues.minute" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="时" v-model="inputValues.hour" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="日" v-model="inputValues.day" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="月" v-model="inputValues.month" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="周" v-model="inputValues.week" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="8" style="margin-bottom: 8px;">
+              <a-input addon-before="年" v-model="inputValues.year" @blur="onInputBlur"/>
+            </a-col>
+            <a-col :span="16" style="margin-bottom: 8px;">
+              <a-input addon-before="Cron" v-model="inputValues.cron" @blur="onInputCronBlur"/>
+            </a-col>
+          </a-row>
+        </a-col>
+        <a-col :span="6">
+
+          <div>近十次执行时间（不含年）</div>
+          <a-textarea type="textarea" :value="preTimeList" :rows="5"/>
+        </a-col>
+      </a-row>
+    </div>
+  </div>
+</template>
+
+<script>
+import SecondUi from './tabs/second'
+import MinuteUi from './tabs/minute'
+import HourUi from './tabs/hour'
+import DayUi from './tabs/day'
+import WeekUi from './tabs/week'
+import MonthUi from './tabs/month'
+import YearUi from './tabs/year'
+import CronParser from 'cron-parser'
+import dateFormat from './format-date'
+import { simpleDebounce } from '@/utils/util'
+import ACol from 'ant-design-vue/es/grid/Col'
+
+export default {
+  name: 'easy-cron',
+  components: {
+    ACol,
+    SecondUi,
+    MinuteUi,
+    HourUi,
+    DayUi,
+    WeekUi,
+    MonthUi,
+    YearUi
+  },
+  props: {
+    cronValue: {
+      type: String,
+      default: ''
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    hideSecond: {
+      type: Boolean,
+      default: false
+    },
+    hideYear: {
+      type: Boolean,
+      default: false
+    },
+    remote: {
+      type: Function,
+      default: null
+    }
+  },
+  data() {
+    return {
+      curtab: this.hideSecond ? 'minute' : 'second',
+      second: '*',
+      minute: '*',
+      hour: '*',
+      day: '*',
+      month: '*',
+      week: '?',
+      year: '*',
+      inputValues: {second: '', minute: '', hour: '', day: '', month: '', week: '', year: '', cron: ''},
+      preTimeList: '执行预览，会忽略年份参数',
+    }
+  },
+  computed: {
+    cronValue_c() {
+      let result = []
+      if (!this.hideSecond) result.push(this.second ? this.second : '*')
+      result.push(this.minute ? this.minute : '*')
+      result.push(this.hour ? this.hour : '*')
+      result.push(this.day ? this.day : '*')
+      result.push(this.month ? this.month : '*')
+      result.push(this.week ? this.week : '?')
+      if (!this.hideYear && !this.hideSecond) result.push(this.year ? this.year : '*')
+      return result.join(' ')
+    },
+    cronValue_c2() {
+      const v = this.cronValue_c
+      if (this.hideYear || this.hideSecond) return v
+      const vs = v.split(' ')
+      return vs.slice(0, vs.length - 1).join(' ')
+    }
+  },
+  watch: {
+    cronValue(newVal, oldVal) {
+      if (newVal === this.cronValue_c) {
+        // console.info('same cron value: ' + newVal)
+        return
+      }
+      this.formatValue()
+    },
+    cronValue_c(newVal, oldVal) {
+      this.calTriggerList()
+      this.$emit('change', newVal)
+      this.assignInput()
+    },
+    minute() {
+      if (this.second === '*') {
+        this.second = '0'
+      }
+    },
+    hour() {
+      if (this.minute === '*') {
+        this.minute = '0'
+      }
+    },
+    day(day) {
+      if (day !== '?' && this.hour === '*') {
+        this.hour = '0'
+      }
+    },
+    week(week) {
+      if (week !== '?' && this.hour === '*') {
+        this.hour = '0'
+      }
+    },
+    month() {
+      if (this.day === '?' && this.week === '*') {
+        this.week = '1'
+      } else if (this.week === '?' && this.day === '*') {
+        this.day = '1'
+      }
+    },
+    year() {
+      if (this.month === '*') {
+        this.month = '1'
+      }
+    },
+  },
+  created() {
+    this.formatValue()
+    this.$nextTick(() => {
+      this.calTriggerListInner()
+    })
+  },
+  methods: {
+    assignInput() {
+      Object.assign(this.inputValues, {
+        second: this.second,
+        minute: this.minute,
+        hour: this.hour,
+        day: this.day,
+        month: this.month,
+        week: this.week,
+        year: this.year,
+        cron: this.cronValue_c,
+      })
+    },
+    formatValue() {
+      if (!this.cronValue) return
+      const values = this.cronValue.split(' ').filter(item => !!item)
+      if (!values || values.length <= 0) return
+      let i = 0
+      if (!this.hideSecond) this.second = values[i++]
+      if (values.length > i) this.minute = values[i++]
+      if (values.length > i) this.hour = values[i++]
+      if (values.length > i) this.day = values[i++]
+      if (values.length > i) this.month = values[i++]
+      if (values.length > i) this.week = values[i++]
+      if (values.length > i) this.year = values[i]
+      this.assignInput()
+    },
+    calTriggerList: simpleDebounce(function () {
+      this.calTriggerListInner()
+    }, 500),
+    calTriggerListInner() {
+      // 设置了回调函数
+      if (this.remote) {
+        this.remote(this.cronValue_c, +new Date(), v => {
+          this.preTimeList = v
+        })
+        return
+      }
+      const format = 'yyyy-MM-dd hh:mm:ss'
+      const options = {
+        currentDate: dateFormat(new Date(), format)
+      }
+      const iter = CronParser.parseExpression(this.cronValue_c2, options)
+      const result = []
+      for (let i = 1; i <= 10; i++) {
+        result.push(dateFormat(new Date(iter.next()), format))
+      }
+      this.preTimeList = result.length > 0 ? result.join('\n') : '无执行时间'
+    },
+    onInputBlur(){
+      this.second = this.inputValues.second
+      this.minute = this.inputValues.minute
+      this.hour = this.inputValues.hour
+      this.day = this.inputValues.day
+      this.month = this.inputValues.month
+      this.week = this.inputValues.week
+      this.year = this.inputValues.year
+    },
+    onInputCronBlur(event){
+      this.$emit('change', event.target.value)
+    },
+  },
+  model: {
+    prop: 'cronValue',
+    event: 'change'
+  },
+}
+</script>
+
+<style scoped lang="less">
+  .j-easy-cron {
+
+    /deep/ .content {
+      .ant-checkbox-wrapper + .ant-checkbox-wrapper {
+        margin-left: 0;
+      }
+    }
+
+  }
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/InputCron.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/InputCron.vue
@ -0,0 +1,99 @@
+<template>
+  <div class="input-cron">
+    <a-input :placeholder="placeholder" v-model="editCronValue" :disabled="disabled">
+      <a slot="addonAfter" @click="showConfigDlg" class="config-btn" :disabled="disabled">
+        <a-icon type="setting"></a-icon>
+        选择
+      </a>
+    </a-input>
+    <j-modal :visible.sync="show" title="Cron表达式" width="800px">
+      <easy-cron
+        v-model="editCronValue"
+        :exeStartTime="exeStartTime"
+        :hideYear="hideYear"
+        :remote="remote"
+        :hideSecond="hideSecond"
+        style="width: 100%"
+      ></easy-cron>
+    </j-modal>
+  </div>
+</template>
+
+<script>
+import EasyCron from './EasyCron.vue'
+
+export default {
+  name: 'input-cron',
+  components: {EasyCron},
+  model: {
+    prop: 'cronValue',
+    event: 'change'
+  },
+  props: {
+    cronValue: {
+      type: String,
+      default: ''
+    },
+    width: {
+      type: String,
+      default: '800px'
+    },
+    placeholder: {
+      type: String,
+      default: '请输入cron表达式'
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    exeStartTime: {
+      type: [Number, String, Object],
+      default: 0
+    },
+    hideSecond: {
+      type: Boolean,
+      default: false
+    },
+    hideYear: {
+      type: Boolean,
+      default: false
+    },
+    remote: {
+      type: Function,
+      default: null
+    }
+  },
+  data() {
+    return {
+      editCronValue: this.cronValue,
+      show: false,
+    }
+  },
+  watch: {
+    cronValue(newVal, oldVal) {
+      if (newVal === this.editCronValue) {
+        return
+      }
+      this.editCronValue = newVal
+    },
+    editCronValue(newVal, oldVal) {
+      this.$emit('change', newVal)
+    }
+  },
+  methods: {
+    showConfigDlg() {
+      if (!this.disabled) {
+        this.show = true
+      }
+    }
+  }
+}
+</script>
+
+<style scoped>
+
+  .config-btn {
+    cursor: pointer;
+  }
+
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/format-date.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/format-date.js
@ -0,0 +1,37 @@
+const dateFormat = (date, block) => {
+  if (!date) {
+    return ''
+  }
+
+  let format = block || 'yyyy-MM-dd'
+
+  date = new Date(date)
+
+  const map = {
+    M: date.getMonth() + 1, // 月份
+    d: date.getDate(), // 日
+    h: date.getHours(), // 小时
+    m: date.getMinutes(), // 分
+    s: date.getSeconds(), // 秒
+    q: Math.floor((date.getMonth() + 3) / 3), // 季度
+    S: date.getMilliseconds() // 毫秒
+  }
+
+  format = format.replace(/([yMdhmsqS])+/g, (all, t) => {
+    let v = map[t]
+    if (v !== undefined) {
+      if (all.length > 1) {
+        v = `0${v}`
+        v = v.substr(v.length - 2)
+      }
+      return v
+    } else if (t === 'y') {
+      return (date.getFullYear().toString()).substr(4 - all.length)
+    }
+    return all
+  })
+
+  return format
+}
+
+export default dateFormat
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/index.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/index.js
@ -0,0 +1,6 @@
+// 原开源项目地址：https://gitee.com/toktok/easy-cron
+
+import InputCron from './InputCron.vue'
+
+InputCron.name = 'JEasyCron'
+export default InputCron
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/const.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/const.js
@ -0,0 +1,21 @@
+export const WEEK_MAP_EN = {
+  'SUN': '0',
+  'MON': '1',
+  'TUE': '2',
+  'WED': '3',
+  'THU': '4',
+  'FRI': '5',
+  'SAT': '6'
+}
+
+export const replaceWeekName = (c) => {
+  // console.info('after: ' + c)
+  if (c) {
+    Object.keys(WEEK_MAP_EN).forEach(k => {
+      c = c.replace(new RegExp(k, 'g'), WEEK_MAP_EN[k])
+    })
+    c = c.replace(new RegExp('7', 'g'), '0')
+  }
+  // console.info('after: ' + c)
+  return c
+}
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/day.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/day.vue
@ -0,0 +1,101 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_NOT_SET" class="choice" :disabled="disableChoice">不设置</a-radio>
+        <span class="tip-info">日和周只能设置其中之一</span>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_EVERY" class="choice" :disabled="disableChoice">每日</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disableChoice">区间</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_RANGE || disableChoice" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.start"/>
+        日
+        至
+        <a-input-number :disabled="type!==TYPE_RANGE || disableChoice" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.end"/>
+        日
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disableChoice">循环</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_LOOP || disableChoice" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.start"/>
+        日开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disableChoice" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        日
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_WORK" class="choice" :disabled="disableChoice">工作日</a-radio>
+        本月
+        <a-input-number :disabled="type!==TYPE_WORK || disableChoice" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueWork"/>
+        日，最近的工作日
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LAST" class="choice" :disabled="disableChoice">最后一日</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_SPECIFY" class="choice" :disabled="disableChoice">指定</a-radio>
+        <div class="list">
+          <a-checkbox-group v-model="valueList">
+            <template v-for="i of specifyRange">
+              <a-checkbox class="list-check-item" :key="`key-${i}`" :value="i" :disabled="type!==TYPE_SPECIFY || disabled">{{i}}</a-checkbox>
+            </template>
+          </a-checkbox-group>
+        </div>
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+
+export default {
+  name: 'day',
+  mixins: [mixin],
+  props: {
+    week: {
+      type: String,
+      default: '?'
+    }
+  },
+  data() {
+    return {}
+  },
+  computed: {
+    disableChoice() {
+      return (this.week && this.week !== '?') || this.disabled
+    }
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      // 数值变化
+      this.updateValue()
+    },
+    week(newVal, oldVal) {
+      // console.info('new week: ' + newVal)
+      this.updateValue()
+    }
+  },
+  methods: {
+    updateValue() {
+      this.$emit('change', this.disableChoice ? '?' : this.value_c)
+    }
+  },
+  created() {
+    this.DEFAULT_VALUE = '*'
+    this.minValue = 1
+    this.maxValue = 31
+    this.valueRange.start = 1
+    this.valueRange.end = 31
+    this.valueLoop.start = 1
+    this.valueLoop.interval = 1
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/hour.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/hour.vue
@ -0,0 +1,67 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_EVERY" class="choice" :disabled="disabled">每时</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disabled">区间</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.start"/>
+        时
+        至
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.end"/>
+        时
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disabled">循环</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.start"/>
+        时开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        时
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_SPECIFY" class="choice" :disabled="disabled">指定</a-radio>
+        <div class="list">
+          <a-checkbox-group v-model="valueList">
+            <template v-for="i in specifyRange">
+              <a-checkbox class="list-check-item" :key="`key-${i}`" :value="i" :disabled="type!==TYPE_SPECIFY || disabled">{{i}}</a-checkbox>
+            </template>
+          </a-checkbox-group>
+        </div>
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+
+export default {
+  name: 'minute',
+  mixins: [mixin],
+  data() {
+    return {}
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      this.$emit('change', newVal)
+    }
+  },
+  created() {
+    this.DEFAULT_VALUE = '*'
+    this.minValue = 0
+    this.maxValue = 23
+    this.valueRange.start = 0
+    this.valueRange.end = 23
+    this.valueLoop.start = 0
+    this.valueLoop.interval = 1
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/minute.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/minute.vue
@ -0,0 +1,67 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_EVERY" class="choice" :disabled="disabled">每分</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disabled">区间</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.start"/>
+        分
+        至
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.end"/>
+        分
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disabled">循环</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.start"/>
+        分开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        分
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_SPECIFY" class="choice" :disabled="disabled">指定</a-radio>
+        <div class="list">
+          <a-checkbox-group v-model="valueList">
+            <template v-for="i in specifyRange">
+              <a-checkbox class="list-check-item" :key="`key-${i}`" :value="i" :disabled="type!==TYPE_SPECIFY || disabled">{{i}}</a-checkbox>
+            </template>
+          </a-checkbox-group>
+        </div>
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+
+export default {
+  name: 'minute',
+  mixins: [mixin],
+  data() {
+    return {}
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      this.$emit('change', newVal)
+    }
+  },
+  created() {
+    this.DEFAULT_VALUE = '*'
+    this.minValue = 0
+    this.maxValue = 59
+    this.valueRange.start = 0
+    this.valueRange.end = 59
+    this.valueLoop.start = 0
+    this.valueLoop.interval = 1
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/mixin.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/mixin.js
@ -0,0 +1,162 @@
+// 主要用于日和星期的互斥使用
+const TYPE_NOT_SET = 'TYPE_NOT_SET'
+const TYPE_EVERY = 'TYPE_EVERY'
+const TYPE_RANGE = 'TYPE_RANGE'
+const TYPE_LOOP = 'TYPE_LOOP'
+const TYPE_WORK = 'TYPE_WORK'
+const TYPE_LAST = 'TYPE_LAST'
+const TYPE_SPECIFY = 'TYPE_SPECIFY'
+
+const DEFAULT_VALUE = '?'
+
+export default {
+  model: {
+    prop: 'prop',
+    event: 'change'
+  },
+  props: {
+    prop: {
+      type: String,
+      default: DEFAULT_VALUE
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    }
+  },
+  data () {
+    const type = TYPE_EVERY
+    return {
+      DEFAULT_VALUE,
+      // 类型
+      type,
+      // 启用日或者星期互斥用
+      TYPE_NOT_SET,
+      TYPE_EVERY,
+      TYPE_RANGE,
+      TYPE_LOOP,
+      TYPE_WORK,
+      TYPE_LAST,
+      TYPE_SPECIFY,
+      // 对于不同的类型，所定义的值也有所不同
+      valueRange: {
+        start: 0,
+        end: 0
+      },
+      valueLoop: {
+        start: 0,
+        interval: 1
+      },
+      valueWeek: {
+        start: 0,
+        end: 0
+      },
+      valueList: [],
+      valueWork: 1,
+      maxValue: 0,
+      minValue: 0
+    }
+  },
+  watch: {
+    prop (newVal, oldVal) {
+      if (newVal === this.value_c) {
+        // console.info('skip ' + newVal)
+        return
+      }
+      this.parseProp(newVal)
+    }
+  },
+  computed: {
+    value_c () {
+      let result = []
+      switch (this.type) {
+        case TYPE_NOT_SET:
+          result.push('?')
+          break
+        case TYPE_EVERY:
+          result.push('*')
+          break
+        case TYPE_RANGE:
+          result.push(`${this.valueRange.start}-${this.valueRange.end}`)
+          break
+        case TYPE_LOOP:
+          result.push(`${this.valueLoop.start}/${this.valueLoop.interval}`)
+          break
+        case TYPE_WORK:
+          result.push(`${this.valueWork}W`)
+          break
+        case TYPE_LAST:
+          result.push('L')
+          break
+        case TYPE_SPECIFY:
+          if (this.valueList.length === 0) {
+            this.valueList.push(this.minValue)
+          }
+          result.push(this.valueList.join(','))
+          break
+        default:
+          result.push(this.DEFAULT_VALUE)
+          break
+      }
+      return result.length > 0 ? result.join('') : this.DEFAULT_VALUE
+    },
+    // 指定值范围区间，介于最小值和最大值之间
+    specifyRange() {
+      let range = []
+      for (let i = this.minValue; i <= this.maxValue; i++) {
+        range.push(i)
+      }
+      return range
+    },
+  },
+  methods: {
+    parseProp (value) {
+      if (value === this.value_c) {
+        // console.info('same ' + value)
+        return
+      }
+      if (typeof (this.preProcessProp) === 'function') {
+        value = this.preProcessProp(value)
+      }
+      try {
+        if (!value || value === this.DEFAULT_VALUE) {
+          this.type = TYPE_EVERY
+        } else if (value.indexOf('?') >= 0) {
+          this.type = TYPE_NOT_SET
+        } else if (value.indexOf('-') >= 0) {
+          this.type = TYPE_RANGE
+          const values = value.split('-')
+          if (values.length >= 2) {
+            this.valueRange.start = parseInt(values[0])
+            this.valueRange.end = parseInt(values[1])
+          }
+        } else if (value.indexOf('/') >= 0) {
+          this.type = TYPE_LOOP
+          const values = value.split('/')
+          if (values.length >= 2) {
+            this.valueLoop.start = value[0] === '*' ? 0 : parseInt(values[0])
+            this.valueLoop.interval = parseInt(values[1])
+          }
+        } else if (value.indexOf('W') >= 0) {
+          this.type = TYPE_WORK
+          const values = value.split('W')
+          if (!values[0] && !isNaN(values[0])) {
+            this.valueWork = parseInt(values[0])
+          }
+        } else if (value.indexOf('L') >= 0) {
+          this.type = TYPE_LAST
+          const values = value.split('L')
+          this.valueLast = parseInt(values[0])
+        } else if (value.indexOf(',') >= 0 || !isNaN(value)) {
+          this.type = TYPE_SPECIFY
+          this.valueList = value.split(',').map(item => parseInt(item))
+        } else {
+          this.type = TYPE_EVERY
+        }
+      } catch (e) {
+        // console.info(e)
+        this.type = TYPE_EVERY
+      }
+    }
+  }
+}
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/mixin.less
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/mixin.less
@ -0,0 +1,35 @@
+
+.config-list {
+  text-align: left;
+  margin: 0 10px 10px 10px;
+}
+
+.item {
+  margin-top: 5px;
+}
+
+.choice {
+  padding: 5px 8px;
+}
+
+
+.w60 {
+  width: 60px;
+}
+.w80 {
+  width: 80px;
+}
+
+.list {
+  margin: 0 20px;
+}
+
+.list-check-item {
+  padding: 1px 3px;
+  width: 4em;
+}
+
+.tip-info {
+  color: #999
+}
+
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/month.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/month.vue
@ -0,0 +1,67 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_EVERY" class="choice" :disabled="disabled">每月</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disabled">区间</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.start"/>
+        月
+        至
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.end"/>
+        月
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disabled">循环</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.start"/>
+        月开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        月
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_SPECIFY" class="choice" :disabled="disabled">指定</a-radio>
+        <div class="list">
+          <a-checkbox-group v-model="valueList">
+            <template v-for="i of specifyRange">
+              <a-checkbox class="list-check-item" :key="`key-${i}`" :value="i" :disabled="type!==TYPE_SPECIFY || disabled">{{i}}</a-checkbox>
+            </template>
+          </a-checkbox-group>
+        </div>
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+
+export default {
+  name: 'month',
+  mixins: [mixin],
+  data() {
+    return {}
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      this.$emit('change', newVal)
+    }
+  },
+  created() {
+    this.DEFAULT_VALUE = '*'
+    this.minValue = 1
+    this.maxValue = 12
+    this.valueRange.start = 1
+    this.valueRange.end = 12
+    this.valueLoop.start = 1
+    this.valueLoop.interval = 1
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/second.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/second.vue
@ -0,0 +1,68 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_EVERY" class="choice" :disabled="disabled">每秒</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disabled">区间</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.start"/>
+        秒
+        至
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueRange.end"/>
+        秒
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disabled">循环</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.start"/>
+        秒开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        秒
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_SPECIFY" class="choice" :disabled="disabled">指定</a-radio>
+        <div class="list">
+          <a-checkbox-group v-model="valueList">
+            <template v-for="i in specifyRange">
+              <a-checkbox class="list-check-item" :key="`key-${i}`" :value="i" :disabled="type!==TYPE_SPECIFY || disabled">{{i}}</a-checkbox>
+            </template>
+          </a-checkbox-group>
+        </div>
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+
+export default {
+  name: 'second',
+  mixins: [mixin],
+  data() {
+    return {}
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      this.$emit('change', newVal)
+    }
+  },
+  created() {
+    this.DEFAULT_VALUE = '*'
+    this.minValue = 0
+    this.maxValue = 59
+    this.valueRange.start = 0
+    this.valueRange.end = 59
+    this.valueLoop.start = 0
+    this.valueLoop.interval = 1
+    // console.info('created')
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/week.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/week.vue
@ -0,0 +1,118 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_NOT_SET" class="choice" :disabled="disableChoice">不设置</a-radio>
+        <span class="tip-info">日和周只能设置其中之一</span>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disableChoice">区间</a-radio>
+        从
+        <a-select v-model="valueRange.start" class="w80" :disabled="type!==TYPE_RANGE || disableChoice">
+          <template v-for="(v, k) of WEEK_MAP">
+            <a-select-option :value="v">{{k}}</a-select-option>
+          </template>
+        </a-select>
+        至
+        <a-select v-model="valueRange.end" class="w80" :disabled="type!==TYPE_RANGE || disableChoice">
+          <template v-for="(v, k) of WEEK_MAP">
+            <a-select-option :value="v">{{k}}</a-select-option>
+          </template>
+        </a-select>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disableChoice">循环</a-radio>
+        从
+        <a-select v-model="valueLoop.start" class="w80" :disabled="type!==TYPE_LOOP || disableChoice">
+          <template v-for="(v, k) of WEEK_MAP">
+            <a-select-option :value="v">{{k}}</a-select-option>
+          </template>
+        </a-select>
+        开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disableChoice" :max="maxValue" :min="minValue" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        天
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_SPECIFY" class="choice" :disabled="disableChoice">指定</a-radio>
+        <div class="list">
+          <a-checkbox-group v-model="valueList">
+            <template v-for="i in specifyRange">
+              <a-checkbox class="list-check-item" :key="`key-${i}`" :value="i" :disabled="type!==TYPE_SPECIFY || disabled">{{i}}</a-checkbox>
+            </template>
+          </a-checkbox-group>
+        </div>
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+import { replaceWeekName, WEEK_MAP_EN } from './const.js'
+
+const WEEK_MAP = {
+  '周一': 1,
+  '周二': 2,
+  '周三': 3,
+  '周四': 4,
+  '周五': 5,
+  '周六': 6,
+  // 按照国人习惯，将周日放到每周的最后一天
+  '周日': 7,
+}
+
+export default {
+  name: 'week',
+  mixins: [mixin],
+  props: {
+    day: {
+      type: String,
+      default: '*'
+    }
+  },
+  data() {
+    return {
+      WEEK_MAP,
+      WEEK_MAP_EN
+    }
+  },
+  computed: {
+    disableChoice() {
+      return (this.day && this.day !== '?') || this.disabled
+    }
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      // 如果设置日，那么星期就直接不设置
+      this.updateValue()
+    },
+    day(newVal) {
+      // console.info('new day: ' + newVal)
+      this.updateValue()
+    }
+  },
+  methods: {
+    updateValue() {
+      this.$emit('change', this.disableChoice ? '?' : this.value_c)
+    },
+    preProcessProp(c) {
+      return replaceWeekName(c)
+    }
+  },
+  created() {
+    this.DEFAULT_VALUE = '*'
+    // 0,7表示周日 1表示周一
+    this.minValue = 1
+    this.maxValue = 7
+    this.valueRange.start = 1
+    this.valueRange.end = 7
+    this.valueLoop.start = 2
+    this.valueLoop.interval = 1
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/year.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/tabs/year.vue
@ -0,0 +1,60 @@
+<template>
+  <div class="config-list">
+    <a-radio-group v-model="type">
+      <div class="item">
+        <a-radio value="TYPE_EVERY" class="choice" :disabled="disabled">每年</a-radio>
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_RANGE" class="choice" :disabled="disabled">区间</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :min="0" :precision="0" class="w60" v-model="valueRange.start"/>
+        年
+        至
+        <a-input-number :disabled="type!==TYPE_RANGE || disabled" :min="1" :precision="0" class="w60" v-model="valueRange.end"/>
+        年
+      </div>
+      <div class="item">
+        <a-radio value="TYPE_LOOP" class="choice" :disabled="disabled">循环</a-radio>
+        从
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :min="0" :precision="0" class="w60" v-model="valueLoop.start"/>
+        年开始，间隔
+        <a-input-number :disabled="type!==TYPE_LOOP || disabled" :min="1" :precision="0" class="w60" v-model="valueLoop.interval"/>
+        年
+      </div>
+    </a-radio-group>
+  </div>
+</template>
+
+<script>
+import mixin from './mixin'
+
+export default {
+  name: 'year',
+  mixins: [mixin],
+  data() {
+    return {}
+  },
+  watch: {
+    value_c(newVal, oldVal) {
+      // console.info('change:' + newVal)
+      this.$emit('change', newVal)
+    }
+  },
+  created() {
+    const nowYear = (new Date()).getFullYear()
+    this.DEFAULT_VALUE = '*'
+    this.minValue = 0
+    this.maxValue = 0
+    this.valueRange.start = nowYear
+    this.valueRange.end = nowYear + 100
+    this.valueLoop.start = nowYear
+    this.valueLoop.interval = 1
+    // console.info('created')
+    this.parseProp(this.prop)
+  }
+}
+</script>
+
+<style lang="less" scoped>
+  @import "mixin.less";
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/validator.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEasyCron/validator.js
@ -0,0 +1,51 @@
+import CronParser from 'cron-parser'
+import { replaceWeekName } from './tabs/const'
+
+export default (rule, value, callback) => {
+  // 没填写就不校验
+  if (!value) {
+    callback()
+    return true
+  }
+  const values = value.split(' ').filter(item => !!item)
+  if (values.length > 7) {
+    callback(new Error('Cron表达式最多7项！'))
+    return false
+  }
+  // 检查第7项
+  let e = value
+  if (values.length === 7) {
+    const year = replaceWeekName(values[6])
+    if (year !== '*' && year !== '?') {
+      let yearValues = []
+      if (year.indexOf('-') >= 0) {
+        yearValues = year.split('-')
+      } else if (year.indexOf('/')) {
+        yearValues = year.split('/')
+      } else {
+        yearValues = [year]
+      }
+      // console.info(yearValues)
+      // 判断是否都是数字
+      const checkYear = yearValues.some(item => isNaN(item))
+      if (checkYear) {
+        callback(new Error('Cron表达式参数[年]错误：' + year))
+        return false
+      }
+    }
+    // 取其中的前六项
+    e = values.slice(0, 6).join(' ')
+  }
+  // 6位 没有年
+  // 5位没有秒、年
+  let result = true
+  try {
+    const iter = CronParser.parseExpression(e)
+    iter.next()
+    callback()
+  } catch (e) {
+    callback(new Error('Cron表达式错误：' + e))
+    result = false
+  }
+  return result
+}
--- a/ant-design-vue-jeecg/src/components/jeecg/JEditableTable.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEditableTable.vue
--- a/ant-design-vue-jeecg/src/components/jeecg/JEditor.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JEditor.vue
@ -128,12 +128,23 @@
              this.reload()
            }
          })
+          //update--begin--autor:liusq-----date:20210316------for：富文本编辑器tab父组件可能导致的赋值问题------
+          this.reload()
+          //update--end--autor:liusq-----date:20210316------for：富文本编辑器tab父组件可能导致的赋值问题------
        }else{
          //update--begin--autor:wangshuai-----date:20200724------for：富文本编辑器切换tab无法修改------
          let tabLayout = getVmParentByName(this, 'TabLayout')
-          tabLayout.excuteCallback(()=>{
-            this.reload()
-          })
+          //update--begin--autor:liusq-----date:20210713------for：处理特殊情况excuteCallback不能使用------
+          try {
+            tabLayout.excuteCallback(() => {
+              this.reload()
+            })
+          } catch (error) {
+            if (tabLayout) {
+              this.reload()
+            }
+          }
+          //update--end--autor:liusq-----date:20210713------for：处理特殊情况excuteCallback不能使用------
          //update--begin--autor:wangshuai-----date:20200724------for：文本编辑器切换tab无法修改------
        }
      },
--- a/ant-design-vue-jeecg/src/components/jeecg/JImageUpload.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JImageUpload.vue
@ -11,14 +11,16 @@
      :beforeUpload="beforeUpload"
      :disabled="disabled"
      :isMultiple="isMultiple"
-      :showUploadList="isMultiple"
+
      @change="handleChange"
      @preview="handlePreview"
-      :class="!isMultiple?'imgupload':''">
-      <img v-if="!isMultiple && picUrl" :src="getAvatarView()" style="height:104px;max-width:300px"/>
-      <div v-else class="iconp">
-        <a-icon :type="uploadLoading ? 'loading' : 'plus'" />
-        <div class="ant-upload-text">{{ text }}</div>
+      :class="[!isMultiple?'imgupload':'', (!isMultiple && picUrl)?'image-upload-single-over':'' ]">
+      <div>
+        <!--<img v-if="!isMultiple && picUrl" :src="getAvatarView()" style="width:100%;height:100%"/>-->
+        <div class="iconp">
+          <a-icon :type="uploadLoading ? 'loading' : 'plus'" />
+          <div class="ant-upload-text">{{ text }}</div>
+        </div>
      </div>
      <a-modal :visible="previewVisible" :footer="null" @cancel="handleCancel()">
        <img alt="example" style="width: 100%" :src="previewImage"/>
@ -80,18 +82,29 @@
        type:Boolean,
        required:false,
        default: false
+      },
+      //update-begin-author:wangshuai date:20201021 for:LOWCOD-969 新增number属性，用于判断上传数量
+      number:{
+        type:Number,
+        required:false,
+        default:0
      }
+      //update-end-author:wangshuai date:20201021 for:LOWCOD-969 新增number属性，用于判断上传数量
    },
    watch:{
-      value(val){
-        if (val instanceof Array) {
-          this.initFileList(val.join(','))
-        } else {
-          this.initFileList(val)
-        }
-        if(!val || val.length==0){
-          this.picUrl = false;
-        }
+      value: {
+        handler(val,oldValue) {
+          if (val instanceof Array) {
+            this.initFileList(val.join(','))
+          } else {
+            this.initFileList(val)
+          }
+          if(!val || val.length==0){
+            this.picUrl = false;
+          }
+        },
+        //立刻执行handler
+        immediate: true
      }
    },
    created(){
@ -132,6 +145,11 @@
      handleChange(info) {
        this.picUrl = false;
        let fileList = info.fileList
+        //update-begin-author:wangshuai date:20201022 for:LOWCOD-969 判断number是否大于0和是否多选，返回选定的元素。
+        if(this.number>0 && this.isMultiple){
+          fileList = fileList.slice(-this.number);
+        }
+        //update-end-author:wangshuai date:20201022 for:LOWCOD-969 判断number是否大于0和是否多选，返回选定的元素。
        if(info.file.status==='done'){
          if(info.file.response.success){
            this.picUrl = true;
@ -171,7 +189,7 @@
          path = ''
        }
        let arr = [];
-        if(!this.isMultiple){
+        if(!this.isMultiple && uploadFiles.length>0){
          arr.push(uploadFiles[uploadFiles.length-1].response.message)
        }else{
          for(let a=0;a<uploadFiles.length;a++){
@ -213,8 +231,9 @@
  * https://github.com/zhangdaiscott/jeecg-boot/issues/1810
  * https://github.com/zhangdaiscott/jeecg-boot/issues/1779
  */
-  /deep/ .imgupload .ant-upload-select{display:block}
-  /deep/ .imgupload .ant-upload.ant-upload-select-picture-card{ width:120px;height: 120px;}
-  /deep/ .imgupload .iconp{padding:32px;}
+
+  /deep/ .imgupload .iconp{padding:20px;}
  /* update--end--autor:lvdandan-----date:20201016------for：j-image-upload图片组件单张图片详情回显空白*/
-</style>
+
+  /deep/ .image-upload-single-over .ant-upload-select{display: none}
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JImportModal.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JImportModal.vue
@ -6,6 +6,13 @@
    :confirmLoading="uploading"
    @cancel="handleClose">

+    <div style="margin: 0px 0px 5px 1px" v-if="online">
+      <span style="display: inline-block;height: 32px;line-height: 32px;vertical-align: middle;">是否开启校验:</span>
+      <span style="display: inline-block;height: 32px;margin-left: 6px">
+         <a-switch :checked="validateStatus==1" @change="handleChangeValidateStatus" checked-children="是" un-checked-children="否" size="small"/>
+      </span>
+    </div>
+
    <a-upload
      name="file"
      :multiple="true"
@ -47,6 +54,12 @@
        type: String,
        default: '',
        required: false
+      },
+      //是否online导入
+      online:{
+        type: Boolean,
+        default: false,
+        required: false
      }
    },
    data(){
@ -55,7 +68,8 @@
        uploading:false,
        fileList:[],
        uploadAction:'',
-        foreignKeys:''
+        foreignKeys:'',
+        validateStatus: 0
      }
    },
    watch: {
@ -78,6 +92,7 @@
        this.uploading = false
        this.visible = true
        this.foreignKeys = arg;
+        this.validateStatus = 0
      },
      handleRemove(file) {
        const index = this.fileList.indexOf(file);
@ -98,6 +113,9 @@
        if(this.foreignKeys && this.foreignKeys.length>0){
          formData.append('foreignKeys',this.foreignKeys);
        }
+        if(this.online==true){
+          formData.append('validateStatus',this.validateStatus);
+        }
        fileList.forEach((file) => {
          formData.append('files[]', file);
        });
@ -105,14 +123,41 @@
        postAction(this.uploadAction, formData).then((res) => {
          this.uploading = false
          if(res.success){
-            this.$message.success(res.message)
+            if(res.code == 201){
+              this.errorTip(res.message, res.result)
+            }else{
+              this.$message.success(res.message)
+            }
            this.visible=false
            this.$emit('ok')
          }else{
            this.$message.warning(res.message)
          }
        })
-      }
+      },
+      // 是否开启校验 开关改变事件
+      handleChangeValidateStatus(checked){
+        this.validateStatus = checked==true?1:0
+      },
+      // 错误信息提示
+      errorTip(tipMessage, fileUrl) {
+        const h = this.$createElement;
+        let href = window._CONFIG['domianURL'] + fileUrl
+        this.$warning({
+          title: '导入成功,但是有错误数据!',
+          content: h('div', {}, [
+            h('div', tipMessage),
+            h('span', '具体详情请 '),
+            h('a', {
+              attrs: {
+                href: href,
+                target: '_blank'
+              },
+            },'点击下载'),
+          ]),
+          onOk() {},
+        });
+      },

    }
  }
--- a/ant-design-vue-jeecg/src/components/jeecg/JMarkdownEditor/default-options.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JMarkdownEditor/default-options.js
@ -21,7 +21,6 @@ export default {
    'outdent',
    'divider',
    'table',
-    'image',
    'link',
    'divider',
    'code',
--- a/ant-design-vue-jeecg/src/components/jeecg/JMarkdownEditor/index.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JMarkdownEditor/index.vue
@ -1,5 +1,28 @@
 <template>
-  <div class="j-markdown-editor" :id="id"/>
+  <div>
+    <div class="j-markdown-editor" :id="id"/>
+    <div v-if="isShow">
+      <j-modal
+        title="图片上传"
+        :visible.sync="dialogVisible"
+        width="30%"
+        :before-close="handleClose"
+        @ok="handleOk">
+        <a-tabs default-active-key="1" @change="handleChange">
+          <a-tab-pane tab="本地图片上传" key="1" :forceRender="true">
+            <j-upload v-model="fileList" :number="1"></j-upload>
+            <div style="margin-top: 20px">
+              <a-input v-model="remark" placeholder="请填写备注"></a-input>
+            </div>
+          </a-tab-pane>
+          <a-tab-pane tab="网络图片地址" key="2" :forceRender="true">
+            <a-input v-model="networkPic" placeholder="请填写网络图片地址"></a-input>
+            <a-input style="margin-top: 20px" v-model="remark" placeholder="请填写备注"></a-input>
+          </a-tab-pane>
+        </a-tabs>
+      </j-modal>
+    </div>
+  </div>
 </template>

 <script>
@ -9,9 +32,14 @@ import '@toast-ui/editor/dist/i18n/zh-cn';

 import Editor from '@toast-ui/editor';
 import defaultOptions from './default-options'
+import JUpload from '@/components/jeecg/JUpload'
+import { getFileAccessHttpUrl } from '@/api/manage'

 export default {
  name: 'JMarkdownEditor',
+  components: {
+    JUpload,
+  },
  props: {
    value: {
      type: String,
@ -47,7 +75,16 @@ export default {
  },
  data() {
    return {
-      editor: null
+      editor: null,
+      isShow:false,
+      activeIndex:"1",
+      dialogVisible:false,
+      index:"1",
+      fileList:[],
+      remark:"",
+      imageName:"",
+      imageUrl:"",
+      networkPic:""
    }
  },
  computed: {
@ -94,6 +131,40 @@ export default {
      this.editor.on('change', () => {
        this.$emit('change', this.editor.getMarkdown())
      })
+      //--begin 添加自定义上传按钮
+      /*
+       * 添加自定义按钮
+       */
+      //获取编辑器上的功能条
+      let toolbar = this.editor.getUI().getToolbar();
+      let fileDom = this.$refs.files;
+      //添加图片点击事件
+      this.editor.eventManager.addEventType('isShowClickEvent');
+      this.editor.eventManager.listen('isShowClickEvent', () => {
+        this.isShow = true
+        this.dialogVisible = true
+      });
+      //addImageBlobHook图片上传、剪切、拖拽都会走此方法
+      // 删除默认监听事件
+      this.editor.eventManager.removeEventHandler('addImageBlobHook')
+      // 添加自定义监听事件
+      this.editor.eventManager.listen('addImageBlobHook', (blob, callback) => {
+        this.upload(blob, url => {
+          callback(url)
+        })
+      })
+      // 添加自定义按钮 第二个参数代表位置，不传默认放在最后
+      toolbar.insertItem(15,{
+        type: 'button',
+        options:{
+          name: 'customize',
+          className: 'tui-image tui-toolbar-icons',
+          event: 'isShowClickEvent',
+          tooltip: '上传图片',
+        }
+        //
+      });
+      //--end 添加自定义上传按钮
    },
    destroyEditor() {
      if (!this.editor) return
@ -111,7 +182,57 @@ export default {
    },
    getHtml() {
      return this.editor.getHtml()
-    }
+    },
+    handleOk(){
+      if(this.index=='1'){
+        this.imageUrl = getFileAccessHttpUrl(this.fileList)
+        if(this.remark){
+          this.addImgToMd(this.imageUrl,this.remark)
+        }else{
+          this.addImgToMd(this.imageUrl,"")
+        }
+      }else{
+        if(this.remark){
+          this.addImgToMd(this.networkPic,this.remark)
+        }else{
+          this.addImgToMd(this.networkPic,"")
+        }
+      }
+      this.index="1"
+      this.fileList=[]
+      this.imageName="";
+      this.imageUrl="";
+      this.remark=""
+      this.networkPic=""
+      this.dialogVisible=false
+      this.isShow=false;
+    },
+    handleClose(done) {
+      done();
+    },
+    handleChange(val){
+      this.fileList=[]
+      this.remark=""
+      this.imageName=""
+      this.imageUrl=""
+      this.networkPic=""
+      this.index=val
+    },
+    //添加图片到markdown
+    addImgToMd(data,name) {
+      let editor = this.editor.getCodeMirror();
+      let editorHtml = this.editor.getCurrentModeEditor();
+      let isMarkdownMode = this.editor.isMarkdownMode();
+      if (isMarkdownMode) {
+        editor.replaceSelection(`![${name}](${data})`);
+      } else {
+        let range = editorHtml.getRange();
+        let img = document.createElement('img');
+        img.src = `${data}`;
+        img.alt = name;
+        range.insertNode(img);
+      }
+    },
  },
  model: {
    prop: 'value',
--- a/ant-design-vue-jeecg/src/components/jeecg/JModal/JModal.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JModal/JModal.vue
@ -8,10 +8,11 @@
    v-on="$listeners"
    @ok="handleOk"
    @cancel="handleCancel"
+    destroyOnClose
  >

    <slot></slot>
-
+    <!--有设置标题-->
    <template v-if="!isNoTitle" slot="title">
      <a-row class="j-modal-title-row" type="flex">
        <a-col class="left">
@ -22,6 +23,14 @@
        </a-col>
      </a-row>
    </template>
+    <!--没有设置标题-->
+    <template v-else slot="title">
+      <a-row class="j-modal-title-row" type="flex">
+        <a-col v-if="switchFullscreen" class="right" @click="toggleFullscreen">
+          <a-button class="ant-modal-close ant-modal-close-x" ghost type="link" :icon="fullscreenButtonIcon"/>
+        </a-col>
+      </a-row>
+    </template>

    <!-- 处理 scopedSlots -->
    <template v-for="slotName of scopedSlotsKeys" :slot="slotName">
@ -38,10 +47,10 @@

 <script>

-  import { getClass, getStyle } from '@/utils/props-util'
-  import { triggerWindowResizeEvent } from '@/utils/util'
+import { getClass, getStyle } from '@/utils/props-util'
+import { triggerWindowResizeEvent } from '@/utils/util'

-  export default {
+export default {
    name: 'JModal',
    props: {
      title: String,
@ -160,8 +169,8 @@
 </script>

 <style lang="less">
+  
  .j-modal-box {
-
    &.fullscreen {
      top: 0;
      left: 0;
@ -190,7 +199,6 @@
          height: calc(100% - 55px);
        }
      }
-
      &.no-title.no-footer {
        .ant-modal-body {
          height: 100%;
@ -217,6 +225,12 @@
        }
      }
    }
+    &.no-title{
+      .ant-modal-header {
+        padding: 0px 24px;
+        border-bottom: 0px !important;
+      }
+    }
  }

  @media (max-width: 767px) {
--- a/ant-design-vue-jeecg/src/components/jeecg/JModal/JPrompt.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JModal/JPrompt.vue
@ -0,0 +1,124 @@
+<template>
+  <j-modal :visible="visible" :confirmLoading="loading" :after-close="afterClose" v-bind="modalProps" @ok="onOk" @cancel="onCancel">
+    <a-spin :spinning="loading">
+      <div v-html="content"></div>
+      <a-form-model ref="form" :model="model" :rules="rules">
+        <a-form-model-item prop="input">
+          <a-input ref="input" v-model="model.input" v-bind="inputProps" @pressEnter="onInputPressEnter"/>
+        </a-form-model-item>
+      </a-form-model>
+    </a-spin>
+  </j-modal>
+</template>
+
+<script>
+import pick from 'lodash.pick'
+
+export default {
+  name: 'JPrompt',
+  data() {
+    return {
+      visible: false,
+      loading: false,
+      content: '',
+      // 弹窗参数
+      modalProps: {
+        title: '',
+      },
+      inputProps: {
+        placeholder: '',
+      },
+      // form model
+      model: {
+        input: '',
+      },
+      // 校验
+      rule: [],
+      // 回调函数
+      callback: {},
+    }
+  },
+  computed: {
+    rules() {
+      return {
+        input: this.rule
+      }
+    },
+  },
+  methods: {
+    show(options) {
+      this.content = options.content
+      if (Array.isArray(options.rule)) {
+        this.rule = options.rule
+      }
+      if (options.defaultValue != null) {
+        this.model.input = options.defaultValue
+      }
+      // 取出常用的弹窗参数
+      let pickModalProps = pick(options, 'title', 'centered', 'cancelText', 'closable', 'mask', 'maskClosable', 'okText', 'okType', 'okButtonProps', 'cancelButtonProps', 'width', 'wrapClassName', 'zIndex', 'dialogStyle', 'dialogClass')
+      this.modalProps = Object.assign({}, pickModalProps, options.modalProps)
+      // 取出常用的input参数
+      let pickInputProps = pick(options, 'placeholder', 'allowClear')
+      this.inputProps = Object.assign({}, pickInputProps, options.inputProps)
+      // 回调函数
+      this.callback = pick(options, 'onOk', 'onOkAsync', 'onCancel')
+      this.visible = true
+      this.$nextTick(() => this.$refs.input.focus())
+    },
+
+    onOk() {
+      this.$refs.form.validate((ok, err) => {
+        if (ok) {
+          let event = {value: this.model.input, target: this}
+          // 异步方法优先级高于同步方法
+          if (typeof this.callback.onOkAsync === 'function') {
+            this.callback.onOkAsync(event)
+          } else if (typeof this.callback.onOk === 'function') {
+            this.callback.onOk(event)
+            this.close()
+          } else {
+            this.close()
+          }
+        }
+      })
+    },
+    onCancel() {
+      if (typeof this.callback.onCancel === 'function') {
+        this.callback.onCancel(this.model.input)
+      }
+      this.close()
+    },
+
+    onInputPressEnter() {
+      this.onOk()
+    },
+
+    close() {
+      this.visible = this.loading ? this.visible : false
+    },
+
+    forceClose() {
+      this.visible = false
+    },
+
+    showLoading() {
+      this.loading = true
+    },
+    hideLoading() {
+      this.loading = false
+    },
+
+    afterClose(e) {
+      if (typeof this.modalProps.afterClose === 'function') {
+        this.modalProps.afterClose(e)
+      }
+      this.$emit('after-close', e)
+    },
+
+  },
+}
+</script>
+
+<style scoped>
+
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JModal/index.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JModal/index.js
@ -0,0 +1,18 @@
+import JModal from './JModal'
+import JPrompt from './JPrompt'
+
+export default {
+  install(Vue) {
+    Vue.component(JModal.name, JModal)
+
+    const JPromptExtend = Vue.extend(JPrompt)
+    Vue.prototype.$JPrompt = function (options = {}) {
+      // 创建prompt实例
+      const vm = new JPromptExtend().$mount()
+      vm.show(options)
+      // 关闭后销毁
+      vm.$on('after-close', () => vm.$destroy())
+      return vm
+    }
+  },
+}
--- a/ant-design-vue-jeecg/src/components/jeecg/JPopup.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JPopup.vue
@ -10,7 +10,9 @@
      ref="jPopupOnlReport"
      :code="code"
      :multi="multi"
+      :sorter="sorter"
      :groupId="uniqGroupId"
+      :param="param"
      @ok="callBack"
    />

@ -46,6 +48,11 @@
        default: '',
        required: false
      },
+      /** 排序列，指定要排序的列，使用方式：列名=desc|asc */
+      sorter: {
+        type: String,
+        default: ''
+      },
      width: {
        type: Number,
        default: 1200,
@ -75,6 +82,17 @@
        required: false,
        default: false
      },
+      //popup动态参数 支持系统变量语法
+      param:{
+        type: Object,
+        required: false,
+        default: ()=>{}
+      },
+      spliter:{
+        type: String,
+        required: false,
+        default: ','
+      },
      /** 分组ID，用于将多个popup的请求合并到一起，不传不分组 */
      groupId: String

@ -101,7 +119,7 @@
          if (!val) {
            this.showText = ''
          } else {
-            this.showText = val
+            this.showText = val.split(this.spliter).join(',')
          }
        }
      }
@ -155,9 +173,11 @@
            let tempDestArr = []
            for(let rw of rows){
              let val = rw[orgFieldsArr[i]]
-              if(!val){
+              // update--begin--autor:liusq-----date:20210713------for：处理val等于0的情况issues/I3ZL4T------
+              if(typeof val=='undefined'|| val==null || val.toString()==""){
                val = ""
              }
+              // update--end--autor:liusq-----date:20210713------for：处理val等于0的情况issues/I3ZL4T------
              tempDestArr.push(val)
            }
            res[destFieldsArr[i]] = tempDestArr.join(",")
@ -181,7 +201,11 @@
        } else {
          //v-model时 需要传一个参数field 表示当前这个字段 从而根据这个字段的顺序找到原始值
          // this.$emit("input",row[orgFieldsArr[destFieldsArr.indexOf(this.field)]])
-          this.$emit('input', this.showText, res)
+          let str = ''
+          if(this.showText){
+            str = this.showText.split(',').join(this.spliter)
+          }
+          this.$emit('input', str, res)
        }
      }
    }
--- a/ant-design-vue-jeecg/src/components/jeecg/JSelectMultiple.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JSelectMultiple.vue
@ -1,8 +1,9 @@
 <template>
-  <a-select :value="arrayValue" @change="onChange" mode="multiple" :placeholder="placeholder">
+  <a-select :value="arrayValue" @change="onChange" mode="multiple" :placeholder="placeholder" allowClear>
    <a-select-option
-      v-for="(item,index) in options"
+      v-for="(item,index) in selectOptions"
      :key="index"
+      :getPopupContainer="getParentContainer"
      :value="item.value">
      {{ item.text || item.label }}
    </a-select-option>
@ -11,6 +12,8 @@

 <script>
  //option {label:,value:}
+  import { getAction } from '@api/manage'
+
  export default {
    name: 'JSelectMultiple',
    props: {
@ -30,36 +33,80 @@
      },
      options:{
        type: Array,
-        required: true
+        default:()=>[],
+        required: false
      },
      triggerChange:{
        type: Boolean,
        required: false,
        default: false
-      }
+      },
+      spliter:{
+        type: String,
+        required: false,
+        default: ','
+      },
+      popContainer:{
+        type:String,
+        default:'',
+        required:false
+      },
+      dictCode:{
+        type:String,
+        required:false
+      },
    },
    data(){
      return {
-        arrayValue:!this.value?[]:this.value.split(",")
+        arrayValue:!this.value?[]:this.value.split(this.spliter),
+        dictOptions: [],
      }
    },
+    computed:{
+      selectOptions(){
+        return this.dictOptions.length > 0 ? this.dictOptions : this.options
+      },
+    },
    watch:{
      value (val) {
        if(!val){
          this.arrayValue = []
        }else{
-          this.arrayValue = this.value.split(",")
+          this.arrayValue = this.value.split(this.spliter)
        }
      }
    },
+    mounted(){
+      if (this.dictCode) {
+        this.loadDictOptions()
+      }
+    },
    methods:{
      onChange (selectedValue) {
        if(this.triggerChange){
-          this.$emit('change', selectedValue.join(","));
+          this.$emit('change', selectedValue.join(this.spliter));
        }else{
-          this.$emit('input', selectedValue.join(","));
+          this.$emit('input', selectedValue.join(this.spliter));
        }
      },
+      getParentContainer(node){
+        if(!this.popContainer){
+          return node.parentNode
+        }else{
+          return document.querySelector(this.popContainer)
+        }
+      },
+      // 根据字典code查询字典项
+      loadDictOptions(){
+        getAction(`/sys/dict/getDictItems/${this.dictCode}`,{}).then(res=>{
+          if (res.success) {
+            this.dictOptions = res.result.map(item => ({value: item.value, label: item.text}))
+          } else {
+            console.error('getDictItems error: : ', res)
+            this.dictOptions = []
+          }
+        })
+      },
    },

  }
--- a/ant-design-vue-jeecg/src/components/jeecg/JSuperQuery.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JSuperQuery.vue
@ -101,7 +101,15 @@
              </a-col>

              <a-col :md="8" :xs="24" style="margin-bottom: 12px;">
-                <template v-if="item.dictCode">
+                <!-- 下拉搜索 -->
+                <j-search-select-tag v-if="item.type==='sel_search'" v-model="item.val" :dict="getDictInfo(item)" placeholder="请选择"/>
+                <!-- 下拉多选 -->
+                <template v-else-if="item.type==='list_multi'">
+                  <j-multi-select-tag v-if="item.options" v-model="item.val" :options="item.options" placeholder="请选择"/>
+                  <j-multi-select-tag v-else v-model="item.val" :dictCode="getDictInfo(item)" placeholder="请选择"/>
+                </template>
+
+                <template v-else-if="item.dictCode">
                  <template v-if="item.type === 'table-dict'">
                    <j-popup
                      v-model="item.val"
@ -109,6 +117,7 @@
                      :field="item.dictCode"
                      :orgFields="item.dictCode"
                      :destFields="item.dictCode"
+                      :multi="true"
                    ></j-popup>
                  </template>
                  <template v-else>
@ -116,7 +125,13 @@
                    <j-dict-select-tag v-show="!allowMultiple(item)" v-model="item.val" :dictCode="item.dictCode" placeholder="请选择"/>
                  </template>
                </template>
-                <j-popup v-else-if="item.type === 'popup'" :value="item.val" v-bind="item.popup" group-id="superQuery" @input="(e,v)=>handleChangeJPopup(item,e,v)"/>
+                <j-popup
+                  v-else-if="item.type === 'popup'"
+                  :value="item.val"
+                  v-bind="item.popup"
+                  group-id="superQuery"
+                  @input="(e,v)=>handleChangeJPopup(item,e,v)"
+                  :multi="true"/>
                <j-select-multi-user
                  v-else-if="item.type === 'select-user' || item.type === 'sel_user'"
                  v-model="item.val"
@ -338,6 +353,17 @@
        }
        this.visible = true
      },
+
+      getDictInfo(item) {
+        let str = ''
+        if(!item.dictTable){
+          str = item.dictCode
+        }else{
+          str = item.dictTable+','+item.dictText+','+item.dictCode
+        }
+        console.log('高级查询字典信息',str)
+        return str
+      },
      handleOk() {
        if (!this.isNullArray(this.queryParamsModel)) {
          let event = {
@ -353,7 +379,7 @@
          this.$message.warn("不能查询空条件")
        }
      },
-      emitCallback(event = {}) {
+      emitCallback(event = {}, loadStatus = true) {
        let { params = [], matchType = this.matchType } = event
        this.superQueryFlag = (params && params.length > 0)
        for (let param of params) {
@ -362,7 +388,7 @@
          }
        }
        console.debug('---高级查询参数--->', { params, matchType })
-        this.$emit(this.callback, params, matchType)
+        this.$emit(this.callback, params, matchType, loadStatus)
      },
      handleCancel() {
        this.close()
@ -386,11 +412,13 @@
        this.queryParamsModel.splice(index, 1)
      },
      handleSelected(node, item) {
-        let { type, options, dictCode, dictTable, customReturnField, popup } = node.dataRef
+        let { type, dbType, options, dictCode, dictTable, dictText, customReturnField, popup } = node.dataRef
        item['type'] = type
+        item['dbType'] = dbType
        item['options'] = options
        item['dictCode'] = dictCode
        item['dictTable'] = dictTable
+        item['dictText'] = dictText
        item['customReturnField'] = customReturnField
        if (popup) {
          item['popup'] = popup
@ -400,9 +428,13 @@
      handleOpen() {
        this.show()
      },
+      handleOutReset(loadStaus=true) {
+        this.resetLine()
+        this.emitCallback({}, loadStaus)
+      },
      handleReset() {
        this.resetLine()
-        this.emitCallback()
+        this.emitCallback({}, true)
      },
      handleSave() {
        let queryParams = this.removeEmptyObject(this.queryParamsModel)
--- a/ant-design-vue-jeecg/src/components/jeecg/JUpload.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JUpload.vue
@ -12,12 +12,12 @@

    <a-upload
      name="file"
-      :multiple="true"
+      :multiple="multiple"
      :action="uploadAction"
      :headers="headers"
      :data="{'biz':bizPath}"
      :fileList="fileList"
-      :beforeUpload="beforeUpload"
+      :beforeUpload="doBeforeUpload"
      @change="handleChange"
      :disabled="disabled"
      :returnUrl="returnUrl"
@ -135,6 +135,13 @@
        required:false,
        default: true
      },
+      multiple: {
+        type: Boolean,
+        default: true
+      },
+      beforeUpload: {
+        type: Function
+      },
    },
    watch:{
      value:{
@ -238,7 +245,7 @@
        }
        this.$emit('change', path);
      },
-      beforeUpload(file){
+      doBeforeUpload(file){
        this.uploadGoOn=true
        var fileType = file.type;
        if(this.fileType===FILE_TYPE_IMG){
@ -248,7 +255,10 @@
            return false;
          }
        }
-        //TODO 扩展功能验证文件大小
+        // 扩展 beforeUpload 验证
+        if (typeof this.beforeUpload === 'function') {
+          return this.beforeUpload(file)
+        }
        return true
      },
      handleChange(info) {
@ -374,14 +384,17 @@
    },
    mounted(){
      const moverObj = document.getElementById(this.containerId+'-mover');
-      moverObj.addEventListener('mouseover',()=>{
-        this.moverHold = true
-        this.moveDisplay = 'block';
-      });
-      moverObj.addEventListener('mouseout',()=>{
-        this.moverHold = false
-        this.moveDisplay = 'none';
-      });
+      if(moverObj){
+        moverObj.addEventListener('mouseover',()=>{
+          this.moverHold = true
+          this.moveDisplay = 'block';
+        });
+        moverObj.addEventListener('mouseout',()=>{
+          this.moverHold = false
+          this.moveDisplay = 'none';
+        });
+      }
+    
      let picList = document.getElementById(this.containerId)?document.getElementById(this.containerId).getElementsByClassName('ant-upload-list-picture-card'):[];
      if(picList && picList.length>0){
        picList[0].addEventListener('mouseover',(ev)=>{
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/JVxeSubPopover.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/JVxeSubPopover.vue
@ -1,5 +1,5 @@
 <template>
-  <a-popover :visible="visible" placement="bottom" overlayClassName="j-vxe-popover-overlay" :overlayStyle="overlayStyle">
+  <a-popover :visible="visible" :placement="placement" overlayClassName="j-vxe-popover-overlay" :overlayStyle="overlayStyle">
    <div class="j-vxe-popover-title" slot="title">
      <div>子表</div>
      <div class="j-vxe-popover-title-close" @click="close">
@ -34,6 +34,7 @@
          width: null,
          zIndex: 100
        },
+        placement: 'bottom'
      }
    },
    created() {
@ -41,6 +42,14 @@
    methods: {

      toggle(event) {
+
+        //update-begin-author:taoyan date:20200921 for: 弹出子表时，子表会闪一下，类似重新计算子表的位置
+        if(document.body.clientHeight - event.$event.clientY > 350){
+          this.placement = 'bottom'
+        }else{
+          this.placement = 'top'
+        }
+        //update-end-author:taoyan date:20200921 for: 弹出子表时，子表会闪一下，类似重新计算子表的位置
        if (this.row == null) {
          this.open(event)
        } else {
@ -83,13 +92,22 @@
          this.$refs.div.style.height = clientHeight + 'px'
          this.overlayStyle.width = Number.parseInt((clientWidth - clientWidth * 0.04)) + 'px'
          this.overlayStyle.maxWidth = this.overlayStyle.width
-          domAlign(this.$refs.div, tr, {
+          //update-begin-author:taoyan date:20200921 for: 子表弹出位置存在现实位置问题。
+          //let realTable = getParentNodeByTagName(tr, 'table')
+          //let left = realTable.parentNode.scrollLeft
+          let h = event.$event.clientY
+          if(h){
+            h = h-140
+          }
+          let toolbar = this.$refs.div.nextSibling
+          domAlign(this.$refs.div, toolbar, {
            points: ['tl', 'tl'],
-            offset: [0, 0],
+            offset: [0, h],
            overflow: {
              alwaysByViewport: true
            },
          })
+          //update-end-author:taoyan date:20200921 for: 子表弹出位置存在现实位置问题。
          this.$nextTick(() => {
            this.visible = true
            this.$nextTick(() => {
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/JVxeTable.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/JVxeTable.js
@ -1,6 +1,6 @@
 import XEUtils from 'xe-utils'
 import PropTypes from 'ant-design-vue/es/_util/vue-types'
-import { JVXETypes } from '@/components/jeecg/JVxeTable/index'
+import { JVXETypes } from '@/components/jeecg/JVxeTable/jvxeTypes'
 import VxeWebSocketMixins from '../mixins/vxe.web.socket.mixins'
 import { initDictOptions } from '@/components/dict/JDictSelectUtil'

@ -13,7 +13,7 @@ import JVxeDetailsModal from './JVxeDetailsModal'
 import JVxePagination from './JVxePagination'
 import { cloneObject, getVmParentByName, pushIfNotExist, randomString, simpleDebounce } from '@/utils/util'
 import { UtilTools } from 'vxe-table/packages/tools/src/utils'
-import { getNoAuthCols } from "@/utils/authFilter"
+import { getNoAuthCols } from '@/utils/authFilter'

 export default {
  name: 'JVxeTable',
@ -95,6 +95,11 @@ export default {
    // 是否异步删除行，如果你要实现异步删除，那么需要把这个选项开启，
    // 在remove事件里调用confirmRemove方法才会真正删除（除非删除的全是新增的行）
    asyncRemove: PropTypes.bool.def(false),
+    // 是否一直显示组件，如果为false则只有点击的时候才出现组件
+    // 注：该参数不能动态修改；如果行、列字段多的情况下，会根据机器性能造成不同程度的卡顿。
+    alwaysEdit: PropTypes.bool.def(false),
+    // 联动配置，数组，详情配置见文档
+    linkageConfig: PropTypes.array.def(() => []),
  },
  data() {
    return {
@ -148,7 +153,10 @@ export default {
      // 允许执行刷新特效的行ID
      reloadEffectRowKeysMap: {},
      //配置了但是没有授权的按钮和列 集合
-      excludeCode:[]
+      excludeCode:[],
+      // 联动下拉选项（用于隔离不同的下拉选项）
+      // 内部联动配置，map
+      _innerLinkageConfig: null,
    }
  },
  computed: {
@ -175,12 +183,46 @@ export default {
            renderOptions.target = this
          }
        }
+        // 处理联动列，联动列只能作用于 select 组件
+        if (column.$type === JVXETypes.select && this._innerLinkageConfig != null) {
+          // 判断当前列是否是联动列
+          if (this._innerLinkageConfig.has(column.key)) {
+            renderOptions.linkage = {
+              config: this._innerLinkageConfig.get(column.key),
+              getLinkageOptionsSibling: this.getLinkageOptionsSibling,
+              getLinkageOptionsAsync: this.getLinkageOptionsAsync,
+              linkageSelectChange: this.linkageSelectChange,
+            }
+          }
+        }
        if (column.editRender) {
          Object.assign(column.editRender, renderOptions)
        }
        if (column.cellRender) {
          Object.assign(column.cellRender, renderOptions)
        }
+        // update--begin--autor:lvdandan-----date:20201019------for:LOWCOD-882 【新行编辑】列表上带按钮的遮挡问题
+        if (column.$type === JVXETypes.file || column.$type === JVXETypes.image) {
+          if (column.width && column.width.endsWith('px')) {
+            column.width = Number.parseInt(column.width.substr(0,column.width.length-2))+Number.parseInt(1)+'px';
+          }
+        }
+        // update--begin--autor:lvdandan-----date:20201019------for:LOWCOD-882 【新行编辑】列表上带按钮的遮挡问题
+
+        // update--begin--autor:lvdandan-----date:20201211------for:JT-118 【online】 日期、时间控件长度较小
+        if (column.$type === JVXETypes.datetime || column.$type === JVXETypes.userSelect || column.$type === JVXETypes.departSelect) {
+          let width = column.width && column.width.endsWith('px')?Number.parseInt(column.width.substr(0,column.width.length-2)):0;
+          if(width <= 190){
+            column.width = '190px'
+          }
+        }
+        if (column.$type === JVXETypes.date) {
+          let width = column.width && column.width.endsWith('px')?Number.parseInt(column.width.substr(0,column.width.length-2)):0;
+          if(width <= 135){
+            column.width = '135px'
+          }
+        }
+        // update--end--autor:lvdandan-----date:20201211------for:JT-118 【online】 日期、时间控件长度较小
      })
      return this._innerColumns
    },
@ -253,15 +295,21 @@ export default {
      immediate: true,
      async handler() {
        let vxe = await getRefPromise(this, 'vxe')
-        // 阻断vue监听大数据，提高性能

-        // 开启了排序就自动计算排序值
-        if (this.dragSort) {
-          this.dataSource.forEach((data, idx) => {
+        this.dataSource.forEach((data, idx) => {
+          // 开启了排序就自动计算排序值
+          if (this.dragSort) {
            this.$set(data, this.dragSortKey, idx + 1)
-          })
-        }
+          }
+          // 处理联动回显数据
+          if (this._innerLinkageConfig != null) {
+            for (let configItem of this._innerLinkageConfig.values()) {
+              this.autoSetLinkageOptionsByData(data, '', configItem, 0)
+            }
+          }
+        })

+        // 阻断vue监听大数据，提高性能
        vxe.loadData(this.dataSource)

        // TODO 解析disabledRows
@ -332,7 +380,7 @@ export default {
                  col.visible = false
                } else if (enhanced.switches.editRender) {
                  renderName = 'editRender'
-                  renderOptions.type = enhanced.switches.visible ? 'visible' : 'default'
+                  renderOptions.type = (enhanced.switches.visible || this.alwaysEdit) ? 'visible' : 'default'
                }
              } else {
                renderOptions.name = JVXETypes._prefix + JVXETypes.normal
@ -444,7 +492,40 @@ export default {
        this._innerColumns = _innerColumns
        this._innerEditRules = _innerEditRules
      }
-    }
+    },
+    // watch linkageConfig
+    // 整理多级联动配置
+    linkageConfig: {
+      immediate: true,
+      handler() {
+        if (Array.isArray(this.linkageConfig) && this.linkageConfig.length > 0) {
+          // 获取联动的key顺序
+          let getLcKeys = (key, arr) => {
+            let col = this._innerColumns.find(col => col.key === key)
+            if (col) {
+              arr.push(col.key)
+              if (col.linkageKey) {
+                return getLcKeys(col.linkageKey, arr)
+              }
+            }
+            return arr
+          }
+          let configMap = new Map()
+          this.linkageConfig.forEach(lc => {
+            let keys = getLcKeys(lc.key, [])
+            // 多个key共享一个，引用地址
+            let configItem = {
+              ...lc, keys,
+              optionsMap: new Map()
+            }
+            keys.forEach(k => configMap.set(k, configItem))
+          })
+          this._innerLinkageConfig = configMap
+        } else {
+          this._innerLinkageConfig = null
+        }
+      }
+    },
  },
  created() {
  },
@ -643,7 +724,24 @@ export default {
    async loadNewData(dataSource) {
      if (Array.isArray(dataSource)) {
        let {xTable} = this.$refs.vxe.$refs
-        return await xTable.loadData(dataSource)
+        // issues/2784
+        // 先清空所有数据
+        xTable.loadData([])
+
+        dataSource.forEach((data, idx) => {
+          // 开启了排序就自动计算排序值
+          if (this.dragSort) {
+            this.$set(data, this.dragSortKey, idx + 1)
+          }
+          // 处理联动回显数据
+          if (this._innerLinkageConfig != null) {
+            for (let configItem of this._innerLinkageConfig.values()) {
+              this.autoSetLinkageOptionsByData(data, '', configItem, 0)
+            }
+          }
+        })
+        // 再新增
+        return xTable.insertAt(dataSource)
      }
      return []
    },
@ -702,6 +800,11 @@ export default {
        deleteData: this.getDeleteData()
      }
    },
+    /** 获取表格表单里的值 */
+    getValues(callback, rowIds) {
+      let tableData = this.getTableData({rowIds: rowIds})
+      callback('', tableData)
+    },
    /** 获取表格数据 */
    getTableData(options = {}) {
      let {rowIds} = options
@ -727,6 +830,11 @@ export default {
      newData.forEach(row => delete row.id)
      return newData
    },
+    /** 仅获取新增的数据,带有id */
+    getNewDataWithId() {
+      let newData = cloneObject(this.$refs.vxe.getInsertRecords())
+      return newData
+    },
    /** 根据ID获取行，新增的行也能查出来 */
    getIfRowById(id) {
      let row = this.getRowById(id), isNew = false
@ -758,10 +866,11 @@ export default {
     * 添加一行或多行
     *
     * @param rows
+     * @param isOnlJs 是否是onlineJS增强触发的
     * @return
     */
-    async addRows(rows = {}) {
-      return this._addOrInsert(rows, -1, 'added')
+    async addRows(rows = {}, isOnlJs) {
+      return this._addOrInsert(rows, -1, 'added', isOnlJs)
    },

    /**
@ -852,9 +961,94 @@ export default {
    trigger(name, event = {}) {
      event.$target = this
      event.$table = this.$refs.vxe
+      //online增强参数兼容
+      event.target = this
      this.$emit(name, event)
    },

+    /** 【多级联动】获取同级联动下拉选项 */
+    getLinkageOptionsSibling(row, col, config, request) {
+      // 如果当前列不是顶级列
+      let key = ''
+      if (col.key !== config.key) {
+        // 就找出联动上级列
+        let idx = config.keys.findIndex(k => col.key === k)
+        let parentKey = config.keys[idx - 1]
+        key = row[parentKey]
+        // 如果联动上级列没有选择数据，就直接返回空数组
+        if (key === '' || key == null) {
+          return []
+        }
+      } else {
+        key = 'root'
+      }
+      let options = config.optionsMap.get(key)
+      if (!Array.isArray(options)) {
+        if (request) {
+          let parent = key === 'root' ? '' : key
+          return this.getLinkageOptionsAsync(config, parent)
+        } else {
+          options = []
+        }
+      }
+      return options
+    },
+    /** 【多级联动】获取联动下拉选项（异步） */
+    getLinkageOptionsAsync(config, parent) {
+      return new Promise(resolve => {
+        let key = parent ? parent : 'root'
+        let options
+        if (config.optionsMap.has(key)) {
+          options = config.optionsMap.get(key)
+          if (options instanceof Promise) {
+            options.then(opt => {
+              config.optionsMap.set(key, opt)
+              resolve(opt)
+            })
+          } else {
+            resolve(options)
+          }
+        } else if (typeof config.requestData === 'function') {
+          // 调用requestData方法，通过传入parent来获取子级
+          let promise = config.requestData(parent)
+          config.optionsMap.set(key, promise)
+          promise.then(opt => {
+            config.optionsMap.set(key, opt)
+            resolve(opt)
+          })
+        } else {
+          resolve([])
+        }
+      })
+    },
+    // 【多级联动】 用于回显数据，自动填充 optionsMap
+    autoSetLinkageOptionsByData(data, parent, config, level) {
+      if (level === 0) {
+        this.getLinkageOptionsAsync(config, '')
+      } else {
+        this.getLinkageOptionsAsync(config, parent)
+      }
+      if (config.keys.length - 1 > level) {
+        let value = data[config.keys[level]]
+        if (value) {
+          this.autoSetLinkageOptionsByData(data, value, config, level + 1)
+        }
+      }
+    },
+    // 【多级联动】联动组件change时，清空下级组件
+    linkageSelectChange(row, col, config, value) {
+      if (col.linkageKey) {
+        this.getLinkageOptionsAsync(config, value)
+        let idx = config.keys.findIndex(k => k === col.key)
+        let values = {}
+        for (let i = idx; i < config.keys.length; i++) {
+          values[config.keys[i]] = ''
+        }
+        // 清空后几列的数据
+        this.setValues([{rowKey: row.id, values}])
+      }
+    },
+
    /** 加载数据字典并合并到 options */
    _loadDictConcatToOptions(column) {
      initDictOptions(column.dictCode).then((res) => {
@ -873,7 +1067,11 @@ export default {
        }
      })
    },
-
+    //options自定义赋值 刷新
+    virtualRefresh(){
+      this.scrolling = true
+      this.closeScrolling()
+    },
    // 设置 this.scrolling 防抖模式
    closeScrolling: simpleDebounce(function () {
      this.scrolling = false
@ -1005,7 +1203,7 @@ export default {
      return await xTable.updateData()
    },

-    async _addOrInsert(rows = {}, index, triggerName) {
+    async _addOrInsert(rows = {}, index, triggerName, isOnlJs) {
      let {xTable} = this.$refs.vxe.$refs
      let records
      if (Array.isArray(rows)) {
@ -1017,14 +1215,19 @@ export default {
      records.forEach(record => this._createRow(record))
      let result = await this.pushRows(records, {index: index, setActive: true})
      // 遍历插入的行
-      for (let i = 0; i < result.rows.length; i++) {
-        let row = result.rows[i]
-        this.trigger(triggerName, {
-          row: row,
-          $table: xTable,
-          target: this,
-        })
+      // update--begin--autor:lvdandan-----date:20201117------for:LOWCOD-987 【新行编辑】js增强附表内置方法调用问题 #1819
+      // online js增强时以传过来值为准，不再赋默认值
+      if (isOnlJs != true) {
+        for (let i = 0; i < result.rows.length; i++) {
+          let row = result.rows[i]
+          this.trigger(triggerName, {
+            row: row,
+            $table: xTable,
+            target: this,
+          })
+        }
      }
+      // update--end--autor:lvdandan-----date:20201117------for:LOWCOD-987 【新行编辑】js增强附表内置方法调用问题 #1819
      return result
    },
    // 创建新行，自动添加默认值
@ -1033,11 +1236,20 @@ export default {
      // 添加默认值
      xTable.tableFullColumn.forEach(column => {
        let col = column.own
-        if (record[col.key] == null || record[col.key] === '') {
+        if (col.key && (record[col.key] == null || record[col.key] === '')) {
          // 设置默认值
-          let createValue = getEnhancedMixins(col.$type, 'createValue')
+          let createValue = getEnhancedMixins(col.$type || col.type, 'createValue')
          record[col.key] = createValue({row: record, column, $table: xTable})
        }
+        // update-begin--author:sunjianlei---date:20210819------for: 处理联动列，联动列只能作用于 select 组件
+        if (col.$type === JVXETypes.select && this._innerLinkageConfig != null) {
+          // 判断当前列是否是联动列
+          if (this._innerLinkageConfig.has(col.key)) {
+            let configItem = this._innerLinkageConfig.get(col.key)
+            this.getLinkageOptionsAsync(configItem, '')
+          }
+        }
+        // update-end--author:sunjianlei---date:20210819------for: 处理联动列，联动列只能作用于 select 组件
      })
      return record
    },
@ -1184,7 +1396,7 @@ export default {
 // 兼容 online 的规则
 const fooPatterns = [
  {title: '非空', value: '*', pattern: /^.+$/},
-  {title: '6到16位数字', value: 'n6-16', pattern: /^\d{6,18}$/},
+  {title: '6到16位数字', value: 'n6-16', pattern: /^\d{6,16}$/},
  {title: '6到16位任意字符', value: '*6-16', pattern: /^.{6,16}$/},
  {title: '6到18位字母', value: 's6-18', pattern: /^[a-z|A-Z]{6,18}$/},
  {title: '网址', value: 'url', pattern: /^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/},
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/JVxeToolbar.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/JVxeToolbar.vue
@ -59,7 +59,7 @@
        // TODO 需要将remove替换batch_delete
        // 系统默认的批量删除编码配置为 batch_delete 此处需要转化一下
        if(exclude.indexOf('batch_delete')>=0){
-          exclude.add('remove')
+          exclude.push('remove')
        }
        // 按钮权限 需要去掉不被授权的按钮
        return arr.filter(item=>{
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeDateCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeDateCell.vue
@ -55,7 +55,9 @@
    // 【组件增强】注释详见：JVxeCellMixins.js
    enhanced: {
      aopEvents: {
-        editActived: event => dispatchEvent(event, 'ant-calendar-picker', el => el.children[0].dispatchEvent(event.$event)),
+        editActived(event) {
+          dispatchEvent.call(this, event, 'ant-calendar-picker', el => el.children[0].dispatchEvent(event.$event))
+        },
      },
    }
  }
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeDepartSelectCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeDepartSelectCell.vue
@ -0,0 +1,170 @@
+<template>
+  <div>
+      <a-input
+        v-show="!departIds"
+        @click="openSelect"
+        placeholder="请点击选择部门"
+        v-model="departNames"
+        readOnly
+        :disabled="componentDisabled"
+        class="jvxe-select-input">
+        <a-icon slot="prefix" type="cluster" title="部门选择控件"/>
+      </a-input>
+      <j-select-depart-modal
+        ref="innerDepartSelectModal"
+        :modal-width="modalWidth"
+        :multi="multi"
+        :rootOpened="rootOpened"
+        :depart-id="departIds"
+        :store="storeField()"
+        :text="textField()"
+        @ok="handleOK"
+        @initComp="initComp"/>
+    <span style="display: inline-block;height:100%;padding-left:14px" v-if="departIds" >
+      <span @click="openSelect" style="display: inline-block;vertical-align: middle">{{ departNames }}</span>
+      <a-icon style="margin-left:5px;vertical-align: middle" type="close-circle" @click="handleEmpty" title="清空"/>
+    </span>
+  </div>
+</template>
+
+<script>
+  import JVxeCellMixins, { dispatchEvent } from '@/components/jeecg/JVxeTable/mixins/JVxeCellMixins'
+  import JSelectDepartModal from '@/components/jeecgbiz/modal/JSelectDepartModal'
+
+  export default {
+    name: 'JVxeDepartSelectCell',
+    mixins: [JVxeCellMixins],
+    components:{
+      JSelectDepartModal
+    },
+    data() {
+      return {
+        departNames: '',
+        departIds: '',
+        selectedOptions: [],
+        customReturnField: 'id'
+      }
+    },
+    computed: {
+      custProps() {
+        const {departIds, originColumn: col, caseId, cellProps} = this
+        return {
+          ...cellProps,
+          value: departIds,
+          field: col.field || col.key,
+          groupId: caseId,
+          class: 'jvxe-select'
+        }
+      },
+      componentDisabled(){
+        if(this.cellProps.disabled==true){
+          return true
+        }
+        return false
+      },
+      modalWidth(){
+        if(this.cellProps.modalWidth){
+          return this.cellProps.modalWidth
+        }else{
+          return 500
+        }
+      },
+      multi(){
+        if(this.cellProps.multi==false || this.originColumn.multi===false){
+          return false
+        }else{
+          return true
+        }
+      },
+      rootOpened(){
+        if(this.cellProps.open==false){
+          return false
+        }else{
+          return true
+        }
+      }
+    },
+    watch: {
+      innerValue: {
+        immediate: true,
+        handler(val) {
+          if (val == null || val === '') {
+            this.departIds = ''
+          } else {
+            this.departIds = val
+          }
+        }
+      }
+    },
+    methods: {
+      openSelect(){
+        this.$refs.innerDepartSelectModal.show()
+      },
+      handleEmpty(){
+        this.handleOK('')
+      },
+      handleOK(rows) {
+        let value = ''
+        if (!rows && rows.length <= 0) {
+          this.departNames = ''
+          this.departIds = ''
+        } else {
+          let storeField = this.storeField();
+          let textField = this.textField();
+          value = rows.map(row => row[storeField]).join(',')
+          this.departNames = rows.map(row => row[textField]).join(',')
+          this.departIds = value
+        }
+        this.handleChangeCommon(this.departIds)
+      },
+      initComp(departNames){
+        this.departNames = departNames
+      },
+      handleChange(value) {
+        this.handleChangeCommon(value)
+      },
+      storeField(){
+        if(this.originColumn){
+          const str = this.originColumn.fieldExtendJson
+          if(str){
+            let json = JSON.parse(str)
+            if(json && json.store){
+              return json.store
+            }
+          }else if(this.originColumn.store){
+            return this.originColumn.store
+          }
+        }
+        return 'id'
+      },
+      textField(){
+        if(this.originColumn){
+          const str = this.originColumn.fieldExtendJson
+          if(str){
+            let json = JSON.parse(str)
+            if(json && json.text){
+              return json.text
+            }
+          }else if(this.originColumn.text){
+            return this.originColumn.text
+          }
+        }
+        return 'departName'
+      }
+    },
+    enhanced: {
+      switches: {
+        visible: true
+      },
+      translate: {
+        enabled: false
+      }
+    }
+  }
+</script>
+
+<style scoped>
+  /deep/ .jvxe-select-input .ant-input{
+    border: none !important;
+  }
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeDragSortCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeDragSortCell.vue
@ -34,7 +34,7 @@
        return this.rowIndex === 0
      },
      disabledMoveDown() {
-        return this.rowIndex === (this.rows.length - 1)
+        return this.rowIndex === (this.fullDataLength - 1)
      },
    },
    methods: {
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeSelectCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeSelectCell.vue
@ -7,11 +7,16 @@
    v-bind="selectProps"
    style="width: 100%;"
    @blur="handleBlur"
-    @change="handleChangeCommon"
+    @change="handleChange"
    @search="handleSearchSelect"
  >

-    <template v-for="option of originColumn.options">
+    <div v-if="loading" slot="notFoundContent">
+      <a-icon type="loading"  />
+      <span>&nbsp;加载中…</span>
+    </div>
+
+    <template v-for="option of selectOptions">
      <a-select-option :key="option.value" :value="option.value" :disabled="option.disabled">
        <span>{{option.text || option.label || option.title|| option.value}}</span>
      </a-select-option>
@ -23,10 +28,18 @@
 <script>
  import JVxeCellMixins, { dispatchEvent } from '@/components/jeecg/JVxeTable/mixins/JVxeCellMixins'
  import { JVXETypes } from '@comp/jeecg/JVxeTable/index'
+  import { filterDictText } from '@comp/dict/JDictSelectUtil'

  export default {
    name: 'JVxeSelectCell',
    mixins: [JVxeCellMixins],
+    data(){
+      return {
+        loading: false,
+        // 异步加载的options（用于多级联动）
+        asyncOptions: null,
+      }
+    },
    computed: {
      selectProps() {
        let props = {...this.cellProps}
@ -37,6 +50,32 @@
        }
        return props
      },
+      // 下拉选项
+      selectOptions() {
+        if (this.asyncOptions) {
+          return this.asyncOptions
+        }
+        let {linkage} = this.renderOptions
+        if (linkage) {
+          let {getLinkageOptionsSibling, config} = linkage
+          let res = getLinkageOptionsSibling(this.row, this.originColumn, config, true)
+          // 当返回Promise时，说明是多级联动
+          if (res instanceof Promise) {
+            this.loading = true
+            res.then(opt => {
+              this.asyncOptions = opt
+              this.loading = false
+            }).catch(e => {
+              console.error(e)
+              this.loading = false
+            })
+          } else {
+            this.asyncOptions = null
+            return res
+          }
+        }
+        return this.originColumn.options
+      },
    },
    created() {
      let multiple = [JVXETypes.selectMultiple, JVXETypes.list_multi]
@ -54,6 +93,15 @@
    },
    methods: {

+      handleChange(value) {
+        // 处理下级联动
+        let linkage = this.renderOptions.linkage
+        if (linkage) {
+          linkage.linkageSelectChange(this.row, this.originColumn, linkage.config, value)
+        }
+        this.handleChangeCommon(value)
+      },
+
      /** 处理blur失去焦点事件 */
      handleBlur(value) {
        let {allowInput, options} = this.originColumn
@ -116,9 +164,32 @@
    // 【组件增强】注释详见：JVxeCellMixins.js
    enhanced: {
      aopEvents: {
-        editActived: event => dispatchEvent(event, 'ant-select'),
+        editActived(event) {
+          dispatchEvent.call(this, event, 'ant-select')
+        },
+      },
+      translate: {
+        enabled: true,
+        async handler(value,) {
+          let options
+          let {linkage} = this.renderOptions
+          // 判断是否是多级联动，如果是就通过接口异步翻译
+          if (linkage) {
+            let {getLinkageOptionsSibling, config} = linkage
+            options = getLinkageOptionsSibling(this.row, this.originColumn, config, true)
+            if (options instanceof Promise) {
+              return new Promise(resolve => {
+                options.then(opt => {
+                  resolve(filterDictText(opt, value))
+                })
+              })
+            }
+          } else {
+            options = this.column.own.options
+          }
+          return filterDictText(options, value)
+        },
      },
-      translate: {enabled: true},
      getValue(value) {
        if (Array.isArray(value)) {
          return value.join(',')
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeTextareaCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeTextareaCell.vue
@ -23,7 +23,9 @@
        autofocus: '.ant-input',
      },
      aopEvents: {
-        editActived: event => dispatchEvent(event, 'anticon-fullscreen'),
+        editActived(event) {
+          dispatchEvent.call(this, event, 'anticon-fullscreen')
+        },
      },
    },
  }
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeTimeCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeTimeCell.vue
@ -0,0 +1,57 @@
+<template>
+  <a-time-picker
+    ref="timePicker"
+    :value="innerDateValue"
+    allowClear
+    dropdownClassName="j-vxe-date-picker"
+    style="min-width: 0;"
+    v-bind="cellProps"
+    @change="handleChange"
+  />
+</template>
+
+<script>
+  import moment from 'moment'
+  import JVxeCellMixins, { dispatchEvent } from '@/components/jeecg/JVxeTable/mixins/JVxeCellMixins'
+
+  export default {
+    name: 'JVxeTimeCell',
+    mixins: [JVxeCellMixins],
+    props: {},
+    data() {
+      return {
+        innerDateValue: null,
+        dateFormat: 'HH:mm:ss'
+      }
+    },
+    watch: {
+      innerValue: {
+        immediate: true,
+        handler(val) {
+          if (val == null || val === '') {
+            this.innerDateValue = null
+          } else {
+            this.innerDateValue = moment(val, this.dateFormat)
+          }
+        }
+      }
+    },
+    methods: {
+      handleChange(mom, dateStr) {
+        this.handleChangeCommon(dateStr)
+      }
+    },
+    // 【组件增强】注释详见：JVxeCellMixins.js
+    enhanced: {
+      aopEvents: {
+        editActived(event) {
+          dispatchEvent.call(this, event, 'ant-calendar-picker', el => el.children[0].dispatchEvent(event.$event))
+        },
+      },
+    }
+  }
+</script>
+
+<style scoped>
+
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeUploadCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeUploadCell.vue
@ -14,7 +14,7 @@
          <a-tooltip v-else-if="file.status === 'done'" title="上传完成">
            <a-icon type="check-circle" style="color:#00DB00;"/>
          </a-tooltip>
-          <a-tooltip v-else title="上传失败">
+          <a-tooltip v-else :title="file.message||'上传失败'">
            <a-icon type="exclamation-circle" style="color:red;"/>
          </a-tooltip>
        </template>
@ -118,8 +118,17 @@
          value['responseName'] = file.response[col.responseName]
        }
        if (file.status === 'done') {
-          value['path'] = file.response[col.responseName]
-          this.handleChangeCommon(value)
+          if (typeof file.response.success === 'boolean') {
+            if (file.response.success) {
+              value['path'] = file.response[col.responseName]
+            } else {
+              value['status'] = 'error'
+              value['message'] = file.response.message || '未知错误'
+            }
+          } else {
+            // 考虑到如果设置action上传路径为非jeecg-boot后台，可能不会返回 success 属性的情况，就默认为成功
+            value['path'] = file.response[col.responseName]
+          }
        } else if (file.status === 'error') {
          value['message'] = file.response.message || '未知错误'
        }
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeUserSelectCell.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/components/cells/JVxeUserSelectCell.vue
@ -0,0 +1,158 @@
+<template>
+  <div>
+    <a-input
+      v-show="!userIds"
+      @click="openSelect"
+      placeholder="请选择用户"
+      v-model="userNames"
+      readOnly
+      class="jvxe-select-input"
+      :disabled="componentDisabled">
+      <a-icon slot="prefix" type="user" title="用户选择控件"/>
+    </a-input>
+    <j-select-user-by-dep-modal
+      ref="selectModal"
+      :modal-width="modalWidth"
+      :multi="multi"
+      :user-ids="userIds"
+      @ok="selectOK"
+      :store="storeField"
+      :text="textField"
+      @initComp="initComp"/>
+    <span style="display: inline-block;height:100%;padding-left:14px" v-if="userIds" >
+      <span @click="openSelect" style="display: inline-block;vertical-align: middle">{{ userNames }}</span>
+      <a-icon style="margin-left:5px;vertical-align: middle" type="close-circle" @click="handleEmpty" title="清空"/>
+    </span>
+  </div>
+
+ <!-- <j-select-user-by-dep
+    v-bind="custProps"
+    @change="handleChange"
+    :trigger-change="true">
+  </j-select-user-by-dep>-->
+</template>
+
+<script>
+  import JVxeCellMixins, { dispatchEvent } from '@/components/jeecg/JVxeTable/mixins/JVxeCellMixins'
+  import JSelectUserByDepModal from '@/components/jeecgbiz/modal/JSelectUserByDepModal'
+
+  export default {
+    name: 'JVxeUserSelectCell',
+    mixins: [JVxeCellMixins],
+    components: { JSelectUserByDepModal },
+    data() {
+      return {
+        userIds:'',
+        userNames:'',
+        innerUserValue: '',
+        selectedOptions: []
+      }
+    },
+    computed: {
+      custProps() {
+        const {userIds, originColumn: col, caseId, cellProps} = this
+        return {
+          ...cellProps,
+          value: userIds,
+          field: col.field || col.key,
+          groupId: caseId,
+          class: 'jvxe-select'
+        }
+      },
+      componentDisabled(){
+        console.log('333',this.cellProps)
+        if(this.cellProps.disabled==true){
+          return true
+        }
+        return false
+      },
+      modalWidth(){
+        if(this.cellProps.modalWidth){
+          return this.cellProps.modalWidth
+        }else{
+          return 1250
+        }
+      },
+      multi(){
+        if(this.cellProps.multi==false){
+          return false
+        }else{
+          return true
+        }
+      },
+      storeField(){
+        if(this.originColumn){
+          const str = this.originColumn.fieldExtendJson
+          if(str){
+            let json = JSON.parse(str)
+            if(json && json.store){
+              return json.store
+            }
+          }
+        }
+        return 'username'
+      },
+      textField(){
+        if(this.originColumn){
+          const str = this.originColumn.fieldExtendJson
+          if(str){
+            let json = JSON.parse(str)
+            if(json && json.text){
+              return json.text
+            }
+          }
+        }
+        return 'realname'
+      }
+    },
+    watch: {
+      innerValue: {
+        immediate: true,
+        handler(val) {
+          if (val == null || val === '') {
+            this.userIds = ''
+          } else {
+            this.userIds = val
+          }
+        }
+      }
+    },
+    methods: {
+      openSelect() {
+        this.$refs.selectModal.showModal()
+      },
+      selectOK(rows, idstr) {
+        console.log("当前选中用户", rows)
+        console.log("当前选中用户ID", idstr)
+        if (!rows) {
+          this.userNames = ''
+          this.userIds = ''
+        } else {
+          this.userIds = rows.map(row => row[this.storeField]).join(',')
+          this.userNames = rows.map(row => row[this.textField]).join(',')
+        }
+        this.handleChangeCommon(this.userIds)
+      },
+      handleEmpty(){
+        this.selectOK('')
+      },
+      initComp(userNames) {
+        this.userNames = userNames
+      },
+    },
+    enhanced: {
+      switches: {
+        visible: true
+      },
+      translate: {
+        enabled: false
+      }
+    }
+  }
+</script>
+
+<style scoped>
+  /deep/ .jvxe-select-input .ant-input {
+    border: none !important;
+  }
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/index.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/index.js
@ -1,3 +1,4 @@
+import * as jvxeTypes from './jvxeTypes'
 import { installCell, mapCell } from './install'
 import JVxeTable from './components/JVxeTable'

@ -5,6 +6,7 @@ import JVxeSlotCell from './components/cells/JVxeSlotCell'
 import JVxeNormalCell from './components/cells/JVxeNormalCell'
 import JVxeInputCell from './components/cells/JVxeInputCell'
 import JVxeDateCell from './components/cells/JVxeDateCell'
+import JVxeTimeCell from './components/cells/JVxeTimeCell'
 import JVxeSelectCell from './components/cells/JVxeSelectCell'
 import JVxeCheckboxCell from './components/cells/JVxeCheckboxCell'
 import JVxeUploadCell from './components/cells/JVxeUploadCell'
@ -12,46 +14,13 @@ import { TagsInputCell, TagsSpanCell } from './components/cells/JVxeTagsCell'
 import JVxeProgressCell from './components/cells/JVxeProgressCell'
 import JVxeTextareaCell from './components/cells/JVxeTextareaCell'
 import JVxeDragSortCell from './components/cells/JVxeDragSortCell'
+import JVxeDepartSelectCell from './components/cells/JVxeDepartSelectCell'
+import JVxeUserSelectCell from './components/cells/JVxeUserSelectCell'

+//update--begin--autor:lvdandan-----date:20201216------for：JVxeTable--JVXETypes 【online】代码结构调整，便于online打包
 // 组件类型
-export const JVXETypes = {
-  // 为了防止和 vxe 内置的类型冲突，所以加上一个前缀
-  // 前缀是自动加的，代码中直接用就行（JVXETypes.input）
-  _prefix: 'j-',
-
-  // 行号列
-  rowNumber: 'row-number',
-  // 选择列
-  rowCheckbox: 'row-checkbox',
-  // 单选列
-  rowRadio: 'row-radio',
-  // 展开列
-  rowExpand: 'row-expand',
-  // 上下排序
-  rowDragSort: 'row-drag-sort',
-
-  input: 'input',
-  inputNumber: 'inputNumber',
-  textarea: 'textarea',
-  select: 'select',
-  date: 'date',
-  datetime: 'datetime',
-  checkbox: 'checkbox',
-  upload: 'upload',
-  // 下拉搜索
-  selectSearch: 'select-search',
-  // 下拉多选
-  selectMultiple: 'select-multiple',
-  // 进度条
-  progress: 'progress',
-
-  // 拖轮Tags（暂无用）
-  tags: 'tags',
-
-  slot: 'slot',
-  normal: 'normal',
-  hidden: 'hidden',
-}
+export const JVXETypes = jvxeTypes.JVXETypes
+//update--end--autor:lvdandan-----date:20201216------for：JVxeTable--JVXETypes 【online】代码结构调整，便于online打包

 // 注册自定义组件
 export const AllCells = {
@ -64,6 +33,7 @@ export const AllCells = {
  ...mapCell(JVXETypes.selectMultiple, JVxeSelectCell),  // 下拉多选
  ...mapCell(JVXETypes.date, JVxeDateCell),
  ...mapCell(JVXETypes.datetime, JVxeDateCell),
+  ...mapCell(JVXETypes.time, JVxeTimeCell),
  ...mapCell(JVXETypes.upload, JVxeUploadCell),
  ...mapCell(JVXETypes.textarea, JVxeTextareaCell),

@ -72,6 +42,8 @@ export const AllCells = {

  ...mapCell(JVXETypes.rowDragSort, JVxeDragSortCell),
  ...mapCell(JVXETypes.slot, JVxeSlotCell),
+  ...mapCell(JVXETypes.departSelect, JVxeDepartSelectCell),
+  ...mapCell(JVXETypes.userSelect, JVxeUserSelectCell)

  /* hidden 是特殊的组件，不在这里注册 */
 }
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/install.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/install.js
@ -62,8 +62,8 @@ VXETable.interceptor.add('event.clearActived', function (params, event, target)
    if (className.includes('j-input-pop')) {
      return false
    }
-    // 点击的标签是JPopup的弹出层
-    if (className.includes('j-popup-modal')) {
+    // 点击的标签是JPopup的弹出层、部门选择、用户选择
+    if (className.includes('j-popup-modal') || className.includes('j-depart-select-modal') || className.includes('j-user-select-modal')) {
      return false
    }
    // 执行增强
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/jvxeTypes.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/jvxeTypes.js
@ -0,0 +1,45 @@
+// 组件类型
+export default JVXETypes
+export const JVXETypes = {
+  // 为了防止和 vxe 内置的类型冲突，所以加上一个前缀
+  // 前缀是自动加的，代码中直接用就行（JVXETypes.input）
+  _prefix: 'j-',
+
+  // 行号列
+  rowNumber: 'row-number',
+  // 选择列
+  rowCheckbox: 'row-checkbox',
+  // 单选列
+  rowRadio: 'row-radio',
+  // 展开列
+  rowExpand: 'row-expand',
+  // 上下排序
+  rowDragSort: 'row-drag-sort',
+
+  input: 'input',
+  inputNumber: 'inputNumber',
+  textarea: 'textarea',
+  select: 'select',
+  date: 'date',
+  datetime: 'datetime',
+  time: 'time',
+  checkbox: 'checkbox',
+  upload: 'upload',
+  // 下拉搜索
+  selectSearch: 'select-search',
+  // 下拉多选
+  selectMultiple: 'select-multiple',
+  // 进度条
+  progress: 'progress',
+  //部门选择
+  departSelect: 'sel_depart',
+  //用户选择
+  userSelect: 'sel_user',
+
+  // 拖轮Tags（暂无用）
+  tags: 'tags',
+
+  slot: 'slot',
+  normal: 'normal',
+  hidden: 'hidden',
+}
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/mixins/JVxeCellMixins.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/mixins/JVxeCellMixins.js
@ -36,6 +36,9 @@ export default {
    rows() {
      return this.params.data
    },
+    fullDataLength() {
+      return this.params.$table.tableFullData.length
+    },
    rowIndex() {
      return this.params.rowIndex
    },
@ -70,6 +73,16 @@ export default {
        props['disabled'] = true
      }

+      // update-begin-author:taoyan date:20211011 for: online表单，附表用户选择器{"multiSelect":false}不生效，单表可以生效 #3036
+      let jsonStr = col['fieldExtendJson']
+      if(jsonStr){
+        let fieldExtendJson = JSON.parse(jsonStr)
+        if(fieldExtendJson && fieldExtendJson['multiSelect']==false){
+          props['multi'] = false
+        }
+      }
+      // update-end-author:taoyan date:20211011 for: online表单，附表用户选择器{"multiSelect":false}不生效，单表可以生效 #3036
+
      return props
    },
  },
@ -99,7 +112,13 @@ export default {

        // 判断是否启用翻译
        if (this.renderType === JVXERenderType.spaner && this.enhanced.translate.enabled) {
-          this.innerValue = this.enhanced.translate.handler.call(this, value)
+          let res = this.enhanced.translate.handler.call(this, value)
+          // 异步翻译，目前仅【多级联动】使用
+          if (res instanceof Promise) {
+            res.then(value => this.innerValue = value)
+          } else {
+            this.innerValue = res
+          }
        }
      },
    },
@ -149,6 +168,8 @@ export default {
    packageEvent(name, event = {}) {
      event.row = this.row
      event.column = this.column
+      //online增强参数兼容
+      event.column['key'] = this.column['property']
      event.cellTarget = this
      if (!event.type) {
        event.type = name
@ -289,6 +310,10 @@ export function vModel(value, row, property) {

 /** 模拟触发事件 */
 export function dispatchEvent({cell, $event}, className, handler) {
+  // alwaysEdit 下不模拟触发事件，否者会导致触发两次
+  if (this && this.alwaysEdit) {
+    return
+  }
  window.setTimeout(() => {
    let element = cell.getElementsByClassName(className)
    if (element && element.length > 0) {
@ -296,7 +321,9 @@ export function dispatchEvent({cell, $event}, className, handler) {
        handler(element[0])
      } else {
        // 模拟触发点击事件
-        element[0].dispatchEvent($event)
+        if($event){
+          element[0].dispatchEvent($event)
+        }
      }
    }
  }, 10)
--- a/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/utils/vxeUtils.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/JVxeTable/utils/vxeUtils.js
@ -141,6 +141,33 @@ export async function validateFormAndTables(form, cases, autoJumpTab) {
  return dataMap
 }

+/**
+ * 一次性验证主表单和所有的次表单
+ * @param form 主表单 form 对象
+ * @param cases 接收一个数组，每项都是一个JVxeTable实例
+ * @param autoJumpTab
+ * @returns {Promise<any>}
+ * @author sunjianlei
+ */
+export async function validateFormModelAndTables(form,formData, cases, autoJumpTab) {
+  if (!(form && typeof form.validate === 'function')) {
+    throw `form 参数需要的是一个form对象，而传入的却是${typeof form}`
+  }
+  let dataMap = {}
+  let values = await new Promise((resolve, reject) => {
+    // 验证主表表单
+    form.validate((valid,obj) => {
+      valid ?resolve(formData): reject({error: VALIDATE_FAILED, originError: valid})
+    })
+  })
+  Object.assign(dataMap, {formValue: values})
+  // 验证所有子表的表单
+  let subData = await validateTables(cases, autoJumpTab)
+  // 合并最终数据
+  dataMap = Object.assign(dataMap, {tablesValue: subData})
+  return dataMap
+}
+
 /**
 * 验证并获取一个或多个表格的所有值
 *
--- a/ant-design-vue-jeecg/src/components/jeecg/README.md
+++ b/ant-design-vue-jeecg/src/components/jeecg/README.md
@ -258,7 +258,7 @@ export default {
    components: { JTreeTable },
    data() {
      return {
-        url: '/api/asynTreeList',
+        url: '/mock/api/asynTreeList',
        columns: [
          { title: '菜单名称', dataIndex: 'name' },
          { title: '组件', dataIndex: 'component' },
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/JEditorDyn.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/JEditorDyn.vue
@ -1,246 +0,0 @@
-<template>
-  <div class="tinymce-containerty" :style="{width:containerWidth}">
-    <textarea :id="tinymceId" class="tinymce-textarea" @change="ada"/>
-  </div>
-</template>
-
-<script>
-  /**
-   * docs:
-   * https://panjiachen.github.io/vue-element-admin-site/feature/component/rich-editor.html#tinymce
-   */
-  import load from './load'
-  //const toolbar = ['searchreplace bold italic underline strikethrough alignleft aligncenter alignright outdent indent  blockquote undo redo removeformat subscript superscript code codesample', 'hr bullist numlist link image charmap preview anchor pagebreak insertdatetime media table emoticons forecolor backcolor fullscreen']
-  //const plugins = ['advlist anchor autolink autosave code codesample colorpicker colorpicker contextmenu directionality emoticons fullscreen hr image imagetools insertdatetime link lists media nonbreaking noneditable pagebreak paste preview print save searchreplace spellchecker tabfocus table template textcolor textpattern visualblocks visualchars wordcount']
-  // why use this cdn, detail see https://github.com/PanJiaChen/tinymce-all-in-one
-  const tinymceCDN = 'https://cdn.jsdelivr.net/npm/tinymce-all-in-one@4.9.3/tinymce.min.js'
-
-  export default {
-    name: 'JEditorDyn',
-    props: {
-      id: {
-        type: String,
-        default: function() {
-          return 'vue-tinymce-' + +new Date() + ((Math.random() * 1000).toFixed(0) + '')
-        }
-      },
-      value: {
-        type: String,
-        default: ''
-      },
-      toolbar: {
-        type: [String, Array],
-        required: false,
-        default: 'undo redo |  formatselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | lists link unlink image media table | removeformat | fullscreen',
-      },
-      menubar: {
-        type: String,
-        default: 'file edit insert view format table'
-      },
-      height: {
-        type: [Number, String],
-        required: false,
-        default: 360
-      },
-      width: {
-        type: [Number, String],
-        required: false,
-        default: 'auto'
-      },
-      plugins: {
-        type: [String, Array],
-        default: 'lists image link media table textcolor wordcount contextmenu fullscreen'
-      }
-    },
-    data() {
-      return {
-        hasChange: false,
-        hasInit: false,
-        tinymceId: this.id,
-        fullscreen: false,
-        languageTypeList: {
-          'en': 'en',
-          'zh': 'zh_CN',
-          'es': 'es_MX',
-          'ja': 'ja'
-        }
-      }
-    },
-    computed: {
-      containerWidth() {
-        const width = this.width
-        if (/^[\d]+(\.[\d]+)?$/.test(width)) { // matches `100`, `'100'`
-          return `${width}px`
-        }
-        return width
-      }
-    },
-    watch: {
-      value(val) {
-        if (!this.hasChange && this.hasInit) {
-          this.$nextTick(() =>
-            window.tinymce.get(this.tinymceId).setContent(val || ''))
-        }
-      }
-    },
-    mounted() {
-      this.init()
-    },
-    activated() {
-      if (window.tinymce) {
-        this.initTinymce()
-      }
-    },
-    deactivated() {
-      this.destroyTinymce()
-    },
-    destroyed() {
-      this.destroyTinymce()
-    },
-    methods: {
-      ada() {
-        console.log('change')
-      },
-      init() {
-        // dynamic load tinymce from cdn
-        load(tinymceCDN, (err) => {
-          if (err) {
-            this.$message.error(err.message)
-            return
-          }
-          this.initTinymce()
-        })
-      },
-      initTinymce() {
-        const _this = this
-        window.tinymce.init({
-          selector: `#${this.tinymceId}`,
-          language: this.languageTypeList['zh'],
-          height: this.height,
-          body_class: 'panel-body ',
-          object_resizing: false,
-          toolbar: this.toolbar,
-          menubar: false,
-          plugins: this.plugins,
-          end_container_on_empty_block: true,
-          powerpaste_word_import: 'clean',
-          code_dialog_height: 450,
-          code_dialog_width: 1000,
-          advlist_bullet_styles: 'square',
-          advlist_number_styles: 'default',
-          imagetools_cors_hosts: ['www.tinymce.com', 'codepen.io'],
-          default_link_target: '_blank',
-          link_title: false,
-          nonbreaking_force_tab: true, // inserting nonbreaking space &nbsp; need Nonbreaking Space Plugin
-          init_instance_callback: editor => {
-            if (_this.value) {
-              editor.setContent(_this.value)
-            }
-            _this.hasInit = true
-            editor.on('NodeChange Change KeyUp SetContent', () => {
-              this.hasChange = true
-              this.$emit('input', editor.getContent())
-            })
-          },
-          setup(editor) {
-            editor.on('FullscreenStateChanged', (e) => {
-              _this.fullscreen = e.state
-            })
-          },
-          // it will try to keep these URLs intact
-          // https://www.tiny.cloud/docs-3x/reference/configuration/Configuration3x@convert_urls/
-          // https://stackoverflow.com/questions/5196205/disable-tinymce-absolute-to-relative-url-conversions
-          convert_urls: false
-          // 整合七牛上传
-          // images_dataimg_filter(img) {
-          //   setTimeout(() => {
-          //     const $image = $(img);
-          //     $image.removeAttr('width');
-          //     $image.removeAttr('height');
-          //     if ($image[0].height && $image[0].width) {
-          //       $image.attr('data-wscntype', 'image');
-          //       $image.attr('data-wscnh', $image[0].height);
-          //       $image.attr('data-wscnw', $image[0].width);
-          //       $image.addClass('wscnph');
-          //     }
-          //   }, 0);
-          //   return img
-          // },
-          // images_upload_handler(blobInfo, success, failure, progress) {
-          //   progress(0);
-          //   const token = _this.$store.getters.token;
-          //   getToken(token).then(response => {
-          //     const url = response.data.qiniu_url;
-          //     const formData = new FormData();
-          //     formData.append('token', response.data.qiniu_token);
-          //     formData.append('key', response.data.qiniu_key);
-          //     formData.append('file', blobInfo.blob(), url);
-          //     upload(formData).then(() => {
-          //       success(url);
-          //       progress(100);
-          //     })
-          //   }).catch(err => {
-          //     failure('err')
-          //     console.log(err);
-          //   });
-          // },
-        })
-      },
-      destroyTinymce() {
-        const tinymce = window.tinymce.get(this.tinymceId)
-        if (this.fullscreen) {
-          tinymce.execCommand('mceFullScreen')
-        }
-
-        if (tinymce) {
-          tinymce.destroy()
-        }
-      },
-      setContent(value) {
-        window.tinymce.get(this.tinymceId).setContent(value)
-      },
-      getContent() {
-        window.tinymce.get(this.tinymceId).getContent()
-      },
-      imageSuccessCBK(arr) {
-        arr.forEach(v => window.tinymce.get(this.tinymceId).insertContent(`<img class="wscnph" src="${v.url}" >`))
-      }
-    }
-  }
-</script>
-
-<style lang="less" scoped>
-  .tinymce-containerty {
-    position: relative;
-    line-height: normal;
-  }
-
-  .tinymce-containerty {
-    ::v-deep {
-      .mce-fullscreen {
-        z-index: 10000;
-      }
-    }
-  }
-
-  .tinymce-textarea {
-    visibility: hidden;
-    z-index: -1;
-  }
-
-  .editor-custom-btn-container {
-    position: absolute;
-    right: 4px;
-    top: 4px;
-    /*z-index: 2005;*/
-  }
-
-  .fullscreen .editor-custom-btn-container {
-    z-index: 10000;
-    position: fixed;
-  }
-
-  .editor-upload-btn {
-    display: inline-block;
-  }
-</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/JMdEditorDyn.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/JMdEditorDyn.vue
@ -1,142 +0,0 @@
-<template>
-  <div class="j-markdown-editor" :id="dynamicId"/>
-</template>
-
-<script>
-  import load from './load'
-  import { md_js, md_zh_cn_js } from './Resource'
-  import defaultOptions from '@/components/jeecg/JMarkdownEditor/default-options.js'
-
-  export default {
-    name: 'JMdEditorDyn',
-    props: {
-      value: {
-        type: String,
-        default: ''
-      },
-      id: {
-        type: String,
-        required: false,
-        default() {
-          return 'markdown-editor-' + +new Date() + ((Math.random() * 1000).toFixed(0) + '')
-        }
-      },
-      options: {
-        type: Object,
-        default() {
-          return defaultOptions
-        }
-      },
-      mode: {
-        type: String,
-        default: 'markdown'
-      },
-      height: {
-        type: String,
-        required: false,
-        default: '300px'
-      },
-      language: {
-        type: String,
-        required: false,
-        default: 'zh-CN'
-      }
-    },
-    data() {
-      return {
-        editor: null,
-        dynamicId: this.id
-      }
-    },
-    computed: {
-      editorOptions() {
-        const options = Object.assign({}, defaultOptions, this.options)
-        options.initialEditType = this.mode
-        options.height = this.height
-        options.language = this.language
-        return options
-      }
-    },
-    watch: {
-      value(newValue, preValue) {
-        if (newValue !== preValue && newValue !== this.editor.getMarkdown()) {
-          this.editor.setMarkdown(newValue)
-        }
-      },
-      language(val) {
-        this.destroyEditor()
-        this.initEditor()
-      },
-      height(newValue) {
-        this.editor.height(newValue)
-      },
-      mode(newValue) {
-        this.editor.changeMode(newValue)
-      }
-    },
-    mounted() {
-      this.init()
-    },
-    destroyed() {
-      this.destroyEditor()
-    },
-    methods: {
-      init(){
-
-        this.initEditor()
-       /* load(md_js,'',()=>{
-          load(md_zh_cn_js,'',()=>{
-
-          })
-        })*/
-      },
-      initEditor() {
-        const Editor = toastui.Editor
-        this.editor = new Editor({
-          el: document.getElementById(this.dynamicId),
-          ...this.editorOptions
-        })
-        if (this.value) {
-          this.editor.setMarkdown(this.value)
-        }
-        this.editor.on('change', () => {
-          this.$emit('change', this.editor.getMarkdown())
-        })
-      },
-      destroyEditor() {
-        if (!this.editor) return
-        this.editor.off('change')
-        this.editor.remove()
-      },
-      setMarkdown(value) {
-        this.editor.setMarkdown(value)
-      },
-      getMarkdown() {
-        return this.editor.getMarkdown()
-      },
-      setHtml(value) {
-        this.editor.setHtml(value)
-      },
-      getHtml() {
-        return this.editor.getHtml()
-      }
-    },
-    model: {
-      prop: 'value',
-      event: 'change'
-    }
-  }
-</script>
-<style scoped lang="less">
-
-  .j-markdown-editor {
-    /deep/ .tui-editor-defaultUI {
-      .te-mode-switch,
-      .tui-scrollsync
-      {
-        line-height: 1.5;
-      }
-    }
-  }
-
-</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/JSqlCodeEditorDyn.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/JSqlCodeEditorDyn.vue
@ -1,325 +0,0 @@
-<template>
-  <div class="jeecg-editor-ty" :class="fullCoder?'jeecg-editor-max':'jeecg-editor-min'">
-    <a-icon v-if="fullScreen" class="full-screen-icon" :type="iconType" @click="()=>fullCoder=!fullCoder"/>
-    <textarea :id="dynamicId" />
-    <span @click="nullTipClick" class="null-tip" :class="{'null-tip-hidden': hasCode}" :style="nullTipStyle">{{ placeholderShow }}</span>
-  </div>
-</template>
-
-<script>
-  import load from './load'
-  import '@/assets/less/codemirror_idea.css'
-  import './cm_sql_hint.js'
-  import { sql_keyword } from './Resource'
-
-
-  export default {
-    name: 'JSqlCodeEditorDyn',
-    props:{
-      id: {
-        type: String,
-        default: function() {
-          return 'vue-editor-' + new Date() + ((Math.random() * 1000).toFixed(0) + '')
-        }
-      },
-      value: {
-        type: String,
-        default: ''
-      },
-      // 显示行号
-      lineNumbers: {
-        type: Boolean,
-        default: true
-      },
-      placeholder: {
-        type: String,
-        default: ''
-      },
-      zIndex: {
-        type: [Number, String],
-        default: 999
-      },
-      autoHeight: {
-        type: [String, Boolean],
-        default: true
-      },
-      // 不自适应高度的情况下生效的固定高度
-      height: {
-        type: [String, Number],
-        default: '240px'
-      },
-      autoHeight: {
-        type: [String, Boolean],
-        default: true
-      },
-      // 是否显示全屏按钮
-      fullScreen: {
-        type: Boolean,
-        default: false
-      },
-      autoHint:{
-        type: Boolean,
-        default: true
-      }
-
-    },
-    data(){
-      return {
-        dynamicId: this.id,
-        coder: '',
-        hasCode: false,
-        code: '',
-        // code 编辑器 是否全屏
-        fullCoder: false,
-        iconType: 'fullscreen',
-      }
-    },
-    computed:{
-      placeholderShow() {
-        if (this.placeholder == null) {
-          return `请在此输入javascript代码`
-        } else {
-          return this.placeholder
-        }
-      },
-      nullTipStyle(){
-        if (this.lineNumbers) {
-          return { left: '36px' }
-        } else {
-          return { left: '12px' }
-        }
-      },
-      isAutoHeight() {
-        let {autoHeight} = this
-        if (typeof autoHeight === 'string' && autoHeight.toLowerCase().trim() === '!ie') {
-          autoHeight = !(isIE() || isIE11())
-        } else {
-          autoHeight = true
-        }
-        return autoHeight
-      },
-      fullScreenParentProps() {
-        let props = {
-          class: {
-            'full-screen-parent': true,
-            'full-screen': this.fullCoder,
-            'auto-height': this.isAutoHeight
-          },
-          style: {}
-        }
-        if (this.fullCoder) {
-          props.style['z-index'] = this.zIndex
-        }
-        if (!this.isAutoHeight) {
-          props.style['height'] = (typeof this.height === 'number' ? this.height + 'px' : this.height)
-        }
-        return props
-      }
-    },
-    watch: {
-      fullCoder:{
-        handler(value) {
-          if(value){
-            this.iconType="fullscreen-exit"
-          }else{
-            this.iconType="fullscreen"
-          }
-        }
-      }
-    },
-    mounted() {
-      this.init()
-    },
-    methods:{
-      init(){
-        this.main();
-      },
-      main(){
-        let obj = document.getElementById(this.dynamicId);
-        const that = this;
-        let editor = CodeMirror.fromTextArea(obj,{
-          theme:'idea',
-          lineNumbers: this.lineNumbers,
-          lineWrapping: true,
-          mode: "sql",
-          indentUnit: 1,
-          indentWithTabs: true,
-          styleActiveLine: true,
-          /* styleSelectedText: false, */
-          extraKeys: {
-            "F11": function(cm) {
-              that.fullCoder = !that.fullCoder
-              cm.setOption("fullScreen", !cm.getOption("fullScreen"));
-            },
-            "Esc": function(cm) {
-              that.fullCoder = false
-              if (cm.getOption("fullScreen")) cm.setOption("fullScreen", false);
-            },
-            "Alt-/":  function(cm) {
-              cm.showHint();
-            },
-            "Tab": (cm) => {
-              if (cm.somethingSelected()) {
-                cm.indentSelection('add');
-              } else {
-                //cm.indentLine(cm.getCursor().line, "add");
-                //走两格 第三格输入
-                cm.replaceSelection(Array(3).join(" "), "end", "+input");
-              }
-            },
-            "Shift-Tab": (cm) => {
-              if (cm.somethingSelected()) {
-                cm.indentSelection('subtract');
-              } else {
-                // cm.indentLine(cm.getCursor().line, "subtract");
-                const cursor = cm.getCursor();
-                // 光标回退 indexUnit 字符
-                cm.setCursor({line: cursor.line, ch: cursor.ch - 4});
-              }
-              return ;
-            }
-          }
-        })
-        this.coder = editor
-        this.addEvent();
-        this.setCoderValue();
-        this.addSystemHint();
-      },
-      setCoderValue(){
-        if(this.value||this.code){
-          this.hasCode=true
-          this.setCodeContent(this.value || this.code)
-        }else{
-          this.coder.setValue('')
-          this.hasCode=false
-        }
-      },
-      getCodeContent(){
-        return this.code
-      },
-      setCodeContent(val){
-        setTimeout(()=>{
-          if(!val){
-            this.coder.setValue('')
-          }else{
-            this.coder.setValue(val)
-          }
-        },300)
-      },
-      addSystemHint(){
-        this.coder.setOption('hintOptions', {
-          completeSingle: false,
-          tables: sql_keyword
-        });
-      },
-      addEvent(){
-        if(this.autoHint){
-          this.coder.on('cursorActivity', ()=>{
-            this.coder.showHint();
-          });
-        }
-        this.coder.on('change', (coder) => {
-          this.code = coder.getValue()
-          if(this.code){
-            this.hasCode=true
-          }else{
-            this.hasCode=false
-          }
-          if (this.$emit) {
-            this.$emit('input', this.code)
-          }
-        });
-        this.coder.on('focus', () => {
-          this.hasCode=true
-        });
-        this.coder.on('blur', () => {
-          if(this.code){
-            this.hasCode=true
-          }else{
-            this.hasCode=false
-          }
-        });
-      },
-      loadResource(src,type){
-        return new Promise((resolve,reject)=>{
-          load(src,type,(msg)=>{
-            if(!msg){
-              resolve();
-            }else{
-              reject(msg)
-            }
-          })
-        })
-      },
-      nullTipClick(){
-        this.coder.focus()
-      },
-      fullToggle(){
-        this.fullCoder = !this.fullCoder
-        this.coder.setOption("fullScreen", this.fullCoder);
-      }
-
-    }
-
-
-  }
-</script>
-<style lang="less" >
-  .jeecg-editor-ty{
-    position: relative;
-
-    .full-screen-icon {
-      opacity: 0;
-      color: black;
-      width: 20px;
-      height: 20px;
-      line-height: 24px;
-      background-color: white;
-      position: absolute;
-      top: 4px;
-      right: 2px;
-      z-index: 9;
-      cursor: pointer;
-      transition: opacity 0.3s;
-    }
-    &:hover {
-      .full-screen-icon {
-        opacity: 1;
-
-        &:hover {
-          background-color: rgba(255, 255, 255, 0.88);
-        }
-      }
-    }
-
-    .null-tip{
-      position: absolute;
-      top: 4px;
-      left: 36px;
-      z-index: 10;
-      font-size:16px;
-      color: #acaaaac9;
-      line-height: initial;
-    }
-    .null-tip-hidden{
-      display: none;
-    }
-  }
-  .jeecg-editor-max{
-    position: fixed;
-    left: 0;
-    top: 0;
-    z-index: 999;
-    height: 100%;
-    width: 100% !important;
-
-    .CodeMirror{
-      position: inherit !important;
-      width: 100%;
-      height: 100%;
-    }
-    .full-screen-icon{
-      z-index:9999;
-    }
-  }
-</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/JsCodeEditorDyn.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/JsCodeEditorDyn.vue
@ -1,319 +0,0 @@
-<template>
-  <div class="jeecg-editor-ty" :class="fullCoder?'jeecg-editor-max':'jeecg-editor-min'">
-    <a-icon v-if="fullScreen" class="full-screen-icon" :type="iconType" @click="()=>fullCoder=!fullCoder"/>
-    <textarea :id="dynamicId" />
-    <span @click="nullTipClick" class="null-tip" :class="{'null-tip-hidden': hasCode}" :style="nullTipStyle">{{ placeholderShow }}</span>
-  </div>
-</template>
-
-<script>
-
-  import '@/assets/less/codemirror_idea.css'
-  import './cm_hint.js'
-
-  export default {
-    name: 'JsCodeEditorDyn',
-    props:{
-      id: {
-        type: String,
-        default: function() {
-          return 'vue-editor-' + new Date() + ((Math.random() * 1000).toFixed(0) + '')
-        }
-      },
-      value: {
-        type: String,
-        default: ''
-      },
-      // 显示行号
-      lineNumbers: {
-        type: Boolean,
-        default: true
-      },
-      placeholder: {
-        type: String,
-        default: ''
-      },
-      zIndex: {
-        type: [Number, String],
-        default: 999
-      },
-      autoHeight: {
-        type: [String, Boolean],
-        default: true
-      },
-      // 不自适应高度的情况下生效的固定高度
-      height: {
-        type: [String, Number],
-        default: '240px'
-      },
-      autoHeight: {
-        type: [String, Boolean],
-        default: true
-      },
-      // 是否显示全屏按钮
-      fullScreen: {
-        type: Boolean,
-        default: false
-      },
-
-    },
-    data(){
-      return {
-        dynamicId: this.id,
-        coder: '',
-        hasCode: false,
-        code: '',
-        // code 编辑器 是否全屏
-        fullCoder: false,
-        iconType: 'fullscreen',
-      }
-    },
-    computed:{
-      placeholderShow() {
-        if (this.placeholder == null) {
-          return `请在此输入javascript代码`
-        } else {
-          return this.placeholder
-        }
-      },
-      nullTipStyle(){
-        if (this.lineNumbers) {
-          return { left: '36px' }
-        } else {
-          return { left: '12px' }
-        }
-      },
-      isAutoHeight() {
-        let {autoHeight} = this
-        if (typeof autoHeight === 'string' && autoHeight.toLowerCase().trim() === '!ie') {
-          autoHeight = !(isIE() || isIE11())
-        } else {
-          autoHeight = true
-        }
-        return autoHeight
-      },
-      fullScreenParentProps() {
-        let props = {
-          class: {
-            'full-screen-parent': true,
-            'full-screen': this.fullCoder,
-            'auto-height': this.isAutoHeight
-          },
-          style: {}
-        }
-        if (this.fullCoder) {
-          props.style['z-index'] = this.zIndex
-        }
-        if (!this.isAutoHeight) {
-          props.style['height'] = (typeof this.height === 'number' ? this.height + 'px' : this.height)
-        }
-        return props
-      }
-    },
-    watch: {
-      fullCoder:{
-        handler(value) {
-          if(value){
-            this.iconType="fullscreen-exit"
-          }else{
-            this.iconType="fullscreen"
-          }
-        }
-      }
-    },
-    mounted() {
-      this.init()
-    },
-    methods:{
-      init(){
-        this.main();
-      },
-      main(){
-        let obj = document.getElementById(this.dynamicId);
-        const that = this;
-        let editor = CodeMirror.fromTextArea(obj,{
-          theme:'idea',
-          lineNumbers: this.lineNumbers,
-          lineWrapping: true,
-          mode: "javascript",
-          indentUnit: 1,
-          indentWithTabs: true,
-          styleActiveLine: true,
-          /* styleSelectedText: false, */
-          extraKeys: {
-            "F11": function(cm) {
-              that.fullCoder = !that.fullCoder
-              cm.setOption("fullScreen", !cm.getOption("fullScreen"));
-            },
-            "Esc": function(cm) {
-              that.fullCoder = false
-              if (cm.getOption("fullScreen")) cm.setOption("fullScreen", false);
-            },
-            "Alt-/":  function(cm) {
-              let a = cm.getValue()+""
-              console.log('a',a)
-              cm.showHint();
-            },
-            "Tab": (cm) => {
-              if (cm.somethingSelected()) {
-                cm.indentSelection('add');
-              } else {
-                //cm.indentLine(cm.getCursor().line, "add");
-                //走两格 第三格输入
-                cm.replaceSelection(Array(3).join(" "), "end", "+input");
-              }
-            },
-            "Shift-Tab": (cm) => {
-              if (cm.somethingSelected()) {
-                cm.indentSelection('subtract');
-              } else {
-                // cm.indentLine(cm.getCursor().line, "subtract");
-                const cursor = cm.getCursor();
-                // 光标回退 indexUnit 字符
-                cm.setCursor({line: cursor.line, ch: cursor.ch - 4});
-              }
-              return ;
-            }
-          }
-        })
-        this.coder = editor
-        this.addEvent();
-        this.setCoderValue();
-      },
-      setCoderValue(){
-        if(this.value||this.code){
-          this.hasCode=true
-          this.setCodeContent(this.value || this.code)
-        }else{
-          this.coder.setValue('')
-          this.hasCode=false
-        }
-      },
-      getCodeContent(){
-        return this.code
-      },
-      setCodeContent(val){
-        setTimeout(()=>{
-          if(!val){
-            this.coder.setValue('')
-          }else{
-            this.coder.setValue(val)
-          }
-        },300)
-      },
-      addEvent(){
-        const that = this;
-        this.coder.on('cursorActivity',function(wl) {
-          let arr = wl.state.activeLines
-          if(arr && arr.length>0){
-            let text = arr[0].text
-            if(text.lastIndexOf('that.')>=0){
-              that.coder.showHint();
-            }
-          }
-        });
-        this.coder.on('change', (coder) => {
-          this.code = coder.getValue()
-          if(this.code){
-            this.hasCode=true
-          }else{
-            this.hasCode=false
-          }
-          if (this.$emit) {
-            this.$emit('input', this.code)
-          }
-        });
-        this.coder.on('focus', () => {
-          this.hasCode=true
-        });
-        this.coder.on('blur', () => {
-          if(this.code){
-            this.hasCode=true
-          }else{
-            this.hasCode=false
-          }
-        });
-      },
-      loadResource(src,type){
-        return new Promise((resolve,reject)=>{
-          load(src,type,(msg)=>{
-            if(!msg){
-              resolve();
-            }else{
-              reject(msg)
-            }
-          })
-        })
-      },
-      nullTipClick(){
-        this.coder.focus()
-      },
-      fullToggle(){
-        this.fullCoder = !this.fullCoder
-        this.coder.setOption("fullScreen", this.fullCoder);
-      }
-
-    }
-
-
-  }
-</script>
-<style lang="less" >
-  .jeecg-editor-ty{
-    position: relative;
-
-    .full-screen-icon {
-      opacity: 0;
-      color: black;
-      width: 20px;
-      height: 20px;
-      line-height: 24px;
-      background-color: white;
-      position: absolute;
-      top: 4px;
-      right: 2px;
-      z-index: 9;
-      cursor: pointer;
-      transition: opacity 0.3s;
-    }
-    &:hover {
-      .full-screen-icon {
-        opacity: 1;
-
-        &:hover {
-          background-color: rgba(255, 255, 255, 0.88);
-        }
-      }
-    }
-
-    .null-tip{
-      position: absolute;
-      top: 4px;
-      left: 36px;
-      z-index: 10;
-      font-size:16px;
-      color: #acaaaac9;
-      line-height: initial;
-    }
-    .null-tip-hidden{
-      display: none;
-    }
-  }
-  .jeecg-editor-max{
-    position: fixed;
-    left: 0;
-    top: 0;
-    z-index: 999;
-    height: 100%;
-    width: 100% !important;
-
-    .CodeMirror{
-      position: inherit !important;
-      width: 100%;
-      height: 100%;
-    }
-    .full-screen-icon{
-      z-index:9999;
-    }
-  }
-</style>
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/Resource.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/Resource.js
@ -1,24 +0,0 @@
-
-/**js编辑器关键词用于提示*/
-const js_keyword = [
-  'that',
-  'getAction','postAction','deleteAction',
-  'beforeAdd','beforeEdit','beforeDelete','mounted','created','show'
-]
-
-/**js编辑器 方法名用于提示*/
-const js_method = [
-  '.getSelectOptions','.changeOptions','.triggleChangeValues','.immediateEnhance ','.simpleDateFormat','.lodash'
-]
-
-/**sql编辑器 表名字段名用于提示*/
-const sql_keyword = {
-  sys_user: ['USERNAME', 'REALNAME', 'ID','BIRTHDAY','AGE'],
-  demo: ['name', 'age', 'id', 'sex']
-}
-
-export {
-  js_keyword,
-  js_method,
-  sql_keyword
-}
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/cm_hint.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/cm_hint.js
@ -1,177 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: https://codemirror.net/LICENSE
-import { js_keyword, js_method } from './Resource'
-(function(mod) {
-  mod(CodeMirror);
-  /*if (typeof exports == "object" && typeof module == "object") // CommonJS
-    mod(require("../../lib/codemirror"));
-  else if (typeof define == "function" && define.amd) // AMD
-    define(["../../lib/codemirror"], mod);
-  else // Plain browser env*/
-
-})(function(CodeMirror) {
-  var Pos = CodeMirror.Pos;
-
-  function forEach(arr, f) {
-    for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]);
-  }
-
-  function arrayContains(arr, item) {
-    if (!Array.prototype.indexOf) {
-      var i = arr.length;
-      while (i--) {
-        if (arr[i] === item) {
-          return true;
-        }
-      }
-      return false;
-    }
-    return arr.indexOf(item) != -1;
-  }
-
-  function scriptHint(editor, keywords, getToken, options) {
-    // Find the token at the cursor
-    var cur = editor.getCursor(), token = getToken(editor, cur);
-    if (/\b(?:string|comment)\b/.test(token.type)) return;
-    var innerMode = CodeMirror.innerMode(editor.getMode(), token.state);
-    if (innerMode.mode.helperType === "json") return;
-    token.state = innerMode.state;
-    if('.' === token.string){
-      let arr = []
-      for(let k of js_method){
-        arr.push(k)
-      }
-      return {
-        list: arr,
-        from: Pos(cur.line, token.start),
-        to: Pos(cur.line, token.end)
-      };
-    }
-    // If it's not a 'word-style' token, ignore the token.
-    if (!/^[\w$_]*$/.test(token.string)) {
-      token = {start: cur.ch, end: cur.ch, string: "", state: token.state,
-        type: token.string == "." ? "property" : null};
-    } else if (token.end > cur.ch) {
-      token.end = cur.ch;
-      token.string = token.string.slice(0, cur.ch - token.start);
-    }
-
-    var tprop = token;
-    // If it is a property, find out what it is a property of.
-    while (tprop.type == "property") {
-      tprop = getToken(editor, Pos(cur.line, tprop.start));
-      if (tprop.string != ".") return;
-      tprop = getToken(editor, Pos(cur.line, tprop.start));
-      if (!context) var context = [];
-      context.push(tprop);
-    }
-    return {list: getCompletions(token, context, keywords, options),
-      from: Pos(cur.line, token.start),
-      to: Pos(cur.line, token.end)};
-  }
-
-  function javascriptHint(editor, options) {
-    return scriptHint(editor, javascriptKeywords,
-      function (e, cur) {return e.getTokenAt(cur);},
-      options);
-  };
-  CodeMirror.registerHelper("hint", "javascript", javascriptHint);
-
-  function getCoffeeScriptToken(editor, cur) {
-    // This getToken, it is for coffeescript, imitates the behavior of
-    // getTokenAt method in javascript.js, that is, returning "property"
-    // type and treat "." as indepenent token.
-    var token = editor.getTokenAt(cur);
-    if (cur.ch == token.start + 1 && token.string.charAt(0) == '.') {
-      token.end = token.start;
-      token.string = '.';
-      token.type = "property";
-    }
-    else if (/^\.[\w$_]*$/.test(token.string)) {
-      token.type = "property";
-      token.start++;
-      token.string = token.string.replace(/\./, '');
-    }
-    return token;
-  }
-
-  function coffeescriptHint(editor, options) {
-    return scriptHint(editor, coffeescriptKeywords, getCoffeeScriptToken, options);
-  }
-  CodeMirror.registerHelper("hint", "coffeescript", coffeescriptHint);
-
-  var stringProps = ("charAt charCodeAt indexOf lastIndexOf substring substr slice trim trimLeft trimRight " +
-    "toUpperCase toLowerCase split concat match replace search").split(" ");
-  var arrayProps = ("length concat join splice push pop shift unshift slice reverse sort indexOf " +
-    "lastIndexOf every some filter forEach map reduce reduceRight ").split(" ");
-  var funcProps = "prototype apply call bind".split(" ");
-
-  var javascriptKeywords = ("break case catch class const continue debugger default delete do else export extends false finally for function " +
-    "if in import instanceof new null return super switch this throw true try typeof var void while with yield that").split(" ");
-  for(let jk of js_keyword){
-    javascriptKeywords.push(jk)
-  }
-  var coffeescriptKeywords = ("and break catch class continue delete do else extends false finally for " +
-    "if in instanceof isnt new no not null of off on or return switch then throw true try typeof until void while with yes").split(" ");
-
-  function forAllProps(obj, callback) {
-    if (!Object.getOwnPropertyNames || !Object.getPrototypeOf) {
-      for (var name in obj) callback(name)
-    } else {
-      for (var o = obj; o; o = Object.getPrototypeOf(o))
-        Object.getOwnPropertyNames(o).forEach(callback)
-    }
-  }
-
-  function getCompletions(token, context, keywords, options) {
-    var found = [], start = token.string, global = options && options.globalScope || window;
-    function maybeAdd(str) {
-      if (str.lastIndexOf(start, 0) == 0 && !arrayContains(found, str)) found.push(str);
-    }
-    function gatherCompletions(obj) {
-      if (typeof obj == "string") forEach(stringProps, maybeAdd);
-      else if (obj instanceof Array) forEach(arrayProps, maybeAdd);
-      else if (obj instanceof Function) forEach(funcProps, maybeAdd);
-      forAllProps(obj, maybeAdd)
-    }
-
-    if (context && context.length) {
-      // If this is a property, see if it belongs to some object we can
-      // find in the current environment.
-      var obj = context.pop(), base;
-      if (obj.type && obj.type.indexOf("variable") === 0) {
-        if (options && options.additionalContext)
-          base = options.additionalContext[obj.string];
-        if (!options || options.useGlobalScope !== false)
-          base = base || global[obj.string];
-      } else if (obj.type == "string") {
-        base = "";
-      } else if (obj.type == "atom") {
-        base = 1;
-      } else if (obj.type == "function") {
-        if (global.jQuery != null && (obj.string == '$' || obj.string == 'jQuery') &&
-          (typeof global.jQuery == 'function'))
-          base = global.jQuery();
-        else if (global._ != null && (obj.string == '_') && (typeof global._ == 'function'))
-          base = global._();
-      }
-      while (base != null && context.length)
-        base = base[context.pop().string];
-      if (base != null) gatherCompletions(base);
-    } else {
-      // If not, just look in the global object, any local scope, and optional additional-context
-      // (reading into JS mode internals to get at the local and global variables)
-      for (var v = token.state.localVars; v; v = v.next) maybeAdd(v.name);
-      for (var c = token.state.context; c; c = c.prev)
-        for (var v = c.vars; v; v = v.next) maybeAdd(v.name)
-      for (var v = token.state.globalVars; v; v = v.next) maybeAdd(v.name);
-      if (options && options.additionalContext != null)
-        for (var key in options.additionalContext)
-          maybeAdd(key);
-      if (!options || options.useGlobalScope !== false)
-        gatherCompletions(global);
-      forEach(keywords, maybeAdd);
-    }
-    return found;
-  }
-});
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/cm_sql_hint.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/cm_sql_hint.js
@ -1,305 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: https://codemirror.net/LICENSE
-
-(function(mod) {
-  /*if (typeof exports == "object" && typeof module == "object") // CommonJS
-    mod(require("../../lib/codemirror"), require("../../mode/sql/sql"));
-  else if (typeof define == "function" && define.amd) // AMD
-    define(["../../lib/codemirror", "../../mode/sql/sql"], mod);
-  else */
-    // Plain browser env
-    mod(CodeMirror);
-})(function(CodeMirror) {
-  "use strict";
-
-  var tables;
-  var defaultTable;
-  var keywords;
-  var identifierQuote;
-  var CONS = {
-    QUERY_DIV: ";",
-    ALIAS_KEYWORD: "AS"
-  };
-  var Pos = CodeMirror.Pos, cmpPos = CodeMirror.cmpPos;
-
-  function isArray(val) { return Object.prototype.toString.call(val) == "[object Array]" }
-
-  function getKeywords(editor) {
-    var mode = editor.doc.modeOption;
-    if (mode === "sql") mode = "text/x-sql";
-    return CodeMirror.resolveMode(mode).keywords;
-  }
-
-  function getIdentifierQuote(editor) {
-    var mode = editor.doc.modeOption;
-    if (mode === "sql") mode = "text/x-sql";
-    return CodeMirror.resolveMode(mode).identifierQuote || "`";
-  }
-
-  function getText(item) {
-    return typeof item == "string" ? item : item.text;
-  }
-
-  function wrapTable(name, value) {
-    if (isArray(value)) value = {columns: value}
-    if (!value.text) value.text = name
-    return value
-  }
-
-  function parseTables(input) {
-    var result = {}
-    if (isArray(input)) {
-      for (var i = input.length - 1; i >= 0; i--) {
-        var item = input[i]
-        result[getText(item).toUpperCase()] = wrapTable(getText(item), item)
-      }
-    } else if (input) {
-      for (var name in input)
-        result[name.toUpperCase()] = wrapTable(name, input[name])
-    }
-    return result
-  }
-
-  function getTable(name) {
-    return tables[name.toUpperCase()]
-  }
-
-  function shallowClone(object) {
-    var result = {};
-    for (var key in object) if (object.hasOwnProperty(key))
-      result[key] = object[key];
-    return result;
-  }
-
-  function match(string, word) {
-    var len = string.length;
-    var sub = getText(word).substr(0, len);
-    return string.toUpperCase() === sub.toUpperCase();
-  }
-
-  function addMatches(result, search, wordlist, formatter) {
-    if (isArray(wordlist)) {
-      for (var i = 0; i < wordlist.length; i++)
-        if (match(search, wordlist[i])) result.push(formatter(wordlist[i]))
-    } else {
-      for (var word in wordlist) if (wordlist.hasOwnProperty(word)) {
-        var val = wordlist[word]
-        if (!val || val === true)
-          val = word
-        else
-          val = val.displayText ? {text: val.text, displayText: val.displayText} : val.text
-        if (match(search, val)) result.push(formatter(val))
-      }
-    }
-  }
-
-  function cleanName(name) {
-    // Get rid name from identifierQuote and preceding dot(.)
-    if (name.charAt(0) == ".") {
-      name = name.substr(1);
-    }
-    // replace doublicated identifierQuotes with single identifierQuotes
-    // and remove single identifierQuotes
-    var nameParts = name.split(identifierQuote+identifierQuote);
-    for (var i = 0; i < nameParts.length; i++)
-      nameParts[i] = nameParts[i].replace(new RegExp(identifierQuote,"g"), "");
-    return nameParts.join(identifierQuote);
-  }
-
-  function insertIdentifierQuotes(name) {
-    var nameParts = getText(name).split(".");
-    for (var i = 0; i < nameParts.length; i++)
-      nameParts[i] = identifierQuote +
-        // doublicate identifierQuotes
-        nameParts[i].replace(new RegExp(identifierQuote,"g"), identifierQuote+identifierQuote) +
-        identifierQuote;
-    var escaped = nameParts.join(".");
-    if (typeof name == "string") return escaped;
-    name = shallowClone(name);
-    name.text = escaped;
-    return name;
-  }
-
-  function nameCompletion(cur, token, result, editor) {
-    // Try to complete table, column names and return start position of completion
-    var useIdentifierQuotes = false;
-    var nameParts = [];
-    var start = token.start;
-    var cont = true;
-    while (cont) {
-      cont = (token.string.charAt(0) == ".");
-      useIdentifierQuotes = useIdentifierQuotes || (token.string.charAt(0) == identifierQuote);
-
-      start = token.start;
-      nameParts.unshift(cleanName(token.string));
-
-      token = editor.getTokenAt(Pos(cur.line, token.start));
-      if (token.string == ".") {
-        cont = true;
-        token = editor.getTokenAt(Pos(cur.line, token.start));
-      }
-    }
-
-    // Try to complete table names
-    var string = nameParts.join(".");
-    addMatches(result, string, tables, function(w) {
-      return useIdentifierQuotes ? insertIdentifierQuotes(w) : w;
-    });
-
-    // Try to complete columns from defaultTable
-    addMatches(result, string, defaultTable, function(w) {
-      return useIdentifierQuotes ? insertIdentifierQuotes(w) : w;
-    });
-
-    // Try to complete columns
-    string = nameParts.pop();
-    var table = nameParts.join(".");
-
-    var alias = false;
-    var aliasTable = table;
-    // Check if table is available. If not, find table by Alias
-    if (!getTable(table)) {
-      var oldTable = table;
-      table = findTableByAlias(table, editor);
-      if (table !== oldTable) alias = true;
-    }
-
-    var columns = getTable(table);
-    if (columns && columns.columns)
-      columns = columns.columns;
-
-    if (columns) {
-      addMatches(result, string, columns, function(w) {
-        var tableInsert = table;
-        if (alias == true) tableInsert = aliasTable;
-        if (typeof w == "string") {
-          w = tableInsert + "." + w;
-        } else {
-          w = shallowClone(w);
-          w.text = tableInsert + "." + w.text;
-        }
-        return useIdentifierQuotes ? insertIdentifierQuotes(w) : w;
-      });
-    }
-
-    return start;
-  }
-
-  function eachWord(lineText, f) {
-    var words = lineText.split(/\s+/)
-    for (var i = 0; i < words.length; i++)
-      if (words[i]) f(words[i].replace(/[,;]/g, ''))
-  }
-
-  function findTableByAlias(alias, editor) {
-    var doc = editor.doc;
-    var fullQuery = doc.getValue();
-    var aliasUpperCase = alias.toUpperCase();
-    var previousWord = "";
-    var table = "";
-    var separator = [];
-    var validRange = {
-      start: Pos(0, 0),
-      end: Pos(editor.lastLine(), editor.getLineHandle(editor.lastLine()).length)
-    };
-
-    //add separator
-    var indexOfSeparator = fullQuery.indexOf(CONS.QUERY_DIV);
-    while(indexOfSeparator != -1) {
-      separator.push(doc.posFromIndex(indexOfSeparator));
-      indexOfSeparator = fullQuery.indexOf(CONS.QUERY_DIV, indexOfSeparator+1);
-    }
-    separator.unshift(Pos(0, 0));
-    separator.push(Pos(editor.lastLine(), editor.getLineHandle(editor.lastLine()).text.length));
-
-    //find valid range
-    var prevItem = null;
-    var current = editor.getCursor()
-    for (var i = 0; i < separator.length; i++) {
-      if ((prevItem == null || cmpPos(current, prevItem) > 0) && cmpPos(current, separator[i]) <= 0) {
-        validRange = {start: prevItem, end: separator[i]};
-        break;
-      }
-      prevItem = separator[i];
-    }
-
-    if (validRange.start) {
-      var query = doc.getRange(validRange.start, validRange.end, false);
-
-      for (var i = 0; i < query.length; i++) {
-        var lineText = query[i];
-        eachWord(lineText, function(word) {
-          var wordUpperCase = word.toUpperCase();
-          if (wordUpperCase === aliasUpperCase && getTable(previousWord))
-            table = previousWord;
-          if (wordUpperCase !== CONS.ALIAS_KEYWORD)
-            previousWord = word;
-        });
-        if (table) break;
-      }
-    }
-    return table;
-  }
-
-  CodeMirror.registerHelper("hint", "sql", function(editor, options) {
-    tables = parseTables(options && options.tables)
-    var defaultTableName = options && options.defaultTable;
-    var disableKeywords = options && options.disableKeywords;
-    defaultTable = defaultTableName && getTable(defaultTableName);
-    keywords = getKeywords(editor);
-    identifierQuote = getIdentifierQuote(editor);
-
-    if (defaultTableName && !defaultTable)
-      defaultTable = findTableByAlias(defaultTableName, editor);
-
-    defaultTable = defaultTable || [];
-
-    if (defaultTable.columns)
-      defaultTable = defaultTable.columns;
-
-    var cur = editor.getCursor();
-    var result = [];
-    var token = editor.getTokenAt(cur), start, end, search;
-    if (token.end > cur.ch) {
-      token.end = cur.ch;
-      token.string = token.string.slice(0, cur.ch - token.start);
-    }
-
-    if (token.string.match(/^[.`"'\w@][\w$#]*$/g)) {
-      search = token.string;
-      start = token.start;
-      end = token.end;
-    } else {
-      start = end = cur.ch;
-      search = "";
-    }
-    if (search.charAt(0) == "." || search.charAt(0) == identifierQuote) {
-      start = nameCompletion(cur, token, result, editor);
-    } else {
-      var objectOrClass = function(w, className) {
-        if (typeof w === "object") {
-          w.className = className;
-        } else {
-          w = { text: w, className: className };
-        }
-        return w;
-      };
-      addMatches(result, search, defaultTable, function(w) {
-        return objectOrClass(w, "CodeMirror-hint-table CodeMirror-hint-default-table");
-      });
-      addMatches(
-        result,
-        search,
-        tables, function(w) {
-          return objectOrClass(w, "CodeMirror-hint-table");
-        }
-      );
-      if (!disableKeywords)
-        addMatches(result, search, keywords, function(w) {
-          return objectOrClass(w.toUpperCase(), "CodeMirror-hint-keyword");
-        });
-    }
-
-    return {list: result, from: Pos(cur.line, start), to: Pos(cur.line, end)};
-  });
-});
--- a/ant-design-vue-jeecg/src/components/jeecg/dynamic/load.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/dynamic/load.js
@ -1,92 +0,0 @@
-let callbacks = []
-
-function loadSuccess(key) {
-  // to fixed https://github.com/PanJiaChen/vue-element-admin/issues/2144
-  // check is successfully downloaded script
-  return window[key]
-}
-
-const load = (src, type, callback) => {
-  if(type=='link'){
-
-    loadStyle(src, callback)
-  }else{
-    let loadKey = ''
-    if(src.indexOf('tinymce')>=0){
-      loadKey = 'tinymce'
-    }else if(src.indexOf('codemirror')>=0){
-      loadKey = 'CodeMirror'
-    }
-    const scriptTag = document.getElementById(src)
-    //const cb = callback || function() {}
-    if (!scriptTag) {
-      const script = document.createElement('script')
-      script.src = src // src url for the third-party library being loaded.
-      script.id = src
-      script.onload=()=>callback()
-      script.onerror=()=>callback('加载失败：'+src)
-      document.body.appendChild(script)
-      //callbacks.push(cb)
-     // const onEnd = 'onload' in script ? stdOnEnd : ieOnEnd
-     // onEnd(script)
-    }else{
-      if (loadSuccess(loadKey)) {
-        callback()
-      }
-    }
-
-    if (scriptTag) {
-     /* else {
-        callbacks.push(cb)
-      }*/
-    }
-  }
-
-  function stdOnEnd(script) {
-    script['onload'] = function() {
-      // this.onload = null here is necessary
-      // because even IE9 works not like others
-      this.onerror = this.onload = null
-      for (const cb of callbacks) {
-        cb(null, script)
-      }
-      callbacks = null
-    }
-    script['onerror'] = function() {
-      this.onerror = this.onload = null
-      cb(new Error('Failed to load ' + src), script)
-    }
-  }
-
-  function ieOnEnd(script) {
-    script.onreadystatechange = function() {
-      if (this.readyState !== 'complete' && this.readyState !== 'loaded') return
-      this.onreadystatechange = null
-      for (const cb of callbacks) {
-        cb(null, script) // there is no way to catch loading errors in IE8
-      }
-      callbacks = null
-    }
-  }
-
-  function loadStyle(src, callback) {
-    const link = document.getElementById(src)
-    if (!link) {
-      const link = document.createElement('link')
-      link.setAttribute("rel", "stylesheet");
-      link.setAttribute("type", "text/css");
-      link.setAttribute("href", src);
-      link.id = src
-      let heads = document.getElementsByTagName("head")
-      if(heads.length){
-        heads[0].appendChild(link)
-      }else{
-        document.documentElement.appendChild(link)
-      }
-    }
-    callback();
-  }
-
-}
-
-export default load
--- a/ant-design-vue-jeecg/src/components/jeecg/index.js
+++ b/ant-design-vue-jeecg/src/components/jeecg/index.js
@ -1,11 +1,91 @@
 import JModal from './JModal'
 import JFormContainer from './JFormContainer.vue'
 import JPopup from './JPopup.vue'
+import JMarkdownEditor from './JMarkdownEditor'
+import JCodeEditor from './JCodeEditor.vue'
+import JEditor from './JEditor.vue'
+import JEditableTable from './JEditableTable.vue'
+import JAreaLinkage from './JAreaLinkage.vue'
+import JSuperQuery from './JSuperQuery.vue'
+import JUpload from './JUpload.vue'
+import JTreeSelect from './JTreeSelect.vue'
+import JCategorySelect from './JCategorySelect.vue'
+import JImageUpload from './JImageUpload.vue'
+import JImportModal from './JImportModal.vue'
+import JTreeDict from './JTreeDict.vue'
+import JCheckbox from './JCheckbox.vue'
+import JCron from './JCron.vue'
+import JDate from './JDate.vue'
+import JEllipsis from './JEllipsis.vue'
+import JInput from './JInput.vue'
+import JPopupOnlReport from './modal/JPopupOnlReport.vue'
+import JFilePop from './minipop/JFilePop.vue'
+import JInputPop from './minipop/JInputPop.vue'
+import JSelectMultiple from './JSelectMultiple.vue'
+import JSlider from './JSlider.vue'
+import JSwitch from './JSwitch.vue'
+import JTime from './JTime.vue'
+import JTreeTable from './JTreeTable.vue'
+import JEasyCron from '@/components/jeecg/JEasyCron'
+//jeecgbiz
+import JSelectDepart from '../jeecgbiz/JSelectDepart.vue'
+import JSelectMultiUser from '../jeecgbiz/JSelectMultiUser.vue'
+import JSelectPosition from '../jeecgbiz/JSelectPosition.vue'
+import JSelectRole from '../jeecgbiz/JSelectRole.vue'
+import JSelectUserByDep from '../jeecgbiz/JSelectUserByDep.vue'
+//引入需要全局注册的js函数和变量
+import { Modal, notification,message } from 'ant-design-vue'
+import lodash_object from 'lodash'
+import debounce from 'lodash/debounce'
+import pick from 'lodash.pick'
+import data from 'china-area-data'

 export default {
  install(Vue) {
+    Vue.use(JModal)
+    Vue.component('JMarkdownEditor', JMarkdownEditor)
+    Vue.component('JPopupOnlReport', JPopupOnlReport)
+    Vue.component('JFilePop', JFilePop)
+    Vue.component('JInputPop', JInputPop)
+    Vue.component('JAreaLinkage', JAreaLinkage)
+    Vue.component('JCategorySelect', JCategorySelect)
+    Vue.component('JCheckbox', JCheckbox)
+    Vue.component('JCodeEditor', JCodeEditor)
+    Vue.component('JCron', JCron)
+    Vue.component('JDate', JDate)
+    Vue.component('JEditableTable', JEditableTable)
+    Vue.component('JEditor', JEditor)
+    Vue.component('JEllipsis', JEllipsis)
    Vue.component('JFormContainer', JFormContainer)
+    Vue.component('JImageUpload', JImageUpload)
+    Vue.component('JImportModal', JImportModal)
+    Vue.component('JInput', JInput)
    Vue.component('JPopup', JPopup)
-    Vue.component(JModal.name, JModal)
+    Vue.component('JSelectMultiple', JSelectMultiple)
+    Vue.component('JSlider', JSlider)
+    Vue.component('JSuperQuery', JSuperQuery)
+    Vue.component('JSwitch', JSwitch)
+    Vue.component('JTime', JTime)
+    Vue.component('JTreeDict', JTreeDict)
+    Vue.component('JTreeSelect', JTreeSelect)
+    Vue.component('JTreeTable', JTreeTable)
+    Vue.component('JUpload', JUpload)
+
+    //jeecgbiz
+    Vue.component('JSelectDepart', JSelectDepart)
+    Vue.component('JSelectMultiUser', JSelectMultiUser)
+    Vue.component('JSelectPosition', JSelectPosition)
+    Vue.component('JSelectRole', JSelectRole)
+    Vue.component('JSelectUserByDep', JSelectUserByDep)
+    Vue.component(JEasyCron.name, JEasyCron)
+
+    //注册全局js函数和变量
+    Vue.prototype.$Jnotification = notification
+    Vue.prototype.$Jmodal = Modal
+    Vue.prototype.$Jmessage = message
+    Vue.prototype.$Jlodash = lodash_object
+    Vue.prototype.$Jdebounce= debounce
+    Vue.prototype.$Jpick = pick
+    Vue.prototype.$Jpcaa = data
  }
 }
--- a/ant-design-vue-jeecg/src/components/jeecg/minipop/JFilePop.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/minipop/JFilePop.vue
@ -8,13 +8,12 @@
      cancelText="取消"
      @cancel="close">
      <!--style="top: 20px;"-->
-      <j-upload :file-type="fileType" :value="filePath" @change="handleChange" :disabled="disabled"></j-upload>
+      <j-upload :file-type="fileType" :value="filePath" @change="handleChange" :disabled="disabled" :number="number"></j-upload>
    </a-modal>
  </div>
 </template>

 <script>
-  import JUpload from '@/components/jeecg/JUpload'
  import { getFileAccessHttpUrl } from '@/api/manage';

  const getFileName=(path)=>{
@ -27,7 +26,7 @@

  export default {
    name: 'JFilePop',
-    components: { JUpload },
+    components: { },
    props:{
      title:{
        type:String,
@ -59,6 +58,11 @@
        type:Boolean,
        default:false,
        required:false
+      },
+      number:{
+        type:Number,
+        required:false,
+        default: 0
      }
    },
    data(){
--- a/ant-design-vue-jeecg/src/components/jeecg/minipop/JInputPop.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/minipop/JInputPop.vue
@ -7,7 +7,7 @@
        <a-icon type="close" @click="visible=false"/>
      </span>
    </div>
-    <a-input :value="inputContent" :disabled="disabled" @change="handleInputChange">
+    <a-input :value="inputContent" :disabled="disabled" @change="handleInputChange" :placeholder="placeholder">
      <a-icon slot="suffix" type="fullscreen" @click.stop="pop" />
    </a-input>
    <div slot="content">
@ -53,6 +53,10 @@
        type: Boolean,
        default: false,
      },
+      placeholder:{
+        type:String,
+        required:false
+      }

    },
    data(){
--- a/ant-design-vue-jeecg/src/components/jeecg/modal/JCronModal.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/modal/JCronModal.vue
@ -1,6 +1,6 @@
 <template>
  <a-modal
-          title="corn表达式"
+          title="cron表达式"
          :width="modalWidth"
          :visible="visible"
          :confirmLoading="confirmLoading"
--- a/ant-design-vue-jeecg/src/components/jeecg/modal/JPopupOnlReport.vue
+++ b/ant-design-vue-jeecg/src/components/jeecg/modal/JPopupOnlReport.vue
@ -74,11 +74,12 @@
  import {filterObj} from '@/utils/util'
  import { filterMultiDictText } from '@/components/dict/JDictSelectUtil'
  import { httpGroupRequest } from '@/api/GroupRequest.js'
+  import md5 from 'md5'

  const MODAL_WIDTH = 1200;
  export default {
    name: 'JPopupOnlReport',
-    props: ['multi', 'code', 'groupId'],
+    props: ['multi', 'code', 'sorter', 'groupId', 'param'],
    components:{
    },
    data(){
@ -121,17 +122,51 @@
        },
        cgRpConfigId:"",
        modalWidth:MODAL_WIDTH,
-        tableScroll:{x:MODAL_WIDTH-100}
-
+        tableScroll:{x:true},
+        dynamicParam:{},
+        // 排序字段，默认无排序
+        iSorter: null,
      }
    },
    mounted() {
-      this.loadColumnsInfo()
+      //this.loadColumnsInfo()
    },
    watch: {
      code() {
        this.loadColumnsInfo()
-      }
+      },
+      param:{
+        deep:true,
+        handler(){
+          // update--begin--autor:liusq-----date:20210706------for：JPopup组件在modal中使用报错#2729------
+          if(this.visible){
+            this.dynamicParamHandler()
+            this.loadData();
+          }
+          // update--begin--autor:liusq-----date:20210706------for：JPopup组件在modal中使用报错#2729------
+        },
+      },
+      sorter: {
+        immediate: true,
+        handler() {
+          if (this.sorter) {
+            let arr = this.sorter.split('=')
+            if (arr.length === 2 && ['asc', 'desc'].includes(arr[1].toLowerCase())) {
+              this.iSorter = {column: arr[0], order: arr[1].toLowerCase()}
+              // 排序字段受控
+              this.table.columns.forEach(col => {
+                if (col.dataIndex === this.iSorter.column) {
+                  this.$set(col, 'sortOrder', this.iSorter.order === 'asc' ? 'ascend' : 'descend')
+                } else {
+                  this.$set(col, 'sortOrder', false)
+                }
+              })
+            } else {
+              console.warn('【JPopup】sorter参数不合法')
+            }
+          }
+        },
+      },
    },
    computed:{
      showSearchFlag(){
@ -159,10 +194,13 @@
                  return filterMultiDictText(this.dictOptions[dictCode], text+"");
                }
              }
+              // 排序字段受控
+              if (this.iSorter && currColumns[a].dataIndex === this.iSorter.column) {
+                currColumns[a].sortOrder = this.iSorter.order === 'asc' ? 'ascend' : 'descend'
+              }
            }
            this.table.columns = [...currColumns]
            this.initQueryInfo()
-            this.loadData(1)
          }
        })
      },
@ -176,12 +214,43 @@
        httpGroupRequest(() => getAction(url), groupIdKey).then((res) => {
          // console.log("获取查询条件", res);
          if (res.success) {
+            this.dynamicParamHandler(res.result)
            this.queryInfo = res.result
+            //查询条件加载后再请求数据
+            this.loadData(1)
          } else {
            this.$message.warning(res.message)
          }
        })
      },
+      //处理动态参数
+      dynamicParamHandler(arr){
+        if(arr && arr.length>0){
+          //第一次加载查询条件前 初始化queryParam为空对象
+          let queryTemp = {}
+          for(let item of arr){
+            if(item.mode==='single'){
+              queryTemp[item.field] = ''
+            }
+          }
+          this.queryParam = {...queryTemp}
+        }
+        let dynamicTemp = {}
+        if(this.param){
+          Object.keys(this.param).map(key=>{
+            let str = this.param[key]
+            if(key in this.queryParam){
+              if(str && str.startsWith("'") && str.endsWith("'")){
+                str = str.substring(1,str.length-1)
+              }
+              //如果查询条件包含参数 设置值
+              this.queryParam[key]=str
+            }
+            dynamicTemp[key] = this.param[key]
+          })
+        }
+        this.dynamicParam = {...dynamicTemp}
+      },
      loadData(arg) {
        if (arg == 1) {
          this.table.pagination.current = 1
@ -208,7 +277,14 @@
        })
      },
      getQueryParams() {
-        let param = Object.assign({}, this.queryParam, this.sorter);
+        let paramTarget = {}
+        if(this.dynamicParam){
+          //处理自定义参数
+         Object.keys(this.dynamicParam).map(key=>{
+           paramTarget['self_'+key] = this.dynamicParam[key]
+         })
+        }
+        let param = Object.assign(paramTarget, this.queryParam, this.iSorter);
        param.pageNo = this.table.pagination.current;
        param.pageSize = this.table.pagination.pageSize;
        return filterObj(param);
@ -243,8 +319,18 @@
      handleChangeInTable(pagination, filters, sorter) {
        //分页、排序、筛选变化时触发
        if (Object.keys(sorter).length > 0) {
-          this.sorter.column = sorter.field
-          this.sorter.order = 'ascend' == sorter.order ? 'asc' : 'desc'
+          this.iSorter = {
+            column: sorter.field,
+            order: 'ascend' === sorter.order ? 'asc' : 'desc'
+          }
+          // 排序字段受控
+          this.table.columns.forEach(col => {
+            if (col.dataIndex === sorter.field) {
+              this.$set(col, 'sortOrder',sorter.order)
+            } else {
+              this.$set(col, 'sortOrder', false)
+            }
+          })
        }
        this.table.pagination = pagination
        this.loadData()
@ -272,7 +358,8 @@
        this.onClearSelected()
      },
      show(){
-        this.visible = true;
+        this.visible = true
+        this.loadColumnsInfo()
      },
      handleToggleSearch(){
        this.toggleSearchStatus = !this.toggleSearchStatus;
@ -296,11 +383,20 @@
      combineRowKey(record){
        let res = ''
         Object.keys(record).forEach(key=>{
-           res+=record[key]
+           //update-begin---author:liusq   Date:20210203  for：pop选择器列主键问题 issues/I29P9Q------------
+           if(key=='id'){
+             res=record[key]+res
+           }else{
+             res+=record[key]
+           }
+           //update-end---author:liusq     Date:20210203  for：pop选择器列主键问题 issues/I29P9Q------------
         })
-        if(res.length>50){
+        // update-begin---author:taoyan   Date:20211025 for：jpopup 表格key重复BUG /issues/3121
+        res = md5(res)
+        /*if(res.length>50){
          res = res.substring(0,50)
-        }
+        }*/
+        // update-end---author:taoyan   Date:20211025 for：jpopup 表格key重复BUG /issues/3121
        return res
      },

--- a/ant-design-vue-jeecg/src/components/jeecgbiz/JSelectBizComponent/index.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/JSelectBizComponent/index.vue
@ -12,7 +12,7 @@
          :open="selectOpen"
          style="width: 100%;"
          @dropdownVisibleChange="handleDropdownVisibleChange"
-          @click.native="visible=(buttons?visible:true)"
+          @click.native="visible=(buttons || disabled ?visible:true)"
        />
      </slot>
    </a-col>
--- a/ant-design-vue-jeecg/src/components/jeecgbiz/JSelectDepart.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/JSelectDepart.vue
@ -1,9 +1,9 @@
 <template>
  <div class="components-input-demo-presuffix">
    <!---->
-    <a-input @click="openModal" placeholder="请点击选择部门" v-model="departNames" readOnly :disabled="disabled">
+    <a-input @click="openModal" placeholder="请点击选择部门" v-model="textVals" readOnly :disabled="disabled">
      <a-icon slot="prefix" type="cluster" title="部门选择控件"/>
-      <a-icon v-if="departIds" slot="suffix" type="close-circle" @click="handleEmpty" title="清空"/>
+      <a-icon v-if="storeVals" slot="suffix" type="close-circle" @click="handleEmpty" title="清空"/>
    </a-input>

    <j-select-depart-modal
@ -11,7 +11,10 @@
      :modal-width="modalWidth"
      :multi="multi"
      :rootOpened="rootOpened"
-      :depart-id="departIds"
+      :depart-id="value"
+      :store="storeField"
+      :text="textField"
+      :treeOpera="treeOpera"
      @ok="handleOK"
      @initComp="initComp"/>
  </div>
@ -19,6 +22,7 @@

 <script>
  import JSelectDepartModal from './modal/JSelectDepartModal'
+  import { underLinetoHump } from '@/components/_util/StringUtil'
  export default {
    name: 'JSelectDepart',
    components:{
@ -52,57 +56,100 @@
      // 自定义返回字段，默认返回 id
      customReturnField: {
        type: String,
-        default: 'id'
+        default: ''
+      },
+      backDepart: {
+        type: Boolean,
+        default: false,
+        required: false
+      },
+      // 存储字段 [key field]
+      store: {
+        type: String,
+        default: 'id',
+        required: false
+      },
+      // 显示字段 [label field]
+      text: {
+        type: String,
+        default: 'departName',
+        required: false
+      },
+      treeOpera: {
+        type: Boolean,
+        default: false,
+        required: false
      }
+      
    },
    data(){
      return {
        visible:false,
        confirmLoading:false,
-        departNames:"",
-        departIds:''
+        storeVals: '', //[key values]
+        textVals: '' //[label values]
+      }
+    },
+    computed:{
+      storeField(){
+        let field = this.customReturnField
+        if(!field){
+          field = this.store;
+        }
+        return underLinetoHump(field)
+      },
+      textField(){
+        return underLinetoHump(this.text)
      }
    },
    mounted(){
-      this.departIds = this.value
+      this.storeVals = this.value
    },
    watch:{
      value(val){
-        if (this.customReturnField === 'id') {
-          this.departIds = val
-        }
+        this.storeVals = val
      }
    },
    methods:{
-      initComp(departNames){
-        this.departNames = departNames
-        //update-begin-author:lvdandan date:20200513 for:TESTA-438 部门选择组件自定义返回值，数据无法回填
-        //TODO 当返回字段为部门名称时会有问题,因为部门名称不唯一
-        //返回字段不为id时，根据返回字段获取id
-        if(this.customReturnField !== 'id' && this.value){
-          const dataList = this.$refs.innerDepartSelectModal.dataList;
-          console.log('this.value',this.value)
-          this.departIds = this.value.split(',').map(item => {
-            const data = dataList.filter(d=>d[this.customReturnField] === item)
-            return data.length > 0 ? data[0].id : ''
-          }).join(',')
+      initComp(textVals){
+        this.textVals = textVals
+      },
+      //返回选中的部门信息
+      backDeparInfo(){
+        if(this.backDepart===true){
+          if(this.departIds && this.departIds.length>0){
+            let arr1 = this.storeVals.split(',')
+            let arr2 = this.textVals.split(',')
+            let info = []
+            for(let i=0;i<arr1.length;i++){
+              info.push({
+                value: arr1[i],
+                text: arr2[i]
+              })
+            }
+            this.$emit('back', info)
+          }
        }
-        //update-end-author:lvdandan date:20200513 for:TESTA-438 部门选择组件自定义返回值，数据无法回填
      },
      openModal(){
        this.$refs.innerDepartSelectModal.show()
      },
-      handleOK(rows, idstr) {
-        let value = ''
+      handleOK(rows) {
        if (!rows && rows.length <= 0) {
-          this.departNames = ''
-          this.departIds = ''
+          this.textVals = ''
+          this.storeVals = ''
        } else {
-          value = rows.map(row => row[this.customReturnField]).join(',')
-          this.departNames = rows.map(row => row['departName']).join(',')
-          this.departIds = idstr
+          let arr1 = []
+          let arr2 = []
+          for(let dep of rows){
+            arr1.push(dep[this.storeField])
+            arr2.push(dep[this.textField])
+          }
+          this.storeVals = arr1.join(',')
+          this.textVals = arr2.join(',')
        }
-        this.$emit("change", value)
+        this.$emit("change", this.storeVals)
+        this.backDeparInfo()
      },
      getDepartNames(){
        return this.departNames
--- a/ant-design-vue-jeecg/src/components/jeecgbiz/JSelectUserByDep.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/JSelectUserByDep.vue
@ -1,19 +1,28 @@
 <template>
  <div>
    <a-input-search
-      v-model="userNames"
+      v-model="textVals"
      placeholder="请先选择用户"
      readOnly
      unselectable="on"
      @search="onSearchDepUser">
      <a-button slot="enterButton" :disabled="disabled">选择用户</a-button>
    </a-input-search>
-    <j-select-user-by-dep-modal ref="selectModal" :modal-width="modalWidth" :multi="multi" @ok="selectOK" :user-ids="value" @initComp="initComp"/>
+    <j-select-user-by-dep-modal
+      ref="selectModal"
+      :modal-width="modalWidth"
+      :multi="multi"
+      @ok="selectOK"
+      :user-ids="value"
+      :store="storeField"
+      :text="textField"
+      @initComp="initComp"/>
  </div>
 </template>

 <script>
  import JSelectUserByDepModal from './modal/JSelectUserByDepModal'
+  import { underLinetoHump } from '@/components/_util/StringUtil'

  export default {
    name: 'JSelectUserByDep',
@ -38,19 +47,48 @@
        default: true,
        required: false
      },
+      backUser: {
+        type: Boolean,
+        default: false,
+        required: false
+      },
+      // 存储字段 [key field]
+      store: {
+        type: String,
+        default: 'username',
+        required: false
+      },
+      // 显示字段 [label field]
+      text: {
+        type: String,
+        default: 'realname',
+        required: false
+      }
    },
    data() {
      return {
-        userIds: "",
-        userNames: ""
+        storeVals: '', //[key values]
+        textVals: '' //[label values]
+      }
+    },
+    computed:{
+      storeField(){
+        let field = this.customReturnField
+        if(!field){
+          field = this.store;
+        }
+        return underLinetoHump(field)
+      },
+      textField(){
+        return underLinetoHump(this.text)
      }
    },
    mounted() {
-      this.userIds = this.value
+      this.storeVals = this.value
    },
    watch: {
      value(val) {
-        this.userIds = val
+        this.storeVals = val
      }
    },
    model: {
@ -58,27 +96,45 @@
      event: 'change'
    },
    methods: {
-      initComp(userNames) {
-        this.userNames = userNames
+      initComp(textVals) {
+        this.textVals = textVals
+      },
+      //返回选中的用户信息
+      backDeparInfo(){
+        if(this.backUser===true){
+          if(this.storeVals && this.storeVals.length>0){
+            let arr1 = this.storeVals.split(',')
+            let arr2 = this.textVals.split(',')
+            let info = []
+            for(let i=0;i<arr1.length;i++){
+              info.push({
+                value: arr1[i],
+                text: arr2[i]
+              })
+            }
+            this.$emit('back', info)
+          }
+        }
      },
      onSearchDepUser() {
        this.$refs.selectModal.showModal()
      },
-      selectOK(rows, idstr) {
+      selectOK(rows) {
        console.log("当前选中用户", rows)
-        console.log("当前选中用户ID", idstr)
        if (!rows) {
-          this.userNames = ''
-          this.userIds = ''
+          this.storeVals = ''
+          this.textVals = ''
        } else {
-          let temp = ''
+          let temp1 = []
+          let temp2 = []
          for (let item of rows) {
-            temp += ',' + item.realname
+            temp1.push(item[this.storeField])
+            temp2.push(item[this.textField])
          }
-          this.userNames = temp.substring(1)
-          this.userIds = idstr
+          this.storeVals = temp1.join(',')
+          this.textVals = temp2.join(',')
        }
-        this.$emit("change", this.userIds)
+        this.$emit("change", this.storeVals)
      }
    }
  }
--- a/ant-design-vue-jeecg/src/components/jeecgbiz/modal/JSelectDepartModal.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/modal/JSelectDepartModal.vue
@ -6,15 +6,17 @@
    :confirmLoading="confirmLoading"
    @ok="handleSubmit"
    @cancel="handleCancel"
+    @update:fullscreen="isFullscreen"
+    wrapClassName="j-depart-select-modal"
    switchFullscreen
    cancelText="关闭">
    <a-spin tip="Loading..." :spinning="false">
      <a-input-search style="margin-bottom: 1px" placeholder="请输入部门名称按回车进行搜索" @search="onSearch" />
      <a-tree
        checkable
-        class="my-dept-select-tree"
+        :class="treeScreenClass"
        :treeData="treeData"
-        :checkStrictly="true"
+        :checkStrictly="checkStrictly"
        @check="onCheck"
        @select="onSelect"
        @expand="onExpand"
@ -31,8 +33,23 @@
          <span v-else>{{title}}</span>
        </template>
      </a-tree>
-
    </a-spin>
+    <!--底部父子关联操作和确认取消按钮-->
+    <template slot="footer" v-if="treeOpera && multi">
+      <div class="drawer-bootom-button">
+        <a-dropdown style="float: left" :trigger="['click']" placement="topCenter">
+          <a-menu slot="overlay">
+            <a-menu-item key="1" @click="switchCheckStrictly(1)">父子关联</a-menu-item>
+            <a-menu-item key="2" @click="switchCheckStrictly(2)">取消关联</a-menu-item>
+          </a-menu>
+          <a-button>
+            树操作 <a-icon type="up" />
+          </a-button>
+        </a-dropdown>
+        <a-button @click="handleCancel" type="primary" style="margin-right: 0.8rem">关闭</a-button>
+        <a-button @click="handleSubmit" type="primary" >确认</a-button>
+      </div>
+    </template>
  </j-modal>
 </template>

@ -40,7 +57,7 @@
  import { queryDepartTreeList } from '@/api/api'
  export default {
    name: 'JSelectDepartModal',
-    props:['modalWidth','multi','rootOpened','departId'],
+    props:['modalWidth','multi','rootOpened','departId', 'store', 'text','treeOpera'],
    data(){
      return {
        visible:false,
@ -51,7 +68,9 @@
        dataList:[],
        checkedKeys:[],
        checkedRows:[],
-        searchValue:""
+        searchValue:"",
+        checkStrictly: true,
+        fullscreen:false
      }
    },
    created(){
@ -63,15 +82,18 @@
      },
      visible: {
        handler() {
-          if (this.departId) {
-            this.checkedKeys = this.departId.split(",");
-            // console.log('this.departId', this.departId)
-          } else {
-            this.checkedKeys = [];
-          }
+          this.initDepartComponent(true)
        }
      }
    },
+    computed:{
+      treeScreenClass() {
+        return {
+          'my-dept-select-tree': true,
+          'fullscreen': this.fullscreen,
+        }
+      },
+    },
    methods:{
      show(){
        this.visible=true
@ -79,6 +101,7 @@
        this.checkedKeys=[]
      },
      loadDepart(){
+        // 这个方法是找到所有的部门信息
        queryDepartTreeList().then(res=>{
          if(res.success){
            let arr = [...res.result]
@ -91,20 +114,23 @@
          }
        })
      },
-      initDepartComponent(){
-        let names = ''
+      initDepartComponent(flag){
+        let arr = []
+        //该方法两个地方用 1.visible改变事件重新设置选中项 2.组件编辑页面回显
+        let fieldName = flag==true?'key':this.text
        if(this.departId){
-          let currDepartId = this.departId
+          let arr2 = this.departId.split(',')
          for(let item of this.dataList){
-            if(currDepartId.indexOf(item.key)>=0){
-              names+=","+item.title
+            if(arr2.indexOf(item[this.store])>=0){
+              arr.push(item[fieldName])
            }
          }
-          if(names){
-            names = names.substring(1)
-          }
        }
-        this.$emit("initComp",names)
+        if(flag==true){
+          this.checkedKeys = [...arr]
+        }else{
+          this.$emit("initComp", arr.join(','))
+        }
      },
      reWriterWithSlot(arr){
        for(let item of arr){
@ -128,8 +154,11 @@
            }
          }
          this.expandedKeys=[...keys]
+          //全部keys
+          //this.allTreeKeys = [...keys]
        }else{
          this.expandedKeys=[]
+          //this.allTreeKeys = []
        }
      },
      onCheck (checkedKeys,info) {
@ -138,25 +167,32 @@
          this.checkedKeys = [...arr]
          this.checkedRows = (this.checkedKeys.length === 0) ? [] : [info.node.dataRef]
        }else{
-          this.checkedKeys = checkedKeys.checked
+          if(this.checkStrictly){
+            this.checkedKeys = checkedKeys.checked
+          }else{
+            this.checkedKeys = checkedKeys
+          }
          this.checkedRows = this.getCheckedRows(this.checkedKeys)
        }
      },
      onSelect(selectedKeys,info) {
-        let keys = []
-        keys.push(selectedKeys[0])
-        if(!this.checkedKeys || this.checkedKeys.length===0 || !this.multi){
-          this.checkedKeys = [...keys]
-          this.checkedRows=[info.node.dataRef]
-        }else{
-          let currKey = info.node.dataRef.key
-          if(this.checkedKeys.indexOf(currKey)>=0){
-            this.checkedKeys = this.checkedKeys.filter(item=> item !==currKey)
+        //取消关联的情况下才走onSelect的逻辑
+        if(this.checkStrictly){
+          let keys = []
+          keys.push(selectedKeys[0])
+          if(!this.checkedKeys || this.checkedKeys.length===0 || !this.multi){
+            this.checkedKeys = [...keys]
+            this.checkedRows=[info.node.dataRef]
          }else{
-            this.checkedKeys.push(...keys)
+            let currKey = info.node.dataRef.key
+            if(this.checkedKeys.indexOf(currKey)>=0){
+              this.checkedKeys = this.checkedKeys.filter(item=> item !==currKey)
+            }else{
+              this.checkedKeys.push(...keys)
+            }
          }
+          this.checkedRows = this.getCheckedRows(this.checkedKeys)
        }
-        this.checkedRows = this.getCheckedRows(this.checkedKeys)
      },
      onExpand (expandedKeys) {
        this.expandedKeys = expandedKeys
@ -166,7 +202,9 @@
        if(!this.checkedKeys || this.checkedKeys.length==0){
          this.$emit("ok",'')
        }else{
-          this.$emit("ok",this.checkedRows,this.checkedKeys.join(","))
+          let checkRow = this.getCheckedRows(this.checkedKeys)
+          let keyStr = this.checkedKeys.join(",")
+          this.$emit("ok", checkRow, keyStr)
        }
        this.handleClear()
      },
@ -232,6 +270,16 @@
          }
        }
        return rows
+      },
+      switchCheckStrictly (v) {
+        if(v==1){
+          this.checkStrictly = false
+        }else if(v==2){
+          this.checkStrictly = true
+        }
+      },
+      isFullscreen(val){
+        this.fullscreen=val
      }
    }
  }
@ -241,8 +289,22 @@
 <style lang="less" scoped>
  // 限制部门选择树高度，避免部门太多时点击确定不便
  .my-dept-select-tree{
-    height: 350px;
+    height:350px;
+    
+    &.fullscreen{
+      height: calc(100vh - 250px);
+    }
    overflow-y: scroll;
  }
-
+  .drawer-bootom-button {
+    position: absolute;
+    bottom: 0;
+    width: 100%;
+    border-top: 1px solid #e8e8e8;
+    padding: 10px 16px;
+    text-align: right;
+    left: 0;
+    background: #fff;
+    border-radius: 0 0 2px 2px;
+  }
 </style>
--- a/ant-design-vue-jeecg/src/components/jeecgbiz/modal/JSelectUserByDepModal.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/modal/JSelectUserByDepModal.vue
@ -4,6 +4,7 @@
    :visible="visible"
    :title="title"
    switchFullscreen
+    wrapClassName="j-user-select-modal"
    @ok="handleSubmit"
    @cancel="close"
    style="top:50px"
@ -55,13 +56,14 @@
 </template>

 <script>
-  import {filterObj} from '@/utils/util'
+  import { pushIfNotExist, filterObj } from '@/utils/util'
  import {queryDepartTreeList, getUserList, queryUserByDepId} from '@/api/api'
+  import { getAction } from '@/api/manage'

  export default {
    name: 'JSelectUserByDepModal',
    components: {},
-    props: ['modalWidth', 'multi', 'userIds'],
+    props: ['modalWidth', 'multi', 'userIds', 'store', 'text'],
    data() {
      return {
        queryParam: {
@ -100,11 +102,12 @@
          {
            title: '部门',
            align: 'center',
-            dataIndex: 'orgCode'
+            dataIndex: 'orgCodeTxt'
          }
        ],
        scrollTrigger: {},
        dataSource: [],
+        selectionRows: [],
        selectedRowKeys: [],
        selectUserRows: [],
        selectUserIds: [],
@ -156,45 +159,43 @@
        if (this.userIds) {
          // 这里最后加一个 , 的原因是因为无论如何都要使用 in 查询，防止后台进行了模糊匹配，导致查询结果不准确
          let values = this.userIds.split(',') + ','
-          getUserList({
-            username: values,
-            pageNo: 1,
-            pageSize: values.length
-          }).then((res) => {
-            if (res.success) {
-              let selectedRowKeys = []
-              let realNames = []
-              res.result.records.forEach(user => {
-                realNames.push(user['realname'])
+          let param = {[this.store]: values}
+          getAction('/sys/user/getMultiUser', param).then((list)=>{
+            this.selectionRows = []
+            let selectedRowKeys = []
+            let textArray = []
+            if(list && list.length>0){
+              for(let user of list){
+                textArray.push(user[this.text])
                selectedRowKeys.push(user['id'])
-              })
-              this.selectedRowKeys = selectedRowKeys
-              this.$emit('initComp', realNames.join(','))
+                this.selectionRows.push(user)
+              }
            }
+            this.selectedRowKeys = selectedRowKeys
+            this.$emit('initComp', textArray.join(','))
          })
+
        } else {
          // JSelectUserByDep组件bug issues/I16634
          this.$emit('initComp', '')
+          // 前端用户选择单选无法置空的问题 #2610
+          this.selectedRowKeys = []
        }
      },
      async loadData(arg) {
        if (arg === 1) {
          this.ipagination.current = 1;
        }
-        if (this.selectedDepIds && this.selectedDepIds.length > 0) {
-          await this.initQueryUserByDepId(this.selectedDepIds)
-        } else {
-          this.loading = true
-          let params = this.getQueryParams()//查询条件
-          await getUserList(params).then((res) => {
-            if (res.success) {
-              this.dataSource = res.result.records
-              this.ipagination.total = res.result.total
-            }
-          }).finally(() => {
-            this.loading = false
-          })
-        }
+        let params = this.getQueryParams()//查询条件
+        this.loading = true
+        getAction('/sys/user/queryUserComponentData', params).then(res=>{
+          if (res.success) {
+            this.dataSource = res.result.records
+            this.ipagination.total = res.result.total
+          }
+        }).finally(() => {
+          this.loading = false
+        })
      },
      // 触发屏幕自适应
      resetScreenSize() {
@ -217,6 +218,7 @@
        param.field = this.getQueryField();
        param.pageNo = this.ipagination.current;
        param.pageSize = this.ipagination.pageSize;
+        param.departId = this.selectedDepIds.join(',')
        return filterObj(param);
      },
      getQueryField() {
@ -228,13 +230,13 @@
      },
      searchReset(num) {
        let that = this;
+        that.selectedRowKeys = [];
+        that.selectUserIds = [];
+        that.selectedDepIds = [];
        if (num !== 0) {
          that.queryParam = {};
          that.loadData(1);
        }
-        that.selectedRowKeys = [];
-        that.selectUserIds = [];
-        that.selectedDepIds = [];
      },
      close() {
        this.searchReset(0);
@ -252,35 +254,32 @@
      handleSubmit() {
        let that = this;
        this.getSelectUserRows();
-        that.$emit('ok', that.selectUserRows, that.selectUserIds);
+        that.$emit('ok', that.selectUserRows);
        that.searchReset(0)
        that.close();
      },
      //获取选择用户信息
-      getSelectUserRows(rowId) {
-        let dataSource = this.dataSource;
-        let userIds = "";
-        this.selectUserRows = [];
-        for (let i = 0, len = dataSource.length; i < len; i++) {
-          if (this.selectedRowKeys.includes(dataSource[i].id)) {
-            this.selectUserRows.push(dataSource[i]);
-            userIds = userIds + "," + dataSource[i].username
+      getSelectUserRows() {
+        this.selectUserRows = []
+        for (let row of this.selectionRows) {
+          if (this.selectedRowKeys.includes(row.id)) {
+            this.selectUserRows.push(row)
          }
        }
-        this.selectUserIds = userIds.substring(1);
+        this.selectUserIds = this.selectUserRows.map(row => row.username).join(',')
      },
      // 点击树节点,筛选出对应的用户
      onDepSelect(selectedDepIds) {
        if (selectedDepIds[0] != null) {
-          this.initQueryUserByDepId(selectedDepIds); // 调用方法根据选选择的id查询用户信息
          if (this.selectedDepIds[0] !== selectedDepIds[0]) {
            this.selectedDepIds = [selectedDepIds[0]];
          }
+          this.loadData(1);
        }
      },
      onSelectChange(selectedRowKeys, selectionRows) {
        this.selectedRowKeys = selectedRowKeys;
-        this.selectionRows = selectionRows;
+        selectionRows.forEach(row => pushIfNotExist(this.selectionRows, row, 'id'))
      },
      onSearch() {
        this.loadData(1);
--- a/ant-design-vue-jeecg/src/components/jeecgbiz/thirdApp/JThirdAppButton.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/thirdApp/JThirdAppButton.vue
@ -0,0 +1,214 @@
+<template>
+  <span v-if="syncToApp || syncToLocal">
+    <j-third-app-dropdown v-if="enabledTypes.wechatEnterprise" type="wechatEnterprise" name="企微" v-bind="bindAttrs" v-on="bindEvents"/>
+    <j-third-app-dropdown v-if="enabledTypes.dingtalk" type="dingtalk" name="钉钉" v-bind="bindAttrs" v-on="bindEvents"/>
+  </span>
+  <span v-else>未设置任何同步方向</span>
+</template>
+
+<script>
+import { getAction } from '@/api/manage'
+import { cloneObject } from '@/utils/util'
+import JThirdAppDropdown from './JThirdAppDropdown'
+
+const backEndUrl = {
+  // 获取启用的第三方App
+  getEnabledType: '/sys/thirdApp/getEnabledType',
+  // 企业微信
+  wechatEnterprise: {
+    user: '/sys/thirdApp/sync/wechatEnterprise/user',
+    depart: '/sys/thirdApp/sync/wechatEnterprise/depart',
+  },
+  // 钉钉
+  dingtalk: {
+    user: '/sys/thirdApp/sync/dingtalk/user',
+    depart: '/sys/thirdApp/sync/dingtalk/depart',
+  }
+}
+
+export default {
+  name: 'JThirdAppButton',
+  components: {JThirdAppDropdown},
+  props: {
+    // 同步类型，可以是 user、depart
+    bizType: {
+      type: String,
+      required: true,
+    },
+    // 是否允许同步到第三方APP
+    syncToApp: Boolean,
+    // 是否允许第三方APP同步到本地
+    syncToLocal: Boolean,
+    // 选择的行
+    selectedRowKeys: Array,
+  },
+  data() {
+    return {
+      enabledTypes: {},
+      attrs: {
+        dingtalk: {},
+      },
+    }
+  },
+  computed: {
+    bindAttrs() {
+      return {
+        syncToApp: this.syncToApp,
+        syncToLocal: this.syncToLocal
+      }
+    },
+    bindEvents() {
+      return {
+        'to-app': this.onToApp,
+        'to-local': this.onToLocal,
+      }
+    },
+  },
+  created() {
+    this.loadEnabledTypes()
+  },
+  methods: {
+    handleMenuClick() {
+      console.log(arguments)
+    },
+    onToApp(e) {
+      this.doSync(e.type, '/toApp')
+    },
+    onToLocal(e) {
+      this.doSync(e.type, '/toLocal')
+    },
+    // 获取启用的第三方App
+    async loadEnabledTypes() {
+      this.enabledTypes = await loadEnabledTypes()
+    },
+    // 开始同步第三方App
+    doSync(type, direction) {
+      let urls = backEndUrl[type]
+      if (!(urls && urls[this.bizType])) {
+        console.warn('配置出错')
+        return
+      }
+      let url = urls[this.bizType] + direction
+
+      let selectedRowKeys = this.selectedRowKeys
+      let content = '确定要开始同步全部数据吗？可能花费较长时间！'
+      if (Array.isArray(selectedRowKeys) && selectedRowKeys.length > 0) {
+        content = `确定要开始同步这 ${selectedRowKeys.length} 项吗？`
+      } else {
+        selectedRowKeys = []
+      }
+      return new Promise((resolve, reject) => {
+        let model = this.$confirm({
+          title: '同步',
+          content,
+          onOk: () => {
+            model.update({
+              keyboard: false,
+              okText: '同步中…',
+              cancelButtonProps: {props: {disabled: true}}
+            })
+            return getAction(url, {
+              ids: selectedRowKeys.join(',')
+            }).then(res => {
+              let options = null
+              if (res.result) {
+                options = {
+                  width: 600,
+                  title: res.message,
+                  content: (h) => {
+                    let nodes
+                    let successInfo = [
+                      `成功信息如下：`,
+                      this.renderTextarea(h, res.result.successInfo.map((v, i) => `${i + 1}. ${v}`).join('\n')),
+                    ]
+                    if (res.success) {
+                      nodes = [
+                        ...successInfo,
+                        h('br'),
+                        `无失败信息！`,
+                      ]
+                    } else {
+                      nodes = [
+                        `失败信息如下：`,
+                        this.renderTextarea(h, res.result.failInfo.map((v, i) => `${i + 1}. ${v}`).join('\n')),
+                        h('br'),
+                        ...successInfo,
+                      ]
+                    }
+                    return nodes
+                  }
+                }
+              }
+              if (res.success) {
+                if (options != null) {
+                  this.$success(options)
+                } else {
+                  this.$message.success(res.message)
+                }
+                this.$emit('sync-ok')
+              } else {
+                if (options != null) {
+                  this.$warning(options)
+                } else {
+                  this.$message.warning(res.message)
+                }
+                this.$emit('sync-error')
+              }
+            }).catch(() => model.destroy()).finally(() => {
+              resolve()
+              this.$emit('sync-finally', {
+                type,
+                direction,
+                isToApp: direction === '/toApp',
+                isToLocal: direction === '/toLocal',
+              })
+            })
+          },
+          onCancel() {
+            resolve()
+          },
+        })
+      })
+    },
+    renderTextarea(h, value) {
+      return h('a-textarea', {
+        props: {
+          value: value,
+          readOnly: true,
+          autosize: {minRows: 5, maxRows: 10},
+        },
+        style: {
+          // 关闭textarea的自动换行，使其可以左右滚动
+          whiteSpace: 'pre',
+          overflow: 'auto',
+        }
+      })
+    }
+  },
+}
+
+// 启用了哪些第三方App（在此缓存）
+let enabledTypes = null
+
+// 获取启用的第三方App
+export async function loadEnabledTypes() {
+  // 获取缓存
+  if (enabledTypes != null) {
+    return cloneObject(enabledTypes)
+  } else {
+    let {success, result} = await getAction(backEndUrl.getEnabledType)
+    if (success) {
+      // 在此缓存
+      enabledTypes = cloneObject(result)
+      return result
+    } else {
+      console.warn('getEnabledType查询失败：', res)
+    }
+  }
+  return {}
+}
+</script>
+
+<style scoped>
+
+</style>
--- a/ant-design-vue-jeecg/src/components/jeecgbiz/thirdApp/JThirdAppDropdown.vue
+++ b/ant-design-vue-jeecg/src/components/jeecgbiz/thirdApp/JThirdAppDropdown.vue
@ -0,0 +1,34 @@
+<template>
+  <a-dropdown v-if="syncToApp && syncToLocal">
+    <a-button type="primary" icon="sync">同步{{name}}</a-button>
+    <a-menu slot="overlay" @click="handleMenuClick">
+      <a-menu-item v-if="syncToApp" key="to-app">同步到{{name}}</a-menu-item>
+      <a-menu-item v-if="syncToLocal" key="to-local">同步到本地</a-menu-item>
+    </a-menu>
+  </a-dropdown>
+  <a-button v-else-if="syncToApp" type="primary" icon="sync" @click="handleMenuClick({key:'to-app'})">同步{{name}}</a-button>
+  <a-button v-else type="primary" icon="sync" @click="handleMenuClick({key:'to-local'})">同步{{name}}到本地</a-button>
+</template>
+
+<script>
+
+/* JThirdAppButton 的子组件，不可单独使用 */
+export default {
+  name: 'JThirdAppDropdown',
+  props: {
+    type: String,
+    name: String,
+    syncToApp: Boolean,
+    syncToLocal: Boolean,
+  },
+  methods: {
+    handleMenuClick(event) {
+      this.$emit(event.key, {type: this.type})
+    },
+  },
+}
+</script>
+
+<style scoped>
+
+</style>
--- a/ant-design-vue-jeecg/src/components/layouts/IframePageView.vue
+++ b/ant-design-vue-jeecg/src/components/layouts/IframePageView.vue
@ -38,16 +38,20 @@
        //url = "http://www.baidu.com"
        console.log("------url------"+url)
        if (url !== null && url !== undefined) {
-          this.url = url;
+          //-----------------------------------------------------------------------------------------
+          //url支持通过 ${token}方式传递当前登录TOKEN
+          let tokenStr = "${token}";
+          if(url.indexOf(tokenStr)!=-1) {
+            let token = Vue.ls.get(ACCESS_TOKEN);
+            this.url = url.replace(tokenStr, token);
+          } else {
+            this.url = url
+          }
+          //-----------------------------------------------------------------------------------------
+
          /*update_begin author:wuxianquan date:20190908 for:判断打开方式，新窗口打开时this.$route.meta.internalOrExternal==true */
          if(this.$route.meta.internalOrExternal != undefined && this.$route.meta.internalOrExternal==true){
            this.closeCurrent();
-            //外部url加入token
-            let tokenStr = "${token}";
-            if(url.indexOf(tokenStr)!=-1){
-              let token = Vue.ls.get(ACCESS_TOKEN);
-               this.url = url.replace(tokenStr,token);
-            }
            window.open(this.url);
          }
          /*update_end author:wuxianquan date:20190908 for:判断打开方式，新窗口打开时this.$route.meta.internalOrExternal==true */
--- a/ant-design-vue-jeecg/src/components/layouts/RouteView.vue
+++ b/ant-design-vue-jeecg/src/components/layouts/RouteView.vue
@ -1,6 +1,6 @@
 <template>
  <div class="main">
-  <keep-alive>
+  <keep-alive :include="includedComponents">
    <router-view v-if="keepAlive" />
  </keep-alive>
  <router-view v-if="!keepAlive" />
@ -8,9 +8,32 @@
 </template>

 <script>
+  import Vue from 'vue'
+  import { CACHE_INCLUDED_ROUTES } from "@/store/mutation-types"
+
  export default {
    name: "RouteView",
    computed: {
+      //update-begin--Author:scott  Date:20201015 for：路由缓存问题，关闭了tab页时再打开就不刷新 #842
+      includedComponents() {
+        const includedRouters = Vue.ls.get(CACHE_INCLUDED_ROUTES)
+        console.log("includedRouters：" + includedRouters)
+
+        //如果是缓存路由，则加入到 cache_included_routes
+        if (this.$route.meta.keepAlive && this.$route.meta.componentName) {
+          let cacheRouterArray = Vue.ls.get(CACHE_INCLUDED_ROUTES) || []
+          if(!cacheRouterArray.includes(this.$route.meta.componentName)){
+            cacheRouterArray.push(this.$route.meta.componentName)
+            // cacheRouterArray.push("OnlCgformHeadList")
+            console.log("Vue ls set componentName ：" + this.$route.meta.componentName)
+            Vue.ls.set(CACHE_INCLUDED_ROUTES, cacheRouterArray)
+            console.log("Vue ls includedRouterArrays ：" + Vue.ls.get(CACHE_INCLUDED_ROUTES))
+            return cacheRouterArray;
+          }
+        }
+        return includedRouters;
+      },
+      //update-end--Author:scott  Date:20201015 for：路由缓存问题，关闭了tab页时再打开就不刷新 #842
      keepAlive () {
        return this.$route.meta.keepAlive
      }
--- a/Show More
+++ b/Show More