Merge branch 'master' of http://gitlab.scsmile.cn/zxf/smart_gov_platform

base-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterQuery.java

@@ -8,7 +8,7 @@ import com.mortals.xhx.module.matter.model.MatterEntity;
  * 基础事项查询对象
  *
  * @author zxfei
- * @date 2022-12-28
+ * @date 2023-02-20
  */
 public class MatterQuery extends MatterEntity {
     /** 开始 序号，主键，自增长 */
@@ -23,6 +23,9 @@ public class MatterQuery extends MatterEntity {
     /** 序号，主键，自增长列表 */
     private List <Long> idList;
 
+    /** 序号，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
     /** 开始 站点ID */
     private Long siteIdStart;
 
@@ -35,84 +38,139 @@ public class MatterQuery extends MatterEntity {
     /** 站点ID列表 */
     private List <Long> siteIdList;
 
+    /** 站点ID排除列表 */
+    private List <Long> siteIdNotList;
+
     /** 从政务系统来的事项id */
     private List<String> tidList;
 
+    /** 从政务系统来的事项id排除列表 */
+    private List <String> tidNotList;
     /** 从政务系统来的事项code */
     private List<String> tcodeList;
 
+    /** 从政务系统来的事项code排除列表 */
+    private List <String> tcodeNotList;
     /** 从政务系统来的事项name */
     private List<String> tnameList;
 
+    /** 从政务系统来的事项name排除列表 */
+    private List <String> tnameNotList;
     /** 事项名称 */
     private List<String> matterNameList;
 
+    /** 事项名称排除列表 */
+    private List <String> matterNameNotList;
     /** 英语事项名 */
     private List<String> englishNameList;
 
+    /** 英语事项名排除列表 */
+    private List <String> englishNameNotList;
     /** 事项编号 */
     private List<String> matterNoList;
 
+    /** 事项编号排除列表 */
+    private List <String> matterNoNotList;
     /** 区域编码 */
     private List<String> areaCodeList;
 
+    /** 区域编码排除列表 */
+    private List <String> areaCodeNotList;
     /** 部门编号 */
     private List<String> deptCodeList;
 
+    /** 部门编号排除列表 */
+    private List <String> deptCodeNotList;
     /** 部门名称 */
     private List<String> deptNameList;
 
+    /** 部门名称排除列表 */
+    private List <String> deptNameNotList;
     /** 行政权力编号 */
     private List<String> powerCodeList;
 
+    /** 行政权力编号排除列表 */
+    private List <String> powerCodeNotList;
     /** 主题编号 */
     private List<String> themeCodeList;
 
+    /** 主题编号排除列表 */
+    private List <String> themeCodeNotList;
     /** 服务类型编号 */
     private List<String> usertypeCodeList;
 
+    /** 服务类型编号排除列表 */
+    private List <String> usertypeCodeNotList;
     /** 事项组名 */
     private List<String> groupNameList;
 
+    /** 事项组名排除列表 */
+    private List <String> groupNameNotList;
     /** 事项详情链接 */
     private List<String> urlList;
 
+    /** 事项详情链接排除列表 */
+    private List <String> urlNotList;
     /** 是否获取事项详情 */
     private List<String> haveGetMatterInfoList;
 
+    /** 是否获取事项详情排除列表 */
+    private List <String> haveGetMatterInfoNotList;
     /** 所属部门 */
     private List<String> belongDeptList;
 
+    /** 所属部门排除列表 */
+    private List <String> belongDeptNotList;
     /** 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织） */
     private List<String> appoveObjectShowList;
 
+    /** 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）排除列表 */
+    private List <String> appoveObjectShowNotList;
     /** 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]） */
     private List<String> operatScopeShowList;
 
+    /** 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）排除列表 */
+    private List <String> operatScopeShowNotList;
     /** 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件） */
     private List<String> appoveTimeLimitShowList;
 
+    /** 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）排除列表 */
+    private List <String> appoveTimeLimitShowNotList;
     /** 办理形式（窗口办理.窗口办理，网上办理.网上办理）	 */
     private List<String> handleTypeList;
 
+    /** 办理形式（窗口办理.窗口办理，网上办理.网上办理）	排除列表 */
+    private List <String> handleTypeNotList;
     /** 法定办结时限 */
     private List<String> legalTimeLimitShowList;
 
+    /** 法定办结时限排除列表 */
+    private List <String> legalTimeLimitShowNotList;
     /** 法定时限办结说明 */
     private List<String> legalEndExplainList;
 
+    /** 法定时限办结说明排除列表 */
+    private List <String> legalEndExplainNotList;
     /** 承诺办结时限 */
     private List<String> promiseTimeLimitShowList;
 
+    /** 承诺办结时限排除列表 */
+    private List <String> promiseTimeLimitShowNotList;
     /** 承诺时限办结说明 */
     private List<String> promiseEndExplainList;
 
+    /** 承诺时限办结说明排除列表 */
+    private List <String> promiseEndExplainNotList;
     /** 是否收费（否.否，是.是） */
     private List<String> isChargesShowList;
 
+    /** 是否收费（否.否，是.是）排除列表 */
+    private List <String> isChargesShowNotList;
     /** 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签） */
     private List<String> certificationLevelsShowList;
 
+    /** 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）排除列表 */
+    private List <String> certificationLevelsShowNotList;
     /** 开始 计划生效日期 */
     private String planTakeTimeStart;
 
@@ -128,6 +186,8 @@ public class MatterQuery extends MatterEntity {
     /** 特别程序 */
     private List<String> specialProcedureList;
 
+    /** 特别程序排除列表 */
+    private List <String> specialProcedureNotList;
     /** 开始 窗口到现场次数 */
     private Integer windowToTheSceneNumStart;
 
@@ -140,24 +200,39 @@ public class MatterQuery extends MatterEntity {
     /** 窗口到现场次数列表 */
     private List <Integer> windowToTheSceneNumList;
 
+    /** 窗口到现场次数排除列表 */
+    private List <Integer> windowToTheSceneNumNotList;
+
     /** 是否网上预约,窗口办理选（否.否，是.是） */
     private List<String> isOnlineSubscribeShowList;
 
+    /** 是否网上预约,窗口办理选（否.否，是.是）排除列表 */
+    private List <String> isOnlineSubscribeShowNotList;
     /** 物流快递,窗口办理选（否.否，是.是） */
     private List<String> isExpressTakeShowList;
 
+    /** 物流快递,窗口办理选（否.否，是.是）排除列表 */
+    private List <String> isExpressTakeShowNotList;
     /** 是否支持全省范围就近取件（否.否，是.是） */
     private List<String> isProvinceAcquisitionShowList;
 
+    /** 是否支持全省范围就近取件（否.否，是.是）排除列表 */
+    private List <String> isProvinceAcquisitionShowNotList;
     /** 是否支持全省范围就近办理（否.否，是.是） */
     private List<String> isApplyProvinceShowList;
 
+    /** 是否支持全省范围就近办理（否.否，是.是）排除列表 */
+    private List <String> isApplyProvinceShowNotList;
     /** 必须到现场原因 */
     private List<String> mustSceneExplainList;
 
+    /** 必须到现场原因排除列表 */
+    private List <String> mustSceneExplainNotList;
     /** 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办） */
     private List<String> onlineTypeList;
 
+    /** 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）排除列表 */
+    private List <String> onlineTypeNotList;
     /** 开始 网办到现场次数 */
     private Integer onlineToTheSceneNumStart;
 
@@ -170,60 +245,99 @@ public class MatterQuery extends MatterEntity {
     /** 网办到现场次数列表 */
     private List <Integer> onlineToTheSceneNumList;
 
+    /** 网办到现场次数排除列表 */
+    private List <Integer> onlineToTheSceneNumNotList;
+
     /** 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他） */
     private List<String> onlineOperatDeepList;
 
+    /** 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）排除列表 */
+    private List <String> onlineOperatDeepNotList;
     /** 物流快递，网上办理选（否.否，是.是） */
     private List<String> isExpressTakeOnlineShowList;
 
+    /** 物流快递，网上办理选（否.否，是.是）排除列表 */
+    private List <String> isExpressTakeOnlineShowNotList;
     /** 是否支持上门收取申请（否.否，是.是） */
     private List<String> isDoorTakeShowList;
 
+    /** 是否支持上门收取申请（否.否，是.是）排除列表 */
+    private List <String> isDoorTakeShowNotList;
     /** 网上必须到现场原因 */
     private List<String> onlineMustSceneExplainList;
 
+    /** 网上必须到现场原因排除列表 */
+    private List <String> onlineMustSceneExplainNotList;
     /** 实施主体 */
     private List<String> performDeptTypeList;
 
+    /** 实施主体排除列表 */
+    private List <String> performDeptTypeNotList;
     /** 事项版本 */
     private List<String> matterEditionList;
 
+    /** 事项版本排除列表 */
+    private List <String> matterEditionNotList;
     /** 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项） */
     private List<String> eventTypeShowList;
 
+    /** 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）排除列表 */
+    private List <String> eventTypeShowNotList;
     /** 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级） */
     private List<String> performHierarchyShowList;
 
+    /** 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）排除列表 */
+    private List <String> performHierarchyShowNotList;
     /** 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托） */
     private List<String> powerSourceShowList;
 
+    /** 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）排除列表 */
+    private List <String> powerSourceShowNotList;
     /** 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织） */
     private List<String> performDeptTypeShowList;
 
+    /** 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）排除列表 */
+    private List <String> performDeptTypeShowNotList;
     /** 是否进驻中心（否.否，是.是） */
     private List<String> goveServiceCenterShowList;
 
+    /** 是否进驻中心（否.否，是.是）排除列表 */
+    private List <String> goveServiceCenterShowNotList;
     /** 是否纳入便民服务中心（否.否，是.是） */
     private List<String> isConvenientCenterShowList;
 
+    /** 是否纳入便民服务中心（否.否，是.是）排除列表 */
+    private List <String> isConvenientCenterShowNotList;
     /** 自助终端办理 （否.否，是.是） */
     private List<String> terminalHandleList;
 
+    /** 自助终端办理 （否.否，是.是）排除列表 */
+    private List <String> terminalHandleNotList;
     /** 是否网办 （否.否，是.是） */
     private List<String> isOnlineList;
 
+    /** 是否网办 （否.否，是.是）排除列表 */
+    private List <String> isOnlineNotList;
     /** 支持网上支付（否.否，是.是） */
     private List<String> isOnlinePayShowList;
 
+    /** 支持网上支付（否.否，是.是）排除列表 */
+    private List <String> isOnlinePayShowNotList;
     /** 委托部门（否.否，是.是） */
     private List<String> entrustmentDepartmenList;
 
+    /** 委托部门（否.否，是.是）排除列表 */
+    private List <String> entrustmentDepartmenNotList;
     /** 联办机构 */
     private List<String> jointInfoShowList;
 
+    /** 联办机构排除列表 */
+    private List <String> jointInfoShowNotList;
     /** 事项状态（停用.停用，在用.在用） */
     private List<String> matterStatusList;
 
+    /** 事项状态（停用.停用，在用.在用）排除列表 */
+    private List <String> matterStatusNotList;
     /** 开始 数量限制 */
     private Long numberLimitStart;
 
@@ -236,48 +350,79 @@ public class MatterQuery extends MatterEntity {
     /** 数量限制列表 */
     private List <Long> numberLimitList;
 
+    /** 数量限制排除列表 */
+    private List <Long> numberLimitNotList;
+
     /** 主题类型 */
     private List<String> typeList;
 
+    /** 主题类型排除列表 */
+    private List <String> typeNotList;
     /** 基本编码 */
     private List<String> baseCodeList;
 
+    /** 基本编码排除列表 */
+    private List <String> baseCodeNotList;
     /** 实施编码 */
     private List<String> implementCodeList;
 
+    /** 实施编码排除列表 */
+    private List <String> implementCodeNotList;
     /** 实施主体编码 */
     private List<String> implementBodyCodeList;
 
+    /** 实施主体编码排除列表 */
+    private List <String> implementBodyCodeNotList;
     /** 办理项编码 */
     private List<String> operateItemCodeList;
 
+    /** 办理项编码排除列表 */
+    private List <String> operateItemCodeNotList;
     /** 乡镇街道名称 */
     private List<String> townshipNameList;
 
+    /** 乡镇街道名称排除列表 */
+    private List <String> townshipNameNotList;
     /** 乡镇街道代码 */
     private List<String> townshipCodeList;
 
+    /** 乡镇街道代码排除列表 */
+    private List <String> townshipCodeNotList;
     /** 村居社区名称 */
     private List<String> villageNameList;
 
+    /** 村居社区名称排除列表 */
+    private List <String> villageNameNotList;
     /** 村居社区代码 */
     private List<String> villageCodeList;
 
+    /** 村居社区代码排除列表 */
+    private List <String> villageCodeNotList;
     /** 办理时间 */
     private List<String> operateTimeList;
 
+    /** 办理时间排除列表 */
+    private List <String> operateTimeNotList;
     /** 办理地点 */
     private List<String> operateSiteList;
 
+    /** 办理地点排除列表 */
+    private List <String> operateSiteNotList;
     /** 咨询方式 */
     private List<String> cousultingShowList;
 
+    /** 咨询方式排除列表 */
+    private List <String> cousultingShowNotList;
     /** 咨询电话 */
     private List<String> cousultingTelephoneShowList;
 
+    /** 咨询电话排除列表 */
+    private List <String> cousultingTelephoneShowNotList;
     /** 监督投诉方式 */
     private List<String> superviseShowList;
 
+    /** 监督投诉方式排除列表 */
+    private List <String> superviseShowNotList;
     /** 开始 排序 */
     private Integer sortStart;
 
@@ -290,6 +435,9 @@ public class MatterQuery extends MatterEntity {
     /** 排序列表 */
     private List <Integer> sortList;
 
+    /** 排序排除列表 */
+    private List <Integer> sortNotList;
+
     /** 开始 事项来源(0.政务网，1.自定义) */
     private Integer sourceStart;
 
@@ -302,6 +450,9 @@ public class MatterQuery extends MatterEntity {
     /** 事项来源(0.政务网，1.自定义)列表 */
     private List <Integer> sourceList;
 
+    /** 事项来源(0.政务网，1.自定义)排除列表 */
+    private List <Integer> sourceNotList;
+
     /** 开始 创建时间 */
     private String createTimeStart;
 
@@ -320,6 +471,9 @@ public class MatterQuery extends MatterEntity {
     /** 创建用户列表 */
     private List <Long> createUserIdList;
 
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
     /** 开始 修改时间 */
     private String updateTimeStart;
 
@@ -329,9 +483,13 @@ public class MatterQuery extends MatterEntity {
     /** 评价地址 */
     private List<String> evaluationUrlList;
 
+    /** 评价地址排除列表 */
+    private List <String> evaluationUrlNotList;
     /** 申请地址 */
     private List<String> netApplyUrlList;
 
+    /** 申请地址排除列表 */
+    private List <String> netApplyUrlNotList;
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<MatterQuery> orConditionList;
 
@@ -404,6 +562,23 @@ public class MatterQuery extends MatterEntity {
         this.idList = idList;
     }
 
+    /**
+     * 获取 序号，主键，自增长
+     * @return idNotList
+     */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
     /**
      * 获取 开始 站点ID
      * @return siteIdStart
@@ -468,6 +643,23 @@ public class MatterQuery extends MatterEntity {
         this.siteIdList = siteIdList;
     }
 
+    /**
+     * 获取 站点ID
+     * @return siteIdNotList
+     */
+    public List<Long> getSiteIdNotList(){
+        return this.siteIdNotList;
+    }
+
+    /**
+     * 设置 站点ID
+     * @param siteIdNotList
+     */
+    public void setSiteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+    }
+
+
     /**
      * 获取 从政务系统来的事项id
      * @return tidList
@@ -483,6 +675,23 @@ public class MatterQuery extends MatterEntity {
     public void setTidList(List<String> tidList){
         this.tidList = tidList;
     }
+
+    /**
+     * 获取 从政务系统来的事项id
+     * @return tidNotList
+     */
+    public List<String> getTidNotList(){
+        return this.tidNotList;
+    }
+
+    /**
+     * 设置 从政务系统来的事项id
+     * @param tidNotList
+     */
+    public void setTidNotList(List<String> tidNotList){
+        this.tidNotList = tidNotList;
+    }
+
     /**
      * 获取 从政务系统来的事项code
      * @return tcodeList
@@ -498,6 +707,23 @@ public class MatterQuery extends MatterEntity {
     public void setTcodeList(List<String> tcodeList){
         this.tcodeList = tcodeList;
     }
+
+    /**
+     * 获取 从政务系统来的事项code
+     * @return tcodeNotList
+     */
+    public List<String> getTcodeNotList(){
+        return this.tcodeNotList;
+    }
+
+    /**
+     * 设置 从政务系统来的事项code
+     * @param tcodeNotList
+     */
+    public void setTcodeNotList(List<String> tcodeNotList){
+        this.tcodeNotList = tcodeNotList;
+    }
+
     /**
      * 获取 从政务系统来的事项name
      * @return tnameList
@@ -513,6 +739,23 @@ public class MatterQuery extends MatterEntity {
     public void setTnameList(List<String> tnameList){
         this.tnameList = tnameList;
     }
+
+    /**
+     * 获取 从政务系统来的事项name
+     * @return tnameNotList
+     */
+    public List<String> getTnameNotList(){
+        return this.tnameNotList;
+    }
+
+    /**
+     * 设置 从政务系统来的事项name
+     * @param tnameNotList
+     */
+    public void setTnameNotList(List<String> tnameNotList){
+        this.tnameNotList = tnameNotList;
+    }
+
     /**
      * 获取 事项名称
      * @return matterNameList
@@ -528,6 +771,23 @@ public class MatterQuery extends MatterEntity {
     public void setMatterNameList(List<String> matterNameList){
         this.matterNameList = matterNameList;
     }
+
+    /**
+     * 获取 事项名称
+     * @return matterNameNotList
+     */
+    public List<String> getMatterNameNotList(){
+        return this.matterNameNotList;
+    }
+
+    /**
+     * 设置 事项名称
+     * @param matterNameNotList
+     */
+    public void setMatterNameNotList(List<String> matterNameNotList){
+        this.matterNameNotList = matterNameNotList;
+    }
+
     /**
      * 获取 英语事项名
      * @return englishNameList
@@ -543,6 +803,23 @@ public class MatterQuery extends MatterEntity {
     public void setEnglishNameList(List<String> englishNameList){
         this.englishNameList = englishNameList;
     }
+
+    /**
+     * 获取 英语事项名
+     * @return englishNameNotList
+     */
+    public List<String> getEnglishNameNotList(){
+        return this.englishNameNotList;
+    }
+
+    /**
+     * 设置 英语事项名
+     * @param englishNameNotList
+     */
+    public void setEnglishNameNotList(List<String> englishNameNotList){
+        this.englishNameNotList = englishNameNotList;
+    }
+
     /**
      * 获取 事项编号
      * @return matterNoList
@@ -558,6 +835,23 @@ public class MatterQuery extends MatterEntity {
     public void setMatterNoList(List<String> matterNoList){
         this.matterNoList = matterNoList;
     }
+
+    /**
+     * 获取 事项编号
+     * @return matterNoNotList
+     */
+    public List<String> getMatterNoNotList(){
+        return this.matterNoNotList;
+    }
+
+    /**
+     * 设置 事项编号
+     * @param matterNoNotList
+     */
+    public void setMatterNoNotList(List<String> matterNoNotList){
+        this.matterNoNotList = matterNoNotList;
+    }
+
     /**
      * 获取 区域编码
      * @return areaCodeList
@@ -573,6 +867,23 @@ public class MatterQuery extends MatterEntity {
     public void setAreaCodeList(List<String> areaCodeList){
         this.areaCodeList = areaCodeList;
     }
+
+    /**
+     * 获取 区域编码
+     * @return areaCodeNotList
+     */
+    public List<String> getAreaCodeNotList(){
+        return this.areaCodeNotList;
+    }
+
+    /**
+     * 设置 区域编码
+     * @param areaCodeNotList
+     */
+    public void setAreaCodeNotList(List<String> areaCodeNotList){
+        this.areaCodeNotList = areaCodeNotList;
+    }
+
     /**
      * 获取 部门编号
      * @return deptCodeList
@@ -588,6 +899,23 @@ public class MatterQuery extends MatterEntity {
     public void setDeptCodeList(List<String> deptCodeList){
         this.deptCodeList = deptCodeList;
     }
+
+    /**
+     * 获取 部门编号
+     * @return deptCodeNotList
+     */
+    public List<String> getDeptCodeNotList(){
+        return this.deptCodeNotList;
+    }
+
+    /**
+     * 设置 部门编号
+     * @param deptCodeNotList
+     */
+    public void setDeptCodeNotList(List<String> deptCodeNotList){
+        this.deptCodeNotList = deptCodeNotList;
+    }
+
     /**
      * 获取 部门名称
      * @return deptNameList
@@ -603,6 +931,23 @@ public class MatterQuery extends MatterEntity {
     public void setDeptNameList(List<String> deptNameList){
         this.deptNameList = deptNameList;
     }
+
+    /**
+     * 获取 部门名称
+     * @return deptNameNotList
+     */
+    public List<String> getDeptNameNotList(){
+        return this.deptNameNotList;
+    }
+
+    /**
+     * 设置 部门名称
+     * @param deptNameNotList
+     */
+    public void setDeptNameNotList(List<String> deptNameNotList){
+        this.deptNameNotList = deptNameNotList;
+    }
+
     /**
      * 获取 行政权力编号
      * @return powerCodeList
@@ -618,6 +963,23 @@ public class MatterQuery extends MatterEntity {
     public void setPowerCodeList(List<String> powerCodeList){
         this.powerCodeList = powerCodeList;
     }
+
+    /**
+     * 获取 行政权力编号
+     * @return powerCodeNotList
+     */
+    public List<String> getPowerCodeNotList(){
+        return this.powerCodeNotList;
+    }
+
+    /**
+     * 设置 行政权力编号
+     * @param powerCodeNotList
+     */
+    public void setPowerCodeNotList(List<String> powerCodeNotList){
+        this.powerCodeNotList = powerCodeNotList;
+    }
+
     /**
      * 获取 主题编号
      * @return themeCodeList
@@ -633,6 +995,23 @@ public class MatterQuery extends MatterEntity {
     public void setThemeCodeList(List<String> themeCodeList){
         this.themeCodeList = themeCodeList;
     }
+
+    /**
+     * 获取 主题编号
+     * @return themeCodeNotList
+     */
+    public List<String> getThemeCodeNotList(){
+        return this.themeCodeNotList;
+    }
+
+    /**
+     * 设置 主题编号
+     * @param themeCodeNotList
+     */
+    public void setThemeCodeNotList(List<String> themeCodeNotList){
+        this.themeCodeNotList = themeCodeNotList;
+    }
+
     /**
      * 获取 服务类型编号
      * @return usertypeCodeList
@@ -648,6 +1027,23 @@ public class MatterQuery extends MatterEntity {
     public void setUsertypeCodeList(List<String> usertypeCodeList){
         this.usertypeCodeList = usertypeCodeList;
     }
+
+    /**
+     * 获取 服务类型编号
+     * @return usertypeCodeNotList
+     */
+    public List<String> getUsertypeCodeNotList(){
+        return this.usertypeCodeNotList;
+    }
+
+    /**
+     * 设置 服务类型编号
+     * @param usertypeCodeNotList
+     */
+    public void setUsertypeCodeNotList(List<String> usertypeCodeNotList){
+        this.usertypeCodeNotList = usertypeCodeNotList;
+    }
+
     /**
      * 获取 事项组名
      * @return groupNameList
@@ -663,6 +1059,23 @@ public class MatterQuery extends MatterEntity {
     public void setGroupNameList(List<String> groupNameList){
         this.groupNameList = groupNameList;
     }
+
+    /**
+     * 获取 事项组名
+     * @return groupNameNotList
+     */
+    public List<String> getGroupNameNotList(){
+        return this.groupNameNotList;
+    }
+
+    /**
+     * 设置 事项组名
+     * @param groupNameNotList
+     */
+    public void setGroupNameNotList(List<String> groupNameNotList){
+        this.groupNameNotList = groupNameNotList;
+    }
+
     /**
      * 获取 事项详情链接
      * @return urlList
@@ -678,6 +1091,23 @@ public class MatterQuery extends MatterEntity {
     public void setUrlList(List<String> urlList){
         this.urlList = urlList;
     }
+
+    /**
+     * 获取 事项详情链接
+     * @return urlNotList
+     */
+    public List<String> getUrlNotList(){
+        return this.urlNotList;
+    }
+
+    /**
+     * 设置 事项详情链接
+     * @param urlNotList
+     */
+    public void setUrlNotList(List<String> urlNotList){
+        this.urlNotList = urlNotList;
+    }
+
     /**
      * 获取 是否获取事项详情
      * @return haveGetMatterInfoList
@@ -693,6 +1123,23 @@ public class MatterQuery extends MatterEntity {
     public void setHaveGetMatterInfoList(List<String> haveGetMatterInfoList){
         this.haveGetMatterInfoList = haveGetMatterInfoList;
     }
+
+    /**
+     * 获取 是否获取事项详情
+     * @return haveGetMatterInfoNotList
+     */
+    public List<String> getHaveGetMatterInfoNotList(){
+        return this.haveGetMatterInfoNotList;
+    }
+
+    /**
+     * 设置 是否获取事项详情
+     * @param haveGetMatterInfoNotList
+     */
+    public void setHaveGetMatterInfoNotList(List<String> haveGetMatterInfoNotList){
+        this.haveGetMatterInfoNotList = haveGetMatterInfoNotList;
+    }
+
     /**
      * 获取 所属部门
      * @return belongDeptList
@@ -708,6 +1155,23 @@ public class MatterQuery extends MatterEntity {
     public void setBelongDeptList(List<String> belongDeptList){
         this.belongDeptList = belongDeptList;
     }
+
+    /**
+     * 获取 所属部门
+     * @return belongDeptNotList
+     */
+    public List<String> getBelongDeptNotList(){
+        return this.belongDeptNotList;
+    }
+
+    /**
+     * 设置 所属部门
+     * @param belongDeptNotList
+     */
+    public void setBelongDeptNotList(List<String> belongDeptNotList){
+        this.belongDeptNotList = belongDeptNotList;
+    }
+
     /**
      * 获取 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
      * @return appoveObjectShowList
@@ -723,6 +1187,23 @@ public class MatterQuery extends MatterEntity {
     public void setAppoveObjectShowList(List<String> appoveObjectShowList){
         this.appoveObjectShowList = appoveObjectShowList;
     }
+
+    /**
+     * 获取 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
+     * @return appoveObjectShowNotList
+     */
+    public List<String> getAppoveObjectShowNotList(){
+        return this.appoveObjectShowNotList;
+    }
+
+    /**
+     * 设置 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
+     * @param appoveObjectShowNotList
+     */
+    public void setAppoveObjectShowNotList(List<String> appoveObjectShowNotList){
+        this.appoveObjectShowNotList = appoveObjectShowNotList;
+    }
+
     /**
      * 获取 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
      * @return operatScopeShowList
@@ -738,6 +1219,23 @@ public class MatterQuery extends MatterEntity {
     public void setOperatScopeShowList(List<String> operatScopeShowList){
         this.operatScopeShowList = operatScopeShowList;
     }
+
+    /**
+     * 获取 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
+     * @return operatScopeShowNotList
+     */
+    public List<String> getOperatScopeShowNotList(){
+        return this.operatScopeShowNotList;
+    }
+
+    /**
+     * 设置 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
+     * @param operatScopeShowNotList
+     */
+    public void setOperatScopeShowNotList(List<String> operatScopeShowNotList){
+        this.operatScopeShowNotList = operatScopeShowNotList;
+    }
+
     /**
      * 获取 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
      * @return appoveTimeLimitShowList
@@ -753,6 +1251,23 @@ public class MatterQuery extends MatterEntity {
     public void setAppoveTimeLimitShowList(List<String> appoveTimeLimitShowList){
         this.appoveTimeLimitShowList = appoveTimeLimitShowList;
     }
+
+    /**
+     * 获取 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
+     * @return appoveTimeLimitShowNotList
+     */
+    public List<String> getAppoveTimeLimitShowNotList(){
+        return this.appoveTimeLimitShowNotList;
+    }
+
+    /**
+     * 设置 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
+     * @param appoveTimeLimitShowNotList
+     */
+    public void setAppoveTimeLimitShowNotList(List<String> appoveTimeLimitShowNotList){
+        this.appoveTimeLimitShowNotList = appoveTimeLimitShowNotList;
+    }
+
     /**
      * 获取 办理形式（窗口办理.窗口办理，网上办理.网上办理）
      * @return handleTypeList
@@ -768,6 +1283,23 @@ public class MatterQuery extends MatterEntity {
     public void setHandleTypeList(List<String> handleTypeList){
         this.handleTypeList = handleTypeList;
     }
+
+    /**
+     * 获取 办理形式（窗口办理.窗口办理，网上办理.网上办理）
+     * @return handleTypeNotList
+     */
+    public List<String> getHandleTypeNotList(){
+        return this.handleTypeNotList;
+    }
+
+    /**
+     * 设置 办理形式（窗口办理.窗口办理，网上办理.网上办理）
+     * @param handleTypeNotList
+     */
+    public void setHandleTypeNotList(List<String> handleTypeNotList){
+        this.handleTypeNotList = handleTypeNotList;
+    }
+
     /**
      * 获取 法定办结时限
      * @return legalTimeLimitShowList
@@ -783,12 +1315,29 @@ public class MatterQuery extends MatterEntity {
     public void setLegalTimeLimitShowList(List<String> legalTimeLimitShowList){
         this.legalTimeLimitShowList = legalTimeLimitShowList;
     }
+
     /**
-     * 获取 法定时限办结说明
-     * @return legalEndExplainList
+     * 获取 法定办结时限
+     * @return legalTimeLimitShowNotList
      */
-    public List<String> getLegalEndExplainList(){
-        return this.legalEndExplainList;
+    public List<String> getLegalTimeLimitShowNotList(){
+        return this.legalTimeLimitShowNotList;
+    }
+
+    /**
+     * 设置 法定办结时限
+     * @param legalTimeLimitShowNotList
+     */
+    public void setLegalTimeLimitShowNotList(List<String> legalTimeLimitShowNotList){
+        this.legalTimeLimitShowNotList = legalTimeLimitShowNotList;
+    }
+
+    /**
+     * 获取 法定时限办结说明
+     * @return legalEndExplainList
+     */
+    public List<String> getLegalEndExplainList(){
+        return this.legalEndExplainList;
     }
 
     /**
@@ -798,6 +1347,23 @@ public class MatterQuery extends MatterEntity {
     public void setLegalEndExplainList(List<String> legalEndExplainList){
         this.legalEndExplainList = legalEndExplainList;
     }
+
+    /**
+     * 获取 法定时限办结说明
+     * @return legalEndExplainNotList
+     */
+    public List<String> getLegalEndExplainNotList(){
+        return this.legalEndExplainNotList;
+    }
+
+    /**
+     * 设置 法定时限办结说明
+     * @param legalEndExplainNotList
+     */
+    public void setLegalEndExplainNotList(List<String> legalEndExplainNotList){
+        this.legalEndExplainNotList = legalEndExplainNotList;
+    }
+
     /**
      * 获取 承诺办结时限
      * @return promiseTimeLimitShowList
@@ -813,6 +1379,23 @@ public class MatterQuery extends MatterEntity {
     public void setPromiseTimeLimitShowList(List<String> promiseTimeLimitShowList){
         this.promiseTimeLimitShowList = promiseTimeLimitShowList;
     }
+
+    /**
+     * 获取 承诺办结时限
+     * @return promiseTimeLimitShowNotList
+     */
+    public List<String> getPromiseTimeLimitShowNotList(){
+        return this.promiseTimeLimitShowNotList;
+    }
+
+    /**
+     * 设置 承诺办结时限
+     * @param promiseTimeLimitShowNotList
+     */
+    public void setPromiseTimeLimitShowNotList(List<String> promiseTimeLimitShowNotList){
+        this.promiseTimeLimitShowNotList = promiseTimeLimitShowNotList;
+    }
+
     /**
      * 获取 承诺时限办结说明
      * @return promiseEndExplainList
@@ -828,6 +1411,23 @@ public class MatterQuery extends MatterEntity {
     public void setPromiseEndExplainList(List<String> promiseEndExplainList){
         this.promiseEndExplainList = promiseEndExplainList;
     }
+
+    /**
+     * 获取 承诺时限办结说明
+     * @return promiseEndExplainNotList
+     */
+    public List<String> getPromiseEndExplainNotList(){
+        return this.promiseEndExplainNotList;
+    }
+
+    /**
+     * 设置 承诺时限办结说明
+     * @param promiseEndExplainNotList
+     */
+    public void setPromiseEndExplainNotList(List<String> promiseEndExplainNotList){
+        this.promiseEndExplainNotList = promiseEndExplainNotList;
+    }
+
     /**
      * 获取 是否收费（否.否，是.是）
      * @return isChargesShowList
@@ -843,6 +1443,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsChargesShowList(List<String> isChargesShowList){
         this.isChargesShowList = isChargesShowList;
     }
+
+    /**
+     * 获取 是否收费（否.否，是.是）
+     * @return isChargesShowNotList
+     */
+    public List<String> getIsChargesShowNotList(){
+        return this.isChargesShowNotList;
+    }
+
+    /**
+     * 设置 是否收费（否.否，是.是）
+     * @param isChargesShowNotList
+     */
+    public void setIsChargesShowNotList(List<String> isChargesShowNotList){
+        this.isChargesShowNotList = isChargesShowNotList;
+    }
+
     /**
      * 获取 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
      * @return certificationLevelsShowList
@@ -858,6 +1475,23 @@ public class MatterQuery extends MatterEntity {
     public void setCertificationLevelsShowList(List<String> certificationLevelsShowList){
         this.certificationLevelsShowList = certificationLevelsShowList;
     }
+
+    /**
+     * 获取 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
+     * @return certificationLevelsShowNotList
+     */
+    public List<String> getCertificationLevelsShowNotList(){
+        return this.certificationLevelsShowNotList;
+    }
+
+    /**
+     * 设置 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
+     * @param certificationLevelsShowNotList
+     */
+    public void setCertificationLevelsShowNotList(List<String> certificationLevelsShowNotList){
+        this.certificationLevelsShowNotList = certificationLevelsShowNotList;
+    }
+
     /**
      * 获取 开始 计划生效日期
      * @return planTakeTimeStart
@@ -937,6 +1571,23 @@ public class MatterQuery extends MatterEntity {
     public void setSpecialProcedureList(List<String> specialProcedureList){
         this.specialProcedureList = specialProcedureList;
     }
+
+    /**
+     * 获取 特别程序
+     * @return specialProcedureNotList
+     */
+    public List<String> getSpecialProcedureNotList(){
+        return this.specialProcedureNotList;
+    }
+
+    /**
+     * 设置 特别程序
+     * @param specialProcedureNotList
+     */
+    public void setSpecialProcedureNotList(List<String> specialProcedureNotList){
+        this.specialProcedureNotList = specialProcedureNotList;
+    }
+
     /**
      * 获取 开始 窗口到现场次数
      * @return windowToTheSceneNumStart
@@ -1001,6 +1652,23 @@ public class MatterQuery extends MatterEntity {
         this.windowToTheSceneNumList = windowToTheSceneNumList;
     }
 
+    /**
+     * 获取 窗口到现场次数
+     * @return windowToTheSceneNumNotList
+     */
+    public List<Integer> getWindowToTheSceneNumNotList(){
+        return this.windowToTheSceneNumNotList;
+    }
+
+    /**
+     * 设置 窗口到现场次数
+     * @param windowToTheSceneNumNotList
+     */
+    public void setWindowToTheSceneNumNotList(List<Integer> windowToTheSceneNumNotList){
+        this.windowToTheSceneNumNotList = windowToTheSceneNumNotList;
+    }
+
+
     /**
      * 获取 是否网上预约,窗口办理选（否.否，是.是）
      * @return isOnlineSubscribeShowList
@@ -1016,6 +1684,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsOnlineSubscribeShowList(List<String> isOnlineSubscribeShowList){
         this.isOnlineSubscribeShowList = isOnlineSubscribeShowList;
     }
+
+    /**
+     * 获取 是否网上预约,窗口办理选（否.否，是.是）
+     * @return isOnlineSubscribeShowNotList
+     */
+    public List<String> getIsOnlineSubscribeShowNotList(){
+        return this.isOnlineSubscribeShowNotList;
+    }
+
+    /**
+     * 设置 是否网上预约,窗口办理选（否.否，是.是）
+     * @param isOnlineSubscribeShowNotList
+     */
+    public void setIsOnlineSubscribeShowNotList(List<String> isOnlineSubscribeShowNotList){
+        this.isOnlineSubscribeShowNotList = isOnlineSubscribeShowNotList;
+    }
+
     /**
      * 获取 物流快递,窗口办理选（否.否，是.是）
      * @return isExpressTakeShowList
@@ -1031,6 +1716,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsExpressTakeShowList(List<String> isExpressTakeShowList){
         this.isExpressTakeShowList = isExpressTakeShowList;
     }
+
+    /**
+     * 获取 物流快递,窗口办理选（否.否，是.是）
+     * @return isExpressTakeShowNotList
+     */
+    public List<String> getIsExpressTakeShowNotList(){
+        return this.isExpressTakeShowNotList;
+    }
+
+    /**
+     * 设置 物流快递,窗口办理选（否.否，是.是）
+     * @param isExpressTakeShowNotList
+     */
+    public void setIsExpressTakeShowNotList(List<String> isExpressTakeShowNotList){
+        this.isExpressTakeShowNotList = isExpressTakeShowNotList;
+    }
+
     /**
      * 获取 是否支持全省范围就近取件（否.否，是.是）
      * @return isProvinceAcquisitionShowList
@@ -1046,6 +1748,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsProvinceAcquisitionShowList(List<String> isProvinceAcquisitionShowList){
         this.isProvinceAcquisitionShowList = isProvinceAcquisitionShowList;
     }
+
+    /**
+     * 获取 是否支持全省范围就近取件（否.否，是.是）
+     * @return isProvinceAcquisitionShowNotList
+     */
+    public List<String> getIsProvinceAcquisitionShowNotList(){
+        return this.isProvinceAcquisitionShowNotList;
+    }
+
+    /**
+     * 设置 是否支持全省范围就近取件（否.否，是.是）
+     * @param isProvinceAcquisitionShowNotList
+     */
+    public void setIsProvinceAcquisitionShowNotList(List<String> isProvinceAcquisitionShowNotList){
+        this.isProvinceAcquisitionShowNotList = isProvinceAcquisitionShowNotList;
+    }
+
     /**
      * 获取 是否支持全省范围就近办理（否.否，是.是）
      * @return isApplyProvinceShowList
@@ -1061,6 +1780,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsApplyProvinceShowList(List<String> isApplyProvinceShowList){
         this.isApplyProvinceShowList = isApplyProvinceShowList;
     }
+
+    /**
+     * 获取 是否支持全省范围就近办理（否.否，是.是）
+     * @return isApplyProvinceShowNotList
+     */
+    public List<String> getIsApplyProvinceShowNotList(){
+        return this.isApplyProvinceShowNotList;
+    }
+
+    /**
+     * 设置 是否支持全省范围就近办理（否.否，是.是）
+     * @param isApplyProvinceShowNotList
+     */
+    public void setIsApplyProvinceShowNotList(List<String> isApplyProvinceShowNotList){
+        this.isApplyProvinceShowNotList = isApplyProvinceShowNotList;
+    }
+
     /**
      * 获取 必须到现场原因
      * @return mustSceneExplainList
@@ -1076,6 +1812,23 @@ public class MatterQuery extends MatterEntity {
     public void setMustSceneExplainList(List<String> mustSceneExplainList){
         this.mustSceneExplainList = mustSceneExplainList;
     }
+
+    /**
+     * 获取 必须到现场原因
+     * @return mustSceneExplainNotList
+     */
+    public List<String> getMustSceneExplainNotList(){
+        return this.mustSceneExplainNotList;
+    }
+
+    /**
+     * 设置 必须到现场原因
+     * @param mustSceneExplainNotList
+     */
+    public void setMustSceneExplainNotList(List<String> mustSceneExplainNotList){
+        this.mustSceneExplainNotList = mustSceneExplainNotList;
+    }
+
     /**
      * 获取 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
      * @return onlineTypeList
@@ -1091,6 +1844,23 @@ public class MatterQuery extends MatterEntity {
     public void setOnlineTypeList(List<String> onlineTypeList){
         this.onlineTypeList = onlineTypeList;
     }
+
+    /**
+     * 获取 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
+     * @return onlineTypeNotList
+     */
+    public List<String> getOnlineTypeNotList(){
+        return this.onlineTypeNotList;
+    }
+
+    /**
+     * 设置 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
+     * @param onlineTypeNotList
+     */
+    public void setOnlineTypeNotList(List<String> onlineTypeNotList){
+        this.onlineTypeNotList = onlineTypeNotList;
+    }
+
     /**
      * 获取 开始 网办到现场次数
      * @return onlineToTheSceneNumStart
@@ -1155,6 +1925,23 @@ public class MatterQuery extends MatterEntity {
         this.onlineToTheSceneNumList = onlineToTheSceneNumList;
     }
 
+    /**
+     * 获取 网办到现场次数
+     * @return onlineToTheSceneNumNotList
+     */
+    public List<Integer> getOnlineToTheSceneNumNotList(){
+        return this.onlineToTheSceneNumNotList;
+    }
+
+    /**
+     * 设置 网办到现场次数
+     * @param onlineToTheSceneNumNotList
+     */
+    public void setOnlineToTheSceneNumNotList(List<Integer> onlineToTheSceneNumNotList){
+        this.onlineToTheSceneNumNotList = onlineToTheSceneNumNotList;
+    }
+
+
     /**
      * 获取 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
      * @return onlineOperatDeepList
@@ -1170,6 +1957,23 @@ public class MatterQuery extends MatterEntity {
     public void setOnlineOperatDeepList(List<String> onlineOperatDeepList){
         this.onlineOperatDeepList = onlineOperatDeepList;
     }
+
+    /**
+     * 获取 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
+     * @return onlineOperatDeepNotList
+     */
+    public List<String> getOnlineOperatDeepNotList(){
+        return this.onlineOperatDeepNotList;
+    }
+
+    /**
+     * 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
+     * @param onlineOperatDeepNotList
+     */
+    public void setOnlineOperatDeepNotList(List<String> onlineOperatDeepNotList){
+        this.onlineOperatDeepNotList = onlineOperatDeepNotList;
+    }
+
     /**
      * 获取 物流快递，网上办理选（否.否，是.是）
      * @return isExpressTakeOnlineShowList
@@ -1185,6 +1989,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsExpressTakeOnlineShowList(List<String> isExpressTakeOnlineShowList){
         this.isExpressTakeOnlineShowList = isExpressTakeOnlineShowList;
     }
+
+    /**
+     * 获取 物流快递，网上办理选（否.否，是.是）
+     * @return isExpressTakeOnlineShowNotList
+     */
+    public List<String> getIsExpressTakeOnlineShowNotList(){
+        return this.isExpressTakeOnlineShowNotList;
+    }
+
+    /**
+     * 设置 物流快递，网上办理选（否.否，是.是）
+     * @param isExpressTakeOnlineShowNotList
+     */
+    public void setIsExpressTakeOnlineShowNotList(List<String> isExpressTakeOnlineShowNotList){
+        this.isExpressTakeOnlineShowNotList = isExpressTakeOnlineShowNotList;
+    }
+
     /**
      * 获取 是否支持上门收取申请（否.否，是.是）
      * @return isDoorTakeShowList
@@ -1200,6 +2021,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsDoorTakeShowList(List<String> isDoorTakeShowList){
         this.isDoorTakeShowList = isDoorTakeShowList;
     }
+
+    /**
+     * 获取 是否支持上门收取申请（否.否，是.是）
+     * @return isDoorTakeShowNotList
+     */
+    public List<String> getIsDoorTakeShowNotList(){
+        return this.isDoorTakeShowNotList;
+    }
+
+    /**
+     * 设置 是否支持上门收取申请（否.否，是.是）
+     * @param isDoorTakeShowNotList
+     */
+    public void setIsDoorTakeShowNotList(List<String> isDoorTakeShowNotList){
+        this.isDoorTakeShowNotList = isDoorTakeShowNotList;
+    }
+
     /**
      * 获取 网上必须到现场原因
      * @return onlineMustSceneExplainList
@@ -1215,6 +2053,23 @@ public class MatterQuery extends MatterEntity {
     public void setOnlineMustSceneExplainList(List<String> onlineMustSceneExplainList){
         this.onlineMustSceneExplainList = onlineMustSceneExplainList;
     }
+
+    /**
+     * 获取 网上必须到现场原因
+     * @return onlineMustSceneExplainNotList
+     */
+    public List<String> getOnlineMustSceneExplainNotList(){
+        return this.onlineMustSceneExplainNotList;
+    }
+
+    /**
+     * 设置 网上必须到现场原因
+     * @param onlineMustSceneExplainNotList
+     */
+    public void setOnlineMustSceneExplainNotList(List<String> onlineMustSceneExplainNotList){
+        this.onlineMustSceneExplainNotList = onlineMustSceneExplainNotList;
+    }
+
     /**
      * 获取 实施主体
      * @return performDeptTypeList
@@ -1230,6 +2085,23 @@ public class MatterQuery extends MatterEntity {
     public void setPerformDeptTypeList(List<String> performDeptTypeList){
         this.performDeptTypeList = performDeptTypeList;
     }
+
+    /**
+     * 获取 实施主体
+     * @return performDeptTypeNotList
+     */
+    public List<String> getPerformDeptTypeNotList(){
+        return this.performDeptTypeNotList;
+    }
+
+    /**
+     * 设置 实施主体
+     * @param performDeptTypeNotList
+     */
+    public void setPerformDeptTypeNotList(List<String> performDeptTypeNotList){
+        this.performDeptTypeNotList = performDeptTypeNotList;
+    }
+
     /**
      * 获取 事项版本
      * @return matterEditionList
@@ -1245,6 +2117,23 @@ public class MatterQuery extends MatterEntity {
     public void setMatterEditionList(List<String> matterEditionList){
         this.matterEditionList = matterEditionList;
     }
+
+    /**
+     * 获取 事项版本
+     * @return matterEditionNotList
+     */
+    public List<String> getMatterEditionNotList(){
+        return this.matterEditionNotList;
+    }
+
+    /**
+     * 设置 事项版本
+     * @param matterEditionNotList
+     */
+    public void setMatterEditionNotList(List<String> matterEditionNotList){
+        this.matterEditionNotList = matterEditionNotList;
+    }
+
     /**
      * 获取 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
      * @return eventTypeShowList
@@ -1260,6 +2149,23 @@ public class MatterQuery extends MatterEntity {
     public void setEventTypeShowList(List<String> eventTypeShowList){
         this.eventTypeShowList = eventTypeShowList;
     }
+
+    /**
+     * 获取 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
+     * @return eventTypeShowNotList
+     */
+    public List<String> getEventTypeShowNotList(){
+        return this.eventTypeShowNotList;
+    }
+
+    /**
+     * 设置 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
+     * @param eventTypeShowNotList
+     */
+    public void setEventTypeShowNotList(List<String> eventTypeShowNotList){
+        this.eventTypeShowNotList = eventTypeShowNotList;
+    }
+
     /**
      * 获取 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
      * @return performHierarchyShowList
@@ -1275,6 +2181,23 @@ public class MatterQuery extends MatterEntity {
     public void setPerformHierarchyShowList(List<String> performHierarchyShowList){
         this.performHierarchyShowList = performHierarchyShowList;
     }
+
+    /**
+     * 获取 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
+     * @return performHierarchyShowNotList
+     */
+    public List<String> getPerformHierarchyShowNotList(){
+        return this.performHierarchyShowNotList;
+    }
+
+    /**
+     * 设置 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
+     * @param performHierarchyShowNotList
+     */
+    public void setPerformHierarchyShowNotList(List<String> performHierarchyShowNotList){
+        this.performHierarchyShowNotList = performHierarchyShowNotList;
+    }
+
     /**
      * 获取 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
      * @return powerSourceShowList
@@ -1290,6 +2213,23 @@ public class MatterQuery extends MatterEntity {
     public void setPowerSourceShowList(List<String> powerSourceShowList){
         this.powerSourceShowList = powerSourceShowList;
     }
+
+    /**
+     * 获取 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
+     * @return powerSourceShowNotList
+     */
+    public List<String> getPowerSourceShowNotList(){
+        return this.powerSourceShowNotList;
+    }
+
+    /**
+     * 设置 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
+     * @param powerSourceShowNotList
+     */
+    public void setPowerSourceShowNotList(List<String> powerSourceShowNotList){
+        this.powerSourceShowNotList = powerSourceShowNotList;
+    }
+
     /**
      * 获取 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
      * @return performDeptTypeShowList
@@ -1305,6 +2245,23 @@ public class MatterQuery extends MatterEntity {
     public void setPerformDeptTypeShowList(List<String> performDeptTypeShowList){
         this.performDeptTypeShowList = performDeptTypeShowList;
     }
+
+    /**
+     * 获取 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
+     * @return performDeptTypeShowNotList
+     */
+    public List<String> getPerformDeptTypeShowNotList(){
+        return this.performDeptTypeShowNotList;
+    }
+
+    /**
+     * 设置 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
+     * @param performDeptTypeShowNotList
+     */
+    public void setPerformDeptTypeShowNotList(List<String> performDeptTypeShowNotList){
+        this.performDeptTypeShowNotList = performDeptTypeShowNotList;
+    }
+
     /**
      * 获取 是否进驻中心（否.否，是.是）
      * @return goveServiceCenterShowList
@@ -1320,6 +2277,23 @@ public class MatterQuery extends MatterEntity {
     public void setGoveServiceCenterShowList(List<String> goveServiceCenterShowList){
         this.goveServiceCenterShowList = goveServiceCenterShowList;
     }
+
+    /**
+     * 获取 是否进驻中心（否.否，是.是）
+     * @return goveServiceCenterShowNotList
+     */
+    public List<String> getGoveServiceCenterShowNotList(){
+        return this.goveServiceCenterShowNotList;
+    }
+
+    /**
+     * 设置 是否进驻中心（否.否，是.是）
+     * @param goveServiceCenterShowNotList
+     */
+    public void setGoveServiceCenterShowNotList(List<String> goveServiceCenterShowNotList){
+        this.goveServiceCenterShowNotList = goveServiceCenterShowNotList;
+    }
+
     /**
      * 获取 是否纳入便民服务中心（否.否，是.是）
      * @return isConvenientCenterShowList
@@ -1335,6 +2309,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsConvenientCenterShowList(List<String> isConvenientCenterShowList){
         this.isConvenientCenterShowList = isConvenientCenterShowList;
     }
+
+    /**
+     * 获取 是否纳入便民服务中心（否.否，是.是）
+     * @return isConvenientCenterShowNotList
+     */
+    public List<String> getIsConvenientCenterShowNotList(){
+        return this.isConvenientCenterShowNotList;
+    }
+
+    /**
+     * 设置 是否纳入便民服务中心（否.否，是.是）
+     * @param isConvenientCenterShowNotList
+     */
+    public void setIsConvenientCenterShowNotList(List<String> isConvenientCenterShowNotList){
+        this.isConvenientCenterShowNotList = isConvenientCenterShowNotList;
+    }
+
     /**
      * 获取 自助终端办理 （否.否，是.是）
      * @return terminalHandleList
@@ -1350,6 +2341,23 @@ public class MatterQuery extends MatterEntity {
     public void setTerminalHandleList(List<String> terminalHandleList){
         this.terminalHandleList = terminalHandleList;
     }
+
+    /**
+     * 获取 自助终端办理 （否.否，是.是）
+     * @return terminalHandleNotList
+     */
+    public List<String> getTerminalHandleNotList(){
+        return this.terminalHandleNotList;
+    }
+
+    /**
+     * 设置 自助终端办理 （否.否，是.是）
+     * @param terminalHandleNotList
+     */
+    public void setTerminalHandleNotList(List<String> terminalHandleNotList){
+        this.terminalHandleNotList = terminalHandleNotList;
+    }
+
     /**
      * 获取 是否网办 （否.否，是.是）
      * @return isOnlineList
@@ -1365,6 +2373,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsOnlineList(List<String> isOnlineList){
         this.isOnlineList = isOnlineList;
     }
+
+    /**
+     * 获取 是否网办 （否.否，是.是）
+     * @return isOnlineNotList
+     */
+    public List<String> getIsOnlineNotList(){
+        return this.isOnlineNotList;
+    }
+
+    /**
+     * 设置 是否网办 （否.否，是.是）
+     * @param isOnlineNotList
+     */
+    public void setIsOnlineNotList(List<String> isOnlineNotList){
+        this.isOnlineNotList = isOnlineNotList;
+    }
+
     /**
      * 获取 支持网上支付（否.否，是.是）
      * @return isOnlinePayShowList
@@ -1380,6 +2405,23 @@ public class MatterQuery extends MatterEntity {
     public void setIsOnlinePayShowList(List<String> isOnlinePayShowList){
         this.isOnlinePayShowList = isOnlinePayShowList;
     }
+
+    /**
+     * 获取 支持网上支付（否.否，是.是）
+     * @return isOnlinePayShowNotList
+     */
+    public List<String> getIsOnlinePayShowNotList(){
+        return this.isOnlinePayShowNotList;
+    }
+
+    /**
+     * 设置 支持网上支付（否.否，是.是）
+     * @param isOnlinePayShowNotList
+     */
+    public void setIsOnlinePayShowNotList(List<String> isOnlinePayShowNotList){
+        this.isOnlinePayShowNotList = isOnlinePayShowNotList;
+    }
+
     /**
      * 获取 委托部门（否.否，是.是）
      * @return entrustmentDepartmenList
@@ -1395,6 +2437,23 @@ public class MatterQuery extends MatterEntity {
     public void setEntrustmentDepartmenList(List<String> entrustmentDepartmenList){
         this.entrustmentDepartmenList = entrustmentDepartmenList;
     }
+
+    /**
+     * 获取 委托部门（否.否，是.是）
+     * @return entrustmentDepartmenNotList
+     */
+    public List<String> getEntrustmentDepartmenNotList(){
+        return this.entrustmentDepartmenNotList;
+    }
+
+    /**
+     * 设置 委托部门（否.否，是.是）
+     * @param entrustmentDepartmenNotList
+     */
+    public void setEntrustmentDepartmenNotList(List<String> entrustmentDepartmenNotList){
+        this.entrustmentDepartmenNotList = entrustmentDepartmenNotList;
+    }
+
     /**
      * 获取 联办机构
      * @return jointInfoShowList
@@ -1410,6 +2469,23 @@ public class MatterQuery extends MatterEntity {
     public void setJointInfoShowList(List<String> jointInfoShowList){
         this.jointInfoShowList = jointInfoShowList;
     }
+
+    /**
+     * 获取 联办机构
+     * @return jointInfoShowNotList
+     */
+    public List<String> getJointInfoShowNotList(){
+        return this.jointInfoShowNotList;
+    }
+
+    /**
+     * 设置 联办机构
+     * @param jointInfoShowNotList
+     */
+    public void setJointInfoShowNotList(List<String> jointInfoShowNotList){
+        this.jointInfoShowNotList = jointInfoShowNotList;
+    }
+
     /**
      * 获取 事项状态（停用.停用，在用.在用）
      * @return matterStatusList
@@ -1425,6 +2501,23 @@ public class MatterQuery extends MatterEntity {
     public void setMatterStatusList(List<String> matterStatusList){
         this.matterStatusList = matterStatusList;
     }
+
+    /**
+     * 获取 事项状态（停用.停用，在用.在用）
+     * @return matterStatusNotList
+     */
+    public List<String> getMatterStatusNotList(){
+        return this.matterStatusNotList;
+    }
+
+    /**
+     * 设置 事项状态（停用.停用，在用.在用）
+     * @param matterStatusNotList
+     */
+    public void setMatterStatusNotList(List<String> matterStatusNotList){
+        this.matterStatusNotList = matterStatusNotList;
+    }
+
     /**
      * 获取 开始 数量限制
      * @return numberLimitStart
@@ -1489,21 +2582,55 @@ public class MatterQuery extends MatterEntity {
         this.numberLimitList = numberLimitList;
     }
 
+    /**
+     * 获取 数量限制
+     * @return numberLimitNotList
+     */
+    public List<Long> getNumberLimitNotList(){
+        return this.numberLimitNotList;
+    }
+
+    /**
+     * 设置 数量限制
+     * @param numberLimitNotList
+     */
+    public void setNumberLimitNotList(List<Long> numberLimitNotList){
+        this.numberLimitNotList = numberLimitNotList;
+    }
+
+
+    /**
+     * 获取 主题类型
+     * @return typeList
+     */
+    public List<String> getTypeList(){
+        return this.typeList;
+    }
+
+    /**
+     * 设置 主题类型
+     * @param typeList
+     */
+    public void setTypeList(List<String> typeList){
+        this.typeList = typeList;
+    }
+
     /**
      * 获取 主题类型
-     * @return typeList
+     * @return typeNotList
      */
-    public List<String> getTypeList(){
-        return this.typeList;
+    public List<String> getTypeNotList(){
+        return this.typeNotList;
     }
 
     /**
      * 设置 主题类型
-     * @param typeList
+     * @param typeNotList
      */
-    public void setTypeList(List<String> typeList){
-        this.typeList = typeList;
+    public void setTypeNotList(List<String> typeNotList){
+        this.typeNotList = typeNotList;
     }
+
     /**
      * 获取 基本编码
      * @return baseCodeList
@@ -1519,6 +2646,23 @@ public class MatterQuery extends MatterEntity {
     public void setBaseCodeList(List<String> baseCodeList){
         this.baseCodeList = baseCodeList;
     }
+
+    /**
+     * 获取 基本编码
+     * @return baseCodeNotList
+     */
+    public List<String> getBaseCodeNotList(){
+        return this.baseCodeNotList;
+    }
+
+    /**
+     * 设置 基本编码
+     * @param baseCodeNotList
+     */
+    public void setBaseCodeNotList(List<String> baseCodeNotList){
+        this.baseCodeNotList = baseCodeNotList;
+    }
+
     /**
      * 获取 实施编码
      * @return implementCodeList
@@ -1534,6 +2678,23 @@ public class MatterQuery extends MatterEntity {
     public void setImplementCodeList(List<String> implementCodeList){
         this.implementCodeList = implementCodeList;
     }
+
+    /**
+     * 获取 实施编码
+     * @return implementCodeNotList
+     */
+    public List<String> getImplementCodeNotList(){
+        return this.implementCodeNotList;
+    }
+
+    /**
+     * 设置 实施编码
+     * @param implementCodeNotList
+     */
+    public void setImplementCodeNotList(List<String> implementCodeNotList){
+        this.implementCodeNotList = implementCodeNotList;
+    }
+
     /**
      * 获取 实施主体编码
      * @return implementBodyCodeList
@@ -1549,6 +2710,23 @@ public class MatterQuery extends MatterEntity {
     public void setImplementBodyCodeList(List<String> implementBodyCodeList){
         this.implementBodyCodeList = implementBodyCodeList;
     }
+
+    /**
+     * 获取 实施主体编码
+     * @return implementBodyCodeNotList
+     */
+    public List<String> getImplementBodyCodeNotList(){
+        return this.implementBodyCodeNotList;
+    }
+
+    /**
+     * 设置 实施主体编码
+     * @param implementBodyCodeNotList
+     */
+    public void setImplementBodyCodeNotList(List<String> implementBodyCodeNotList){
+        this.implementBodyCodeNotList = implementBodyCodeNotList;
+    }
+
     /**
      * 获取 办理项编码
      * @return operateItemCodeList
@@ -1564,6 +2742,23 @@ public class MatterQuery extends MatterEntity {
     public void setOperateItemCodeList(List<String> operateItemCodeList){
         this.operateItemCodeList = operateItemCodeList;
     }
+
+    /**
+     * 获取 办理项编码
+     * @return operateItemCodeNotList
+     */
+    public List<String> getOperateItemCodeNotList(){
+        return this.operateItemCodeNotList;
+    }
+
+    /**
+     * 设置 办理项编码
+     * @param operateItemCodeNotList
+     */
+    public void setOperateItemCodeNotList(List<String> operateItemCodeNotList){
+        this.operateItemCodeNotList = operateItemCodeNotList;
+    }
+
     /**
      * 获取 乡镇街道名称
      * @return townshipNameList
@@ -1579,6 +2774,23 @@ public class MatterQuery extends MatterEntity {
     public void setTownshipNameList(List<String> townshipNameList){
         this.townshipNameList = townshipNameList;
     }
+
+    /**
+     * 获取 乡镇街道名称
+     * @return townshipNameNotList
+     */
+    public List<String> getTownshipNameNotList(){
+        return this.townshipNameNotList;
+    }
+
+    /**
+     * 设置 乡镇街道名称
+     * @param townshipNameNotList
+     */
+    public void setTownshipNameNotList(List<String> townshipNameNotList){
+        this.townshipNameNotList = townshipNameNotList;
+    }
+
     /**
      * 获取 乡镇街道代码
      * @return townshipCodeList
@@ -1594,6 +2806,23 @@ public class MatterQuery extends MatterEntity {
     public void setTownshipCodeList(List<String> townshipCodeList){
         this.townshipCodeList = townshipCodeList;
     }
+
+    /**
+     * 获取 乡镇街道代码
+     * @return townshipCodeNotList
+     */
+    public List<String> getTownshipCodeNotList(){
+        return this.townshipCodeNotList;
+    }
+
+    /**
+     * 设置 乡镇街道代码
+     * @param townshipCodeNotList
+     */
+    public void setTownshipCodeNotList(List<String> townshipCodeNotList){
+        this.townshipCodeNotList = townshipCodeNotList;
+    }
+
     /**
      * 获取 村居社区名称
      * @return villageNameList
@@ -1609,6 +2838,23 @@ public class MatterQuery extends MatterEntity {
     public void setVillageNameList(List<String> villageNameList){
         this.villageNameList = villageNameList;
     }
+
+    /**
+     * 获取 村居社区名称
+     * @return villageNameNotList
+     */
+    public List<String> getVillageNameNotList(){
+        return this.villageNameNotList;
+    }
+
+    /**
+     * 设置 村居社区名称
+     * @param villageNameNotList
+     */
+    public void setVillageNameNotList(List<String> villageNameNotList){
+        this.villageNameNotList = villageNameNotList;
+    }
+
     /**
      * 获取 村居社区代码
      * @return villageCodeList
@@ -1624,6 +2870,23 @@ public class MatterQuery extends MatterEntity {
     public void setVillageCodeList(List<String> villageCodeList){
         this.villageCodeList = villageCodeList;
     }
+
+    /**
+     * 获取 村居社区代码
+     * @return villageCodeNotList
+     */
+    public List<String> getVillageCodeNotList(){
+        return this.villageCodeNotList;
+    }
+
+    /**
+     * 设置 村居社区代码
+     * @param villageCodeNotList
+     */
+    public void setVillageCodeNotList(List<String> villageCodeNotList){
+        this.villageCodeNotList = villageCodeNotList;
+    }
+
     /**
      * 获取 办理时间
      * @return operateTimeList
@@ -1639,6 +2902,23 @@ public class MatterQuery extends MatterEntity {
     public void setOperateTimeList(List<String> operateTimeList){
         this.operateTimeList = operateTimeList;
     }
+
+    /**
+     * 获取 办理时间
+     * @return operateTimeNotList
+     */
+    public List<String> getOperateTimeNotList(){
+        return this.operateTimeNotList;
+    }
+
+    /**
+     * 设置 办理时间
+     * @param operateTimeNotList
+     */
+    public void setOperateTimeNotList(List<String> operateTimeNotList){
+        this.operateTimeNotList = operateTimeNotList;
+    }
+
     /**
      * 获取 办理地点
      * @return operateSiteList
@@ -1654,6 +2934,23 @@ public class MatterQuery extends MatterEntity {
     public void setOperateSiteList(List<String> operateSiteList){
         this.operateSiteList = operateSiteList;
     }
+
+    /**
+     * 获取 办理地点
+     * @return operateSiteNotList
+     */
+    public List<String> getOperateSiteNotList(){
+        return this.operateSiteNotList;
+    }
+
+    /**
+     * 设置 办理地点
+     * @param operateSiteNotList
+     */
+    public void setOperateSiteNotList(List<String> operateSiteNotList){
+        this.operateSiteNotList = operateSiteNotList;
+    }
+
     /**
      * 获取 咨询方式
      * @return cousultingShowList
@@ -1669,6 +2966,23 @@ public class MatterQuery extends MatterEntity {
     public void setCousultingShowList(List<String> cousultingShowList){
         this.cousultingShowList = cousultingShowList;
     }
+
+    /**
+     * 获取 咨询方式
+     * @return cousultingShowNotList
+     */
+    public List<String> getCousultingShowNotList(){
+        return this.cousultingShowNotList;
+    }
+
+    /**
+     * 设置 咨询方式
+     * @param cousultingShowNotList
+     */
+    public void setCousultingShowNotList(List<String> cousultingShowNotList){
+        this.cousultingShowNotList = cousultingShowNotList;
+    }
+
     /**
      * 获取 咨询电话
      * @return cousultingTelephoneShowList
@@ -1684,6 +2998,23 @@ public class MatterQuery extends MatterEntity {
     public void setCousultingTelephoneShowList(List<String> cousultingTelephoneShowList){
         this.cousultingTelephoneShowList = cousultingTelephoneShowList;
     }
+
+    /**
+     * 获取 咨询电话
+     * @return cousultingTelephoneShowNotList
+     */
+    public List<String> getCousultingTelephoneShowNotList(){
+        return this.cousultingTelephoneShowNotList;
+    }
+
+    /**
+     * 设置 咨询电话
+     * @param cousultingTelephoneShowNotList
+     */
+    public void setCousultingTelephoneShowNotList(List<String> cousultingTelephoneShowNotList){
+        this.cousultingTelephoneShowNotList = cousultingTelephoneShowNotList;
+    }
+
     /**
      * 获取 监督投诉方式
      * @return superviseShowList
@@ -1699,6 +3030,23 @@ public class MatterQuery extends MatterEntity {
     public void setSuperviseShowList(List<String> superviseShowList){
         this.superviseShowList = superviseShowList;
     }
+
+    /**
+     * 获取 监督投诉方式
+     * @return superviseShowNotList
+     */
+    public List<String> getSuperviseShowNotList(){
+        return this.superviseShowNotList;
+    }
+
+    /**
+     * 设置 监督投诉方式
+     * @param superviseShowNotList
+     */
+    public void setSuperviseShowNotList(List<String> superviseShowNotList){
+        this.superviseShowNotList = superviseShowNotList;
+    }
+
     /**
      * 获取 开始 排序
      * @return sortStart
@@ -1763,6 +3111,23 @@ public class MatterQuery extends MatterEntity {
         this.sortList = sortList;
     }
 
+    /**
+     * 获取 排序
+     * @return sortNotList
+     */
+    public List<Integer> getSortNotList(){
+        return this.sortNotList;
+    }
+
+    /**
+     * 设置 排序
+     * @param sortNotList
+     */
+    public void setSortNotList(List<Integer> sortNotList){
+        this.sortNotList = sortNotList;
+    }
+
+
     /**
      * 获取 开始 事项来源(0.政务网，1.自定义)
      * @return sourceStart
@@ -1827,6 +3192,23 @@ public class MatterQuery extends MatterEntity {
         this.sourceList = sourceList;
     }
 
+    /**
+     * 获取 事项来源(0.政务网，1.自定义)
+     * @return sourceNotList
+     */
+    public List<Integer> getSourceNotList(){
+        return this.sourceNotList;
+    }
+
+    /**
+     * 设置 事项来源(0.政务网，1.自定义)
+     * @param sourceNotList
+     */
+    public void setSourceNotList(List<Integer> sourceNotList){
+        this.sourceNotList = sourceNotList;
+    }
+
+
     /**
      * 获取 开始 创建时间
      * @return createTimeStart
@@ -1923,6 +3305,23 @@ public class MatterQuery extends MatterEntity {
         this.createUserIdList = createUserIdList;
     }
 
+    /**
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
     /**
      * 获取 开始 修改时间
      * @return updateTimeStart
@@ -1970,6 +3369,23 @@ public class MatterQuery extends MatterEntity {
     public void setEvaluationUrlList(List<String> evaluationUrlList){
         this.evaluationUrlList = evaluationUrlList;
     }
+
+    /**
+     * 获取 评价地址
+     * @return evaluationUrlNotList
+     */
+    public List<String> getEvaluationUrlNotList(){
+        return this.evaluationUrlNotList;
+    }
+
+    /**
+     * 设置 评价地址
+     * @param evaluationUrlNotList
+     */
+    public void setEvaluationUrlNotList(List<String> evaluationUrlNotList){
+        this.evaluationUrlNotList = evaluationUrlNotList;
+    }
+
     /**
      * 获取 申请地址
      * @return netApplyUrlList
@@ -1985,6 +3401,23 @@ public class MatterQuery extends MatterEntity {
     public void setNetApplyUrlList(List<String> netApplyUrlList){
         this.netApplyUrlList = netApplyUrlList;
     }
+
+    /**
+     * 获取 申请地址
+     * @return netApplyUrlNotList
+     */
+    public List<String> getNetApplyUrlNotList(){
+        return this.netApplyUrlNotList;
+    }
+
+    /**
+     * 设置 申请地址
+     * @param netApplyUrlNotList
+     */
+    public void setNetApplyUrlNotList(List<String> netApplyUrlNotList){
+        this.netApplyUrlNotList = netApplyUrlNotList;
+    }
+
     /**
      * 设置  序号，主键，自增长
      * @param id
@@ -2030,6 +3463,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public MatterQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+    }
+
     /**
      * 设置  站点ID
      * @param siteId
@@ -2075,6 +3517,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 站点ID
+     * @param siteIdNotList
+     */
+    public MatterQuery siteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+        return this;
+    }
+
 
     /**
      * 设置 从政务系统来的事项id
@@ -2635,6 +4086,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 窗口到现场次数
+     * @param windowToTheSceneNumNotList
+     */
+    public MatterQuery windowToTheSceneNumNotList(List<Integer> windowToTheSceneNumNotList){
+        this.windowToTheSceneNumNotList = windowToTheSceneNumNotList;
+        return this;
+    }
+
 
     /**
      * 设置 是否网上预约,窗口办理选（否.否，是.是）
@@ -2794,6 +4254,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 网办到现场次数
+     * @param onlineToTheSceneNumNotList
+     */
+    public MatterQuery onlineToTheSceneNumNotList(List<Integer> onlineToTheSceneNumNotList){
+        this.onlineToTheSceneNumNotList = onlineToTheSceneNumNotList;
+        return this;
+    }
+
 
     /**
      * 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
@@ -3181,6 +4650,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 数量限制
+     * @param numberLimitNotList
+     */
+    public MatterQuery numberLimitNotList(List<Long> numberLimitNotList){
+        this.numberLimitNotList = numberLimitNotList;
+        return this;
+    }
+
 
     /**
      * 设置 主题类型
@@ -3492,6 +4970,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 排序
+     * @param sortNotList
+     */
+    public MatterQuery sortNotList(List<Integer> sortNotList){
+        this.sortNotList = sortNotList;
+        return this;
+    }
+
     /**
      * 设置  事项来源(0.政务网，1.自定义)
      * @param source
@@ -3537,6 +5024,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 事项来源(0.政务网，1.自定义)
+     * @param sourceNotList
+     */
+    public MatterQuery sourceNotList(List<Integer> sourceNotList){
+        this.sourceNotList = sourceNotList;
+        return this;
+    }
+
 
     /**
      * 设置  创建用户
@@ -3583,6 +5079,15 @@ public class MatterQuery extends MatterEntity {
         return this;
     }
 
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public MatterQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+    }
+
 
 
     /**

base-manager/src/main/java/com/mortals/xhx/module/matter/model/vo/MatterInfo.java

@@ -54,4 +54,5 @@ public class MatterInfo {
      */
     private String promiseTimeLimitShow;
 
+
 }
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/matter/model/vo/MatterVo.java

@@ -16,4 +16,9 @@ public class MatterVo extends BaseEntityLong {
 
     private List<Long> idList;
 
+    /**
+     * 行政处罚排除
+     */
+    private List <String> eventTypeShowNotList;
+
 }
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/matter/web/MatterController.java

@@ -4,6 +4,7 @@ import cn.hutool.setting.Setting;
 import com.alibaba.fastjson.JSONObject;
 import com.mortals.framework.annotation.UnAuth;
 import com.mortals.framework.common.Rest;
+import com.mortals.framework.exception.AppException;
 import com.mortals.framework.model.Context;
 import com.mortals.framework.model.PageInfo;
 import com.mortals.framework.model.Result;
@@ -25,6 +26,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -54,6 +56,23 @@ public class MatterController extends BaseCRUDJsonBodyMappingController<MatterSe
         super.setModuleDesc("基础事项");
     }
 
+    /**
+     * @param query
+     * @param model
+     * @param context
+     * @throws AppException
+     */
+    @Override
+    protected void doListBefore(MatterEntity query, Map<String, Object> model, Context context) throws AppException {
+        if(ObjectUtils.isEmpty(query.getEventTypeShowNotList())){
+            ArrayList<String> notList = new ArrayList<>();
+            notList.add("行政处罚");
+            query.setEventTypeShowNotList(notList);
+        }
+
+        super.doListBefore(query, model, context);
+    }
+
     @Override
     protected void init(Map<String, Object> model, Context context) {
         this.addDict(model, "appoveObjectShow", paramService.getParamBySecondOrganize("Matter", "appoveObjectShow"));

base-manager/src/main/resources/sqlmap/module/matter/MatterMapper.xml

@@ -1361,6 +1361,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('idNotList')">
+            ${_conditionType_} a.id not in
+            <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
             ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
         </if>
@@ -1382,6 +1388,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('siteIdNotList')">
+            ${_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>
@@ -1404,6 +1416,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('tidNotList')">
+            ${_conditionType_} a.tid not in
+            <foreach collection="conditionParamRef.tidNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('tcode')">
             <if test="conditionParamRef.tcode != null and conditionParamRef.tcode != ''">
@@ -1419,6 +1437,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('tcodeNotList')">
+            ${_conditionType_} a.tcode not in
+            <foreach collection="conditionParamRef.tcodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('tname')">
             <if test="conditionParamRef.tname != null and conditionParamRef.tname != ''">
@@ -1434,6 +1458,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('tnameNotList')">
+            ${_conditionType_} a.tname not in
+            <foreach collection="conditionParamRef.tnameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('matterName')">
             <if test="conditionParamRef.matterName != null and conditionParamRef.matterName != ''">
@@ -1449,6 +1479,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('matterNameNotList')">
+            ${_conditionType_} a.matterName not in
+            <foreach collection="conditionParamRef.matterNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('englishName')">
             <if test="conditionParamRef.englishName != null and conditionParamRef.englishName != ''">
@@ -1464,6 +1500,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('englishNameNotList')">
+            ${_conditionType_} a.englishName not in
+            <foreach collection="conditionParamRef.englishNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('matterNo')">
             <if test="conditionParamRef.matterNo != null and conditionParamRef.matterNo != ''">
@@ -1479,6 +1521,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('matterNoNotList')">
+            ${_conditionType_} a.matterNo not in
+            <foreach collection="conditionParamRef.matterNoNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('areaCode')">
             <if test="conditionParamRef.areaCode != null and conditionParamRef.areaCode != ''">
@@ -1494,6 +1542,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('areaCodeNotList')">
+            ${_conditionType_} a.areaCode not in
+            <foreach collection="conditionParamRef.areaCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('deptCode')">
             <if test="conditionParamRef.deptCode != null and conditionParamRef.deptCode != ''">
@@ -1509,6 +1563,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('deptCodeNotList')">
+            ${_conditionType_} a.deptCode not in
+            <foreach collection="conditionParamRef.deptCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('deptName')">
             <if test="conditionParamRef.deptName != null and conditionParamRef.deptName != ''">
@@ -1524,6 +1584,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('deptNameNotList')">
+            ${_conditionType_} a.deptName not in
+            <foreach collection="conditionParamRef.deptNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('powerCode')">
             <if test="conditionParamRef.powerCode != null and conditionParamRef.powerCode != ''">
@@ -1539,6 +1605,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('powerCodeNotList')">
+            ${_conditionType_} a.powerCode not in
+            <foreach collection="conditionParamRef.powerCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('themeCode')">
             <if test="conditionParamRef.themeCode != null and conditionParamRef.themeCode != ''">
@@ -1554,6 +1626,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('themeCodeNotList')">
+            ${_conditionType_} a.themeCode not in
+            <foreach collection="conditionParamRef.themeCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('usertypeCode')">
             <if test="conditionParamRef.usertypeCode != null and conditionParamRef.usertypeCode != ''">
@@ -1569,6 +1647,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('usertypeCodeNotList')">
+            ${_conditionType_} a.usertypeCode not in
+            <foreach collection="conditionParamRef.usertypeCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('groupName')">
             <if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
@@ -1584,6 +1668,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('groupNameNotList')">
+            ${_conditionType_} a.groupName not in
+            <foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('url')">
             <if test="conditionParamRef.url != null and conditionParamRef.url != ''">
@@ -1599,6 +1689,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('urlNotList')">
+            ${_conditionType_} a.url not in
+            <foreach collection="conditionParamRef.urlNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('haveGetMatterInfo')">
             <if test="conditionParamRef.haveGetMatterInfo != null and conditionParamRef.haveGetMatterInfo != ''">
@@ -1614,6 +1710,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('haveGetMatterInfoNotList')">
+            ${_conditionType_} a.haveGetMatterInfo not in
+            <foreach collection="conditionParamRef.haveGetMatterInfoNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('belongDept')">
             <if test="conditionParamRef.belongDept != null and conditionParamRef.belongDept != ''">
@@ -1629,6 +1731,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('belongDeptNotList')">
+            ${_conditionType_} a.belongDept not in
+            <foreach collection="conditionParamRef.belongDeptNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('appoveObjectShow')">
             <if test="conditionParamRef.appoveObjectShow != null and conditionParamRef.appoveObjectShow != ''">
@@ -1644,6 +1752,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('appoveObjectShowNotList')">
+            ${_conditionType_} a.appoveObjectShow not in
+            <foreach collection="conditionParamRef.appoveObjectShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('operatScopeShow')">
             <if test="conditionParamRef.operatScopeShow != null and conditionParamRef.operatScopeShow != ''">
@@ -1659,6 +1773,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('operatScopeShowNotList')">
+            ${_conditionType_} a.operatScopeShow not in
+            <foreach collection="conditionParamRef.operatScopeShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('appoveTimeLimitShow')">
             <if test="conditionParamRef.appoveTimeLimitShow != null and conditionParamRef.appoveTimeLimitShow != ''">
@@ -1674,6 +1794,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('appoveTimeLimitShowNotList')">
+            ${_conditionType_} a.appoveTimeLimitShow not in
+            <foreach collection="conditionParamRef.appoveTimeLimitShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('handleType')">
             <if test="conditionParamRef.handleType != null and conditionParamRef.handleType != ''">
@@ -1689,6 +1815,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('handleTypeNotList')">
+            ${_conditionType_} a.handleType not in
+            <foreach collection="conditionParamRef.handleTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('legalTimeLimitShow')">
             <if test="conditionParamRef.legalTimeLimitShow != null and conditionParamRef.legalTimeLimitShow != ''">
@@ -1704,6 +1836,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('legalTimeLimitShowNotList')">
+            ${_conditionType_} a.legalTimeLimitShow not in
+            <foreach collection="conditionParamRef.legalTimeLimitShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('legalEndExplain')">
             <if test="conditionParamRef.legalEndExplain != null and conditionParamRef.legalEndExplain != ''">
@@ -1719,6 +1857,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('legalEndExplainNotList')">
+            ${_conditionType_} a.legalEndExplain not in
+            <foreach collection="conditionParamRef.legalEndExplainNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('promiseTimeLimitShow')">
             <if test="conditionParamRef.promiseTimeLimitShow != null and conditionParamRef.promiseTimeLimitShow != ''">
@@ -1734,6 +1878,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('promiseTimeLimitShowNotList')">
+            ${_conditionType_} a.promiseTimeLimitShow not in
+            <foreach collection="conditionParamRef.promiseTimeLimitShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('promiseEndExplain')">
             <if test="conditionParamRef.promiseEndExplain != null and conditionParamRef.promiseEndExplain != ''">
@@ -1749,6 +1899,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('promiseEndExplainNotList')">
+            ${_conditionType_} a.promiseEndExplain not in
+            <foreach collection="conditionParamRef.promiseEndExplainNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isChargesShow')">
             <if test="conditionParamRef.isChargesShow != null and conditionParamRef.isChargesShow != ''">
@@ -1764,6 +1920,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isChargesShowNotList')">
+            ${_conditionType_} a.isChargesShow not in
+            <foreach collection="conditionParamRef.isChargesShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('certificationLevelsShow')">
             <if test="conditionParamRef.certificationLevelsShow != null and conditionParamRef.certificationLevelsShow != ''">
@@ -1779,6 +1941,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('certificationLevelsShowNotList')">
+            ${_conditionType_} a.certificationLevelsShow not in
+            <foreach collection="conditionParamRef.certificationLevelsShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('planTakeTime')">
             <if test="conditionParamRef.planTakeTime != null ">
@@ -1824,6 +1992,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('specialProcedureNotList')">
+            ${_conditionType_} a.specialProcedure not in
+            <foreach collection="conditionParamRef.specialProcedureNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('windowToTheSceneNum')">
             <if test="conditionParamRef.windowToTheSceneNum != null ">
                 ${_conditionType_} a.windowToTheSceneNum = #{${_conditionParam_}.windowToTheSceneNum}
@@ -1838,6 +2012,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('windowToTheSceneNumNotList')">
+            ${_conditionType_} a.windowToTheSceneNum not in
+            <foreach collection="conditionParamRef.windowToTheSceneNumNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('windowToTheSceneNumStart') and conditionParamRef.windowToTheSceneNumStart != null">
             ${_conditionType_} a.windowToTheSceneNum <![CDATA[ >= ]]> #{${_conditionParam_}.windowToTheSceneNumStart}
         </if>
@@ -1860,6 +2040,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isOnlineSubscribeShowNotList')">
+            ${_conditionType_} a.isOnlineSubscribeShow not in
+            <foreach collection="conditionParamRef.isOnlineSubscribeShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isExpressTakeShow')">
             <if test="conditionParamRef.isExpressTakeShow != null and conditionParamRef.isExpressTakeShow != ''">
@@ -1875,6 +2061,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isExpressTakeShowNotList')">
+            ${_conditionType_} a.isExpressTakeShow not in
+            <foreach collection="conditionParamRef.isExpressTakeShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isProvinceAcquisitionShow')">
             <if test="conditionParamRef.isProvinceAcquisitionShow != null and conditionParamRef.isProvinceAcquisitionShow != ''">
@@ -1890,6 +2082,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isProvinceAcquisitionShowNotList')">
+            ${_conditionType_} a.isProvinceAcquisitionShow not in
+            <foreach collection="conditionParamRef.isProvinceAcquisitionShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isApplyProvinceShow')">
             <if test="conditionParamRef.isApplyProvinceShow != null and conditionParamRef.isApplyProvinceShow != ''">
@@ -1905,6 +2103,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isApplyProvinceShowNotList')">
+            ${_conditionType_} a.isApplyProvinceShow not in
+            <foreach collection="conditionParamRef.isApplyProvinceShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('mustSceneExplain')">
             <if test="conditionParamRef.mustSceneExplain != null and conditionParamRef.mustSceneExplain != ''">
@@ -1920,6 +2124,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('mustSceneExplainNotList')">
+            ${_conditionType_} a.mustSceneExplain not in
+            <foreach collection="conditionParamRef.mustSceneExplainNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('onlineType')">
             <if test="conditionParamRef.onlineType != null and conditionParamRef.onlineType != ''">
@@ -1935,6 +2145,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('onlineTypeNotList')">
+            ${_conditionType_} a.onlineType not in
+            <foreach collection="conditionParamRef.onlineTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('onlineToTheSceneNum')">
             <if test="conditionParamRef.onlineToTheSceneNum != null ">
                 ${_conditionType_} a.onlineToTheSceneNum = #{${_conditionParam_}.onlineToTheSceneNum}
@@ -1949,6 +2165,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('onlineToTheSceneNumNotList')">
+            ${_conditionType_} a.onlineToTheSceneNum not in
+            <foreach collection="conditionParamRef.onlineToTheSceneNumNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('onlineToTheSceneNumStart') and conditionParamRef.onlineToTheSceneNumStart != null">
             ${_conditionType_} a.onlineToTheSceneNum <![CDATA[ >= ]]> #{${_conditionParam_}.onlineToTheSceneNumStart}
         </if>
@@ -1971,6 +2193,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('onlineOperatDeepNotList')">
+            ${_conditionType_} a.onlineOperatDeep not in
+            <foreach collection="conditionParamRef.onlineOperatDeepNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isExpressTakeOnlineShow')">
             <if test="conditionParamRef.isExpressTakeOnlineShow != null and conditionParamRef.isExpressTakeOnlineShow != ''">
@@ -1986,6 +2214,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isExpressTakeOnlineShowNotList')">
+            ${_conditionType_} a.isExpressTakeOnlineShow not in
+            <foreach collection="conditionParamRef.isExpressTakeOnlineShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isDoorTakeShow')">
             <if test="conditionParamRef.isDoorTakeShow != null and conditionParamRef.isDoorTakeShow != ''">
@@ -2001,6 +2235,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isDoorTakeShowNotList')">
+            ${_conditionType_} a.isDoorTakeShow not in
+            <foreach collection="conditionParamRef.isDoorTakeShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('onlineMustSceneExplain')">
             <if test="conditionParamRef.onlineMustSceneExplain != null and conditionParamRef.onlineMustSceneExplain != ''">
@@ -2016,6 +2256,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('onlineMustSceneExplainNotList')">
+            ${_conditionType_} a.onlineMustSceneExplain not in
+            <foreach collection="conditionParamRef.onlineMustSceneExplainNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('performDeptType')">
             <if test="conditionParamRef.performDeptType != null and conditionParamRef.performDeptType != ''">
@@ -2031,6 +2277,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('performDeptTypeNotList')">
+            ${_conditionType_} a.performDeptType not in
+            <foreach collection="conditionParamRef.performDeptTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('matterEdition')">
             <if test="conditionParamRef.matterEdition != null and conditionParamRef.matterEdition != ''">
@@ -2046,6 +2298,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('matterEditionNotList')">
+            ${_conditionType_} a.matterEdition not in
+            <foreach collection="conditionParamRef.matterEditionNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('eventTypeShow')">
             <if test="conditionParamRef.eventTypeShow != null and conditionParamRef.eventTypeShow != ''">
@@ -2061,6 +2319,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('eventTypeShowNotList')">
+            ${_conditionType_} a.eventTypeShow not in
+            <foreach collection="conditionParamRef.eventTypeShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('performHierarchyShow')">
             <if test="conditionParamRef.performHierarchyShow != null and conditionParamRef.performHierarchyShow != ''">
@@ -2076,6 +2340,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('performHierarchyShowNotList')">
+            ${_conditionType_} a.performHierarchyShow not in
+            <foreach collection="conditionParamRef.performHierarchyShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('powerSourceShow')">
             <if test="conditionParamRef.powerSourceShow != null and conditionParamRef.powerSourceShow != ''">
@@ -2091,6 +2361,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('powerSourceShowNotList')">
+            ${_conditionType_} a.powerSourceShow not in
+            <foreach collection="conditionParamRef.powerSourceShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('performDeptTypeShow')">
             <if test="conditionParamRef.performDeptTypeShow != null and conditionParamRef.performDeptTypeShow != ''">
@@ -2106,6 +2382,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('performDeptTypeShowNotList')">
+            ${_conditionType_} a.performDeptTypeShow not in
+            <foreach collection="conditionParamRef.performDeptTypeShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('goveServiceCenterShow')">
             <if test="conditionParamRef.goveServiceCenterShow != null and conditionParamRef.goveServiceCenterShow != ''">
@@ -2121,6 +2403,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('goveServiceCenterShowNotList')">
+            ${_conditionType_} a.goveServiceCenterShow not in
+            <foreach collection="conditionParamRef.goveServiceCenterShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isConvenientCenterShow')">
             <if test="conditionParamRef.isConvenientCenterShow != null and conditionParamRef.isConvenientCenterShow != ''">
@@ -2136,6 +2424,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isConvenientCenterShowNotList')">
+            ${_conditionType_} a.isConvenientCenterShow not in
+            <foreach collection="conditionParamRef.isConvenientCenterShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('terminalHandle')">
             <if test="conditionParamRef.terminalHandle != null and conditionParamRef.terminalHandle != ''">
@@ -2151,6 +2445,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('terminalHandleNotList')">
+            ${_conditionType_} a.terminalHandle not in
+            <foreach collection="conditionParamRef.terminalHandleNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isOnline')">
             <if test="conditionParamRef.isOnline != null and conditionParamRef.isOnline != ''">
@@ -2166,6 +2466,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isOnlineNotList')">
+            ${_conditionType_} a.isOnline not in
+            <foreach collection="conditionParamRef.isOnlineNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('isOnlinePayShow')">
             <if test="conditionParamRef.isOnlinePayShow != null and conditionParamRef.isOnlinePayShow != ''">
@@ -2181,6 +2487,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('isOnlinePayShowNotList')">
+            ${_conditionType_} a.isOnlinePayShow not in
+            <foreach collection="conditionParamRef.isOnlinePayShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('entrustmentDepartmen')">
             <if test="conditionParamRef.entrustmentDepartmen != null and conditionParamRef.entrustmentDepartmen != ''">
@@ -2196,6 +2508,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('entrustmentDepartmenNotList')">
+            ${_conditionType_} a.entrustmentDepartmen not in
+            <foreach collection="conditionParamRef.entrustmentDepartmenNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('jointInfoShow')">
             <if test="conditionParamRef.jointInfoShow != null and conditionParamRef.jointInfoShow != ''">
@@ -2211,6 +2529,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('jointInfoShowNotList')">
+            ${_conditionType_} a.jointInfoShow not in
+            <foreach collection="conditionParamRef.jointInfoShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('matterStatus')">
             <if test="conditionParamRef.matterStatus != null and conditionParamRef.matterStatus != ''">
@@ -2226,6 +2550,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('matterStatusNotList')">
+            ${_conditionType_} a.matterStatus not in
+            <foreach collection="conditionParamRef.matterStatusNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('numberLimit')">
             <if test="conditionParamRef.numberLimit != null ">
                 ${_conditionType_} a.numberLimit = #{${_conditionParam_}.numberLimit}
@@ -2240,6 +2570,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('numberLimitNotList')">
+            ${_conditionType_} a.numberLimit not in
+            <foreach collection="conditionParamRef.numberLimitNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('numberLimitStart') and conditionParamRef.numberLimitStart != null">
             ${_conditionType_} a.numberLimit <![CDATA[ >= ]]> #{${_conditionParam_}.numberLimitStart}
         </if>
@@ -2262,6 +2598,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('typeNotList')">
+            ${_conditionType_} a.type not in
+            <foreach collection="conditionParamRef.typeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('baseCode')">
             <if test="conditionParamRef.baseCode != null and conditionParamRef.baseCode != ''">
@@ -2277,6 +2619,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('baseCodeNotList')">
+            ${_conditionType_} a.baseCode not in
+            <foreach collection="conditionParamRef.baseCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('implementCode')">
             <if test="conditionParamRef.implementCode != null and conditionParamRef.implementCode != ''">
@@ -2292,6 +2640,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('implementCodeNotList')">
+            ${_conditionType_} a.implementCode not in
+            <foreach collection="conditionParamRef.implementCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('implementBodyCode')">
             <if test="conditionParamRef.implementBodyCode != null and conditionParamRef.implementBodyCode != ''">
@@ -2307,6 +2661,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('implementBodyCodeNotList')">
+            ${_conditionType_} a.implementBodyCode not in
+            <foreach collection="conditionParamRef.implementBodyCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('operateItemCode')">
             <if test="conditionParamRef.operateItemCode != null and conditionParamRef.operateItemCode != ''">
@@ -2322,6 +2682,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('operateItemCodeNotList')">
+            ${_conditionType_} a.operateItemCode not in
+            <foreach collection="conditionParamRef.operateItemCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('townshipName')">
             <if test="conditionParamRef.townshipName != null and conditionParamRef.townshipName != ''">
@@ -2337,6 +2703,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('townshipNameNotList')">
+            ${_conditionType_} a.townshipName not in
+            <foreach collection="conditionParamRef.townshipNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('townshipCode')">
             <if test="conditionParamRef.townshipCode != null and conditionParamRef.townshipCode != ''">
@@ -2352,6 +2724,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('townshipCodeNotList')">
+            ${_conditionType_} a.townshipCode not in
+            <foreach collection="conditionParamRef.townshipCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('villageName')">
             <if test="conditionParamRef.villageName != null and conditionParamRef.villageName != ''">
@@ -2367,6 +2745,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('villageNameNotList')">
+            ${_conditionType_} a.villageName not in
+            <foreach collection="conditionParamRef.villageNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('villageCode')">
             <if test="conditionParamRef.villageCode != null and conditionParamRef.villageCode != ''">
@@ -2382,6 +2766,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('villageCodeNotList')">
+            ${_conditionType_} a.villageCode not in
+            <foreach collection="conditionParamRef.villageCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('operateTime')">
             <if test="conditionParamRef.operateTime != null and conditionParamRef.operateTime != ''">
@@ -2397,6 +2787,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('operateTimeNotList')">
+            ${_conditionType_} a.operateTime not in
+            <foreach collection="conditionParamRef.operateTimeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('operateSite')">
             <if test="conditionParamRef.operateSite != null and conditionParamRef.operateSite != ''">
@@ -2412,6 +2808,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('operateSiteNotList')">
+            ${_conditionType_} a.operateSite not in
+            <foreach collection="conditionParamRef.operateSiteNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('cousultingShow')">
             <if test="conditionParamRef.cousultingShow != null and conditionParamRef.cousultingShow != ''">
@@ -2427,6 +2829,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('cousultingShowNotList')">
+            ${_conditionType_} a.cousultingShow not in
+            <foreach collection="conditionParamRef.cousultingShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('cousultingTelephoneShow')">
             <if test="conditionParamRef.cousultingTelephoneShow != null and conditionParamRef.cousultingTelephoneShow != ''">
@@ -2442,6 +2850,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('cousultingTelephoneShowNotList')">
+            ${_conditionType_} a.cousultingTelephoneShow not in
+            <foreach collection="conditionParamRef.cousultingTelephoneShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('superviseShow')">
             <if test="conditionParamRef.superviseShow != null and conditionParamRef.superviseShow != ''">
@@ -2457,6 +2871,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('superviseShowNotList')">
+            ${_conditionType_} a.superviseShow not in
+            <foreach collection="conditionParamRef.superviseShowNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('sort')">
             <if test="conditionParamRef.sort != null ">
                 ${_conditionType_} a.sort = #{${_conditionParam_}.sort}
@@ -2471,6 +2891,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('sortNotList')">
+            ${_conditionType_} a.sort not in
+            <foreach collection="conditionParamRef.sortNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('sortStart') and conditionParamRef.sortStart != null">
             ${_conditionType_} a.sort <![CDATA[ >= ]]> #{${_conditionParam_}.sortStart}
         </if>
@@ -2492,6 +2918,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('sourceNotList')">
+            ${_conditionType_} a.source not in
+            <foreach collection="conditionParamRef.sourceNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('sourceStart') and conditionParamRef.sourceStart != null">
             ${_conditionType_} a.source <![CDATA[ >= ]]> #{${_conditionParam_}.sourceStart}
         </if>
@@ -2528,6 +2960,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('createUserIdNotList')">
+            ${_conditionType_} a.createUserId not in
+            <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
             ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
         </if>
@@ -2565,6 +3003,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('evaluationUrlNotList')">
+            ${_conditionType_} a.evaluationUrl not in
+            <foreach collection="conditionParamRef.evaluationUrlNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('netApplyUrl')">
             <if test="conditionParamRef.netApplyUrl != null and conditionParamRef.netApplyUrl != ''">
@@ -2580,6 +3024,12 @@
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('netApplyUrlNotList')">
+            ${_conditionType_} a.netApplyUrl not in
+            <foreach collection="conditionParamRef.netApplyUrlNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">

base-manager/src/test/java/com/mortals/httpclient/app/AppController.http

@@ -77,8 +77,7 @@ client.global.set("App_id", JSON.parse(response.body).data.id);
 %}
 
 ###自助终端应用查看
-GET {{baseUrl}}/app/info?id={{App_id}}
-Authorization: {{authToken}}
+GET {{baseUrl}}/app/info?id=1
 Accept: application/json
 
 ###自助终端应用编辑

base-manager/src/test/java/com/mortals/httpclient/matter/MatterController.http

@@ -20,9 +20,8 @@ POST {{baseUrl}}/matter/list
 Content-Type: application/json
 
 {
-  "siteId": "",
-  "matterName": "%对墓穴占地面积超过标准的处罚%",
-  "deptCode":"",
+  "siteId": 1,
+  "eventTypeShowNotList": ["行政处罚"],
   "page": 1,
   "size": 10
 }

base-manager/src/test/java/com/mortals/httpclient/site/SiteController.http

 
 ###站点列表
 POST {{baseUrl}}/site/list
-Authorization: {{authToken}}
 Content-Type: application/json
 
 {

base-manager/src/test/java/com/mortals/httpclient/site/SiteMatterController.http

@@ -6,7 +6,7 @@ Content-Type: application/json
 {
     "siteId":1,
     "page":1,
-    "size":-1
+    "size":10
 }
 
 

portal-manager/pom.xml

@@ -116,7 +116,7 @@
 				<profiles.log.level>INFO</profiles.log.level>
 				<profiles.log.path>/home/mortals/app/logs</profiles.log.path>
 				<package.environment>yibin</package.environment>
-				<skipUi>true</skipUi>
+				<skipUi>false</skipUi>
 			</properties>
 		</profile>
 

portal-manager/src/test/java/com/mortals/httpclient/http-client.env.json

@@ -12,6 +12,10 @@
     "baseUrl": "http://10.12.185.213:11078/zwfw"
   },
 
+  "portal-yibin-web": {
+    "baseUrl": "http://112.19.80.237:11078/zwfw"
+  },
+
   "portal-yibin-web": {
     "baseUrl": "http://112.19.80.237:11078/zwfw"
   }

portal-manager/src/test/java/com/mortals/httpclient/param/ParamController.http

 
 ###参数信息业务列表
 POST {{baseUrl}}/param/list
-Authorization: {{authToken}}
 Content-Type: application/json
 
 {
     "page":1,
-    "size":10
+    "size":1
 }
 
 

smart-gateway/src/main/resources/bootstrap.yml

@@ -85,6 +85,15 @@ spring:
           metadata:
             response-timeout: 200000
             connect-timeout: 200000
+        # 自助服务
+        - id: sst-manager
+          #uri: http://192.168.0.98:17002
+          uri: lb://sst-manager
+          predicates:
+            - Path=/sst/**
+          metadata:
+            response-timeout: 200000
+            connect-timeout: 200000
     nacos:
       # Nacos 作为注册中心的配置项，对应 NacosDiscoveryProperties 配置类
       discovery: