修改职位信息

attendance-performance-manager/src/main/java/com/mortals/xhx/busiz/hik/ArtemisPostTest.java

@@ -93,12 +93,6 @@ public class ArtemisPostTest {
 		return ArtemisHttpUtil.doPostStringArtemis(config,path, body, null, null, "application/json");
 	}
 
-
-
-
-
-
-
 	public static String callPostApiGetDeptList() throws Exception {
 		/**
 		 * https://ip:port/artemis/api/resource/v1/org/orgList

attendance-performance-manager/src/main/java/com/mortals/xhx/daemon/task/SyncUserTaskImpl.java

@@ -4,7 +4,6 @@ import com.mortals.framework.exception.AppException;
 import com.mortals.framework.service.ITask;
 import com.mortals.framework.service.ITaskExcuteService;
 import com.mortals.xhx.base.framework.config.JsonUtils;
-import com.mortals.xhx.base.system.user.service.UserService;
 import com.mortals.xhx.busiz.hik.ArtemisPostTest;
 import com.mortals.xhx.busiz.rsp.DeptHikData;
 import com.mortals.xhx.busiz.rsp.ListDept;

attendance-performance-manager/src/main/java/com/mortals/xhx/module/job/model/JobEntity.java

@@ -7,116 +7,134 @@ import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.job.model.vo.JobVo;
 /**
-* 职位信息实体对象
-*
-* @author zxfei
-* @date 2023-04-07
-*/
+ * 职位信息实体对象
+ *
+ * @author zxfei
+ * @date 2023-04-11
+ */
 
 public class JobEntity extends JobVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 分组id
-    */
+     * 分组id
+     */
     private Long groupId;
     /**
-    * 分组名称
-    */
+     * 分组名称
+     */
     private String groupName;
     /**
-    * 职位编码
-    */
+     * 职位编码
+     */
     private String jobCode;
     /**
-    * 职位名称
-    */
+     * 职位名称
+     */
     private String jobName;
     /**
-    * 备注
-    */
+     * 备注
+     */
     private String remark;
+    /**
+     * 节点类型(1.分组,2.职位)
+     */
+    private Integer type;
 
 
 
     public JobEntity(){}
     /**
-    * 获取 分组id
-    * @return Long
-    */
+     * 获取 分组id
+     * @return Long
+     */
     public Long getGroupId(){
         return groupId;
     }
     /**
-    * 设置 分组id
-    * @param groupId
-    */
+     * 设置 分组id
+     * @param groupId
+     */
     public void setGroupId(Long groupId){
         this.groupId = groupId;
     }
     /**
-    * 获取 分组名称
-    * @return String
-    */
+     * 获取 分组名称
+     * @return String
+     */
     public String getGroupName(){
         return groupName;
     }
     /**
-    * 设置 分组名称
-    * @param groupName
-    */
+     * 设置 分组名称
+     * @param groupName
+     */
     public void setGroupName(String groupName){
         this.groupName = groupName;
     }
     /**
-    * 获取 职位编码
-    * @return String
-    */
+     * 获取 职位编码
+     * @return String
+     */
     public String getJobCode(){
         return jobCode;
     }
     /**
-    * 设置 职位编码
-    * @param jobCode
-    */
+     * 设置 职位编码
+     * @param jobCode
+     */
     public void setJobCode(String jobCode){
         this.jobCode = jobCode;
     }
     /**
-    * 获取 职位名称
-    * @return String
-    */
+     * 获取 职位名称
+     * @return String
+     */
     public String getJobName(){
         return jobName;
     }
     /**
-    * 设置 职位名称
-    * @param jobName
-    */
+     * 设置 职位名称
+     * @param jobName
+     */
     public void setJobName(String jobName){
         this.jobName = jobName;
     }
     /**
-    * 获取 备注
-    * @return String
-    */
+     * 获取 备注
+     * @return String
+     */
     public String getRemark(){
         return remark;
     }
     /**
-    * 设置 备注
-    * @param remark
-    */
+     * 设置 备注
+     * @param remark
+     */
     public void setRemark(String remark){
         this.remark = remark;
     }
+    /**
+     * 获取 节点类型(1.分组,2.职位)
+     * @return Integer
+     */
+    public Integer getType(){
+        return type;
+    }
+    /**
+     * 设置 节点类型(1.分组,2.职位)
+     * @param type
+     */
+    public void setType(Integer type){
+        this.type = type;
+    }
 
 
 
 
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -124,7 +142,7 @@ public class JobEntity extends JobVo {
         if (obj instanceof JobEntity) {
             JobEntity tmp = (JobEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
@@ -137,19 +155,22 @@ public class JobEntity extends JobVo {
         sb.append(",jobCode:").append(getJobCode());
         sb.append(",jobName:").append(getJobName());
         sb.append(",remark:").append(getRemark());
+        sb.append(",type:").append(getType());
         return sb.toString();
     }
 
     public void initAttrValue(){
 
-            this.groupId = null;
+        this.groupId = null;
+
+        this.groupName = "";
 
-            this.groupName = "";
+        this.jobCode = "";
 
-            this.jobCode = "";
+        this.jobName = "";
 
-            this.jobName = "";
+        this.remark = "";
 
-            this.remark = "";
+        this.type = 1;
     }
 }
\ No newline at end of file

attendance-performance-manager/src/main/java/com/mortals/xhx/module/job/model/JobQuery.java

@@ -3,11 +3,11 @@ package com.mortals.xhx.module.job.model;
 import java.util.List;
 import com.mortals.xhx.module.job.model.JobEntity;
 /**
-* 职位信息查询对象
-*
-* @author zxfei
-* @date 2023-04-07
-*/
+ * 职位信息查询对象
+ *
+ * @author zxfei
+ * @date 2023-04-11
+ */
 public class JobQuery extends JobEntity {
     /** 开始 主键，自增长 */
     private Long idStart;
@@ -101,6 +101,21 @@ public class JobQuery extends JobEntity {
     /** 结束 修改时间 */
     private String updateTimeEnd;
 
+    /** 开始 节点类型(1.分组,2.职位) */
+    private Integer typeStart;
+
+    /** 结束 节点类型(1.分组,2.职位) */
+    private Integer typeEnd;
+
+    /** 增加 节点类型(1.分组,2.职位) */
+    private Integer typeIncrement;
+
+    /** 节点类型(1.分组,2.职位)列表 */
+    private List <Integer> typeList;
+
+    /** 节点类型(1.分组,2.职位)排除列表 */
+    private List <Integer> typeNotList;
+
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<JobQuery> orConditionList;
 
@@ -110,843 +125,978 @@ public class JobQuery extends JobEntity {
     public JobQuery(){}
 
     /**
-    * 获取 开始 主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 主键，自增长
-    * @return idList
-    */
+     * 获取 主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 主键，自增长
-    * @param idList
-    */
+     * 设置 主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 主键，自增长
-    * @return idNotList
-    */
+     * 获取 主键，自增长
+     * @return idNotList
+     */
     public List<Long> getIdNotList(){
         return this.idNotList;
     }
 
     /**
-    * 设置 主键，自增长
-    * @param idNotList
-    */
+     * 设置 主键，自增长
+     * @param idNotList
+     */
     public void setIdNotList(List<Long> idNotList){
         this.idNotList = idNotList;
     }
 
 
     /**
-    * 获取 开始 分组id
-    * @return groupIdStart
-    */
+     * 获取 开始 分组id
+     * @return groupIdStart
+     */
     public Long getGroupIdStart(){
         return this.groupIdStart;
     }
 
     /**
-    * 设置 开始 分组id
-    * @param groupIdStart
-    */
+     * 设置 开始 分组id
+     * @param groupIdStart
+     */
     public void setGroupIdStart(Long groupIdStart){
         this.groupIdStart = groupIdStart;
     }
 
     /**
-    * 获取 结束 分组id
-    * @return $groupIdEnd
-    */
+     * 获取 结束 分组id
+     * @return $groupIdEnd
+     */
     public Long getGroupIdEnd(){
         return this.groupIdEnd;
     }
 
     /**
-    * 设置 结束 分组id
-    * @param groupIdEnd
-    */
+     * 设置 结束 分组id
+     * @param groupIdEnd
+     */
     public void setGroupIdEnd(Long groupIdEnd){
         this.groupIdEnd = groupIdEnd;
     }
 
     /**
-    * 获取 增加 分组id
-    * @return groupIdIncrement
-    */
+     * 获取 增加 分组id
+     * @return groupIdIncrement
+     */
     public Long getGroupIdIncrement(){
         return this.groupIdIncrement;
     }
 
     /**
-    * 设置 增加 分组id
-    * @param groupIdIncrement
-    */
+     * 设置 增加 分组id
+     * @param groupIdIncrement
+     */
     public void setGroupIdIncrement(Long groupIdIncrement){
         this.groupIdIncrement = groupIdIncrement;
     }
 
     /**
-    * 获取 分组id
-    * @return groupIdList
-    */
+     * 获取 分组id
+     * @return groupIdList
+     */
     public List<Long> getGroupIdList(){
         return this.groupIdList;
     }
 
     /**
-    * 设置 分组id
-    * @param groupIdList
-    */
+     * 设置 分组id
+     * @param groupIdList
+     */
     public void setGroupIdList(List<Long> groupIdList){
         this.groupIdList = groupIdList;
     }
 
     /**
-    * 获取 分组id
-    * @return groupIdNotList
-    */
+     * 获取 分组id
+     * @return groupIdNotList
+     */
     public List<Long> getGroupIdNotList(){
         return this.groupIdNotList;
     }
 
     /**
-    * 设置 分组id
-    * @param groupIdNotList
-    */
+     * 设置 分组id
+     * @param groupIdNotList
+     */
     public void setGroupIdNotList(List<Long> groupIdNotList){
         this.groupIdNotList = groupIdNotList;
     }
 
 
     /**
-    * 获取 分组名称
-    * @return groupNameList
-    */
+     * 获取 分组名称
+     * @return groupNameList
+     */
     public List<String> getGroupNameList(){
         return this.groupNameList;
     }
 
     /**
-    * 设置 分组名称
-    * @param groupNameList
-    */
+     * 设置 分组名称
+     * @param groupNameList
+     */
     public void setGroupNameList(List<String> groupNameList){
         this.groupNameList = groupNameList;
     }
 
     /**
-    * 获取 分组名称
-    * @return groupNameNotList
-    */
+     * 获取 分组名称
+     * @return groupNameNotList
+     */
     public List<String> getGroupNameNotList(){
         return this.groupNameNotList;
     }
 
     /**
-    * 设置 分组名称
-    * @param groupNameNotList
-    */
+     * 设置 分组名称
+     * @param groupNameNotList
+     */
     public void setGroupNameNotList(List<String> groupNameNotList){
         this.groupNameNotList = groupNameNotList;
     }
 
     /**
-    * 获取 职位编码
-    * @return jobCodeList
-    */
+     * 获取 职位编码
+     * @return jobCodeList
+     */
     public List<String> getJobCodeList(){
         return this.jobCodeList;
     }
 
     /**
-    * 设置 职位编码
-    * @param jobCodeList
-    */
+     * 设置 职位编码
+     * @param jobCodeList
+     */
     public void setJobCodeList(List<String> jobCodeList){
         this.jobCodeList = jobCodeList;
     }
 
     /**
-    * 获取 职位编码
-    * @return jobCodeNotList
-    */
+     * 获取 职位编码
+     * @return jobCodeNotList
+     */
     public List<String> getJobCodeNotList(){
         return this.jobCodeNotList;
     }
 
     /**
-    * 设置 职位编码
-    * @param jobCodeNotList
-    */
+     * 设置 职位编码
+     * @param jobCodeNotList
+     */
     public void setJobCodeNotList(List<String> jobCodeNotList){
         this.jobCodeNotList = jobCodeNotList;
     }
 
     /**
-    * 获取 职位名称
-    * @return jobNameList
-    */
+     * 获取 职位名称
+     * @return jobNameList
+     */
     public List<String> getJobNameList(){
         return this.jobNameList;
     }
 
     /**
-    * 设置 职位名称
-    * @param jobNameList
-    */
+     * 设置 职位名称
+     * @param jobNameList
+     */
     public void setJobNameList(List<String> jobNameList){
         this.jobNameList = jobNameList;
     }
 
     /**
-    * 获取 职位名称
-    * @return jobNameNotList
-    */
+     * 获取 职位名称
+     * @return jobNameNotList
+     */
     public List<String> getJobNameNotList(){
         return this.jobNameNotList;
     }
 
     /**
-    * 设置 职位名称
-    * @param jobNameNotList
-    */
+     * 设置 职位名称
+     * @param jobNameNotList
+     */
     public void setJobNameNotList(List<String> jobNameNotList){
         this.jobNameNotList = jobNameNotList;
     }
 
     /**
-    * 获取 备注
-    * @return remarkList
-    */
+     * 获取 备注
+     * @return remarkList
+     */
     public List<String> getRemarkList(){
         return this.remarkList;
     }
 
     /**
-    * 设置 备注
-    * @param remarkList
-    */
+     * 设置 备注
+     * @param remarkList
+     */
     public void setRemarkList(List<String> remarkList){
         this.remarkList = remarkList;
     }
 
     /**
-    * 获取 备注
-    * @return remarkNotList
-    */
+     * 获取 备注
+     * @return remarkNotList
+     */
     public List<String> getRemarkNotList(){
         return this.remarkNotList;
     }
 
     /**
-    * 设置 备注
-    * @param remarkNotList
-    */
+     * 设置 备注
+     * @param remarkNotList
+     */
     public void setRemarkNotList(List<String> remarkNotList){
         this.remarkNotList = remarkNotList;
     }
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 创建用户
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建用户
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建用户
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdList
-    */
+     * 获取 创建用户
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdNotList
-    */
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
     public List<Long> getCreateUserIdNotList(){
         return this.createUserIdNotList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdNotList
-    */
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
     public void setCreateUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 更新用户
-    * @return updateUserIdStart
-    */
+     * 获取 开始 更新用户
+     * @return updateUserIdStart
+     */
     public Long getUpdateUserIdStart(){
         return this.updateUserIdStart;
     }
 
     /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public void setUpdateUserIdStart(Long updateUserIdStart){
         this.updateUserIdStart = updateUserIdStart;
     }
 
     /**
-    * 获取 结束 更新用户
-    * @return $updateUserIdEnd
-    */
+     * 获取 结束 更新用户
+     * @return $updateUserIdEnd
+     */
     public Long getUpdateUserIdEnd(){
         return this.updateUserIdEnd;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public void setUpdateUserIdEnd(Long updateUserIdEnd){
         this.updateUserIdEnd = updateUserIdEnd;
     }
 
     /**
-    * 获取 增加 更新用户
-    * @return updateUserIdIncrement
-    */
+     * 获取 增加 更新用户
+     * @return updateUserIdIncrement
+     */
     public Long getUpdateUserIdIncrement(){
         return this.updateUserIdIncrement;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
         this.updateUserIdIncrement = updateUserIdIncrement;
     }
 
     /**
-    * 获取 更新用户
-    * @return updateUserIdList
-    */
+     * 获取 更新用户
+     * @return updateUserIdList
+     */
     public List<Long> getUpdateUserIdList(){
         return this.updateUserIdList;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public void setUpdateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
     }
 
     /**
-    * 获取 更新用户
-    * @return updateUserIdNotList
-    */
+     * 获取 更新用户
+     * @return updateUserIdNotList
+     */
     public List<Long> getUpdateUserIdNotList(){
         return this.updateUserIdNotList;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdNotList
-    */
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
     public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 修改时间
-    * @return updateTimeStart
-    */
+     * 获取 开始 修改时间
+     * @return updateTimeStart
+     */
     public String getUpdateTimeStart(){
         return this.updateTimeStart;
     }
 
     /**
-    * 设置 开始 修改时间
-    * @param updateTimeStart
-    */
+     * 设置 开始 修改时间
+     * @param updateTimeStart
+     */
     public void setUpdateTimeStart(String updateTimeStart){
         this.updateTimeStart = updateTimeStart;
     }
 
     /**
-    * 获取 结束 修改时间
-    * @return updateTimeEnd
-    */
+     * 获取 结束 修改时间
+     * @return updateTimeEnd
+     */
     public String getUpdateTimeEnd(){
         return this.updateTimeEnd;
     }
 
     /**
-    * 设置 结束 修改时间
-    * @param updateTimeEnd
-    */
+     * 设置 结束 修改时间
+     * @param updateTimeEnd
+     */
     public void setUpdateTimeEnd(String updateTimeEnd){
         this.updateTimeEnd = updateTimeEnd;
     }
 
     /**
-    * 设置  主键，自增长
-    * @param id
-    */
+     * 获取 开始 节点类型(1.分组,2.职位)
+     * @return typeStart
+     */
+    public Integer getTypeStart(){
+        return this.typeStart;
+    }
+
+    /**
+     * 设置 开始 节点类型(1.分组,2.职位)
+     * @param typeStart
+     */
+    public void setTypeStart(Integer typeStart){
+        this.typeStart = typeStart;
+    }
+
+    /**
+     * 获取 结束 节点类型(1.分组,2.职位)
+     * @return $typeEnd
+     */
+    public Integer getTypeEnd(){
+        return this.typeEnd;
+    }
+
+    /**
+     * 设置 结束 节点类型(1.分组,2.职位)
+     * @param typeEnd
+     */
+    public void setTypeEnd(Integer typeEnd){
+        this.typeEnd = typeEnd;
+    }
+
+    /**
+     * 获取 增加 节点类型(1.分组,2.职位)
+     * @return typeIncrement
+     */
+    public Integer getTypeIncrement(){
+        return this.typeIncrement;
+    }
+
+    /**
+     * 设置 增加 节点类型(1.分组,2.职位)
+     * @param typeIncrement
+     */
+    public void setTypeIncrement(Integer typeIncrement){
+        this.typeIncrement = typeIncrement;
+    }
+
+    /**
+     * 获取 节点类型(1.分组,2.职位)
+     * @return typeList
+     */
+    public List<Integer> getTypeList(){
+        return this.typeList;
+    }
+
+    /**
+     * 设置 节点类型(1.分组,2.职位)
+     * @param typeList
+     */
+    public void setTypeList(List<Integer> typeList){
+        this.typeList = typeList;
+    }
+
+    /**
+     * 获取 节点类型(1.分组,2.职位)
+     * @return typeNotList
+     */
+    public List<Integer> getTypeNotList(){
+        return this.typeNotList;
+    }
+
+    /**
+     * 设置 节点类型(1.分组,2.职位)
+     * @param typeNotList
+     */
+    public void setTypeNotList(List<Integer> typeNotList){
+        this.typeNotList = typeNotList;
+    }
+
+
+    /**
+     * 设置  主键，自增长
+     * @param id
+     */
     public JobQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 主键，自增长
+     * @param idStart
+     */
     public JobQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键，自增长
+     * @param idEnd
+     */
     public JobQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键，自增长
+     * @param idIncrement
+     */
     public JobQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 主键，自增长
-    * @param idList
-    */
+     * 设置 主键，自增长
+     * @param idList
+     */
     public JobQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 主键，自增长
-        * @param idNotList
-        */
-        public JobQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 主键，自增长
+     * @param idNotList
+     */
+    public JobQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  分组id
-    * @param groupId
-    */
+     * 设置  分组id
+     * @param groupId
+     */
     public JobQuery groupId(Long groupId){
-	    setGroupId(groupId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 分组id
-    * @param groupIdStart
-    */
+        setGroupId(groupId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 分组id
+     * @param groupIdStart
+     */
     public JobQuery groupIdStart(Long groupIdStart){
-		this.groupIdStart = groupIdStart;
-		return this;
+        this.groupIdStart = groupIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 分组id
-    * @param groupIdEnd
-    */
+     * 设置 结束 分组id
+     * @param groupIdEnd
+     */
     public JobQuery groupIdEnd(Long groupIdEnd){
-		this.groupIdEnd = groupIdEnd;
-		return this;
+        this.groupIdEnd = groupIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 分组id
-    * @param groupIdIncrement
-    */
+     * 设置 增加 分组id
+     * @param groupIdIncrement
+     */
     public JobQuery groupIdIncrement(Long groupIdIncrement){
-		this.groupIdIncrement = groupIdIncrement;
-		return this;
+        this.groupIdIncrement = groupIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 分组id
-    * @param groupIdList
-    */
+     * 设置 分组id
+     * @param groupIdList
+     */
     public JobQuery groupIdList(List<Long> groupIdList){
         this.groupIdList = groupIdList;
-		return this;
-        }
-
-        /**
-        * 设置 分组id
-        * @param groupIdNotList
-        */
-        public JobQuery groupIdNotList(List<Long> groupIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 分组id
+     * @param groupIdNotList
+     */
+    public JobQuery groupIdNotList(List<Long> groupIdNotList){
         this.groupIdNotList = groupIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 分组名称
-    * @param groupName
-    */
+    /**
+     * 设置 分组名称
+     * @param groupName
+     */
     public JobQuery groupName(String groupName){
         setGroupName(groupName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 分组名称
-    * @param groupNameList
-    */
+     * 设置 分组名称
+     * @param groupNameList
+     */
     public JobQuery groupNameList(List<String> groupNameList){
         this.groupNameList = groupNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 职位编码
-    * @param jobCode
-    */
+    /**
+     * 设置 职位编码
+     * @param jobCode
+     */
     public JobQuery jobCode(String jobCode){
         setJobCode(jobCode);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 职位编码
-    * @param jobCodeList
-    */
+     * 设置 职位编码
+     * @param jobCodeList
+     */
     public JobQuery jobCodeList(List<String> jobCodeList){
         this.jobCodeList = jobCodeList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 职位名称
-    * @param jobName
-    */
+    /**
+     * 设置 职位名称
+     * @param jobName
+     */
     public JobQuery jobName(String jobName){
         setJobName(jobName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 职位名称
-    * @param jobNameList
-    */
+     * 设置 职位名称
+     * @param jobNameList
+     */
     public JobQuery jobNameList(List<String> jobNameList){
         this.jobNameList = jobNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 备注
-    * @param remark
-    */
+    /**
+     * 设置 备注
+     * @param remark
+     */
     public JobQuery remark(String remark){
         setRemark(remark);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 备注
-    * @param remarkList
-    */
+     * 设置 备注
+     * @param remarkList
+     */
     public JobQuery remarkList(List<String> remarkList){
         this.remarkList = remarkList;
-		return this;
+        return this;
     }
 
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public JobQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public JobQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public JobQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public JobQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public JobQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建用户
-        * @param createUserIdNotList
-        */
-        public JobQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public JobQuery createUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  更新用户
-    * @param updateUserId
-    */
+     * 设置  更新用户
+     * @param updateUserId
+     */
     public JobQuery updateUserId(Long updateUserId){
-	    setUpdateUserId(updateUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public JobQuery updateUserIdStart(Long updateUserIdStart){
-		this.updateUserIdStart = updateUserIdStart;
-		return this;
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public JobQuery updateUserIdEnd(Long updateUserIdEnd){
-		this.updateUserIdEnd = updateUserIdEnd;
-		return this;
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public JobQuery updateUserIdIncrement(Long updateUserIdIncrement){
-		this.updateUserIdIncrement = updateUserIdIncrement;
-		return this;
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public JobQuery updateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 更新用户
-        * @param updateUserIdNotList
-        */
-        public JobQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public JobQuery updateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @return orConditionList
-    */
+     * 设置  节点类型(1.分组,2.职位)
+     * @param type
+     */
+    public JobQuery type(Integer type){
+        setType(type);
+        return this;
+    }
+
+    /**
+     * 设置 开始 节点类型(1.分组,2.职位)
+     * @param typeStart
+     */
+    public JobQuery typeStart(Integer typeStart){
+        this.typeStart = typeStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 节点类型(1.分组,2.职位)
+     * @param typeEnd
+     */
+    public JobQuery typeEnd(Integer typeEnd){
+        this.typeEnd = typeEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 节点类型(1.分组,2.职位)
+     * @param typeIncrement
+     */
+    public JobQuery typeIncrement(Integer typeIncrement){
+        this.typeIncrement = typeIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 节点类型(1.分组,2.职位)
+     * @param typeList
+     */
+    public JobQuery typeList(List<Integer> typeList){
+        this.typeList = typeList;
+        return this;
+    }
+
+    /**
+     * 设置 节点类型(1.分组,2.职位)
+     * @param typeNotList
+     */
+    public JobQuery typeNotList(List<Integer> typeNotList){
+        this.typeNotList = typeNotList;
+        return this;
+    }
+
+    /**
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<JobQuery> getOrConditionList(){
-    return this.orConditionList;
+        return this.orConditionList;
     }
 
     /**
-    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @param orConditionList
-    */
+     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @param orConditionList
+     */
     public void setOrConditionList(List<JobQuery> orConditionList){
         this.orConditionList = orConditionList;
     }
 
     /**
-    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @return andConditionList
-    */
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
     public List<JobQuery> getAndConditionList(){
         return this.andConditionList;
     }
 
     /**
-    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @param andConditionList
-    */
+     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @param andConditionList
+     */
     public void setAndConditionList(List<JobQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

attendance-performance-manager/src/main/resources/sqlmap/module/job/JobMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-"mybatis-3-mapper.dtd">
+        "mybatis-3-mapper.dtd">
 <mapper namespace="com.mortals.xhx.module.job.dao.ibatis.JobDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="JobEntity" id="JobEntity-Map">
-            <id  property="id" column="id" />
-            <result property="groupId" column="groupId" />
-            <result property="groupName" column="groupName" />
-            <result property="jobCode" column="jobCode" />
-            <result property="jobName" column="jobName" />
-            <result property="remark" column="remark" />
-            <result property="createTime" column="createTime" />
-            <result property="createUserId" column="createUserId" />
-            <result property="updateUserId" column="updateUserId" />
-            <result property="updateTime" column="updateTime" />
-            
+        <id  property="id" column="id" />
+        <result property="groupId" column="groupId" />
+        <result property="groupName" column="groupName" />
+        <result property="jobCode" column="jobCode" />
+        <result property="jobName" column="jobName" />
+        <result property="remark" column="remark" />
+        <result property="createTime" column="createTime" />
+        <result property="createUserId" column="createUserId" />
+        <result property="updateUserId" column="updateUserId" />
+        <result property="updateTime" column="updateTime" />
+        <result property="type" column="type" />
+
     </resultMap>
 
 
     <!-- 表所有列 -->
     <sql id="_columns">
         <trim suffixOverrides="," suffix="">
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
-                    a.id,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))">
-                    a.groupId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
-                    a.groupName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('jobCode') or colPickMode == 1 and data.containsKey('jobCode')))">
-                    a.jobCode,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('jobName') or colPickMode == 1 and data.containsKey('jobName')))">
-                    a.jobName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
-                    a.remark,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
-                    a.createTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
-                    a.createUserId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
-                    a.updateUserId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
-                    a.updateTime,
-                </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
+                a.id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))">
+                a.groupId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
+                a.groupName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('jobCode') or colPickMode == 1 and data.containsKey('jobCode')))">
+                a.jobCode,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('jobName') or colPickMode == 1 and data.containsKey('jobName')))">
+                a.jobName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
+                a.remark,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                a.createTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                a.createUserId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                a.updateUserId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
+                a.updateTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('type') or colPickMode == 1 and data.containsKey('type')))">
+                a.type,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="JobEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_job
-        (groupId,groupName,jobCode,jobName,remark,createTime,createUserId,updateUserId,updateTime)
+        (groupId,groupName,jobCode,jobName,remark,createTime,createUserId,updateUserId,updateTime,type)
         VALUES
-        (#{groupId},#{groupName},#{jobCode},#{jobName},#{remark},#{createTime},#{createUserId},#{updateUserId},#{updateTime})
+        (#{groupId},#{groupName},#{jobCode},#{jobName},#{remark},#{createTime},#{createUserId},#{updateUserId},#{updateTime},#{type})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_job
-        (groupId,groupName,jobCode,jobName,remark,createTime,createUserId,updateUserId,updateTime)
+        (groupId,groupName,jobCode,jobName,remark,createTime,createUserId,updateUserId,updateTime,type)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.groupId},#{item.groupName},#{item.jobCode},#{item.jobName},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime})
+            (#{item.groupId},#{item.groupName},#{item.jobCode},#{item.jobName},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime},#{item.type})
         </foreach>
     </insert>
 
@@ -114,6 +118,12 @@
             <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
                 a.updateTime=#{data.updateTime},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('type')) or (colPickMode==1 and !data.containsKey('type'))">
+                a.type=#{data.type},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('typeIncrement')) or (colPickMode==1 and !data.containsKey('typeIncrement'))">
+                a.type=ifnull(a.type,0) + #{data.typeIncrement},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -126,84 +136,96 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_xhx_job as a
         <trim prefix="set" suffixOverrides=",">
-                        <trim prefix="groupId=(case" suffix="ELSE groupId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('groupId')) or (colPickMode==1 and !item.containsKey('groupId'))">
-                                        when a.id=#{item.id} then #{item.groupId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('groupIdIncrement')) or (colPickMode==1 and !item.containsKey('groupIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.groupId,0) + #{item.groupIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="groupName=(case" suffix="ELSE groupName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))">
-                            when a.id=#{item.id} then #{item.groupName}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="jobCode=(case" suffix="ELSE jobCode end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('jobCode')) or (colPickMode==1 and !item.containsKey('jobCode'))">
-                            when a.id=#{item.id} then #{item.jobCode}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="jobName=(case" suffix="ELSE jobName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('jobName')) or (colPickMode==1 and !item.containsKey('jobName'))">
-                            when a.id=#{item.id} then #{item.jobName}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="remark=(case" suffix="ELSE remark end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
-                            when a.id=#{item.id} then #{item.remark}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
-                            when a.id=#{item.id} then #{item.createTime}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
-                                        when a.id=#{item.id} then #{item.createUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                        <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
-                                        when a.id=#{item.id} then #{item.updateUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
-                            when a.id=#{item.id} then #{item.updateTime}
-                        </if>
-                    </foreach>
-                </trim>
+            <trim prefix="groupId=(case" suffix="ELSE groupId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('groupId')) or (colPickMode==1 and !item.containsKey('groupId'))">
+                            when a.id=#{item.id} then #{item.groupId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('groupIdIncrement')) or (colPickMode==1 and !item.containsKey('groupIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.groupId,0) + #{item.groupIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="groupName=(case" suffix="ELSE groupName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))">
+                        when a.id=#{item.id} then #{item.groupName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="jobCode=(case" suffix="ELSE jobCode end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('jobCode')) or (colPickMode==1 and !item.containsKey('jobCode'))">
+                        when a.id=#{item.id} then #{item.jobCode}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="jobName=(case" suffix="ELSE jobName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('jobName')) or (colPickMode==1 and !item.containsKey('jobName'))">
+                        when a.id=#{item.id} then #{item.jobName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="remark=(case" suffix="ELSE remark end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
+                        when a.id=#{item.id} then #{item.remark}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                        when a.id=#{item.id} then #{item.createTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                            when a.id=#{item.id} then #{item.createUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
+                            when a.id=#{item.id} then #{item.updateUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
+                        when a.id=#{item.id} then #{item.updateTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="type=(case" suffix="ELSE type end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('type')) or (colPickMode==1 and !item.containsKey('type'))">
+                            when a.id=#{item.id} then #{item.type}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('typeIncrement')) or (colPickMode==1 and !item.containsKey('typeIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.type,0) + #{item.typeIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -320,291 +342,323 @@
                 ${_conditionType_} a.id=#{${_conditionParam_}.id}
             </if>
         </if>
-            <if test="conditionParamRef.containsKey('id')">
-                <if test="conditionParamRef.id != null ">
-                    ${_conditionType_} a.id = #{${_conditionParam_}.id}
-                </if>
-                <if test="conditionParamRef.id == null">
-                    ${_conditionType_} a.id is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('idList')">
-                ${_conditionType_} a.id in
-                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('idNotList')">
-                ${_conditionType_} a.id not in
-                <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
-                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
             </if>
-            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
-                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            <if test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+            ${_conditionType_} a.id in
+            <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+            ${_conditionType_} a.id not in
+            <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
+            ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        </if>
+        <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
+            ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('groupId')">
-                <if test="conditionParamRef.groupId != null ">
-                    ${_conditionType_} a.groupId = #{${_conditionParam_}.groupId}
-                </if>
-                <if test="conditionParamRef.groupId == null">
-                    ${_conditionType_} a.groupId is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('groupIdList')">
-                ${_conditionType_} a.groupId in
-                <foreach collection="conditionParamRef.groupIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('groupIdNotList')">
-                ${_conditionType_} a.groupId not in
-                <foreach collection="conditionParamRef.groupIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('groupIdStart') and conditionParamRef.groupIdStart != null">
-                ${_conditionType_} a.groupId <![CDATA[ >= ]]> #{${_conditionParam_}.groupIdStart}
+        <if test="conditionParamRef.containsKey('groupId')">
+            <if test="conditionParamRef.groupId != null ">
+                ${_conditionType_} a.groupId = #{${_conditionParam_}.groupId}
             </if>
-            <if test="conditionParamRef.containsKey('groupIdEnd') and conditionParamRef.groupIdEnd != null">
-                ${_conditionType_} a.groupId <![CDATA[ <= ]]> #{${_conditionParam_}.groupIdEnd}
+            <if test="conditionParamRef.groupId == null">
+                ${_conditionType_} a.groupId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('groupIdList') and conditionParamRef.groupIdList.size() > 0">
+            ${_conditionType_} a.groupId in
+            <foreach collection="conditionParamRef.groupIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('groupIdNotList') and conditionParamRef.groupIdNotList.size() > 0">
+            ${_conditionType_} a.groupId not in
+            <foreach collection="conditionParamRef.groupIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('groupIdStart') and conditionParamRef.groupIdStart != null">
+            ${_conditionType_} a.groupId <![CDATA[ >= ]]> #{${_conditionParam_}.groupIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('groupIdEnd') and conditionParamRef.groupIdEnd != null">
+            ${_conditionType_} a.groupId <![CDATA[ <= ]]> #{${_conditionParam_}.groupIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('groupName')">
-                <if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
-                    ${_conditionType_} a.groupName like #{${_conditionParam_}.groupName}
-                </if>
-                <if test="conditionParamRef.groupName == null">
-                    ${_conditionType_} a.groupName is null
-                </if>
+        <if test="conditionParamRef.containsKey('groupName')">
+            <if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
+                ${_conditionType_} a.groupName like #{${_conditionParam_}.groupName}
             </if>
-            <if test="conditionParamRef.containsKey('groupNameList')">
-                ${_conditionType_} a.groupName in
-                <foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('groupNameNotList')">
-                ${_conditionType_} a.groupName not in
-                <foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.groupName == null">
+                ${_conditionType_} a.groupName is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('groupNameList') and conditionParamRef.groupNameList.size() > 0">
+            ${_conditionType_} a.groupName in
+            <foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('groupNameNotList') and conditionParamRef.groupNameNotList.size() > 0">
+            ${_conditionType_} a.groupName not in
+            <foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('jobCode')">
-                <if test="conditionParamRef.jobCode != null and conditionParamRef.jobCode != ''">
-                    ${_conditionType_} a.jobCode like #{${_conditionParam_}.jobCode}
-                </if>
-                <if test="conditionParamRef.jobCode == null">
-                    ${_conditionType_} a.jobCode is null
-                </if>
+        <if test="conditionParamRef.containsKey('jobCode')">
+            <if test="conditionParamRef.jobCode != null and conditionParamRef.jobCode != ''">
+                ${_conditionType_} a.jobCode like #{${_conditionParam_}.jobCode}
             </if>
-            <if test="conditionParamRef.containsKey('jobCodeList')">
-                ${_conditionType_} a.jobCode in
-                <foreach collection="conditionParamRef.jobCodeList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('jobCodeNotList')">
-                ${_conditionType_} a.jobCode not in
-                <foreach collection="conditionParamRef.jobCodeNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.jobCode == null">
+                ${_conditionType_} a.jobCode is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('jobCodeList') and conditionParamRef.jobCodeList.size() > 0">
+            ${_conditionType_} a.jobCode in
+            <foreach collection="conditionParamRef.jobCodeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('jobCodeNotList') and conditionParamRef.jobCodeNotList.size() > 0">
+            ${_conditionType_} a.jobCode not in
+            <foreach collection="conditionParamRef.jobCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('jobName')">
-                <if test="conditionParamRef.jobName != null and conditionParamRef.jobName != ''">
-                    ${_conditionType_} a.jobName like #{${_conditionParam_}.jobName}
-                </if>
-                <if test="conditionParamRef.jobName == null">
-                    ${_conditionType_} a.jobName is null
-                </if>
+        <if test="conditionParamRef.containsKey('jobName')">
+            <if test="conditionParamRef.jobName != null and conditionParamRef.jobName != ''">
+                ${_conditionType_} a.jobName like #{${_conditionParam_}.jobName}
             </if>
-            <if test="conditionParamRef.containsKey('jobNameList')">
-                ${_conditionType_} a.jobName in
-                <foreach collection="conditionParamRef.jobNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('jobNameNotList')">
-                ${_conditionType_} a.jobName not in
-                <foreach collection="conditionParamRef.jobNameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.jobName == null">
+                ${_conditionType_} a.jobName is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('jobNameList') and conditionParamRef.jobNameList.size() > 0">
+            ${_conditionType_} a.jobName in
+            <foreach collection="conditionParamRef.jobNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('jobNameNotList') and conditionParamRef.jobNameNotList.size() > 0">
+            ${_conditionType_} a.jobName not in
+            <foreach collection="conditionParamRef.jobNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('remark')">
-                <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
-                    ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
-                </if>
-                <if test="conditionParamRef.remark == null">
-                    ${_conditionType_} a.remark is null
-                </if>
+        <if test="conditionParamRef.containsKey('remark')">
+            <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
+                ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
             </if>
-            <if test="conditionParamRef.containsKey('remarkList')">
-                ${_conditionType_} a.remark in
-                <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('remarkNotList')">
-                ${_conditionType_} a.remark not in
-                <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.remark == null">
+                ${_conditionType_} a.remark is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
+            ${_conditionType_} a.remark in
+            <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
+            ${_conditionType_} a.remark not in
+            <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('createTime')">
-                <if test="conditionParamRef.createTime != null ">
-                    ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
-                </if>
-                <if test="conditionParamRef.createTime == null">
-                    ${_conditionType_} a.createTime is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
-                ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
-                ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('createUserId')">
-                <if test="conditionParamRef.createUserId != null ">
-                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
-                </if>
-                <if test="conditionParamRef.createUserId == null">
-                    ${_conditionType_} a.createUserId is null
-                </if>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdList')">
-                ${_conditionType_} a.createUserId in
-                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('createUserIdNotList')">
-                ${_conditionType_} a.createUserId not in
-                <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
-                ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+            ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
+            ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createUserId')">
+            <if test="conditionParamRef.createUserId != null ">
+                ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
-                ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+            <if test="conditionParamRef.createUserId == null">
+                ${_conditionType_} a.createUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+            ${_conditionType_} a.createUserId in
+            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+            ${_conditionType_} a.createUserId not in
+            <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+            ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+            ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('updateUserId')">
-                <if test="conditionParamRef.updateUserId != null ">
-                    ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
-                </if>
-                <if test="conditionParamRef.updateUserId == null">
-                    ${_conditionType_} a.updateUserId is null
-                </if>
+        <if test="conditionParamRef.containsKey('updateUserId')">
+            <if test="conditionParamRef.updateUserId != null ">
+                ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
             </if>
-            <if test="conditionParamRef.containsKey('updateUserIdList')">
-                ${_conditionType_} a.updateUserId in
-                <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('updateUserIdNotList')">
-                ${_conditionType_} a.updateUserId not in
-                <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
-                ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
-            </if>
-            <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
-                ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+            <if test="conditionParamRef.updateUserId == null">
+                ${_conditionType_} a.updateUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+            ${_conditionType_} a.updateUserId in
+            <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
+            ${_conditionType_} a.updateUserId not in
+            <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
+            ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
+            ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('updateTime')">
-                <if test="conditionParamRef.updateTime != null ">
-                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
-                </if>
-                <if test="conditionParamRef.updateTime == null">
-                    ${_conditionType_} a.updateTime is null
-                </if>
+        <if test="conditionParamRef.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
             </if>
-            <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
-                ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            <if test="conditionParamRef.updateTime == null">
+                ${_conditionType_} a.updateTime is null
             </if>
-            <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
-                ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
+            ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
+            ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('type')">
+            <if test="conditionParamRef.type != null ">
+                ${_conditionType_} a.type = #{${_conditionParam_}.type}
             </if>
+            <if test="conditionParamRef.type == null">
+                ${_conditionType_} a.type is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('typeList') and conditionParamRef.typeList.size() > 0">
+            ${_conditionType_} a.type in
+            <foreach collection="conditionParamRef.typeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('typeNotList') and conditionParamRef.typeNotList.size() > 0">
+            ${_conditionType_} a.type not in
+            <foreach collection="conditionParamRef.typeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('typeStart') and conditionParamRef.typeStart != null">
+            ${_conditionType_} a.type <![CDATA[ >= ]]> #{${_conditionParam_}.typeStart}
+        </if>
+        <if test="conditionParamRef.containsKey('typeEnd') and conditionParamRef.typeEnd != null">
+            ${_conditionType_} a.type <![CDATA[ <= ]]> #{${_conditionParam_}.typeEnd}
+        </if>
+
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">
             order by
             <trim suffixOverrides=","  suffix="">
                 <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
-                     ${item.colName} ${item.sortKind}
+                    ${item.colName} ${item.sortKind}
                 </foreach>
             </trim>
         </if>
         <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
             order by
             <trim suffixOverrides=","  suffix="">
-                    <if test="orderCol.containsKey('id')">
-                        a.id
-                        <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('groupId')">
-                        a.groupId
-                        <if test='orderCol.groupId != null and "DESC".equalsIgnoreCase(orderCol.groupId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('groupName')">
-                        a.groupName
-                        <if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('jobCode')">
-                        a.jobCode
-                        <if test='orderCol.jobCode != null and "DESC".equalsIgnoreCase(orderCol.jobCode)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('jobName')">
-                        a.jobName
-                        <if test='orderCol.jobName != null and "DESC".equalsIgnoreCase(orderCol.jobName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('remark')">
-                        a.remark
-                        <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('createTime')">
-                        a.createTime
-                        <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('createUserId')">
-                        a.createUserId
-                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('updateUserId')">
-                        a.updateUserId
-                        <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('updateTime')">
-                        a.updateTime
-                        <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
-                        ,
-                    </if>
+                <if test="orderCol.containsKey('id')">
+                    a.id
+                    <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('groupId')">
+                    a.groupId
+                    <if test='orderCol.groupId != null and "DESC".equalsIgnoreCase(orderCol.groupId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('groupName')">
+                    a.groupName
+                    <if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('jobCode')">
+                    a.jobCode
+                    <if test='orderCol.jobCode != null and "DESC".equalsIgnoreCase(orderCol.jobCode)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('jobName')">
+                    a.jobName
+                    <if test='orderCol.jobName != null and "DESC".equalsIgnoreCase(orderCol.jobName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('remark')">
+                    a.remark
+                    <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createTime')">
+                    a.createTime
+                    <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createUserId')">
+                    a.createUserId
+                    <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateUserId')">
+                    a.updateUserId
+                    <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateTime')">
+                    a.updateTime
+                    <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('type')">
+                    a.type
+                    <if test='orderCol.type != null and "DESC".equalsIgnoreCase(orderCol.type)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>
     </sql>

db/module.sql

@@ -103,19 +103,24 @@ CREATE TABLE mortals_xhx_care_template(
 -- ----------------------------
 DROP TABLE IF EXISTS `mortals_xhx_job`;
 CREATE TABLE mortals_xhx_job(
-                                `id` bigint(20)   AUTO_INCREMENT   COMMENT '主键，自增长',
-                                `groupId` bigint(20)      COMMENT '分组id',
-                                `groupName` varchar(128)      COMMENT '分组名称',
-                                `jobCode` varchar(128)      COMMENT '职位编码',
-                                `jobName` varchar(128)      COMMENT '职位名称',
-                                `remark` varchar(512)      COMMENT '备注',
-                                `createTime` datetime      COMMENT '创建时间',
-                                `createUserId` bigint(20)      COMMENT '创建用户',
-                                `updateUserId` bigint(20)      COMMENT '更新用户',
-                                `updateTime` datetime      COMMENT '修改时间',
-                                PRIMARY KEY  (`id`)
+    `id` bigint(20)   AUTO_INCREMENT   COMMENT '主键，自增长',
+    `groupId` bigint(20)      COMMENT '分组id',
+    `groupName` varchar(128)      COMMENT '分组名称',
+    `jobCode` varchar(128)      COMMENT '职位编码',
+    `jobName` varchar(128)      COMMENT '职位名称',
+    `remark` varchar(512)      COMMENT '备注',
+    `createTime` datetime      COMMENT '创建时间',
+    `createUserId` bigint(20)      COMMENT '创建用户',
+    `updateUserId` bigint(20)      COMMENT '更新用户',
+    `updateTime` datetime      COMMENT '修改时间',
+    `type` tinyint(2)    DEFAULT '1'  COMMENT '节点类型(1.分组,2.职位)',
+PRIMARY KEY  (`id`)
+,KEY `groupName` (`groupName`) USING BTREE
+,KEY `jobCode` (`jobCode`) USING BTREE
+,KEY `jobName` (`jobName`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='职位信息';
 
+
 -- ----------------------------
 -- 员工黑名单信息表
 -- ----------------------------

doc/api.md

@@ -3098,9 +3098,9 @@ jobName|String|否|职位名称,字段前后添加%%模糊查询
 **请求样例:**
 ```
   {
-        "groupName":"221sgc",
-        "jobCode":"buzhdj",
-        "jobName":"vduagu",
+        "groupName":"w4y1au",
+        "jobCode":"p48hfz",
+        "jobName":"tvhi3v",
         "page":1,
         "size":10
   }
@@ -3128,7 +3128,9 @@ data|object|数据对象
   createUserId|Long|创建用户
   updateUserId|Long|更新用户
   updateTime|Date|修改时间
+  type|Integer|节点类型(1.分组,2.职位)
 dict|object|字典对象
+ type|object|字典属性对象，详见附录
 
 **响应消息样例:**
 ```
@@ -3176,23 +3178,26 @@ data|object|数据对象
  createUserId|Long|创建用户
  updateUserId|Long|更新用户
  updateTime|Date|修改时间
+ type|Integer|节点类型(1.分组,2.职位)
 dict|object|字典对象
+ type|object|字典属性对象，详见附录
 
 **响应消息样例:**
 ```
 {
     "code": 1,
     "data": {
-            "id":3224,
-            "groupId":5192,
-            "groupName":"y8zckh",
-            "jobCode":"djdvg1",
-            "jobName":"k2657g",
-            "remark":"ajxdd3",
-            "createTime":"2023-04-07",
-            "createUserId":4686,
-            "updateUserId":8121,
-            "updateTime":"2023-04-07"
+            "id":6214,
+            "groupId":6910,
+            "groupName":"h3qmbp",
+            "jobCode":"ybsxab",
+            "jobName":"mwfwda",
+            "remark":"j454du",
+            "createTime":"2023-04-11",
+            "createUserId":3094,
+            "updateUserId":1149,
+            "updateTime":"2023-04-11",
+            "type":4950
         }
 }
 ```
@@ -3216,15 +3221,17 @@ groupName|String|否|分组名称
 jobCode|String|否|职位编码
 jobName|String|否|职位名称
 remark|String|否|备注
+type|Integer|否|节点类型(1.分组,2.职位)
 
 **请求样例:**
 ```
 {
-    "groupId":3140,
-    "groupName":"q8jukx",
-    "jobCode":"38mrsx",
-    "jobName":"fxtzka",
-    "remark":"owe9bs",
+    "groupId":4323,
+    "groupName":"0rvnhk",
+    "jobCode":"qlhfq6",
+    "jobName":"aw1orv",
+    "remark":"b3g5ig",
+    "type":5729
 }
 
 ```
@@ -3247,6 +3254,7 @@ data|object|数据对象
   createUserId|Long|创建用户
   updateUserId|Long|更新用户
   updateTime|Date|修改时间
+  type|Integer|节点类型(1.分组,2.职位)
 
 **响应消息样例:**
 ```

pom.xml

@@ -22,7 +22,6 @@
         <common-lib.version>0.0.1-SNAPSHOT</common-lib.version>
     </properties>
 
-
     <dependencyManagement>
         <dependencies>
             <dependency>