添加目录字段

one-certificate-manager/db/add_db.sql

@@ -49,3 +49,36 @@ CREATE TABLE `mortals_xhx_child_license`  (
 ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '行业许可子证' ROW_FORMAT = Dynamic;
 
 ALTER TABLE mortals_xhx_child_license ADD COLUMN   `resolutionValue` varchar(64)   DEFAULT ''  COMMENT '设备分辨率'   AFTER resolution;
+
+
+
+-- ----------------------------
+-- 2024-07-30
+-- ----------------------------
+
+ALTER TABLE mortals_xhx_child_license
+    ADD COLUMN   `shortName` varchar(64)   DEFAULT ''  COMMENT '简称' ,
+    ADD COLUMN   `ext1` varchar(255)   DEFAULT ''  COMMENT '扩展列1' ,
+    ADD COLUMN   `ext2` varchar(255)   DEFAULT ''  COMMENT '扩展列2' ,
+    ADD COLUMN   `ext3` varchar(255)   DEFAULT ''  COMMENT '扩展列3' ,
+    ADD COLUMN   `ext4` varchar(255)   DEFAULT ''  COMMENT '扩展列4' ,
+    ADD COLUMN   `ext5` varchar(255)   DEFAULT ''  COMMENT '扩展列5' ,
+    ADD COLUMN   `ext6` varchar(255)   DEFAULT ''  COMMENT '扩展列6' ,
+    ADD COLUMN   `ext7` varchar(255)   DEFAULT ''  COMMENT '扩展列7' ,
+    ADD COLUMN   `ext8` varchar(255)   DEFAULT ''  COMMENT '扩展列8' ,
+    ADD COLUMN  `childStatus` tinyint(2)    DEFAULT '1'  COMMENT '子证状态(0.禁用,1.启用)',
+    ADD COLUMN  `deleted` tinyint(2)    DEFAULT '0'  COMMENT '删除状态(0.未删除,1.已删除)'
+    AFTER remark;
+
+
+ALTER TABLE mortals_xhx_certificate_document
+    ADD COLUMN   `shortName` varchar(64)   DEFAULT ''  COMMENT '简称' AFTER documentName ;
+
+ALTER TABLE mortals_xhx_certificate_catalog
+    ADD COLUMN   `shortName` varchar(64)   DEFAULT ''  COMMENT '简称' AFTER catalogCode ;
+
+
+ALTER TABLE mortals_xhx_certificate_child
+    ADD COLUMN    `catalogName` varchar(64) DEFAULT NULL COMMENT '目录名称',
+    ADD COLUMN    `documentName` varchar(64) DEFAULT NULL COMMENT '子证名称'
+ AFTER catalogId ;
\ No newline at end of file

one-certificate-manager/pom.xml

@@ -42,7 +42,7 @@
 			<id>test</id>
 			<properties>
 				<profiles.active>test</profiles.active>
-				<profiles.server.debug>-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=15505</profiles.server.debug>
+				<profiles.server.debug>-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=15506</profiles.server.debug>
 				<profiles.nacos.server-addr>192.168.0.252:8848</profiles.nacos.server-addr>
 				<profiles.nacos.group>DEFAULT_GROUP</profiles.nacos.group>
 				<profiles.nacos.namespace>smart-gov</profiles.nacos.namespace>

one-certificate-manager/src/main/java/com/mortals/xhx/module/certificate/model/CertificateCatalogEntity.java

@@ -15,7 +15,7 @@ import lombok.Data;
  * 证照目录实体对象
  *
  * @author zxfei
- * @date 2024-07-28
+ * @date 2024-07-30
  */
 @Data
 public class CertificateCatalogEntity extends CertificateCatalogVo {
@@ -101,6 +101,10 @@ public class CertificateCatalogEntity extends CertificateCatalogVo {
      * 打印机纸盒
      */
     private String paperSource;
+    /**
+     * 简称
+     */
+    private String shortName;
     /**
      * 目录子证信息
      */
@@ -149,5 +153,6 @@ public class CertificateCatalogEntity extends CertificateCatalogVo {
         this.printerName = "";
         this.printerIp = "";
         this.paperSource = "";
+        this.shortName = "";
     }
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/certificate/model/CertificateCatalogQuery.java

@@ -7,7 +7,7 @@ import com.mortals.xhx.module.certificate.model.CertificateCatalogEntity;
  * 证照目录查询对象
  *
  * @author zxfei
- * @date 2024-07-28
+ * @date 2024-07-30
  */
 public class CertificateCatalogQuery extends CertificateCatalogEntity {
     /** 开始 序号，主键，自增长 */
@@ -267,6 +267,11 @@ public class CertificateCatalogQuery extends CertificateCatalogEntity {
     /** 结束 更新时间 */
     private String updateTimeEnd;
 
+    /** 简称 */
+    private List<String> shortNameList;
+
+    /** 简称排除列表 */
+    private List <String> shortNameNotList;
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<CertificateCatalogQuery> orConditionList;
 
@@ -1712,6 +1717,38 @@ public class CertificateCatalogQuery extends CertificateCatalogEntity {
         this.updateTimeEnd = updateTimeEnd;
     }
 
+    /**
+     * 获取 简称
+     * @return shortNameList
+     */
+    public List<String> getShortNameList(){
+        return this.shortNameList;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameList
+     */
+    public void setShortNameList(List<String> shortNameList){
+        this.shortNameList = shortNameList;
+    }
+
+    /**
+     * 获取 简称
+     * @return shortNameNotList
+     */
+    public List<String> getShortNameNotList(){
+        return this.shortNameNotList;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameNotList
+     */
+    public void setShortNameNotList(List<String> shortNameNotList){
+        this.shortNameNotList = shortNameNotList;
+    }
+
     /**
      * 设置  序号，主键，自增长
      * @param id
@@ -2606,6 +2643,25 @@ public class CertificateCatalogQuery extends CertificateCatalogEntity {
     }
 
 
+
+    /**
+     * 设置 简称
+     * @param shortName
+     */
+    public CertificateCatalogQuery shortName(String shortName){
+        setShortName(shortName);
+        return this;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameList
+     */
+    public CertificateCatalogQuery shortNameList(List<String> shortNameList){
+        this.shortNameList = shortNameList;
+        return this;
+    }
+
     /**
      * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
      * @return orConditionList

one-certificate-manager/src/main/java/com/mortals/xhx/module/certificate/model/CertificateChildEntity.java

@@ -10,30 +10,38 @@ import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.certificate.model.vo.CertificateChildVo;
 import lombok.Data;
 /**
-* 目录子证实体对象
-*
-* @author zxfei
-* @date 2024-07-28
-*/
+ * 目录子证实体对象
+ *
+ * @author zxfei
+ * @date 2024-07-30
+ */
 @Data
 public class CertificateChildEntity extends CertificateChildVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 站点id
-    */
+     * 站点id
+     */
     private Long siteId;
     /**
-    * 证照目录id
-    */
+     * 证照目录id
+     */
     private Long catalogId;
     /**
-    * 子证id
-    */
+     * 子证id
+     */
     private Long documentId;
+    /**
+     * 子证名称
+     */
+    private String documentName;
+    /**
+     * 目录名称
+     */
+    private String catalogName;
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -41,15 +49,17 @@ public class CertificateChildEntity extends CertificateChildVo {
         if (obj instanceof CertificateChildEntity) {
             CertificateChildEntity tmp = (CertificateChildEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
     }
 
     public void initAttrValue(){
-            this.siteId = null;
-            this.catalogId = null;
-            this.documentId = null;
+        this.siteId = null;
+        this.catalogId = null;
+        this.documentId = null;
+        this.documentName = "";
+        this.catalogName = "";
     }
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/certificate/model/CertificateChildQuery.java

@@ -3,11 +3,11 @@ package com.mortals.xhx.module.certificate.model;
 import java.util.List;
 import com.mortals.xhx.module.certificate.model.CertificateChildEntity;
 /**
-* 目录子证查询对象
-*
-* @author zxfei
-* @date 2024-07-28
-*/
+ * 目录子证查询对象
+ *
+ * @author zxfei
+ * @date 2024-07-30
+ */
 public class CertificateChildQuery extends CertificateChildEntity {
     /** 开始 序号，主键，自增长 */
     private Long idStart;
@@ -111,6 +111,16 @@ public class CertificateChildQuery extends CertificateChildEntity {
     /** 结束 更新时间 */
     private String updateTimeEnd;
 
+    /** 子证名称 */
+    private List<String> documentNameList;
+
+    /** 子证名称排除列表 */
+    private List <String> documentNameNotList;
+    /** 目录名称 */
+    private List<String> catalogNameList;
+
+    /** 目录名称排除列表 */
+    private List <String> catalogNameNotList;
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<CertificateChildQuery> orConditionList;
 
@@ -120,909 +130,1011 @@ public class CertificateChildQuery extends CertificateChildEntity {
     public CertificateChildQuery(){}
 
     /**
-    * 获取 开始 序号，主键，自增长
-    * @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 siteIdStart
-    */
+     * 获取 开始 站点id
+     * @return siteIdStart
+     */
     public Long getSiteIdStart(){
         return this.siteIdStart;
     }
 
     /**
-    * 设置 开始 站点id
-    * @param siteIdStart
-    */
+     * 设置 开始 站点id
+     * @param siteIdStart
+     */
     public void setSiteIdStart(Long siteIdStart){
         this.siteIdStart = siteIdStart;
     }
 
     /**
-    * 获取 结束 站点id
-    * @return $siteIdEnd
-    */
+     * 获取 结束 站点id
+     * @return $siteIdEnd
+     */
     public Long getSiteIdEnd(){
         return this.siteIdEnd;
     }
 
     /**
-    * 设置 结束 站点id
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点id
+     * @param siteIdEnd
+     */
     public void setSiteIdEnd(Long siteIdEnd){
         this.siteIdEnd = siteIdEnd;
     }
 
     /**
-    * 获取 增加 站点id
-    * @return siteIdIncrement
-    */
+     * 获取 增加 站点id
+     * @return siteIdIncrement
+     */
     public Long getSiteIdIncrement(){
         return this.siteIdIncrement;
     }
 
     /**
-    * 设置 增加 站点id
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点id
+     * @param siteIdIncrement
+     */
     public void setSiteIdIncrement(Long siteIdIncrement){
         this.siteIdIncrement = siteIdIncrement;
     }
 
     /**
-    * 获取 站点id
-    * @return siteIdList
-    */
+     * 获取 站点id
+     * @return siteIdList
+     */
     public List<Long> getSiteIdList(){
         return this.siteIdList;
     }
 
     /**
-    * 设置 站点id
-    * @param siteIdList
-    */
+     * 设置 站点id
+     * @param siteIdList
+     */
     public void setSiteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
     }
 
     /**
-    * 获取 站点id
-    * @return siteIdNotList
-    */
+     * 获取 站点id
+     * @return siteIdNotList
+     */
     public List<Long> getSiteIdNotList(){
         return this.siteIdNotList;
     }
 
     /**
-    * 设置 站点id
-    * @param siteIdNotList
-    */
+     * 设置 站点id
+     * @param siteIdNotList
+     */
     public void setSiteIdNotList(List<Long> siteIdNotList){
         this.siteIdNotList = siteIdNotList;
     }
 
 
     /**
-    * 获取 开始 证照目录id
-    * @return catalogIdStart
-    */
+     * 获取 开始 证照目录id
+     * @return catalogIdStart
+     */
     public Long getCatalogIdStart(){
         return this.catalogIdStart;
     }
 
     /**
-    * 设置 开始 证照目录id
-    * @param catalogIdStart
-    */
+     * 设置 开始 证照目录id
+     * @param catalogIdStart
+     */
     public void setCatalogIdStart(Long catalogIdStart){
         this.catalogIdStart = catalogIdStart;
     }
 
     /**
-    * 获取 结束 证照目录id
-    * @return $catalogIdEnd
-    */
+     * 获取 结束 证照目录id
+     * @return $catalogIdEnd
+     */
     public Long getCatalogIdEnd(){
         return this.catalogIdEnd;
     }
 
     /**
-    * 设置 结束 证照目录id
-    * @param catalogIdEnd
-    */
+     * 设置 结束 证照目录id
+     * @param catalogIdEnd
+     */
     public void setCatalogIdEnd(Long catalogIdEnd){
         this.catalogIdEnd = catalogIdEnd;
     }
 
     /**
-    * 获取 增加 证照目录id
-    * @return catalogIdIncrement
-    */
+     * 获取 增加 证照目录id
+     * @return catalogIdIncrement
+     */
     public Long getCatalogIdIncrement(){
         return this.catalogIdIncrement;
     }
 
     /**
-    * 设置 增加 证照目录id
-    * @param catalogIdIncrement
-    */
+     * 设置 增加 证照目录id
+     * @param catalogIdIncrement
+     */
     public void setCatalogIdIncrement(Long catalogIdIncrement){
         this.catalogIdIncrement = catalogIdIncrement;
     }
 
     /**
-    * 获取 证照目录id
-    * @return catalogIdList
-    */
+     * 获取 证照目录id
+     * @return catalogIdList
+     */
     public List<Long> getCatalogIdList(){
         return this.catalogIdList;
     }
 
     /**
-    * 设置 证照目录id
-    * @param catalogIdList
-    */
+     * 设置 证照目录id
+     * @param catalogIdList
+     */
     public void setCatalogIdList(List<Long> catalogIdList){
         this.catalogIdList = catalogIdList;
     }
 
     /**
-    * 获取 证照目录id
-    * @return catalogIdNotList
-    */
+     * 获取 证照目录id
+     * @return catalogIdNotList
+     */
     public List<Long> getCatalogIdNotList(){
         return this.catalogIdNotList;
     }
 
     /**
-    * 设置 证照目录id
-    * @param catalogIdNotList
-    */
+     * 设置 证照目录id
+     * @param catalogIdNotList
+     */
     public void setCatalogIdNotList(List<Long> catalogIdNotList){
         this.catalogIdNotList = catalogIdNotList;
     }
 
 
     /**
-    * 获取 开始 子证id
-    * @return documentIdStart
-    */
+     * 获取 开始 子证id
+     * @return documentIdStart
+     */
     public Long getDocumentIdStart(){
         return this.documentIdStart;
     }
 
     /**
-    * 设置 开始 子证id
-    * @param documentIdStart
-    */
+     * 设置 开始 子证id
+     * @param documentIdStart
+     */
     public void setDocumentIdStart(Long documentIdStart){
         this.documentIdStart = documentIdStart;
     }
 
     /**
-    * 获取 结束 子证id
-    * @return $documentIdEnd
-    */
+     * 获取 结束 子证id
+     * @return $documentIdEnd
+     */
     public Long getDocumentIdEnd(){
         return this.documentIdEnd;
     }
 
     /**
-    * 设置 结束 子证id
-    * @param documentIdEnd
-    */
+     * 设置 结束 子证id
+     * @param documentIdEnd
+     */
     public void setDocumentIdEnd(Long documentIdEnd){
         this.documentIdEnd = documentIdEnd;
     }
 
     /**
-    * 获取 增加 子证id
-    * @return documentIdIncrement
-    */
+     * 获取 增加 子证id
+     * @return documentIdIncrement
+     */
     public Long getDocumentIdIncrement(){
         return this.documentIdIncrement;
     }
 
     /**
-    * 设置 增加 子证id
-    * @param documentIdIncrement
-    */
+     * 设置 增加 子证id
+     * @param documentIdIncrement
+     */
     public void setDocumentIdIncrement(Long documentIdIncrement){
         this.documentIdIncrement = documentIdIncrement;
     }
 
     /**
-    * 获取 子证id
-    * @return documentIdList
-    */
+     * 获取 子证id
+     * @return documentIdList
+     */
     public List<Long> getDocumentIdList(){
         return this.documentIdList;
     }
 
     /**
-    * 设置 子证id
-    * @param documentIdList
-    */
+     * 设置 子证id
+     * @param documentIdList
+     */
     public void setDocumentIdList(List<Long> documentIdList){
         this.documentIdList = documentIdList;
     }
 
     /**
-    * 获取 子证id
-    * @return documentIdNotList
-    */
+     * 获取 子证id
+     * @return documentIdNotList
+     */
     public List<Long> getDocumentIdNotList(){
         return this.documentIdNotList;
     }
 
     /**
-    * 设置 子证id
-    * @param documentIdNotList
-    */
+     * 设置 子证id
+     * @param documentIdNotList
+     */
     public void setDocumentIdNotList(List<Long> documentIdNotList){
         this.documentIdNotList = documentIdNotList;
     }
 
 
     /**
-    * 获取 开始 创建用户
-    * @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 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 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
-    */
+     * 获取 子证名称
+     * @return documentNameList
+     */
+    public List<String> getDocumentNameList(){
+        return this.documentNameList;
+    }
+
+    /**
+     * 设置 子证名称
+     * @param documentNameList
+     */
+    public void setDocumentNameList(List<String> documentNameList){
+        this.documentNameList = documentNameList;
+    }
+
+    /**
+     * 获取 子证名称
+     * @return documentNameNotList
+     */
+    public List<String> getDocumentNameNotList(){
+        return this.documentNameNotList;
+    }
+
+    /**
+     * 设置 子证名称
+     * @param documentNameNotList
+     */
+    public void setDocumentNameNotList(List<String> documentNameNotList){
+        this.documentNameNotList = documentNameNotList;
+    }
+
+    /**
+     * 获取 目录名称
+     * @return catalogNameList
+     */
+    public List<String> getCatalogNameList(){
+        return this.catalogNameList;
+    }
+
+    /**
+     * 设置 目录名称
+     * @param catalogNameList
+     */
+    public void setCatalogNameList(List<String> catalogNameList){
+        this.catalogNameList = catalogNameList;
+    }
+
+    /**
+     * 获取 目录名称
+     * @return catalogNameNotList
+     */
+    public List<String> getCatalogNameNotList(){
+        return this.catalogNameNotList;
+    }
+
+    /**
+     * 设置 目录名称
+     * @param catalogNameNotList
+     */
+    public void setCatalogNameNotList(List<String> catalogNameNotList){
+        this.catalogNameNotList = catalogNameNotList;
+    }
+
+    /**
+     * 设置  序号，主键，自增长
+     * @param id
+     */
     public CertificateChildQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public CertificateChildQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public CertificateChildQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public CertificateChildQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public CertificateChildQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 序号，主键，自增长
-        * @param idNotList
-        */
-        public CertificateChildQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public CertificateChildQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  站点id
-    * @param siteId
-    */
+     * 设置  站点id
+     * @param siteId
+     */
     public CertificateChildQuery siteId(Long siteId){
-	    setSiteId(siteId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 站点id
-    * @param siteIdStart
-    */
+        setSiteId(siteId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 站点id
+     * @param siteIdStart
+     */
     public CertificateChildQuery siteIdStart(Long siteIdStart){
-		this.siteIdStart = siteIdStart;
-		return this;
+        this.siteIdStart = siteIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 站点id
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点id
+     * @param siteIdEnd
+     */
     public CertificateChildQuery siteIdEnd(Long siteIdEnd){
-		this.siteIdEnd = siteIdEnd;
-		return this;
+        this.siteIdEnd = siteIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 站点id
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点id
+     * @param siteIdIncrement
+     */
     public CertificateChildQuery siteIdIncrement(Long siteIdIncrement){
-		this.siteIdIncrement = siteIdIncrement;
-		return this;
+        this.siteIdIncrement = siteIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 站点id
-    * @param siteIdList
-    */
+     * 设置 站点id
+     * @param siteIdList
+     */
     public CertificateChildQuery siteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
-		return this;
-        }
-
-        /**
-        * 设置 站点id
-        * @param siteIdNotList
-        */
-        public CertificateChildQuery siteIdNotList(List<Long> siteIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 站点id
+     * @param siteIdNotList
+     */
+    public CertificateChildQuery siteIdNotList(List<Long> siteIdNotList){
         this.siteIdNotList = siteIdNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  证照目录id
-    * @param catalogId
-    */
+     * 设置  证照目录id
+     * @param catalogId
+     */
     public CertificateChildQuery catalogId(Long catalogId){
-	    setCatalogId(catalogId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 证照目录id
-    * @param catalogIdStart
-    */
+        setCatalogId(catalogId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 证照目录id
+     * @param catalogIdStart
+     */
     public CertificateChildQuery catalogIdStart(Long catalogIdStart){
-		this.catalogIdStart = catalogIdStart;
-		return this;
+        this.catalogIdStart = catalogIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 证照目录id
-    * @param catalogIdEnd
-    */
+     * 设置 结束 证照目录id
+     * @param catalogIdEnd
+     */
     public CertificateChildQuery catalogIdEnd(Long catalogIdEnd){
-		this.catalogIdEnd = catalogIdEnd;
-		return this;
+        this.catalogIdEnd = catalogIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 证照目录id
-    * @param catalogIdIncrement
-    */
+     * 设置 增加 证照目录id
+     * @param catalogIdIncrement
+     */
     public CertificateChildQuery catalogIdIncrement(Long catalogIdIncrement){
-		this.catalogIdIncrement = catalogIdIncrement;
-		return this;
+        this.catalogIdIncrement = catalogIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 证照目录id
-    * @param catalogIdList
-    */
+     * 设置 证照目录id
+     * @param catalogIdList
+     */
     public CertificateChildQuery catalogIdList(List<Long> catalogIdList){
         this.catalogIdList = catalogIdList;
-		return this;
-        }
-
-        /**
-        * 设置 证照目录id
-        * @param catalogIdNotList
-        */
-        public CertificateChildQuery catalogIdNotList(List<Long> catalogIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 证照目录id
+     * @param catalogIdNotList
+     */
+    public CertificateChildQuery catalogIdNotList(List<Long> catalogIdNotList){
         this.catalogIdNotList = catalogIdNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  子证id
-    * @param documentId
-    */
+     * 设置  子证id
+     * @param documentId
+     */
     public CertificateChildQuery documentId(Long documentId){
-	    setDocumentId(documentId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 子证id
-    * @param documentIdStart
-    */
+        setDocumentId(documentId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 子证id
+     * @param documentIdStart
+     */
     public CertificateChildQuery documentIdStart(Long documentIdStart){
-		this.documentIdStart = documentIdStart;
-		return this;
+        this.documentIdStart = documentIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 子证id
-    * @param documentIdEnd
-    */
+     * 设置 结束 子证id
+     * @param documentIdEnd
+     */
     public CertificateChildQuery documentIdEnd(Long documentIdEnd){
-		this.documentIdEnd = documentIdEnd;
-		return this;
+        this.documentIdEnd = documentIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 子证id
-    * @param documentIdIncrement
-    */
+     * 设置 增加 子证id
+     * @param documentIdIncrement
+     */
     public CertificateChildQuery documentIdIncrement(Long documentIdIncrement){
-		this.documentIdIncrement = documentIdIncrement;
-		return this;
+        this.documentIdIncrement = documentIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 子证id
-    * @param documentIdList
-    */
+     * 设置 子证id
+     * @param documentIdList
+     */
     public CertificateChildQuery documentIdList(List<Long> documentIdList){
         this.documentIdList = documentIdList;
-		return this;
-        }
-
-        /**
-        * 设置 子证id
-        * @param documentIdNotList
-        */
-        public CertificateChildQuery documentIdNotList(List<Long> documentIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 子证id
+     * @param documentIdNotList
+     */
+    public CertificateChildQuery documentIdNotList(List<Long> documentIdNotList){
         this.documentIdNotList = documentIdNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public CertificateChildQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public CertificateChildQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public CertificateChildQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public CertificateChildQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public CertificateChildQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建用户
-        * @param createUserIdNotList
-        */
-        public CertificateChildQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public CertificateChildQuery createUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 设置  更新用户
-    * @param updateUserId
-    */
+     * 设置  更新用户
+     * @param updateUserId
+     */
     public CertificateChildQuery updateUserId(Long updateUserId){
-	    setUpdateUserId(updateUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public CertificateChildQuery updateUserIdStart(Long updateUserIdStart){
-		this.updateUserIdStart = updateUserIdStart;
-		return this;
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public CertificateChildQuery updateUserIdEnd(Long updateUserIdEnd){
-		this.updateUserIdEnd = updateUserIdEnd;
-		return this;
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public CertificateChildQuery updateUserIdIncrement(Long updateUserIdIncrement){
-		this.updateUserIdIncrement = updateUserIdIncrement;
-		return this;
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public CertificateChildQuery updateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 更新用户
-        * @param updateUserIdNotList
-        */
-        public CertificateChildQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public CertificateChildQuery updateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
         return this;
-        }
+    }
+
+
 
+    /**
+     * 设置 子证名称
+     * @param documentName
+     */
+    public CertificateChildQuery documentName(String documentName){
+        setDocumentName(documentName);
+        return this;
+    }
+
+    /**
+     * 设置 子证名称
+     * @param documentNameList
+     */
+    public CertificateChildQuery documentNameList(List<String> documentNameList){
+        this.documentNameList = documentNameList;
+        return this;
+    }
+
+
+    /**
+     * 设置 目录名称
+     * @param catalogName
+     */
+    public CertificateChildQuery catalogName(String catalogName){
+        setCatalogName(catalogName);
+        return this;
+    }
+
+    /**
+     * 设置 目录名称
+     * @param catalogNameList
+     */
+    public CertificateChildQuery catalogNameList(List<String> catalogNameList){
+        this.catalogNameList = catalogNameList;
+        return this;
+    }
 
     /**
-    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @return orConditionList
-    */
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<CertificateChildQuery> 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<CertificateChildQuery> 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<CertificateChildQuery> 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<CertificateChildQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

one-certificate-manager/src/main/java/com/mortals/xhx/module/certificate/model/CertificateDocumentEntity.java

@@ -13,7 +13,7 @@ import lombok.Data;
  * 子证配置实体对象
  *
  * @author zxfei
- * @date 2024-07-28
+ * @date 2024-07-30
  */
 @Data
 public class CertificateDocumentEntity extends CertificateDocumentVo {
@@ -47,6 +47,10 @@ public class CertificateDocumentEntity extends CertificateDocumentVo {
      * 内容表单
      */
     private String formContent;
+    /**
+     * 简称
+     */
+    private String shortName;
     @Override
     public int hashCode() {
         return this.getId().hashCode();
@@ -71,5 +75,6 @@ public class CertificateDocumentEntity extends CertificateDocumentVo {
         this.status = 1;
         this.templateContent = "";
         this.formContent = "";
+        this.shortName = "";
     }
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/certificate/model/CertificateDocumentQuery.java

@@ -6,7 +6,7 @@ import com.mortals.xhx.module.certificate.model.CertificateDocumentEntity;
  * 子证配置查询对象
  *
  * @author zxfei
- * @date 2024-07-28
+ * @date 2024-07-30
  */
 public class CertificateDocumentQuery extends CertificateDocumentEntity {
     /** 开始 序号，主键，自增长 */
@@ -131,6 +131,11 @@ public class CertificateDocumentQuery extends CertificateDocumentEntity {
 
     /** 内容表单排除列表 */
     private List <String> formContentNotList;
+    /** 简称 */
+    private List<String> shortNameList;
+
+    /** 简称排除列表 */
+    private List <String> shortNameNotList;
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<CertificateDocumentQuery> orConditionList;
 
@@ -817,6 +822,38 @@ public class CertificateDocumentQuery extends CertificateDocumentEntity {
         this.formContentNotList = formContentNotList;
     }
 
+    /**
+     * 获取 简称
+     * @return shortNameList
+     */
+    public List<String> getShortNameList(){
+        return this.shortNameList;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameList
+     */
+    public void setShortNameList(List<String> shortNameList){
+        this.shortNameList = shortNameList;
+    }
+
+    /**
+     * 获取 简称
+     * @return shortNameNotList
+     */
+    public List<String> getShortNameNotList(){
+        return this.shortNameNotList;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameNotList
+     */
+    public void setShortNameNotList(List<String> shortNameNotList){
+        this.shortNameNotList = shortNameNotList;
+    }
+
     /**
      * 设置  序号，主键，自增长
      * @param id
@@ -1219,6 +1256,25 @@ public class CertificateDocumentQuery extends CertificateDocumentEntity {
         return this;
     }
 
+
+    /**
+     * 设置 简称
+     * @param shortName
+     */
+    public CertificateDocumentQuery shortName(String shortName){
+        setShortName(shortName);
+        return this;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameList
+     */
+    public CertificateDocumentQuery shortNameList(List<String> shortNameList){
+        this.shortNameList = shortNameList;
+        return this;
+    }
+
     /**
      * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
      * @return orConditionList

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/model/ChildLicenseEntity.java

@@ -14,7 +14,7 @@ import lombok.Data;
  * 行业许可子证实体对象
  *
  * @author zxfei
- * @date 2024-07-28
+ * @date 2024-07-30
  */
 @Data
 public class ChildLicenseEntity extends ChildLicenseVo {
@@ -148,6 +148,50 @@ public class ChildLicenseEntity extends ChildLicenseVo {
      * 更新用户名称
      */
     private String updateUserName;
+    /**
+     * 删除状态(0.未删除,1.已删除)
+     */
+    private Integer deleted;
+    /**
+     * 简称
+     */
+    private String shortName;
+    /**
+     * 扩展列1
+     */
+    private String ext1;
+    /**
+     * 扩展列2
+     */
+    private String ext2;
+    /**
+     * 扩展列3
+     */
+    private String ext3;
+    /**
+     * 扩展列4
+     */
+    private String ext4;
+    /**
+     * 扩展列5
+     */
+    private String ext5;
+    /**
+     * 扩展列6
+     */
+    private String ext6;
+    /**
+     * 扩展列7
+     */
+    private String ext7;
+    /**
+     * 扩展列8
+     */
+    private String ext8;
+    /**
+     * 子证状态(0.禁用,1.启用)
+     */
+    private Integer childStatus;
     @Override
     public int hashCode() {
         return this.getId().hashCode();
@@ -197,5 +241,16 @@ public class ChildLicenseEntity extends ChildLicenseVo {
         this.reportTime = null;
         this.createUserName = "";
         this.updateUserName = "";
+        this.deleted = 0;
+        this.shortName = "";
+        this.ext1 = "";
+        this.ext2 = "";
+        this.ext3 = "";
+        this.ext4 = "";
+        this.ext5 = "";
+        this.ext6 = "";
+        this.ext7 = "";
+        this.ext8 = "";
+        this.childStatus = 1;
     }
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/model/ChildLicenseQuery.java

@@ -7,7 +7,7 @@ import com.mortals.xhx.module.child.model.ChildLicenseEntity;
  * 行业许可子证查询对象
  *
  * @author zxfei
- * @date 2024-07-28
+ * @date 2024-07-30
  */
 public class ChildLicenseQuery extends ChildLicenseEntity {
     /** 开始 主键ID，主键，自增长 */
@@ -299,6 +299,81 @@ public class ChildLicenseQuery extends ChildLicenseEntity {
 
     /** 更新用户名称排除列表 */
     private List <String> updateUserNameNotList;
+    /** 开始 删除状态(0.未删除,1.已删除) */
+    private Integer deletedStart;
+
+    /** 结束 删除状态(0.未删除,1.已删除) */
+    private Integer deletedEnd;
+
+    /** 增加 删除状态(0.未删除,1.已删除) */
+    private Integer deletedIncrement;
+
+    /** 删除状态(0.未删除,1.已删除)列表 */
+    private List <Integer> deletedList;
+
+    /** 删除状态(0.未删除,1.已删除)排除列表 */
+    private List <Integer> deletedNotList;
+
+    /** 简称 */
+    private List<String> shortNameList;
+
+    /** 简称排除列表 */
+    private List <String> shortNameNotList;
+    /** 扩展列1 */
+    private List<String> ext1List;
+
+    /** 扩展列1排除列表 */
+    private List <String> ext1NotList;
+    /** 扩展列2 */
+    private List<String> ext2List;
+
+    /** 扩展列2排除列表 */
+    private List <String> ext2NotList;
+    /** 扩展列3 */
+    private List<String> ext3List;
+
+    /** 扩展列3排除列表 */
+    private List <String> ext3NotList;
+    /** 扩展列4 */
+    private List<String> ext4List;
+
+    /** 扩展列4排除列表 */
+    private List <String> ext4NotList;
+    /** 扩展列5 */
+    private List<String> ext5List;
+
+    /** 扩展列5排除列表 */
+    private List <String> ext5NotList;
+    /** 扩展列6 */
+    private List<String> ext6List;
+
+    /** 扩展列6排除列表 */
+    private List <String> ext6NotList;
+    /** 扩展列7 */
+    private List<String> ext7List;
+
+    /** 扩展列7排除列表 */
+    private List <String> ext7NotList;
+    /** 扩展列8 */
+    private List<String> ext8List;
+
+    /** 扩展列8排除列表 */
+    private List <String> ext8NotList;
+    /** 开始 子证状态(0.禁用,1.启用) */
+    private Integer childStatusStart;
+
+    /** 结束 子证状态(0.禁用,1.启用) */
+    private Integer childStatusEnd;
+
+    /** 增加 子证状态(0.禁用,1.启用) */
+    private Integer childStatusIncrement;
+
+    /** 子证状态(0.禁用,1.启用)列表 */
+    private List <Integer> childStatusList;
+
+    /** 子证状态(0.禁用,1.启用)排除列表 */
+    private List <Integer> childStatusNotList;
+
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<ChildLicenseQuery> orConditionList;
 
@@ -1981,6 +2056,456 @@ public class ChildLicenseQuery extends ChildLicenseEntity {
         this.updateUserNameNotList = updateUserNameNotList;
     }
 
+    /**
+     * 获取 开始 删除状态(0.未删除,1.已删除)
+     * @return deletedStart
+     */
+    public Integer getDeletedStart(){
+        return this.deletedStart;
+    }
+
+    /**
+     * 设置 开始 删除状态(0.未删除,1.已删除)
+     * @param deletedStart
+     */
+    public void setDeletedStart(Integer deletedStart){
+        this.deletedStart = deletedStart;
+    }
+
+    /**
+     * 获取 结束 删除状态(0.未删除,1.已删除)
+     * @return $deletedEnd
+     */
+    public Integer getDeletedEnd(){
+        return this.deletedEnd;
+    }
+
+    /**
+     * 设置 结束 删除状态(0.未删除,1.已删除)
+     * @param deletedEnd
+     */
+    public void setDeletedEnd(Integer deletedEnd){
+        this.deletedEnd = deletedEnd;
+    }
+
+    /**
+     * 获取 增加 删除状态(0.未删除,1.已删除)
+     * @return deletedIncrement
+     */
+    public Integer getDeletedIncrement(){
+        return this.deletedIncrement;
+    }
+
+    /**
+     * 设置 增加 删除状态(0.未删除,1.已删除)
+     * @param deletedIncrement
+     */
+    public void setDeletedIncrement(Integer deletedIncrement){
+        this.deletedIncrement = deletedIncrement;
+    }
+
+    /**
+     * 获取 删除状态(0.未删除,1.已删除)
+     * @return deletedList
+     */
+    public List<Integer> getDeletedList(){
+        return this.deletedList;
+    }
+
+    /**
+     * 设置 删除状态(0.未删除,1.已删除)
+     * @param deletedList
+     */
+    public void setDeletedList(List<Integer> deletedList){
+        this.deletedList = deletedList;
+    }
+
+    /**
+     * 获取 删除状态(0.未删除,1.已删除)
+     * @return deletedNotList
+     */
+    public List<Integer> getDeletedNotList(){
+        return this.deletedNotList;
+    }
+
+    /**
+     * 设置 删除状态(0.未删除,1.已删除)
+     * @param deletedNotList
+     */
+    public void setDeletedNotList(List<Integer> deletedNotList){
+        this.deletedNotList = deletedNotList;
+    }
+
+
+    /**
+     * 获取 简称
+     * @return shortNameList
+     */
+    public List<String> getShortNameList(){
+        return this.shortNameList;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameList
+     */
+    public void setShortNameList(List<String> shortNameList){
+        this.shortNameList = shortNameList;
+    }
+
+    /**
+     * 获取 简称
+     * @return shortNameNotList
+     */
+    public List<String> getShortNameNotList(){
+        return this.shortNameNotList;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameNotList
+     */
+    public void setShortNameNotList(List<String> shortNameNotList){
+        this.shortNameNotList = shortNameNotList;
+    }
+
+    /**
+     * 获取 扩展列1
+     * @return ext1List
+     */
+    public List<String> getExt1List(){
+        return this.ext1List;
+    }
+
+    /**
+     * 设置 扩展列1
+     * @param ext1List
+     */
+    public void setExt1List(List<String> ext1List){
+        this.ext1List = ext1List;
+    }
+
+    /**
+     * 获取 扩展列1
+     * @return ext1NotList
+     */
+    public List<String> getExt1NotList(){
+        return this.ext1NotList;
+    }
+
+    /**
+     * 设置 扩展列1
+     * @param ext1NotList
+     */
+    public void setExt1NotList(List<String> ext1NotList){
+        this.ext1NotList = ext1NotList;
+    }
+
+    /**
+     * 获取 扩展列2
+     * @return ext2List
+     */
+    public List<String> getExt2List(){
+        return this.ext2List;
+    }
+
+    /**
+     * 设置 扩展列2
+     * @param ext2List
+     */
+    public void setExt2List(List<String> ext2List){
+        this.ext2List = ext2List;
+    }
+
+    /**
+     * 获取 扩展列2
+     * @return ext2NotList
+     */
+    public List<String> getExt2NotList(){
+        return this.ext2NotList;
+    }
+
+    /**
+     * 设置 扩展列2
+     * @param ext2NotList
+     */
+    public void setExt2NotList(List<String> ext2NotList){
+        this.ext2NotList = ext2NotList;
+    }
+
+    /**
+     * 获取 扩展列3
+     * @return ext3List
+     */
+    public List<String> getExt3List(){
+        return this.ext3List;
+    }
+
+    /**
+     * 设置 扩展列3
+     * @param ext3List
+     */
+    public void setExt3List(List<String> ext3List){
+        this.ext3List = ext3List;
+    }
+
+    /**
+     * 获取 扩展列3
+     * @return ext3NotList
+     */
+    public List<String> getExt3NotList(){
+        return this.ext3NotList;
+    }
+
+    /**
+     * 设置 扩展列3
+     * @param ext3NotList
+     */
+    public void setExt3NotList(List<String> ext3NotList){
+        this.ext3NotList = ext3NotList;
+    }
+
+    /**
+     * 获取 扩展列4
+     * @return ext4List
+     */
+    public List<String> getExt4List(){
+        return this.ext4List;
+    }
+
+    /**
+     * 设置 扩展列4
+     * @param ext4List
+     */
+    public void setExt4List(List<String> ext4List){
+        this.ext4List = ext4List;
+    }
+
+    /**
+     * 获取 扩展列4
+     * @return ext4NotList
+     */
+    public List<String> getExt4NotList(){
+        return this.ext4NotList;
+    }
+
+    /**
+     * 设置 扩展列4
+     * @param ext4NotList
+     */
+    public void setExt4NotList(List<String> ext4NotList){
+        this.ext4NotList = ext4NotList;
+    }
+
+    /**
+     * 获取 扩展列5
+     * @return ext5List
+     */
+    public List<String> getExt5List(){
+        return this.ext5List;
+    }
+
+    /**
+     * 设置 扩展列5
+     * @param ext5List
+     */
+    public void setExt5List(List<String> ext5List){
+        this.ext5List = ext5List;
+    }
+
+    /**
+     * 获取 扩展列5
+     * @return ext5NotList
+     */
+    public List<String> getExt5NotList(){
+        return this.ext5NotList;
+    }
+
+    /**
+     * 设置 扩展列5
+     * @param ext5NotList
+     */
+    public void setExt5NotList(List<String> ext5NotList){
+        this.ext5NotList = ext5NotList;
+    }
+
+    /**
+     * 获取 扩展列6
+     * @return ext6List
+     */
+    public List<String> getExt6List(){
+        return this.ext6List;
+    }
+
+    /**
+     * 设置 扩展列6
+     * @param ext6List
+     */
+    public void setExt6List(List<String> ext6List){
+        this.ext6List = ext6List;
+    }
+
+    /**
+     * 获取 扩展列6
+     * @return ext6NotList
+     */
+    public List<String> getExt6NotList(){
+        return this.ext6NotList;
+    }
+
+    /**
+     * 设置 扩展列6
+     * @param ext6NotList
+     */
+    public void setExt6NotList(List<String> ext6NotList){
+        this.ext6NotList = ext6NotList;
+    }
+
+    /**
+     * 获取 扩展列7
+     * @return ext7List
+     */
+    public List<String> getExt7List(){
+        return this.ext7List;
+    }
+
+    /**
+     * 设置 扩展列7
+     * @param ext7List
+     */
+    public void setExt7List(List<String> ext7List){
+        this.ext7List = ext7List;
+    }
+
+    /**
+     * 获取 扩展列7
+     * @return ext7NotList
+     */
+    public List<String> getExt7NotList(){
+        return this.ext7NotList;
+    }
+
+    /**
+     * 设置 扩展列7
+     * @param ext7NotList
+     */
+    public void setExt7NotList(List<String> ext7NotList){
+        this.ext7NotList = ext7NotList;
+    }
+
+    /**
+     * 获取 扩展列8
+     * @return ext8List
+     */
+    public List<String> getExt8List(){
+        return this.ext8List;
+    }
+
+    /**
+     * 设置 扩展列8
+     * @param ext8List
+     */
+    public void setExt8List(List<String> ext8List){
+        this.ext8List = ext8List;
+    }
+
+    /**
+     * 获取 扩展列8
+     * @return ext8NotList
+     */
+    public List<String> getExt8NotList(){
+        return this.ext8NotList;
+    }
+
+    /**
+     * 设置 扩展列8
+     * @param ext8NotList
+     */
+    public void setExt8NotList(List<String> ext8NotList){
+        this.ext8NotList = ext8NotList;
+    }
+
+    /**
+     * 获取 开始 子证状态(0.禁用,1.启用)
+     * @return childStatusStart
+     */
+    public Integer getChildStatusStart(){
+        return this.childStatusStart;
+    }
+
+    /**
+     * 设置 开始 子证状态(0.禁用,1.启用)
+     * @param childStatusStart
+     */
+    public void setChildStatusStart(Integer childStatusStart){
+        this.childStatusStart = childStatusStart;
+    }
+
+    /**
+     * 获取 结束 子证状态(0.禁用,1.启用)
+     * @return $childStatusEnd
+     */
+    public Integer getChildStatusEnd(){
+        return this.childStatusEnd;
+    }
+
+    /**
+     * 设置 结束 子证状态(0.禁用,1.启用)
+     * @param childStatusEnd
+     */
+    public void setChildStatusEnd(Integer childStatusEnd){
+        this.childStatusEnd = childStatusEnd;
+    }
+
+    /**
+     * 获取 增加 子证状态(0.禁用,1.启用)
+     * @return childStatusIncrement
+     */
+    public Integer getChildStatusIncrement(){
+        return this.childStatusIncrement;
+    }
+
+    /**
+     * 设置 增加 子证状态(0.禁用,1.启用)
+     * @param childStatusIncrement
+     */
+    public void setChildStatusIncrement(Integer childStatusIncrement){
+        this.childStatusIncrement = childStatusIncrement;
+    }
+
+    /**
+     * 获取 子证状态(0.禁用,1.启用)
+     * @return childStatusList
+     */
+    public List<Integer> getChildStatusList(){
+        return this.childStatusList;
+    }
+
+    /**
+     * 设置 子证状态(0.禁用,1.启用)
+     * @param childStatusList
+     */
+    public void setChildStatusList(List<Integer> childStatusList){
+        this.childStatusList = childStatusList;
+    }
+
+    /**
+     * 获取 子证状态(0.禁用,1.启用)
+     * @return childStatusNotList
+     */
+    public List<Integer> getChildStatusNotList(){
+        return this.childStatusNotList;
+    }
+
+    /**
+     * 设置 子证状态(0.禁用,1.启用)
+     * @param childStatusNotList
+     */
+    public void setChildStatusNotList(List<Integer> childStatusNotList){
+        this.childStatusNotList = childStatusNotList;
+    }
+
+
     /**
      * 设置  主键ID，主键，自增长
      * @param id
@@ -2962,6 +3487,285 @@ public class ChildLicenseQuery extends ChildLicenseEntity {
         return this;
     }
 
+    /**
+     * 设置  删除状态(0.未删除,1.已删除)
+     * @param deleted
+     */
+    public ChildLicenseQuery deleted(Integer deleted){
+        setDeleted(deleted);
+        return this;
+    }
+
+    /**
+     * 设置 开始 删除状态(0.未删除,1.已删除)
+     * @param deletedStart
+     */
+    public ChildLicenseQuery deletedStart(Integer deletedStart){
+        this.deletedStart = deletedStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 删除状态(0.未删除,1.已删除)
+     * @param deletedEnd
+     */
+    public ChildLicenseQuery deletedEnd(Integer deletedEnd){
+        this.deletedEnd = deletedEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 删除状态(0.未删除,1.已删除)
+     * @param deletedIncrement
+     */
+    public ChildLicenseQuery deletedIncrement(Integer deletedIncrement){
+        this.deletedIncrement = deletedIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 删除状态(0.未删除,1.已删除)
+     * @param deletedList
+     */
+    public ChildLicenseQuery deletedList(List<Integer> deletedList){
+        this.deletedList = deletedList;
+        return this;
+    }
+
+    /**
+     * 设置 删除状态(0.未删除,1.已删除)
+     * @param deletedNotList
+     */
+    public ChildLicenseQuery deletedNotList(List<Integer> deletedNotList){
+        this.deletedNotList = deletedNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置 简称
+     * @param shortName
+     */
+    public ChildLicenseQuery shortName(String shortName){
+        setShortName(shortName);
+        return this;
+    }
+
+    /**
+     * 设置 简称
+     * @param shortNameList
+     */
+    public ChildLicenseQuery shortNameList(List<String> shortNameList){
+        this.shortNameList = shortNameList;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列1
+     * @param ext1
+     */
+    public ChildLicenseQuery ext1(String ext1){
+        setExt1(ext1);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列1
+     * @param ext1List
+     */
+    public ChildLicenseQuery ext1List(List<String> ext1List){
+        this.ext1List = ext1List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列2
+     * @param ext2
+     */
+    public ChildLicenseQuery ext2(String ext2){
+        setExt2(ext2);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列2
+     * @param ext2List
+     */
+    public ChildLicenseQuery ext2List(List<String> ext2List){
+        this.ext2List = ext2List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列3
+     * @param ext3
+     */
+    public ChildLicenseQuery ext3(String ext3){
+        setExt3(ext3);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列3
+     * @param ext3List
+     */
+    public ChildLicenseQuery ext3List(List<String> ext3List){
+        this.ext3List = ext3List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列4
+     * @param ext4
+     */
+    public ChildLicenseQuery ext4(String ext4){
+        setExt4(ext4);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列4
+     * @param ext4List
+     */
+    public ChildLicenseQuery ext4List(List<String> ext4List){
+        this.ext4List = ext4List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列5
+     * @param ext5
+     */
+    public ChildLicenseQuery ext5(String ext5){
+        setExt5(ext5);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列5
+     * @param ext5List
+     */
+    public ChildLicenseQuery ext5List(List<String> ext5List){
+        this.ext5List = ext5List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列6
+     * @param ext6
+     */
+    public ChildLicenseQuery ext6(String ext6){
+        setExt6(ext6);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列6
+     * @param ext6List
+     */
+    public ChildLicenseQuery ext6List(List<String> ext6List){
+        this.ext6List = ext6List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列7
+     * @param ext7
+     */
+    public ChildLicenseQuery ext7(String ext7){
+        setExt7(ext7);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列7
+     * @param ext7List
+     */
+    public ChildLicenseQuery ext7List(List<String> ext7List){
+        this.ext7List = ext7List;
+        return this;
+    }
+
+
+    /**
+     * 设置 扩展列8
+     * @param ext8
+     */
+    public ChildLicenseQuery ext8(String ext8){
+        setExt8(ext8);
+        return this;
+    }
+
+    /**
+     * 设置 扩展列8
+     * @param ext8List
+     */
+    public ChildLicenseQuery ext8List(List<String> ext8List){
+        this.ext8List = ext8List;
+        return this;
+    }
+
+    /**
+     * 设置  子证状态(0.禁用,1.启用)
+     * @param childStatus
+     */
+    public ChildLicenseQuery childStatus(Integer childStatus){
+        setChildStatus(childStatus);
+        return this;
+    }
+
+    /**
+     * 设置 开始 子证状态(0.禁用,1.启用)
+     * @param childStatusStart
+     */
+    public ChildLicenseQuery childStatusStart(Integer childStatusStart){
+        this.childStatusStart = childStatusStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 子证状态(0.禁用,1.启用)
+     * @param childStatusEnd
+     */
+    public ChildLicenseQuery childStatusEnd(Integer childStatusEnd){
+        this.childStatusEnd = childStatusEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 子证状态(0.禁用,1.启用)
+     * @param childStatusIncrement
+     */
+    public ChildLicenseQuery childStatusIncrement(Integer childStatusIncrement){
+        this.childStatusIncrement = childStatusIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 子证状态(0.禁用,1.启用)
+     * @param childStatusList
+     */
+    public ChildLicenseQuery childStatusList(List<Integer> childStatusList){
+        this.childStatusList = childStatusList;
+        return this;
+    }
+
+    /**
+     * 设置 子证状态(0.禁用,1.启用)
+     * @param childStatusNotList
+     */
+    public ChildLicenseQuery childStatusNotList(List<Integer> childStatusNotList){
+        this.childStatusNotList = childStatusNotList;
+        return this;
+    }
+
     /**
      * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
      * @return orConditionList

one-certificate-manager/src/main/java/com/mortals/xhx/module/record/service/impl/ApplyLogServiceImpl.java

@@ -68,8 +68,8 @@ public class ApplyLogServiceImpl extends AbstractCRUDServiceImpl<ApplyLogDao, Ap
     private String filePath;
 
     /** 应用公网地址 */
-   // @Value("${serviceUrl:http://one.scsmile.cn/h5/#?id=}")
-    private String serviceUrl="http://one.scsmile.cn/h5/#?id=";
+    @Value("${serviceUrl:http://one.scsmile.cn/h5/#?id=}")
+    private String serviceUrl;
 
     @Autowired
     private UploadService uploadService;

one-certificate-manager/src/main/resources/sqlmap/module/certificate/CertificateCatalogMapper.xml

@@ -30,6 +30,7 @@
         <result property="createTime" column="createTime" />
         <result property="updateUserId" column="updateUserId" />
         <result property="updateTime" column="updateTime" />
+        <result property="shortName" column="shortName" />
     </resultMap>
 
     <!-- 表所有列 -->
@@ -110,23 +111,32 @@
             <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('shortName') or colPickMode == 1 and data.containsKey('shortName')))">
+                a.shortName,
+            </if>
+        </trim>
+    </sql>
+    <!-- 子表所有列 -->
+    <sql id="_columns_sub">
+        <trim suffixOverrides="," suffix="">
+            b.id,b.siteId,b.catalogId,b.documentId,b.createUserId,b.createTime,b.updateUserId,b.updateTime,b.documentName,b.catalogName,
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="CertificateCatalogEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_certificate_catalog
-        (siteId,catalogName,catalogCode,holderType,industryId,classifyId,transverse,portrait,inspect,status,templateFileName,templateFileUrl,formContent,exampleFileUrl,excelFile,isPdf,deviceId,printerName,printerIp,paperSource,createUserId,createTime,updateUserId,updateTime)
+        (siteId,catalogName,catalogCode,holderType,industryId,classifyId,transverse,portrait,inspect,status,templateFileName,templateFileUrl,formContent,exampleFileUrl,excelFile,isPdf,deviceId,printerName,printerIp,paperSource,createUserId,createTime,updateUserId,updateTime,shortName)
         VALUES
-        (#{siteId},#{catalogName},#{catalogCode},#{holderType},#{industryId},#{classifyId},#{transverse},#{portrait},#{inspect},#{status},#{templateFileName},#{templateFileUrl},#{formContent},#{exampleFileUrl},#{excelFile},#{isPdf},#{deviceId},#{printerName},#{printerIp},#{paperSource},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
+        (#{siteId},#{catalogName},#{catalogCode},#{holderType},#{industryId},#{classifyId},#{transverse},#{portrait},#{inspect},#{status},#{templateFileName},#{templateFileUrl},#{formContent},#{exampleFileUrl},#{excelFile},#{isPdf},#{deviceId},#{printerName},#{printerIp},#{paperSource},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{shortName})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_certificate_catalog
-        (siteId,catalogName,catalogCode,holderType,industryId,classifyId,transverse,portrait,inspect,status,templateFileName,templateFileUrl,formContent,exampleFileUrl,excelFile,isPdf,deviceId,printerName,printerIp,paperSource,createUserId,createTime,updateUserId,updateTime)
+        (siteId,catalogName,catalogCode,holderType,industryId,classifyId,transverse,portrait,inspect,status,templateFileName,templateFileUrl,formContent,exampleFileUrl,excelFile,isPdf,deviceId,printerName,printerIp,paperSource,createUserId,createTime,updateUserId,updateTime,shortName)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.catalogName},#{item.catalogCode},#{item.holderType},#{item.industryId},#{item.classifyId},#{item.transverse},#{item.portrait},#{item.inspect},#{item.status},#{item.templateFileName},#{item.templateFileUrl},#{item.formContent},#{item.exampleFileUrl},#{item.excelFile},#{item.isPdf},#{item.deviceId},#{item.printerName},#{item.printerIp},#{item.paperSource},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
+            (#{item.siteId},#{item.catalogName},#{item.catalogCode},#{item.holderType},#{item.industryId},#{item.classifyId},#{item.transverse},#{item.portrait},#{item.inspect},#{item.status},#{item.templateFileName},#{item.templateFileUrl},#{item.formContent},#{item.exampleFileUrl},#{item.excelFile},#{item.isPdf},#{item.deviceId},#{item.printerName},#{item.printerIp},#{item.paperSource},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.shortName})
         </foreach>
     </insert>
 
@@ -244,6 +254,9 @@
             <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('shortName')) or (colPickMode==1 and !data.containsKey('shortName'))">
+                a.shortName=#{data.shortName},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -484,6 +497,13 @@
                     </if>
                 </foreach>
             </trim>
+            <trim prefix="shortName=(case" suffix="ELSE shortName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('shortName')) or (colPickMode==1 and !item.containsKey('shortName'))">
+                        when a.id=#{item.id} then #{item.shortName}
+                    </if>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -544,6 +564,7 @@
         </trim>
         <include refid="_orderCols_"/>
     </select>
+    <!-- 获取子列表 -->
 
 
 
@@ -1195,6 +1216,27 @@
         <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('shortName')">
+            <if test="conditionParamRef.shortName != null and conditionParamRef.shortName != ''">
+                ${_conditionType_} a.shortName like #{${_conditionParam_}.shortName}
+            </if>
+            <if test="conditionParamRef.shortName == null">
+                ${_conditionType_} a.shortName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('shortNameList') and conditionParamRef.shortNameList.size() > 0">
+            ${_conditionType_} a.shortName in
+            <foreach collection="conditionParamRef.shortNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('shortNameNotList') and conditionParamRef.shortNameNotList.size() > 0">
+            ${_conditionType_} a.shortName not in
+            <foreach collection="conditionParamRef.shortNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">
@@ -1515,6 +1557,11 @@
                     <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
                     ,
                 </if>
+                <if test="orderCol.containsKey('shortName')">
+                    a.shortName
+                    <if test='orderCol.shortName != null and "DESC".equalsIgnoreCase(orderCol.shortName)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>
 

one-certificate-manager/src/main/resources/sqlmap/module/certificate/CertificateChildMapper.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.certificate.dao.ibatis.CertificateChildDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="CertificateChildEntity" id="CertificateChildEntity-Map">
-            <id  property="id" column="id" />
-            <result property="siteId" column="siteId" />
-            <result property="catalogId" column="catalogId" />
-            <result property="documentId" column="documentId" />
-            <result property="createUserId" column="createUserId" />
-            <result property="createTime" column="createTime" />
-            <result property="updateUserId" column="updateUserId" />
-            <result property="updateTime" column="updateTime" />
+        <id  property="id" column="id" />
+        <result property="siteId" column="siteId" />
+        <result property="catalogId" column="catalogId" />
+        <result property="documentId" column="documentId" />
+        <result property="createUserId" column="createUserId" />
+        <result property="createTime" column="createTime" />
+        <result property="updateUserId" column="updateUserId" />
+        <result property="updateTime" column="updateTime" />
+        <result property="documentName" column="documentName" />
+        <result property="catalogName" column="catalogName" />
     </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('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
-                    a.siteId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('catalogId') or colPickMode == 1 and data.containsKey('catalogId')))">
-                    a.catalogId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('documentId') or colPickMode == 1 and data.containsKey('documentId')))">
-                    a.documentId,
-                </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('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
-                    a.createTime,
-                </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('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
+                a.siteId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('catalogId') or colPickMode == 1 and data.containsKey('catalogId')))">
+                a.catalogId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('documentId') or colPickMode == 1 and data.containsKey('documentId')))">
+                a.documentId,
+            </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('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                a.createTime,
+            </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('documentName') or colPickMode == 1 and data.containsKey('documentName')))">
+                a.documentName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('catalogName') or colPickMode == 1 and data.containsKey('catalogName')))">
+                a.catalogName,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="CertificateChildEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_certificate_child
-        (siteId,catalogId,documentId,createUserId,createTime,updateUserId,updateTime)
+        (siteId,catalogId,documentId,createUserId,createTime,updateUserId,updateTime,documentName,catalogName)
         VALUES
-        (#{siteId},#{catalogId},#{documentId},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
+        (#{siteId},#{catalogId},#{documentId},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{documentName},#{catalogName})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_certificate_child
-        (siteId,catalogId,documentId,createUserId,createTime,updateUserId,updateTime)
+        (siteId,catalogId,documentId,createUserId,createTime,updateUserId,updateTime,documentName,catalogName)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.catalogId},#{item.documentId},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
+            (#{item.siteId},#{item.catalogId},#{item.documentId},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.documentName},#{item.catalogName})
         </foreach>
     </insert>
 
@@ -104,6 +112,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('documentName')) or (colPickMode==1 and !data.containsKey('documentName'))">
+                a.documentName=#{data.documentName},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('catalogName')) or (colPickMode==1 and !data.containsKey('catalogName'))">
+                a.catalogName=#{data.catalogName},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -116,80 +130,94 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_xhx_certificate_child as a
         <trim prefix="set" suffixOverrides=",">
-                        <trim prefix="siteId=(case" suffix="ELSE siteId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
-                                        when a.id=#{item.id} then #{item.siteId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                        <trim prefix="catalogId=(case" suffix="ELSE catalogId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('catalogId')) or (colPickMode==1 and !item.containsKey('catalogId'))">
-                                        when a.id=#{item.id} then #{item.catalogId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('catalogIdIncrement')) or (colPickMode==1 and !item.containsKey('catalogIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.catalogId,0) + #{item.catalogIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                        <trim prefix="documentId=(case" suffix="ELSE documentId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('documentId')) or (colPickMode==1 and !item.containsKey('documentId'))">
-                                        when a.id=#{item.id} then #{item.documentId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('documentIdIncrement')) or (colPickMode==1 and !item.containsKey('documentIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.documentId,0) + #{item.documentIdIncrement}
-                                    </when>
-                                </choose>
-                            </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="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="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="siteId=(case" suffix="ELSE siteId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
+                            when a.id=#{item.id} then #{item.siteId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="catalogId=(case" suffix="ELSE catalogId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('catalogId')) or (colPickMode==1 and !item.containsKey('catalogId'))">
+                            when a.id=#{item.id} then #{item.catalogId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('catalogIdIncrement')) or (colPickMode==1 and !item.containsKey('catalogIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.catalogId,0) + #{item.catalogIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="documentId=(case" suffix="ELSE documentId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('documentId')) or (colPickMode==1 and !item.containsKey('documentId'))">
+                            when a.id=#{item.id} then #{item.documentId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('documentIdIncrement')) or (colPickMode==1 and !item.containsKey('documentIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.documentId,0) + #{item.documentIdIncrement}
+                        </when>
+                    </choose>
+                </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="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="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="documentName=(case" suffix="ELSE documentName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('documentName')) or (colPickMode==1 and !item.containsKey('documentName'))">
+                        when a.id=#{item.id} then #{item.documentName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="catalogName=(case" suffix="ELSE catalogName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('catalogName')) or (colPickMode==1 and !item.containsKey('catalogName'))">
+                        when a.id=#{item.id} then #{item.catalogName}
+                    </if>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -310,335 +338,387 @@
                 ${_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 test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
             </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 test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
             </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('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('siteId')">
+            <if test="conditionParamRef.siteId != null ">
+                ${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
             </if>
-            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
-                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            <if test="conditionParamRef.siteId == null">
+                ${_conditionType_} a.siteId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+            ${_conditionType_} a.siteId in
+            <foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
+            ${_conditionType_} a.siteId not in
+            <foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
+            ${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
+            ${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('siteId')">
-                <if test="conditionParamRef.siteId != null ">
-                    ${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
-                </if>
-                <if test="conditionParamRef.siteId == null">
-                    ${_conditionType_} a.siteId is null
-                </if>
+        <if test="conditionParamRef.containsKey('catalogId')">
+            <if test="conditionParamRef.catalogId != null ">
+                ${_conditionType_} a.catalogId = #{${_conditionParam_}.catalogId}
             </if>
-            <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
-                ${_conditionType_} a.siteId in
-                <foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.catalogId == null">
+                ${_conditionType_} a.catalogId is null
             </if>
-            <if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
-                ${_conditionType_} a.siteId not in
-                <foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('catalogIdList') and conditionParamRef.catalogIdList.size() > 0">
+            ${_conditionType_} a.catalogId in
+            <foreach collection="conditionParamRef.catalogIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('catalogIdNotList') and conditionParamRef.catalogIdNotList.size() > 0">
+            ${_conditionType_} a.catalogId not in
+            <foreach collection="conditionParamRef.catalogIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('catalogIdStart') and conditionParamRef.catalogIdStart != null">
+            ${_conditionType_} a.catalogId <![CDATA[ >= ]]> #{${_conditionParam_}.catalogIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('catalogIdEnd') and conditionParamRef.catalogIdEnd != null">
+            ${_conditionType_} a.catalogId <![CDATA[ <= ]]> #{${_conditionParam_}.catalogIdEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('documentId')">
+            <if test="conditionParamRef.documentId != null ">
+                ${_conditionType_} a.documentId = #{${_conditionParam_}.documentId}
+            </if>
+            <if test="conditionParamRef.documentId == null">
+                ${_conditionType_} a.documentId is null
             </if>
-            <if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
-                ${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('documentIdList') and conditionParamRef.documentIdList.size() > 0">
+            ${_conditionType_} a.documentId in
+            <foreach collection="conditionParamRef.documentIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('documentIdNotList') and conditionParamRef.documentIdNotList.size() > 0">
+            ${_conditionType_} a.documentId not in
+            <foreach collection="conditionParamRef.documentIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('documentIdStart') and conditionParamRef.documentIdStart != null">
+            ${_conditionType_} a.documentId <![CDATA[ >= ]]> #{${_conditionParam_}.documentIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('documentIdEnd') and conditionParamRef.documentIdEnd != null">
+            ${_conditionType_} a.documentId <![CDATA[ <= ]]> #{${_conditionParam_}.documentIdEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('createUserId')">
+            <if test="conditionParamRef.createUserId != null ">
+                ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
             </if>
-            <if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
-                ${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
+            <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('catalogId')">
-                <if test="conditionParamRef.catalogId != null ">
-                    ${_conditionType_} a.catalogId = #{${_conditionParam_}.catalogId}
-                </if>
-                <if test="conditionParamRef.catalogId == null">
-                    ${_conditionType_} a.catalogId is null
-                </if>
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('catalogIdList') and conditionParamRef.catalogIdList.size() > 0">
-                ${_conditionType_} a.catalogId in
-                <foreach collection="conditionParamRef.catalogIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <if test="conditionParamRef.containsKey('catalogIdNotList') and conditionParamRef.catalogIdNotList.size() > 0">
-                ${_conditionType_} a.catalogId not in
-                <foreach collection="conditionParamRef.catalogIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </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('updateUserId')">
+            <if test="conditionParamRef.updateUserId != null ">
+                ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
             </if>
-            <if test="conditionParamRef.containsKey('catalogIdStart') and conditionParamRef.catalogIdStart != null">
-                ${_conditionType_} a.catalogId <![CDATA[ >= ]]> #{${_conditionParam_}.catalogIdStart}
+            <if test="conditionParamRef.updateUserId == null">
+                ${_conditionType_} a.updateUserId is null
             </if>
-            <if test="conditionParamRef.containsKey('catalogIdEnd') and conditionParamRef.catalogIdEnd != null">
-                ${_conditionType_} a.catalogId <![CDATA[ <= ]]> #{${_conditionParam_}.catalogIdEnd}
+        </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>
+        <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('documentId')">
-                <if test="conditionParamRef.documentId != null ">
-                    ${_conditionType_} a.documentId = #{${_conditionParam_}.documentId}
-                </if>
-                <if test="conditionParamRef.documentId == null">
-                    ${_conditionType_} a.documentId is null
-                </if>
+        <if test="conditionParamRef.containsKey('documentName')">
+            <if test="conditionParamRef.documentName != null and conditionParamRef.documentName != ''">
+                ${_conditionType_} a.documentName like #{${_conditionParam_}.documentName}
             </if>
-            <if test="conditionParamRef.containsKey('documentIdList') and conditionParamRef.documentIdList.size() > 0">
-                ${_conditionType_} a.documentId in
-                <foreach collection="conditionParamRef.documentIdList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.documentName == null">
+                ${_conditionType_} a.documentName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('documentNameList') and conditionParamRef.documentNameList.size() > 0">
+            ${_conditionType_} a.documentName in
+            <foreach collection="conditionParamRef.documentNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('documentNameNotList') and conditionParamRef.documentNameNotList.size() > 0">
+            ${_conditionType_} a.documentName not in
+            <foreach collection="conditionParamRef.documentNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('catalogName')">
+            <if test="conditionParamRef.catalogName != null and conditionParamRef.catalogName != ''">
+                ${_conditionType_} a.catalogName like #{${_conditionParam_}.catalogName}
+            </if>
+            <if test="conditionParamRef.catalogName == null">
+                ${_conditionType_} a.catalogName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('catalogNameList') and conditionParamRef.catalogNameList.size() > 0">
+            ${_conditionType_} a.catalogName in
+            <foreach collection="conditionParamRef.catalogNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('catalogNameNotList') and conditionParamRef.catalogNameNotList.size() > 0">
+            ${_conditionType_} a.catalogName not in
+            <foreach collection="conditionParamRef.catalogNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+    </sql>
+    <sql id="_orderCols_">
+        <if test="orderColList != null and !orderColList.isEmpty()">
+            order by
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                field(a.id,
+                <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('documentIdNotList') and conditionParamRef.documentIdNotList.size() > 0">
-                ${_conditionType_} a.documentId not in
-                <foreach collection="conditionParamRef.documentIdNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+                field(a.siteId,
+                <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('documentIdStart') and conditionParamRef.documentIdStart != null">
-                ${_conditionType_} a.documentId <![CDATA[ >= ]]> #{${_conditionParam_}.documentIdStart}
-            </if>
-            <if test="conditionParamRef.containsKey('documentIdEnd') and conditionParamRef.documentIdEnd != null">
-                ${_conditionType_} a.documentId <![CDATA[ <= ]]> #{${_conditionParam_}.documentIdEnd}
+            <if test="conditionParamRef.containsKey('catalogIdList') and conditionParamRef.catalogIdList.size() > 0">
+                field(a.catalogId,
+                <foreach collection="conditionParamRef.catalogIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </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.containsKey('documentIdList') and conditionParamRef.documentIdList.size() > 0">
+                field(a.documentId,
+                <foreach collection="conditionParamRef.documentIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </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=",">
+                field(a.createUserId,
+                <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=",">
+            <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                field(a.updateUserId,
+                <foreach collection="conditionParamRef.updateUserIdList" 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('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>
-            <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')
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+                    a.${item.colName} ${item.sortKind}
+                </foreach>
+            </trim>
+        </if>
+        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
+            order by
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                field(a.id,
+                <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </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('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+                field(a.siteId,
+                <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </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=",">
+            <if test="conditionParamRef.containsKey('catalogIdList') and conditionParamRef.catalogIdList.size() > 0">
+                field(a.catalogId,
+                <foreach collection="conditionParamRef.catalogIdList" 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=",">
+            <if test="conditionParamRef.containsKey('documentIdList') and conditionParamRef.documentIdList.size() > 0">
+                field(a.documentId,
+                <foreach collection="conditionParamRef.documentIdList" 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 test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
-                ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+            <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                field(a.updateUserId,
+                <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </if>
-
-
-            <if test="conditionParamRef.containsKey('updateTime')">
-                <if test="conditionParamRef.updateTime != null ">
-                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+            <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="conditionParamRef.updateTime == null">
-                    ${_conditionType_} a.updateTime is null
+                <if test="orderCol.containsKey('siteId')">
+                    a.siteId
+                    <if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('catalogId')">
+                    a.catalogId
+                    <if test='orderCol.catalogId != null and "DESC".equalsIgnoreCase(orderCol.catalogId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('documentId')">
+                    a.documentId
+                    <if test='orderCol.documentId != null and "DESC".equalsIgnoreCase(orderCol.documentId)'>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('createTime')">
+                    a.createTime
+                    <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>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('documentName')">
+                    a.documentName
+                    <if test='orderCol.documentName != null and "DESC".equalsIgnoreCase(orderCol.documentName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('catalogName')">
+                    a.catalogName
+                    <if test='orderCol.catalogName != null and "DESC".equalsIgnoreCase(orderCol.catalogName)'>DESC</if>
+                    ,
                 </if>
-            </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>
-    </sql>
-    <sql id="_orderCols_">
-        <if test="orderColList != null and !orderColList.isEmpty()">
-            order by
-                    <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
-                        field(a.id,
-                        <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
-                        field(a.siteId,
-                        <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('catalogIdList') and conditionParamRef.catalogIdList.size() > 0">
-                        field(a.catalogId,
-                        <foreach collection="conditionParamRef.catalogIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('documentIdList') and conditionParamRef.documentIdList.size() > 0">
-                        field(a.documentId,
-                        <foreach collection="conditionParamRef.documentIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
-                        field(a.createUserId,
-                        <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
-                        field(a.updateUserId,
-                        <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-            <trim suffixOverrides=","  suffix="">
-                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
-                     a.${item.colName} ${item.sortKind}
-                </foreach>
-            </trim>
-        </if>
-        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
-            order by
-                    <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
-                        field(a.id,
-                        <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
-                        field(a.siteId,
-                        <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('catalogIdList') and conditionParamRef.catalogIdList.size() > 0">
-                        field(a.catalogId,
-                        <foreach collection="conditionParamRef.catalogIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('documentIdList') and conditionParamRef.documentIdList.size() > 0">
-                        field(a.documentId,
-                        <foreach collection="conditionParamRef.documentIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
-                        field(a.createUserId,
-                        <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-                    <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
-                        field(a.updateUserId,
-                        <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
-                            #{item}
-                        </foreach>
-                        ,
-                    </if>
-            <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('siteId')">
-                        a.siteId
-                        <if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('catalogId')">
-                        a.catalogId
-                        <if test='orderCol.catalogId != null and "DESC".equalsIgnoreCase(orderCol.catalogId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('documentId')">
-                        a.documentId
-                        <if test='orderCol.documentId != null and "DESC".equalsIgnoreCase(orderCol.documentId)'>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('createTime')">
-                        a.createTime
-                        <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>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>
             </trim>
         </if>
 

one-certificate-manager/src/main/resources/sqlmap/module/certificate/CertificateDocumentMapper.xml

@@ -17,6 +17,7 @@
         <result property="updateTime" column="updateTime" />
         <result property="templateContent" column="templateContent" />
         <result property="formContent" column="formContent" />
+        <result property="shortName" column="shortName" />
     </resultMap>
 
     <!-- 表所有列 -->
@@ -58,23 +59,26 @@
             <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('formContent') or colPickMode == 1 and data.containsKey('formContent')))">
                 a.formContent,
             </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('shortName') or colPickMode == 1 and data.containsKey('shortName')))">
+                a.shortName,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="CertificateDocumentEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_certificate_document
-        (siteId,deptId,deptName,documentName,status,createUserId,createTime,updateUserId,updateTime,templateContent,formContent)
+        (siteId,deptId,deptName,documentName,status,createUserId,createTime,updateUserId,updateTime,templateContent,formContent,shortName)
         VALUES
-        (#{siteId},#{deptId},#{deptName},#{documentName},#{status},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{templateContent},#{formContent})
+        (#{siteId},#{deptId},#{deptName},#{documentName},#{status},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{templateContent},#{formContent},#{shortName})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_certificate_document
-        (siteId,deptId,deptName,documentName,status,createUserId,createTime,updateUserId,updateTime,templateContent,formContent)
+        (siteId,deptId,deptName,documentName,status,createUserId,createTime,updateUserId,updateTime,templateContent,formContent,shortName)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.deptId},#{item.deptName},#{item.documentName},#{item.status},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.templateContent},#{item.formContent})
+            (#{item.siteId},#{item.deptId},#{item.deptName},#{item.documentName},#{item.status},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.templateContent},#{item.formContent},#{item.shortName})
         </foreach>
     </insert>
 
@@ -132,6 +136,9 @@
             <if test="(colPickMode==0 and data.containsKey('formContent')) or (colPickMode==1 and !data.containsKey('formContent'))">
                 a.formContent=#{data.formContent},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('shortName')) or (colPickMode==1 and !data.containsKey('shortName'))">
+                a.shortName=#{data.shortName},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -246,6 +253,13 @@
                     </if>
                 </foreach>
             </trim>
+            <trim prefix="shortName=(case" suffix="ELSE shortName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('shortName')) or (colPickMode==1 and !item.containsKey('shortName'))">
+                        when a.id=#{item.id} then #{item.shortName}
+                    </if>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -642,6 +656,27 @@
                 #{item}
             </foreach>
         </if>
+
+        <if test="conditionParamRef.containsKey('shortName')">
+            <if test="conditionParamRef.shortName != null and conditionParamRef.shortName != ''">
+                ${_conditionType_} a.shortName like #{${_conditionParam_}.shortName}
+            </if>
+            <if test="conditionParamRef.shortName == null">
+                ${_conditionType_} a.shortName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('shortNameList') and conditionParamRef.shortNameList.size() > 0">
+            ${_conditionType_} a.shortName in
+            <foreach collection="conditionParamRef.shortNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('shortNameNotList') and conditionParamRef.shortNameNotList.size() > 0">
+            ${_conditionType_} a.shortName not in
+            <foreach collection="conditionParamRef.shortNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">
@@ -799,6 +834,11 @@
                     <if test='orderCol.formContent != null and "DESC".equalsIgnoreCase(orderCol.formContent)'>DESC</if>
                     ,
                 </if>
+                <if test="orderCol.containsKey('shortName')">
+                    a.shortName
+                    <if test='orderCol.shortName != null and "DESC".equalsIgnoreCase(orderCol.shortName)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>
 

one-certificate-manager/src/main/resources/sqlmap/module/child/ChildLicenseMapper.xml

@@ -42,6 +42,17 @@
         <result property="reportTime" column="reportTime" />
         <result property="createUserName" column="createUserName" />
         <result property="updateUserName" column="updateUserName" />
+        <result property="deleted" column="deleted" />
+        <result property="shortName" column="shortName" />
+        <result property="ext1" column="ext1" />
+        <result property="ext2" column="ext2" />
+        <result property="ext3" column="ext3" />
+        <result property="ext4" column="ext4" />
+        <result property="ext5" column="ext5" />
+        <result property="ext6" column="ext6" />
+        <result property="ext7" column="ext7" />
+        <result property="ext8" column="ext8" />
+        <result property="childStatus" column="childStatus" />
     </resultMap>
 
     <!-- 表所有列 -->
@@ -158,23 +169,56 @@
             <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
                 a.updateUserName,
             </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deleted') or colPickMode == 1 and data.containsKey('deleted')))">
+                a.deleted,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('shortName') or colPickMode == 1 and data.containsKey('shortName')))">
+                a.shortName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext1') or colPickMode == 1 and data.containsKey('ext1')))">
+                a.ext1,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext2') or colPickMode == 1 and data.containsKey('ext2')))">
+                a.ext2,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext3') or colPickMode == 1 and data.containsKey('ext3')))">
+                a.ext3,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext4') or colPickMode == 1 and data.containsKey('ext4')))">
+                a.ext4,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext5') or colPickMode == 1 and data.containsKey('ext5')))">
+                a.ext5,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext6') or colPickMode == 1 and data.containsKey('ext6')))">
+                a.ext6,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext7') or colPickMode == 1 and data.containsKey('ext7')))">
+                a.ext7,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ext8') or colPickMode == 1 and data.containsKey('ext8')))">
+                a.ext8,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('childStatus') or colPickMode == 1 and data.containsKey('childStatus')))">
+                a.childStatus,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="ChildLicenseEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_child_license
-        (siteId,siteName,catalogId,catalogName,applyId,documentId,documentName,deptId,deptName,marketEntityName,licenseCode,legalPersonName,creditCode,productLicenseTime,certQRCode,certAuthority,businessPlace,licensedItems,originalFileName,originalFilePath,copyFileName,copyFilePath,summary,formStyleContent,formContent,processStatus,remark,createTime,createUserId,updateUserId,updateTime,reportUserId,reportUserName,reportTime,createUserName,updateUserName)
+        (siteId,siteName,catalogId,catalogName,applyId,documentId,documentName,deptId,deptName,marketEntityName,licenseCode,legalPersonName,creditCode,productLicenseTime,certQRCode,certAuthority,businessPlace,licensedItems,originalFileName,originalFilePath,copyFileName,copyFilePath,summary,formStyleContent,formContent,processStatus,remark,createTime,createUserId,updateUserId,updateTime,reportUserId,reportUserName,reportTime,createUserName,updateUserName,deleted,shortName,ext1,ext2,ext3,ext4,ext5,ext6,ext7,ext8,childStatus)
         VALUES
-        (#{siteId},#{siteName},#{catalogId},#{catalogName},#{applyId},#{documentId},#{documentName},#{deptId},#{deptName},#{marketEntityName},#{licenseCode},#{legalPersonName},#{creditCode},#{productLicenseTime},#{certQRCode},#{certAuthority},#{businessPlace},#{licensedItems},#{originalFileName},#{originalFilePath},#{copyFileName},#{copyFilePath},#{summary},#{formStyleContent},#{formContent},#{processStatus},#{remark},#{createTime},#{createUserId},#{updateUserId},#{updateTime},#{reportUserId},#{reportUserName},#{reportTime},#{createUserName},#{updateUserName})
+        (#{siteId},#{siteName},#{catalogId},#{catalogName},#{applyId},#{documentId},#{documentName},#{deptId},#{deptName},#{marketEntityName},#{licenseCode},#{legalPersonName},#{creditCode},#{productLicenseTime},#{certQRCode},#{certAuthority},#{businessPlace},#{licensedItems},#{originalFileName},#{originalFilePath},#{copyFileName},#{copyFilePath},#{summary},#{formStyleContent},#{formContent},#{processStatus},#{remark},#{createTime},#{createUserId},#{updateUserId},#{updateTime},#{reportUserId},#{reportUserName},#{reportTime},#{createUserName},#{updateUserName},#{deleted},#{shortName},#{ext1},#{ext2},#{ext3},#{ext4},#{ext5},#{ext6},#{ext7},#{ext8},#{childStatus})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_child_license
-        (siteId,siteName,catalogId,catalogName,applyId,documentId,documentName,deptId,deptName,marketEntityName,licenseCode,legalPersonName,creditCode,productLicenseTime,certQRCode,certAuthority,businessPlace,licensedItems,originalFileName,originalFilePath,copyFileName,copyFilePath,summary,formStyleContent,formContent,processStatus,remark,createTime,createUserId,updateUserId,updateTime,reportUserId,reportUserName,reportTime,createUserName,updateUserName)
+        (siteId,siteName,catalogId,catalogName,applyId,documentId,documentName,deptId,deptName,marketEntityName,licenseCode,legalPersonName,creditCode,productLicenseTime,certQRCode,certAuthority,businessPlace,licensedItems,originalFileName,originalFilePath,copyFileName,copyFilePath,summary,formStyleContent,formContent,processStatus,remark,createTime,createUserId,updateUserId,updateTime,reportUserId,reportUserName,reportTime,createUserName,updateUserName,deleted,shortName,ext1,ext2,ext3,ext4,ext5,ext6,ext7,ext8,childStatus)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.siteName},#{item.catalogId},#{item.catalogName},#{item.applyId},#{item.documentId},#{item.documentName},#{item.deptId},#{item.deptName},#{item.marketEntityName},#{item.licenseCode},#{item.legalPersonName},#{item.creditCode},#{item.productLicenseTime},#{item.certQRCode},#{item.certAuthority},#{item.businessPlace},#{item.licensedItems},#{item.originalFileName},#{item.originalFilePath},#{item.copyFileName},#{item.copyFilePath},#{item.summary},#{item.formStyleContent},#{item.formContent},#{item.processStatus},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime},#{item.reportUserId},#{item.reportUserName},#{item.reportTime},#{item.createUserName},#{item.updateUserName})
+            (#{item.siteId},#{item.siteName},#{item.catalogId},#{item.catalogName},#{item.applyId},#{item.documentId},#{item.documentName},#{item.deptId},#{item.deptName},#{item.marketEntityName},#{item.licenseCode},#{item.legalPersonName},#{item.creditCode},#{item.productLicenseTime},#{item.certQRCode},#{item.certAuthority},#{item.businessPlace},#{item.licensedItems},#{item.originalFileName},#{item.originalFilePath},#{item.copyFileName},#{item.copyFilePath},#{item.summary},#{item.formStyleContent},#{item.formContent},#{item.processStatus},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime},#{item.reportUserId},#{item.reportUserName},#{item.reportTime},#{item.createUserName},#{item.updateUserName},#{item.deleted},#{item.shortName},#{item.ext1},#{item.ext2},#{item.ext3},#{item.ext4},#{item.ext5},#{item.ext6},#{item.ext7},#{item.ext8},#{item.childStatus})
         </foreach>
     </insert>
 
@@ -319,6 +363,45 @@
             <if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
                 a.updateUserName=#{data.updateUserName},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('deleted')) or (colPickMode==1 and !data.containsKey('deleted'))">
+                a.deleted=#{data.deleted},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('deletedIncrement')) or (colPickMode==1 and !data.containsKey('deletedIncrement'))">
+                a.deleted=ifnull(a.deleted,0) + #{data.deletedIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('shortName')) or (colPickMode==1 and !data.containsKey('shortName'))">
+                a.shortName=#{data.shortName},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext1')) or (colPickMode==1 and !data.containsKey('ext1'))">
+                a.ext1=#{data.ext1},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext2')) or (colPickMode==1 and !data.containsKey('ext2'))">
+                a.ext2=#{data.ext2},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext3')) or (colPickMode==1 and !data.containsKey('ext3'))">
+                a.ext3=#{data.ext3},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext4')) or (colPickMode==1 and !data.containsKey('ext4'))">
+                a.ext4=#{data.ext4},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext5')) or (colPickMode==1 and !data.containsKey('ext5'))">
+                a.ext5=#{data.ext5},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext6')) or (colPickMode==1 and !data.containsKey('ext6'))">
+                a.ext6=#{data.ext6},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext7')) or (colPickMode==1 and !data.containsKey('ext7'))">
+                a.ext7=#{data.ext7},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ext8')) or (colPickMode==1 and !data.containsKey('ext8'))">
+                a.ext8=#{data.ext8},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('childStatus')) or (colPickMode==1 and !data.containsKey('childStatus'))">
+                a.childStatus=#{data.childStatus},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('childStatusIncrement')) or (colPickMode==1 and !data.containsKey('childStatusIncrement'))">
+                a.childStatus=ifnull(a.childStatus,0) + #{data.childStatusIncrement},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -628,6 +711,93 @@
                     </if>
                 </foreach>
             </trim>
+            <trim prefix="deleted=(case" suffix="ELSE deleted end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('deleted')) or (colPickMode==1 and !item.containsKey('deleted'))">
+                            when a.id=#{item.id} then #{item.deleted}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('deletedIncrement')) or (colPickMode==1 and !item.containsKey('deletedIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.deleted,0) + #{item.deletedIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="shortName=(case" suffix="ELSE shortName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('shortName')) or (colPickMode==1 and !item.containsKey('shortName'))">
+                        when a.id=#{item.id} then #{item.shortName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext1=(case" suffix="ELSE ext1 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext1')) or (colPickMode==1 and !item.containsKey('ext1'))">
+                        when a.id=#{item.id} then #{item.ext1}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext2=(case" suffix="ELSE ext2 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext2')) or (colPickMode==1 and !item.containsKey('ext2'))">
+                        when a.id=#{item.id} then #{item.ext2}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext3=(case" suffix="ELSE ext3 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext3')) or (colPickMode==1 and !item.containsKey('ext3'))">
+                        when a.id=#{item.id} then #{item.ext3}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext4=(case" suffix="ELSE ext4 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext4')) or (colPickMode==1 and !item.containsKey('ext4'))">
+                        when a.id=#{item.id} then #{item.ext4}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext5=(case" suffix="ELSE ext5 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext5')) or (colPickMode==1 and !item.containsKey('ext5'))">
+                        when a.id=#{item.id} then #{item.ext5}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext6=(case" suffix="ELSE ext6 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext6')) or (colPickMode==1 and !item.containsKey('ext6'))">
+                        when a.id=#{item.id} then #{item.ext6}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext7=(case" suffix="ELSE ext7 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext7')) or (colPickMode==1 and !item.containsKey('ext7'))">
+                        when a.id=#{item.id} then #{item.ext7}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="ext8=(case" suffix="ELSE ext8 end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ext8')) or (colPickMode==1 and !item.containsKey('ext8'))">
+                        when a.id=#{item.id} then #{item.ext8}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="childStatus=(case" suffix="ELSE childStatus end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('childStatus')) or (colPickMode==1 and !item.containsKey('childStatus'))">
+                            when a.id=#{item.id} then #{item.childStatus}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('childStatusIncrement')) or (colPickMode==1 and !item.containsKey('childStatusIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.childStatus,0) + #{item.childStatusIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -1561,6 +1731,249 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('deleted')">
+            <if test="conditionParamRef.deleted != null ">
+                ${_conditionType_} a.deleted = #{${_conditionParam_}.deleted}
+            </if>
+            <if test="conditionParamRef.deleted == null">
+                ${_conditionType_} a.deleted is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('deletedList') and conditionParamRef.deletedList.size() > 0">
+            ${_conditionType_} a.deleted in
+            <foreach collection="conditionParamRef.deletedList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deletedNotList') and conditionParamRef.deletedNotList.size() > 0">
+            ${_conditionType_} a.deleted not in
+            <foreach collection="conditionParamRef.deletedNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deletedStart') and conditionParamRef.deletedStart != null">
+            ${_conditionType_} a.deleted <![CDATA[ >= ]]> #{${_conditionParam_}.deletedStart}
+        </if>
+        <if test="conditionParamRef.containsKey('deletedEnd') and conditionParamRef.deletedEnd != null">
+            ${_conditionType_} a.deleted <![CDATA[ <= ]]> #{${_conditionParam_}.deletedEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('shortName')">
+            <if test="conditionParamRef.shortName != null and conditionParamRef.shortName != ''">
+                ${_conditionType_} a.shortName like #{${_conditionParam_}.shortName}
+            </if>
+            <if test="conditionParamRef.shortName == null">
+                ${_conditionType_} a.shortName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('shortNameList') and conditionParamRef.shortNameList.size() > 0">
+            ${_conditionType_} a.shortName in
+            <foreach collection="conditionParamRef.shortNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('shortNameNotList') and conditionParamRef.shortNameNotList.size() > 0">
+            ${_conditionType_} a.shortName not in
+            <foreach collection="conditionParamRef.shortNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext1')">
+            <if test="conditionParamRef.ext1 != null and conditionParamRef.ext1 != ''">
+                ${_conditionType_} a.ext1 like #{${_conditionParam_}.ext1}
+            </if>
+            <if test="conditionParamRef.ext1 == null">
+                ${_conditionType_} a.ext1 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext1List') and conditionParamRef.ext1List.size() > 0">
+            ${_conditionType_} a.ext1 in
+            <foreach collection="conditionParamRef.ext1List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext1NotList') and conditionParamRef.ext1NotList.size() > 0">
+            ${_conditionType_} a.ext1 not in
+            <foreach collection="conditionParamRef.ext1NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext2')">
+            <if test="conditionParamRef.ext2 != null and conditionParamRef.ext2 != ''">
+                ${_conditionType_} a.ext2 like #{${_conditionParam_}.ext2}
+            </if>
+            <if test="conditionParamRef.ext2 == null">
+                ${_conditionType_} a.ext2 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext2List') and conditionParamRef.ext2List.size() > 0">
+            ${_conditionType_} a.ext2 in
+            <foreach collection="conditionParamRef.ext2List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext2NotList') and conditionParamRef.ext2NotList.size() > 0">
+            ${_conditionType_} a.ext2 not in
+            <foreach collection="conditionParamRef.ext2NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext3')">
+            <if test="conditionParamRef.ext3 != null and conditionParamRef.ext3 != ''">
+                ${_conditionType_} a.ext3 like #{${_conditionParam_}.ext3}
+            </if>
+            <if test="conditionParamRef.ext3 == null">
+                ${_conditionType_} a.ext3 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext3List') and conditionParamRef.ext3List.size() > 0">
+            ${_conditionType_} a.ext3 in
+            <foreach collection="conditionParamRef.ext3List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext3NotList') and conditionParamRef.ext3NotList.size() > 0">
+            ${_conditionType_} a.ext3 not in
+            <foreach collection="conditionParamRef.ext3NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext4')">
+            <if test="conditionParamRef.ext4 != null and conditionParamRef.ext4 != ''">
+                ${_conditionType_} a.ext4 like #{${_conditionParam_}.ext4}
+            </if>
+            <if test="conditionParamRef.ext4 == null">
+                ${_conditionType_} a.ext4 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext4List') and conditionParamRef.ext4List.size() > 0">
+            ${_conditionType_} a.ext4 in
+            <foreach collection="conditionParamRef.ext4List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext4NotList') and conditionParamRef.ext4NotList.size() > 0">
+            ${_conditionType_} a.ext4 not in
+            <foreach collection="conditionParamRef.ext4NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext5')">
+            <if test="conditionParamRef.ext5 != null and conditionParamRef.ext5 != ''">
+                ${_conditionType_} a.ext5 like #{${_conditionParam_}.ext5}
+            </if>
+            <if test="conditionParamRef.ext5 == null">
+                ${_conditionType_} a.ext5 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext5List') and conditionParamRef.ext5List.size() > 0">
+            ${_conditionType_} a.ext5 in
+            <foreach collection="conditionParamRef.ext5List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext5NotList') and conditionParamRef.ext5NotList.size() > 0">
+            ${_conditionType_} a.ext5 not in
+            <foreach collection="conditionParamRef.ext5NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext6')">
+            <if test="conditionParamRef.ext6 != null and conditionParamRef.ext6 != ''">
+                ${_conditionType_} a.ext6 like #{${_conditionParam_}.ext6}
+            </if>
+            <if test="conditionParamRef.ext6 == null">
+                ${_conditionType_} a.ext6 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext6List') and conditionParamRef.ext6List.size() > 0">
+            ${_conditionType_} a.ext6 in
+            <foreach collection="conditionParamRef.ext6List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext6NotList') and conditionParamRef.ext6NotList.size() > 0">
+            ${_conditionType_} a.ext6 not in
+            <foreach collection="conditionParamRef.ext6NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext7')">
+            <if test="conditionParamRef.ext7 != null and conditionParamRef.ext7 != ''">
+                ${_conditionType_} a.ext7 like #{${_conditionParam_}.ext7}
+            </if>
+            <if test="conditionParamRef.ext7 == null">
+                ${_conditionType_} a.ext7 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext7List') and conditionParamRef.ext7List.size() > 0">
+            ${_conditionType_} a.ext7 in
+            <foreach collection="conditionParamRef.ext7List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext7NotList') and conditionParamRef.ext7NotList.size() > 0">
+            ${_conditionType_} a.ext7 not in
+            <foreach collection="conditionParamRef.ext7NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ext8')">
+            <if test="conditionParamRef.ext8 != null and conditionParamRef.ext8 != ''">
+                ${_conditionType_} a.ext8 like #{${_conditionParam_}.ext8}
+            </if>
+            <if test="conditionParamRef.ext8 == null">
+                ${_conditionType_} a.ext8 is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ext8List') and conditionParamRef.ext8List.size() > 0">
+            ${_conditionType_} a.ext8 in
+            <foreach collection="conditionParamRef.ext8List" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ext8NotList') and conditionParamRef.ext8NotList.size() > 0">
+            ${_conditionType_} a.ext8 not in
+            <foreach collection="conditionParamRef.ext8NotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('childStatus')">
+            <if test="conditionParamRef.childStatus != null ">
+                ${_conditionType_} a.childStatus = #{${_conditionParam_}.childStatus}
+            </if>
+            <if test="conditionParamRef.childStatus == null">
+                ${_conditionType_} a.childStatus is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('childStatusList') and conditionParamRef.childStatusList.size() > 0">
+            ${_conditionType_} a.childStatus in
+            <foreach collection="conditionParamRef.childStatusList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('childStatusNotList') and conditionParamRef.childStatusNotList.size() > 0">
+            ${_conditionType_} a.childStatus not in
+            <foreach collection="conditionParamRef.childStatusNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('childStatusStart') and conditionParamRef.childStatusStart != null">
+            ${_conditionType_} a.childStatus <![CDATA[ >= ]]> #{${_conditionParam_}.childStatusStart}
+        </if>
+        <if test="conditionParamRef.containsKey('childStatusEnd') and conditionParamRef.childStatusEnd != null">
+            ${_conditionType_} a.childStatus <![CDATA[ <= ]]> #{${_conditionParam_}.childStatusEnd}
+        </if>
+
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">
@@ -1635,6 +2048,20 @@
                 </foreach>
                 ,
             </if>
+            <if test="conditionParamRef.containsKey('deletedList') and conditionParamRef.deletedList.size() > 0">
+                field(a.deleted,
+                <foreach collection="conditionParamRef.deletedList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('childStatusList') and conditionParamRef.childStatusList.size() > 0">
+                field(a.childStatus,
+                <foreach collection="conditionParamRef.childStatusList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
             <trim suffixOverrides=","  suffix="">
                 <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
                     a.${item.colName} ${item.sortKind}
@@ -1713,6 +2140,20 @@
                 </foreach>
                 ,
             </if>
+            <if test="conditionParamRef.containsKey('deletedList') and conditionParamRef.deletedList.size() > 0">
+                field(a.deleted,
+                <foreach collection="conditionParamRef.deletedList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('childStatusList') and conditionParamRef.childStatusList.size() > 0">
+                field(a.childStatus,
+                <foreach collection="conditionParamRef.childStatusList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
             <trim suffixOverrides=","  suffix="">
                 <if test="orderCol.containsKey('id')">
                     a.id
@@ -1899,6 +2340,61 @@
                     <if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
                     ,
                 </if>
+                <if test="orderCol.containsKey('deleted')">
+                    a.deleted
+                    <if test='orderCol.deleted != null and "DESC".equalsIgnoreCase(orderCol.deleted)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('shortName')">
+                    a.shortName
+                    <if test='orderCol.shortName != null and "DESC".equalsIgnoreCase(orderCol.shortName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext1')">
+                    a.ext1
+                    <if test='orderCol.ext1 != null and "DESC".equalsIgnoreCase(orderCol.ext1)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext2')">
+                    a.ext2
+                    <if test='orderCol.ext2 != null and "DESC".equalsIgnoreCase(orderCol.ext2)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext3')">
+                    a.ext3
+                    <if test='orderCol.ext3 != null and "DESC".equalsIgnoreCase(orderCol.ext3)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext4')">
+                    a.ext4
+                    <if test='orderCol.ext4 != null and "DESC".equalsIgnoreCase(orderCol.ext4)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext5')">
+                    a.ext5
+                    <if test='orderCol.ext5 != null and "DESC".equalsIgnoreCase(orderCol.ext5)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext6')">
+                    a.ext6
+                    <if test='orderCol.ext6 != null and "DESC".equalsIgnoreCase(orderCol.ext6)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext7')">
+                    a.ext7
+                    <if test='orderCol.ext7 != null and "DESC".equalsIgnoreCase(orderCol.ext7)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ext8')">
+                    a.ext8
+                    <if test='orderCol.ext8 != null and "DESC".equalsIgnoreCase(orderCol.ext8)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('childStatus')">
+                    a.childStatus
+                    <if test='orderCol.childStatus != null and "DESC".equalsIgnoreCase(orderCol.childStatus)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>