Skip to content

S
self-service
Commit 9c5b55e7 authored by 廖旭伟's avatar 廖旭伟
Browse files
Options

申报事项管理，材料管理，公共库管理

parent a017ae9f
Show whitespace changes
Inline Side-by-side
Showing with 24202 additions and 1 deletion
common-lib/src/main/java/com/mortals/xhx/common/pdu/RespData.java
View file @ 9c5b55e7
...@@ -14,6 +14,6 @@ public class RespData<T> { ...@@ -14,6 +14,6 @@ public class RespData<T> {
private T data; private T data;
private T entity; private T entity;
private PageInfo pageInfo; private PageInfo pageInfo;
private Object dict;
} }
common-lib/src/main/java/com/mortals/xhx/common/pdu/dept/DeptPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.dept;
import com.mortals.framework.model.BaseEntityLong;
public class DeptPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 从政务系统来的部门id
*/
private String tid;
/**
* 从政务系统来的部门name
*/
private String tname;
/**
* 部门名称
*/
private String name;
/**
* 从政务系统来的别名
*/
private String simpleName;
/**
* 站点ID
*/
private Long siteId;
/**
* 部门简称
*/
private String deptAbb;
/**
* 部门电话
*/
private String deptTelphone;
/**
* 部门编号
*/
private String deptNumber;
/**
* 填单机展示 (0.否，1.是)
*/
private Integer isAutotable;
/**
* 预约展示 (0.否，1.是)
*/
private Integer isOrder;
/**
* 背靠背展示 (0.否，1.是)
*/
private Integer isBkb;
/**
* 办事指南展示 (0.否，1.是)
*/
private Integer isWorkGuide;
/**
* 是否使用 (0.否，1.是)
*/
private Integer usValid;
/**
* 部门电话是否展示 (0.否，1.是)
*/
private Integer isSecphone;
/**
* 是否展示英文 (0.否，1.是)
*/
private Integer isEnglish;
/**
* 排序
*/
private Integer sort;
/**
* 部门来源
*/
private Integer source;
/**
* 关联事项数量
*/
private Integer total;
public DeptPdu(){}
/**
* 获取 从政务系统来的部门id
* @return String
*/
public String getTid(){
return tid;
}
/**
* 设置 从政务系统来的部门id
* @param tid
*/
public void setTid(String tid){
this.tid = tid;
}
/**
* 获取 从政务系统来的部门name
* @return String
*/
public String getTname(){
return tname;
}
/**
* 设置 从政务系统来的部门name
* @param tname
*/
public void setTname(String tname){
this.tname = tname;
}
/**
* 获取 部门名称
* @return String
*/
public String getName(){
return name;
}
/**
* 设置 部门名称
* @param name
*/
public void setName(String name){
this.name = name;
}
/**
* 获取 从政务系统来的别名
* @return String
*/
public String getSimpleName(){
return simpleName;
}
/**
* 设置 从政务系统来的别名
* @param simpleName
*/
public void setSimpleName(String simpleName){
this.simpleName = simpleName;
}
/**
* 获取 站点ID
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点ID
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 部门简称
* @return String
*/
public String getDeptAbb(){
return deptAbb;
}
/**
* 设置 部门简称
* @param deptAbb
*/
public void setDeptAbb(String deptAbb){
this.deptAbb = deptAbb;
}
/**
* 获取 部门电话
* @return String
*/
public String getDeptTelphone(){
return deptTelphone;
}
/**
* 设置 部门电话
* @param deptTelphone
*/
public void setDeptTelphone(String deptTelphone){
this.deptTelphone = deptTelphone;
}
/**
* 获取 部门编号
* @return String
*/
public String getDeptNumber(){
return deptNumber;
}
/**
* 设置 部门编号
* @param deptNumber
*/
public void setDeptNumber(String deptNumber){
this.deptNumber = deptNumber;
}
/**
* 获取 填单机展示 (0.否，1.是)
* @return Integer
*/
public Integer getIsAutotable(){
return isAutotable;
}
/**
* 设置 填单机展示 (0.否，1.是)
* @param isAutotable
*/
public void setIsAutotable(Integer isAutotable){
this.isAutotable = isAutotable;
}
/**
* 获取 预约展示 (0.否，1.是)
* @return Integer
*/
public Integer getIsOrder(){
return isOrder;
}
/**
* 设置 预约展示 (0.否，1.是)
* @param isOrder
*/
public void setIsOrder(Integer isOrder){
this.isOrder = isOrder;
}
/**
* 获取 背靠背展示 (0.否，1.是)
* @return Integer
*/
public Integer getIsBkb(){
return isBkb;
}
/**
* 设置 背靠背展示 (0.否，1.是)
* @param isBkb
*/
public void setIsBkb(Integer isBkb){
this.isBkb = isBkb;
}
/**
* 获取 办事指南展示 (0.否，1.是)
* @return Integer
*/
public Integer getIsWorkGuide(){
return isWorkGuide;
}
/**
* 设置 办事指南展示 (0.否，1.是)
* @param isWorkGuide
*/
public void setIsWorkGuide(Integer isWorkGuide){
this.isWorkGuide = isWorkGuide;
}
/**
* 获取 是否使用 (0.否，1.是)
* @return Integer
*/
public Integer getUsValid(){
return usValid;
}
/**
* 设置 是否使用 (0.否，1.是)
* @param usValid
*/
public void setUsValid(Integer usValid){
this.usValid = usValid;
}
/**
* 获取 部门电话是否展示 (0.否，1.是)
* @return Integer
*/
public Integer getIsSecphone(){
return isSecphone;
}
/**
* 设置 部门电话是否展示 (0.否，1.是)
* @param isSecphone
*/
public void setIsSecphone(Integer isSecphone){
this.isSecphone = isSecphone;
}
/**
* 获取 是否展示英文 (0.否，1.是)
* @return Integer
*/
public Integer getIsEnglish(){
return isEnglish;
}
/**
* 设置 是否展示英文 (0.否，1.是)
* @param isEnglish
*/
public void setIsEnglish(Integer isEnglish){
this.isEnglish = isEnglish;
}
/**
* 获取 排序
* @return Integer
*/
public Integer getSort(){
return sort;
}
/**
* 设置 排序
* @param sort
*/
public void setSort(Integer sort){
this.sort = sort;
}
/**
* 获取 部门来源
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 部门来源
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
/**
* 获取 关联事项数量
* @return Integer
*/
public Integer getTotal(){
return total;
}
/**
* 设置 关联事项数量
* @param total
*/
public void setTotal(Integer total){
this.total = total;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof DeptPdu) {
DeptPdu tmp = (DeptPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",tid:").append(getTid());
sb.append(",tname:").append(getTname());
sb.append(",name:").append(getName());
sb.append(",simpleName:").append(getSimpleName());
sb.append(",siteId:").append(getSiteId());
sb.append(",deptAbb:").append(getDeptAbb());
sb.append(",deptTelphone:").append(getDeptTelphone());
sb.append(",deptNumber:").append(getDeptNumber());
sb.append(",isAutotable:").append(getIsAutotable());
sb.append(",isOrder:").append(getIsOrder());
sb.append(",isBkb:").append(getIsBkb());
sb.append(",isWorkGuide:").append(getIsWorkGuide());
sb.append(",usValid:").append(getUsValid());
sb.append(",isSecphone:").append(getIsSecphone());
sb.append(",isEnglish:").append(getIsEnglish());
sb.append(",sort:").append(getSort());
sb.append(",source:").append(getSource());
sb.append(",total:").append(getTotal());
return sb.toString();
}
public void initAttrValue(){
this.tid = null;
this.tname = null;
this.name = null;
this.simpleName = null;
this.siteId = null;
this.deptAbb = null;
this.deptTelphone = null;
this.deptNumber = null;
this.isAutotable = 1;
this.isOrder = 1;
this.isBkb = 1;
this.isWorkGuide = 1;
this.usValid = 1;
this.isSecphone = 1;
this.isEnglish = 1;
this.sort = 0;
this.source = 0;
this.total = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterAcceptPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
import java.util.List;
public class MatterAcceptPdu extends BaseEntityLong {
/**
* 基础事项表id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 受理条件
*/
private String content;
/**
* 事项来源 (0.政务网，1.自定义)
*/
private Integer source;
/** 主键，自增长列表 */
private List<Long> idList;
public Long getMatterId() {
return matterId;
}
public void setMatterId(Long matterId) {
this.matterId = matterId;
}
public String getMatterCode() {
return matterCode;
}
public void setMatterCode(String matterCode) {
this.matterCode = matterCode;
}
public String getMatterName() {
return matterName;
}
public void setMatterName(String matterName) {
this.matterName = matterName;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Integer getSource() {
return source;
}
public void setSource(Integer source) {
this.source = source;
}
public List<Long> getIdList() {
return idList;
}
public void setIdList(List<Long> idList) {
this.idList = idList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterAcceptPdu) {
MatterAcceptPdu tmp = (MatterAcceptPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",content:").append(getContent());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = 0L;
this.matterCode = "";
this.matterName = "";
this.content = "";
this.source = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterChargesPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
import java.util.List;
public class MatterChargesPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 事项基础表matter id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 收费标准
*/
private String content;
/**
* 事项来源，(0.政务网，1.自定义)
*/
private Integer source;
/** 主键，自增长列表 */
private List<Long> idList;
public Long getMatterId() {
return matterId;
}
public void setMatterId(Long matterId) {
this.matterId = matterId;
}
public String getMatterCode() {
return matterCode;
}
public void setMatterCode(String matterCode) {
this.matterCode = matterCode;
}
public String getMatterName() {
return matterName;
}
public void setMatterName(String matterName) {
this.matterName = matterName;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Integer getSource() {
return source;
}
public void setSource(Integer source) {
this.source = source;
}
public List<Long> getIdList() {
return idList;
}
public void setIdList(List<Long> idList) {
this.idList = idList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterChargesPdu) {
MatterChargesPdu tmp = (MatterChargesPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",content:").append(getContent());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = 0L;
this.matterCode = "";
this.matterName = "";
this.content = "";
this.source = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterDatumFilePdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
public class MatterDatumFilePdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 材料id
*/
private Long datumId;
/**
* 事项编码
*/
private String matterCode;
/**
* 材料名
*/
private String materialName;
/**
* 附件名称
*/
private String fileName;
/**
* 附件下载地址
*/
private String fileUrl;
/**
* 附件本地下载地址
*/
private String localFileUrl;
/**
* 附件类型 (示例样表.示例样表，空白表格.空白表格)
*/
private String filetype;
/**
* 附件来源 (0.政务网，1.自定义)
*/
private Integer source;
public Long getDatumId() {
return datumId;
}
public void setDatumId(Long datumId) {
this.datumId = datumId;
}
public String getMatterCode() {
return matterCode;
}
public void setMatterCode(String matterCode) {
this.matterCode = matterCode;
}
public String getMaterialName() {
return materialName;
}
public void setMaterialName(String materialName) {
this.materialName = materialName;
}
public String getFileName() {
return fileName;
}
public void setFileName(String fileName) {
this.fileName = fileName;
}
public String getFileUrl() {
return fileUrl;
}
public void setFileUrl(String fileUrl) {
this.fileUrl = fileUrl;
}
public String getLocalFileUrl() {
return localFileUrl;
}
public void setLocalFileUrl(String localFileUrl) {
this.localFileUrl = localFileUrl;
}
public String getFiletype() {
return filetype;
}
public void setFiletype(String filetype) {
this.filetype = filetype;
}
public Integer getSource() {
return source;
}
public void setSource(Integer source) {
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterDatumFilePdu) {
MatterDatumFilePdu tmp = (MatterDatumFilePdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",datumId:").append(getDatumId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",materialName:").append(getMaterialName());
sb.append(",fileName:").append(getFileName());
sb.append(",fileUrl:").append(getFileUrl());
sb.append(",localFileUrl:").append(getLocalFileUrl());
sb.append(",filetype:").append(getFiletype());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.datumId = null;
this.matterCode = "";
this.materialName = "";
this.fileName = "";
this.fileUrl = "";
this.localFileUrl = "";
this.filetype = "示例样表";
this.source = 1;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterDatumPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
import java.util.ArrayList;
import java.util.List;
public class MatterDatumPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 事项id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 材料名
*/
private String materialName;
/**
* 必交性（非必要.非必要，必要.必要，必要|容缺后补.必要|容缺后补，非必要|容缺后补.非必要|容缺后补）
*/
private String isMust;
/**
* 材料类型（无.无，原件.原件，复印件.复印件，原件和复印件.原件和复印件)
*/
private String materialType;
/**
* 材料形式（纸质.纸质，电子.电子，纸质|电子.纸质|电子）
*/
private String materialProperty;
/**
* 电子材料格式（无.无，不限.不限，jpg.jpg，jpeg.jpeg，pdf.pdf，word.word，pdf|jpg|jpeg.pdf|jpg|jpeg，pdf|jpg.pdf|jpg）
*/
private String electronicgs;
/**
* 材料来源渠道（无.无，申请人自备.申请人自备，政府部门核发.政府部门核发，其他.其他）
*/
private String materialSource;
/**
* 纸质材料份数
*/
private Integer paperNum;
/**
* 纸质材料规格
*/
private String paperGg;
/**
* 减免模式（无.无，减.减，免.免）
*/
private String jianmMs;
/**
* 盖章方式
*/
private String sealWay;
/**
* 是否减免（否.否，是.是）
*/
private String isjianm;
/**
* 材料是否容缺（必要.必要，非必要.非必要）
*/
private String isLack;
/**
* 材料地址
*/
private String ybUrl;
/**
* 来源渠道说明
*/
private String materialSourceSm;
/**
* 填报须知
*/
private String remarkSub;
/**
* 要求提供材料的依据
*/
private String clauseContent;
/**
* 受理标准
*/
private String summary;
/**
* 备注
*/
private String remark;
/**
* 事项来源(0.政务网，1.自定义)
*/
private Integer source;
/** 事项id列表 */
private List <Long> matterIdList;
/**
* 材料附件信息
*/
private List<MatterDatumFilePdu> matterDatumFileList=new ArrayList<>();;
public MatterDatumPdu(){}
/**
* 获取 事项id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 材料名
* @return String
*/
public String getMaterialName(){
return materialName;
}
/**
* 设置 材料名
* @param materialName
*/
public void setMaterialName(String materialName){
this.materialName = materialName;
}
/**
* 获取 必交性（非必要.非必要，必要.必要，必要|容缺后补.必要|容缺后补，非必要|容缺后补.非必要|容缺后补）
* @return String
*/
public String getIsMust(){
return isMust;
}
/**
* 设置 必交性（非必要.非必要，必要.必要，必要|容缺后补.必要|容缺后补，非必要|容缺后补.非必要|容缺后补）
* @param isMust
*/
public void setIsMust(String isMust){
this.isMust = isMust;
}
/**
* 获取 材料类型（无.无，原件.原件，复印件.复印件，原件和复印件.原件和复印件)
* @return String
*/
public String getMaterialType(){
return materialType;
}
/**
* 设置 材料类型（无.无，原件.原件，复印件.复印件，原件和复印件.原件和复印件)
* @param materialType
*/
public void setMaterialType(String materialType){
this.materialType = materialType;
}
/**
* 获取 材料形式（纸质.纸质，电子.电子，纸质|电子.纸质|电子）
* @return String
*/
public String getMaterialProperty(){
return materialProperty;
}
/**
* 设置 材料形式（纸质.纸质，电子.电子，纸质|电子.纸质|电子）
* @param materialProperty
*/
public void setMaterialProperty(String materialProperty){
this.materialProperty = materialProperty;
}
/**
* 获取 电子材料格式（无.无，不限.不限，jpg.jpg，jpeg.jpeg，pdf.pdf，word.word，pdf|jpg|jpeg.pdf|jpg|jpeg，pdf|jpg.pdf|jpg）
* @return String
*/
public String getElectronicgs(){
return electronicgs;
}
/**
* 设置 电子材料格式（无.无，不限.不限，jpg.jpg，jpeg.jpeg，pdf.pdf，word.word，pdf|jpg|jpeg.pdf|jpg|jpeg，pdf|jpg.pdf|jpg）
* @param electronicgs
*/
public void setElectronicgs(String electronicgs){
this.electronicgs = electronicgs;
}
/**
* 获取 材料来源渠道（无.无，申请人自备.申请人自备，政府部门核发.政府部门核发，其他.其他）
* @return String
*/
public String getMaterialSource(){
return materialSource;
}
/**
* 设置 材料来源渠道（无.无，申请人自备.申请人自备，政府部门核发.政府部门核发，其他.其他）
* @param materialSource
*/
public void setMaterialSource(String materialSource){
this.materialSource = materialSource;
}
/**
* 获取 纸质材料份数
* @return Integer
*/
public Integer getPaperNum(){
return paperNum;
}
/**
* 设置 纸质材料份数
* @param paperNum
*/
public void setPaperNum(Integer paperNum){
this.paperNum = paperNum;
}
/**
* 获取 纸质材料规格
* @return String
*/
public String getPaperGg(){
return paperGg;
}
/**
* 设置 纸质材料规格
* @param paperGg
*/
public void setPaperGg(String paperGg){
this.paperGg = paperGg;
}
/**
* 获取 减免模式（无.无，减.减，免.免）
* @return String
*/
public String getJianmMs(){
return jianmMs;
}
/**
* 设置 减免模式（无.无，减.减，免.免）
* @param jianmMs
*/
public void setJianmMs(String jianmMs){
this.jianmMs = jianmMs;
}
/**
* 获取 盖章方式
* @return String
*/
public String getSealWay(){
return sealWay;
}
/**
* 设置 盖章方式
* @param sealWay
*/
public void setSealWay(String sealWay){
this.sealWay = sealWay;
}
/**
* 获取 是否减免（否.否，是.是）
* @return String
*/
public String getIsjianm(){
return isjianm;
}
/**
* 设置 是否减免（否.否，是.是）
* @param isjianm
*/
public void setIsjianm(String isjianm){
this.isjianm = isjianm;
}
/**
* 获取 材料是否容缺（必要.必要，非必要.非必要）
* @return String
*/
public String getIsLack(){
return isLack;
}
/**
* 设置 材料是否容缺（必要.必要，非必要.非必要）
* @param isLack
*/
public void setIsLack(String isLack){
this.isLack = isLack;
}
/**
* 获取 材料地址
* @return String
*/
public String getYbUrl(){
return ybUrl;
}
/**
* 设置 材料地址
* @param ybUrl
*/
public void setYbUrl(String ybUrl){
this.ybUrl = ybUrl;
}
/**
* 获取 来源渠道说明
* @return String
*/
public String getMaterialSourceSm(){
return materialSourceSm;
}
/**
* 设置 来源渠道说明
* @param materialSourceSm
*/
public void setMaterialSourceSm(String materialSourceSm){
this.materialSourceSm = materialSourceSm;
}
/**
* 获取 填报须知
* @return String
*/
public String getRemarkSub(){
return remarkSub;
}
/**
* 设置 填报须知
* @param remarkSub
*/
public void setRemarkSub(String remarkSub){
this.remarkSub = remarkSub;
}
/**
* 获取 要求提供材料的依据
* @return String
*/
public String getClauseContent(){
return clauseContent;
}
/**
* 设置 要求提供材料的依据
* @param clauseContent
*/
public void setClauseContent(String clauseContent){
this.clauseContent = clauseContent;
}
/**
* 获取 受理标准
* @return String
*/
public String getSummary(){
return summary;
}
/**
* 设置 受理标准
* @param summary
*/
public void setSummary(String summary){
this.summary = summary;
}
/**
* 获取 备注
* @return String
*/
public String getRemark(){
return remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark){
this.remark = remark;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
public List<Long> getMatterIdList() {
return matterIdList;
}
public void setMatterIdList(List<Long> matterIdList) {
this.matterIdList = matterIdList;
}
public List<MatterDatumFilePdu> getMatterDatumFileList(){
return matterDatumFileList;
}
public void setMatterDatumFileList(List<MatterDatumFilePdu> matterDatumFileList){
this.matterDatumFileList = matterDatumFileList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterDatumPdu) {
MatterDatumPdu tmp = (MatterDatumPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",materialName:").append(getMaterialName());
sb.append(",isMust:").append(getIsMust());
sb.append(",materialType:").append(getMaterialType());
sb.append(",materialProperty:").append(getMaterialProperty());
sb.append(",electronicgs:").append(getElectronicgs());
sb.append(",materialSource:").append(getMaterialSource());
sb.append(",paperNum:").append(getPaperNum());
sb.append(",paperGg:").append(getPaperGg());
sb.append(",jianmMs:").append(getJianmMs());
sb.append(",sealWay:").append(getSealWay());
sb.append(",isjianm:").append(getIsjianm());
sb.append(",isLack:").append(getIsLack());
sb.append(",ybUrl:").append(getYbUrl());
sb.append(",materialSourceSm:").append(getMaterialSourceSm());
sb.append(",remarkSub:").append(getRemarkSub());
sb.append(",clauseContent:").append(getClauseContent());
sb.append(",summary:").append(getSummary());
sb.append(",remark:").append(getRemark());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = null;
this.matterCode = "";
this.matterName = "";
this.materialName = "";
this.isMust = "非必要";
this.materialType = "无";
this.materialProperty = "纸质";
this.electronicgs = "无";
this.materialSource = "无";
this.paperNum = 1;
this.paperGg = "";
this.jianmMs = "无";
this.sealWay = "";
this.isjianm = "是";
this.isLack = "必要";
this.ybUrl = "";
this.materialSourceSm = "";
this.remarkSub = "";
this.clauseContent = "";
this.summary = "";
this.remark = "";
this.source = 1;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterFlowlimitPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
public class MatterFlowlimitPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 事项基础表id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 办理流程
*/
private String flowName;
/**
* 办理时长
*/
private String flowTime;
/**
* 转外时限
*/
private String flowLimit;
/**
* 办理流程说明
*/
private String flowDesc;
/**
* 事项来源(0.政务网，1.自定义)
*/
private Integer source;
public MatterFlowlimitPdu(){}
/**
* 获取 事项基础表id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项基础表id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 办理流程
* @return String
*/
public String getFlowName(){
return flowName;
}
/**
* 设置 办理流程
* @param flowName
*/
public void setFlowName(String flowName){
this.flowName = flowName;
}
/**
* 获取 办理时长
* @return String
*/
public String getFlowTime(){
return flowTime;
}
/**
* 设置 办理时长
* @param flowTime
*/
public void setFlowTime(String flowTime){
this.flowTime = flowTime;
}
/**
* 获取 转外时限
* @return String
*/
public String getFlowLimit(){
return flowLimit;
}
/**
* 设置 转外时限
* @param flowLimit
*/
public void setFlowLimit(String flowLimit){
this.flowLimit = flowLimit;
}
/**
* 获取 办理流程说明
* @return String
*/
public String getFlowDesc(){
return flowDesc;
}
/**
* 设置 办理流程说明
* @param flowDesc
*/
public void setFlowDesc(String flowDesc){
this.flowDesc = flowDesc;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterFlowlimitPdu) {
MatterFlowlimitPdu tmp = (MatterFlowlimitPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",flowName:").append(getFlowName());
sb.append(",flowTime:").append(getFlowTime());
sb.append(",flowLimit:").append(getFlowLimit());
sb.append(",flowDesc:").append(getFlowDesc());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = 0L;
this.matterCode = "";
this.matterName = "";
this.flowName = "";
this.flowTime = "";
this.flowLimit = "";
this.flowDesc = "";
this.source = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterIntermediaryPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
public class MatterIntermediaryPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 事项matter id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 中介服务事项名称
*/
private String title;
/**
* 中介服务实施机构及资质资格要求
*/
private String intermediaryRequest;
/**
* 服务时限
*/
private String intermediaryRequestTime;
/**
* 内容
*/
private String remark;
/**
* 事项来源，(0.政务网，1.自定义)
*/
private Integer source;
public MatterIntermediaryPdu(){}
/**
* 获取 事项matter id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项matter id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 中介服务事项名称
* @return String
*/
public String getTitle(){
return title;
}
/**
* 设置 中介服务事项名称
* @param title
*/
public void setTitle(String title){
this.title = title;
}
/**
* 获取 中介服务实施机构及资质资格要求
* @return String
*/
public String getIntermediaryRequest(){
return intermediaryRequest;
}
/**
* 设置 中介服务实施机构及资质资格要求
* @param intermediaryRequest
*/
public void setIntermediaryRequest(String intermediaryRequest){
this.intermediaryRequest = intermediaryRequest;
}
/**
* 获取 服务时限
* @return String
*/
public String getIntermediaryRequestTime(){
return intermediaryRequestTime;
}
/**
* 设置 服务时限
* @param intermediaryRequestTime
*/
public void setIntermediaryRequestTime(String intermediaryRequestTime){
this.intermediaryRequestTime = intermediaryRequestTime;
}
/**
* 获取 内容
* @return String
*/
public String getRemark(){
return remark;
}
/**
* 设置 内容
* @param remark
*/
public void setRemark(String remark){
this.remark = remark;
}
/**
* 获取 事项来源，(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源，(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterIntermediaryPdu) {
MatterIntermediaryPdu tmp = (MatterIntermediaryPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",title:").append(getTitle());
sb.append(",intermediaryRequest:").append(getIntermediaryRequest());
sb.append(",intermediaryRequestTime:").append(getIntermediaryRequestTime());
sb.append(",remark:").append(getRemark());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = 0L;
this.matterCode = "";
this.matterName = "";
this.title = "";
this.intermediaryRequest = "";
this.intermediaryRequestTime = "";
this.remark = "";
this.source = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
public class MatterPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 站点ID
*/
private Long siteId;
/**
* 从政务系统来的事项id
*/
private String tid;
/**
* 从政务系统来的事项code
*/
private String tcode;
/**
* 从政务系统来的事项name
*/
private String tname;
/**
* 事项名称
*/
private String matterName;
/**
* 英语事项名
*/
private String englishName;
/**
* 事项编号
*/
private String matterNo;
/**
* 区域编码
*/
private String areaCode;
/**
* 部门编号
*/
private String deptCode;
/**
* 部门名称
*/
private String deptName;
/**
* 行政权力编号
*/
private String powerCode;
/**
* 主题编号
*/
private String themeCode;
/**
* 服务类型编号
*/
private String usertypeCode;
/**
* 事项组名
*/
private String groupName;
/**
* 事项详情链接
*/
private String url;
/**
* 是否获取事项详情
*/
private String haveGetMatterInfo;
/**
* 所属部门
*/
private String belongDept;
/**
* 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
*/
private String appoveObjectShow;
/**
* 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
*/
private String operatScopeShow;
/**
* 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
*/
private String appoveTimeLimitShow;
/**
* 办理形式（窗口办理.窗口办理，网上办理.网上办理）
*/
private String handleType;
/**
* 法定办结时限
*/
private String legalTimeLimitShow;
/**
* 法定时限办结说明
*/
private String legalEndExplain;
/**
* 承诺办结时限
*/
private String promiseTimeLimitShow;
/**
* 承诺时限办结说明
*/
private String promiseEndExplain;
/**
* 是否收费（否.否，是.是）
*/
private String isChargesShow;
/**
* 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
*/
private String certificationLevelsShow;
/**
* 计划生效日期
*/
private Date planTakeTime;
/**
* 承诺生效日期
*/
private Date promiseTakeTime;
/**
* 特别程序
*/
private String specialProcedure;
/**
* 窗口到现场次数
*/
private Integer windowToTheSceneNum;
/**
* 是否网上预约,窗口办理选（否.否，是.是）
*/
private String isOnlineSubscribeShow;
/**
* 物流快递,窗口办理选（否.否，是.是）
*/
private String isExpressTakeShow;
/**
* 是否支持全省范围就近取件（否.否，是.是）
*/
private String isProvinceAcquisitionShow;
/**
* 是否支持全省范围就近办理（否.否，是.是）
*/
private String isApplyProvinceShow;
/**
* 必须到现场原因
*/
private String mustSceneExplain;
/**
* 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
*/
private String onlineType;
/**
* 网办到现场次数
*/
private Integer onlineToTheSceneNum;
/**
* 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
*/
private String onlineOperatDeep;
/**
* 物流快递，网上办理选（否.否，是.是）
*/
private String isExpressTakeOnlineShow;
/**
* 是否支持上门收取申请（否.否，是.是）
*/
private String isDoorTakeShow;
/**
* 网上必须到现场原因
*/
private String onlineMustSceneExplain;
/**
* 实施主体
*/
private String performDeptType;
/**
* 事项版本
*/
private String matterEdition;
/**
* 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
*/
private String eventTypeShow;
/**
* 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
*/
private String performHierarchyShow;
/**
* 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
*/
private String powerSourceShow;
/**
* 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
*/
private String performDeptTypeShow;
/**
* 是否进驻中心（否.否，是.是）
*/
private String goveServiceCenterShow;
/**
* 是否纳入便民服务中心（否.否，是.是）
*/
private String isConvenientCenterShow;
/**
* 自助终端办理 （否.否，是.是）
*/
private String terminalHandle;
/**
* 是否网办 （否.否，是.是）
*/
private String isOnline;
/**
* 支持网上支付（否.否，是.是）
*/
private String isOnlinePayShow;
/**
* 委托部门（否.否，是.是）
*/
private String entrustmentDepartmen;
/**
* 联办机构
*/
private String jointInfoShow;
/**
* 事项状态（停用.停用，在用.在用）
*/
private String matterStatus;
/**
* 数量限制
*/
private Long numberLimit;
/**
* 主题类型
*/
private String type;
/**
* 基本编码
*/
private String baseCode;
/**
* 实施编码
*/
private String implementCode;
/**
* 实施主体编码
*/
private String implementBodyCode;
/**
* 办理项编码
*/
private String operateItemCode;
/**
* 乡镇街道名称
*/
private String townshipName;
/**
* 乡镇街道代码
*/
private String townshipCode;
/**
* 村居社区名称
*/
private String villageName;
/**
* 村居社区代码
*/
private String villageCode;
/**
* 办理时间
*/
private String operateTime;
/**
* 办理地点
*/
private String operateSite;
/**
* 咨询方式
*/
private String cousultingShow;
/**
* 咨询电话
*/
private String cousultingTelephoneShow;
/**
* 监督投诉方式
*/
private String superviseShow;
/**
* 排序
*/
private Integer sort;
/**
* 事项来源(0.政务网，1.自定义)
*/
private Integer source;
/**
* 评价地址
*/
private String evaluationUrl;
/**
* 申请地址
*/
private String netApplyUrl;
public MatterPdu() {
}
/**
* 获取 站点ID
*
* @return Long
*/
public Long getSiteId() {
return siteId;
}
/**
* 设置 站点ID
*
* @param siteId
*/
public void setSiteId(Long siteId) {
this.siteId = siteId;
}
/**
* 获取 从政务系统来的事项id
*
* @return String
*/
public String getTid() {
return tid;
}
/**
* 设置 从政务系统来的事项id
*
* @param tid
*/
public void setTid(String tid) {
this.tid = tid;
}
/**
* 获取 从政务系统来的事项code
*
* @return String
*/
public String getTcode() {
return tcode;
}
/**
* 设置 从政务系统来的事项code
*
* @param tcode
*/
public void setTcode(String tcode) {
this.tcode = tcode;
}
/**
* 获取 从政务系统来的事项name
*
* @return String
*/
public String getTname() {
return tname;
}
/**
* 设置 从政务系统来的事项name
*
* @param tname
*/
public void setTname(String tname) {
this.tname = tname;
}
/**
* 获取 事项名称
*
* @return String
*/
public String getMatterName() {
return matterName;
}
/**
* 设置 事项名称
*
* @param matterName
*/
public void setMatterName(String matterName) {
this.matterName = matterName;
}
/**
* 获取 英语事项名
*
* @return String
*/
public String getEnglishName() {
return englishName;
}
/**
* 设置 英语事项名
*
* @param englishName
*/
public void setEnglishName(String englishName) {
this.englishName = englishName;
}
/**
* 获取 事项编号
*
* @return String
*/
public String getMatterNo() {
return matterNo;
}
/**
* 设置 事项编号
*
* @param matterNo
*/
public void setMatterNo(String matterNo) {
this.matterNo = matterNo;
}
/**
* 获取 区域编码
*
* @return String
*/
public String getAreaCode() {
return areaCode;
}
/**
* 设置 区域编码
*
* @param areaCode
*/
public void setAreaCode(String areaCode) {
this.areaCode = areaCode;
}
/**
* 获取 部门编号
*
* @return String
*/
public String getDeptCode() {
return deptCode;
}
/**
* 设置 部门编号
*
* @param deptCode
*/
public void setDeptCode(String deptCode) {
this.deptCode = deptCode;
}
/**
* 获取 部门名称
*
* @return String
*/
public String getDeptName() {
return deptName;
}
/**
* 设置 部门名称
*
* @param deptName
*/
public void setDeptName(String deptName) {
this.deptName = deptName;
}
/**
* 获取 行政权力编号
*
* @return String
*/
public String getPowerCode() {
return powerCode;
}
/**
* 设置 行政权力编号
*
* @param powerCode
*/
public void setPowerCode(String powerCode) {
this.powerCode = powerCode;
}
/**
* 获取 主题编号
*
* @return String
*/
public String getThemeCode() {
return themeCode;
}
/**
* 设置 主题编号
*
* @param themeCode
*/
public void setThemeCode(String themeCode) {
this.themeCode = themeCode;
}
/**
* 获取 服务类型编号
*
* @return String
*/
public String getUsertypeCode() {
return usertypeCode;
}
/**
* 设置 服务类型编号
*
* @param usertypeCode
*/
public void setUsertypeCode(String usertypeCode) {
this.usertypeCode = usertypeCode;
}
/**
* 获取 事项组名
*
* @return String
*/
public String getGroupName() {
return groupName;
}
/**
* 设置 事项组名
*
* @param groupName
*/
public void setGroupName(String groupName) {
this.groupName = groupName;
}
/**
* 获取 事项详情链接
*
* @return String
*/
public String getUrl() {
return url;
}
/**
* 设置 事项详情链接
*
* @param url
*/
public void setUrl(String url) {
this.url = url;
}
/**
* 获取 是否获取事项详情
*
* @return String
*/
public String getHaveGetMatterInfo() {
return haveGetMatterInfo;
}
/**
* 设置 是否获取事项详情
*
* @param haveGetMatterInfo
*/
public void setHaveGetMatterInfo(String haveGetMatterInfo) {
this.haveGetMatterInfo = haveGetMatterInfo;
}
/**
* 获取 所属部门
*
* @return String
*/
public String getBelongDept() {
return belongDept;
}
/**
* 设置 所属部门
*
* @param belongDept
*/
public void setBelongDept(String belongDept) {
this.belongDept = belongDept;
}
/**
* 获取 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
*
* @return String
*/
public String getAppoveObjectShow() {
return appoveObjectShow;
}
/**
* 设置 服务对象 （事业法人.事业法人，社会组织法人.社会组织法人，非法人企业.非法人企业，企业法人.企业法人，自然人.自然人，其他组织.其他组织）
*
* @param appoveObjectShow
*/
public void setAppoveObjectShow(String appoveObjectShow) {
this.appoveObjectShow = appoveObjectShow;
}
/**
* 获取 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
*
* @return String
*/
public String getOperatScopeShow() {
return operatScopeShow;
}
/**
* 设置 通办范围 （无.无，全国.全国，全市.全市，全县.全县，全镇[乡 街道].全镇[乡 街道]，跨村[社区].跨村[社区]）
*
* @param operatScopeShow
*/
public void setOperatScopeShow(String operatScopeShow) {
this.operatScopeShow = operatScopeShow;
}
/**
* 获取 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
*
* @return String
*/
public String getAppoveTimeLimitShow() {
return appoveTimeLimitShow;
}
/**
* 设置 办件类型（网络办件.网络办件，行政审批一般件.行政审批一般件，综合窗口件.综合窗口件）
*
* @param appoveTimeLimitShow
*/
public void setAppoveTimeLimitShow(String appoveTimeLimitShow) {
this.appoveTimeLimitShow = appoveTimeLimitShow;
}
/**
* 获取 办理形式（窗口办理.窗口办理，网上办理.网上办理）
*
* @return String
*/
public String getHandleType() {
return handleType;
}
/**
* 设置 办理形式（窗口办理.窗口办理，网上办理.网上办理）
*
* @param handleType
*/
public void setHandleType(String handleType) {
this.handleType = handleType;
}
/**
* 获取 法定办结时限
*
* @return String
*/
public String getLegalTimeLimitShow() {
return legalTimeLimitShow;
}
/**
* 设置 法定办结时限
*
* @param legalTimeLimitShow
*/
public void setLegalTimeLimitShow(String legalTimeLimitShow) {
this.legalTimeLimitShow = legalTimeLimitShow;
}
/**
* 获取 法定时限办结说明
*
* @return String
*/
public String getLegalEndExplain() {
return legalEndExplain;
}
/**
* 设置 法定时限办结说明
*
* @param legalEndExplain
*/
public void setLegalEndExplain(String legalEndExplain) {
this.legalEndExplain = legalEndExplain;
}
/**
* 获取 承诺办结时限
*
* @return String
*/
public String getPromiseTimeLimitShow() {
return promiseTimeLimitShow;
}
/**
* 设置 承诺办结时限
*
* @param promiseTimeLimitShow
*/
public void setPromiseTimeLimitShow(String promiseTimeLimitShow) {
this.promiseTimeLimitShow = promiseTimeLimitShow;
}
/**
* 获取 承诺时限办结说明
*
* @return String
*/
public String getPromiseEndExplain() {
return promiseEndExplain;
}
/**
* 设置 承诺时限办结说明
*
* @param promiseEndExplain
*/
public void setPromiseEndExplain(String promiseEndExplain) {
this.promiseEndExplain = promiseEndExplain;
}
/**
* 获取 是否收费（否.否，是.是）
*
* @return String
*/
public String getIsChargesShow() {
return isChargesShow;
}
/**
* 设置 是否收费（否.否，是.是）
*
* @param isChargesShow
*/
public void setIsChargesShow(String isChargesShow) {
this.isChargesShow = isChargesShow;
}
/**
* 获取 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
*
* @return String
*/
public String getCertificationLevelsShow() {
return certificationLevelsShow;
}
/**
* 设置 认证等级需求（实名认证.实名认证，单次面签.单次面签，每次面签.每次面签）
*
* @param certificationLevelsShow
*/
public void setCertificationLevelsShow(String certificationLevelsShow) {
this.certificationLevelsShow = certificationLevelsShow;
}
/**
* 获取 计划生效日期
*
* @return Date
*/
public Date getPlanTakeTime() {
return planTakeTime;
}
/**
* 设置 计划生效日期
*
* @param planTakeTime
*/
public void setPlanTakeTime(Date planTakeTime) {
this.planTakeTime = planTakeTime;
}
/**
* 获取 承诺生效日期
*
* @return Date
*/
public Date getPromiseTakeTime() {
return promiseTakeTime;
}
/**
* 设置 承诺生效日期
*
* @param promiseTakeTime
*/
public void setPromiseTakeTime(Date promiseTakeTime) {
this.promiseTakeTime = promiseTakeTime;
}
/**
* 获取 特别程序
*
* @return String
*/
public String getSpecialProcedure() {
return specialProcedure;
}
/**
* 设置 特别程序
*
* @param specialProcedure
*/
public void setSpecialProcedure(String specialProcedure) {
this.specialProcedure = specialProcedure;
}
/**
* 获取 窗口到现场次数
*
* @return Integer
*/
public Integer getWindowToTheSceneNum() {
return windowToTheSceneNum;
}
/**
* 设置 窗口到现场次数
*
* @param windowToTheSceneNum
*/
public void setWindowToTheSceneNum(Integer windowToTheSceneNum) {
this.windowToTheSceneNum = windowToTheSceneNum;
}
/**
* 获取 是否网上预约,窗口办理选（否.否，是.是）
*
* @return String
*/
public String getIsOnlineSubscribeShow() {
return isOnlineSubscribeShow;
}
/**
* 设置 是否网上预约,窗口办理选（否.否，是.是）
*
* @param isOnlineSubscribeShow
*/
public void setIsOnlineSubscribeShow(String isOnlineSubscribeShow) {
this.isOnlineSubscribeShow = isOnlineSubscribeShow;
}
/**
* 获取 物流快递,窗口办理选（否.否，是.是）
*
* @return String
*/
public String getIsExpressTakeShow() {
return isExpressTakeShow;
}
/**
* 设置 物流快递,窗口办理选（否.否，是.是）
*
* @param isExpressTakeShow
*/
public void setIsExpressTakeShow(String isExpressTakeShow) {
this.isExpressTakeShow = isExpressTakeShow;
}
/**
* 获取 是否支持全省范围就近取件（否.否，是.是）
*
* @return String
*/
public String getIsProvinceAcquisitionShow() {
return isProvinceAcquisitionShow;
}
/**
* 设置 是否支持全省范围就近取件（否.否，是.是）
*
* @param isProvinceAcquisitionShow
*/
public void setIsProvinceAcquisitionShow(String isProvinceAcquisitionShow) {
this.isProvinceAcquisitionShow = isProvinceAcquisitionShow;
}
/**
* 获取 是否支持全省范围就近办理（否.否，是.是）
*
* @return String
*/
public String getIsApplyProvinceShow() {
return isApplyProvinceShow;
}
/**
* 设置 是否支持全省范围就近办理（否.否，是.是）
*
* @param isApplyProvinceShow
*/
public void setIsApplyProvinceShow(String isApplyProvinceShow) {
this.isApplyProvinceShow = isApplyProvinceShow;
}
/**
* 获取 必须到现场原因
*
* @return String
*/
public String getMustSceneExplain() {
return mustSceneExplain;
}
/**
* 设置 必须到现场原因
*
* @param mustSceneExplain
*/
public void setMustSceneExplain(String mustSceneExplain) {
this.mustSceneExplain = mustSceneExplain;
}
/**
* 获取 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
*
* @return String
*/
public String getOnlineType() {
return onlineType;
}
/**
* 设置 网办类型（原件预审.原件预审，原件核验.原件核验，全程网办.全程网办）
*
* @param onlineType
*/
public void setOnlineType(String onlineType) {
this.onlineType = onlineType;
}
/**
* 获取 网办到现场次数
*
* @return Integer
*/
public Integer getOnlineToTheSceneNum() {
return onlineToTheSceneNum;
}
/**
* 设置 网办到现场次数
*
* @param onlineToTheSceneNum
*/
public void setOnlineToTheSceneNum(Integer onlineToTheSceneNum) {
this.onlineToTheSceneNum = onlineToTheSceneNum;
}
/**
* 获取 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
*
* @return String
*/
public String getOnlineOperatDeep() {
return onlineOperatDeep;
}
/**
* 设置 网络办理深度（互联网咨询.互联网咨询，互联网收件.互联网收件，互联网预审.互联网预审，互联网受理.互联网受理，互联网办理.互联网办理，互联网办理结果信息反馈.互联网办理结果信息反馈，其他.其他）
*
* @param onlineOperatDeep
*/
public void setOnlineOperatDeep(String onlineOperatDeep) {
this.onlineOperatDeep = onlineOperatDeep;
}
/**
* 获取 物流快递，网上办理选（否.否，是.是）
*
* @return String
*/
public String getIsExpressTakeOnlineShow() {
return isExpressTakeOnlineShow;
}
/**
* 设置 物流快递，网上办理选（否.否，是.是）
*
* @param isExpressTakeOnlineShow
*/
public void setIsExpressTakeOnlineShow(String isExpressTakeOnlineShow) {
this.isExpressTakeOnlineShow = isExpressTakeOnlineShow;
}
/**
* 获取 是否支持上门收取申请（否.否，是.是）
*
* @return String
*/
public String getIsDoorTakeShow() {
return isDoorTakeShow;
}
/**
* 设置 是否支持上门收取申请（否.否，是.是）
*
* @param isDoorTakeShow
*/
public void setIsDoorTakeShow(String isDoorTakeShow) {
this.isDoorTakeShow = isDoorTakeShow;
}
/**
* 获取 网上必须到现场原因
*
* @return String
*/
public String getOnlineMustSceneExplain() {
return onlineMustSceneExplain;
}
/**
* 设置 网上必须到现场原因
*
* @param onlineMustSceneExplain
*/
public void setOnlineMustSceneExplain(String onlineMustSceneExplain) {
this.onlineMustSceneExplain = onlineMustSceneExplain;
}
/**
* 获取 实施主体
*
* @return String
*/
public String getPerformDeptType() {
return performDeptType;
}
/**
* 设置 实施主体
*
* @param performDeptType
*/
public void setPerformDeptType(String performDeptType) {
this.performDeptType = performDeptType;
}
/**
* 获取 事项版本
*
* @return String
*/
public String getMatterEdition() {
return matterEdition;
}
/**
* 设置 事项版本
*
* @param matterEdition
*/
public void setMatterEdition(String matterEdition) {
this.matterEdition = matterEdition;
}
/**
* 获取 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
*
* @return String
*/
public String getEventTypeShow() {
return eventTypeShow;
}
/**
* 设置 事项类型名称（行政许可.行政许可，行政处罚.行政处罚，行政强制.行政强制，行政征收.行政征收，行政给付.行政给付，行政检查.行政检查，行政确认.行政确认，行政奖励.行政奖励，行政裁决.行政裁决，其他行政权力.其他行政权力，主动服务.主动服务，依申请服务.依申请服务，咨询查询.咨询查询，未归类事项.未归类事项）
*
* @param eventTypeShow
*/
public void setEventTypeShow(String eventTypeShow) {
this.eventTypeShow = eventTypeShow;
}
/**
* 获取 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
*
* @return String
*/
public String getPerformHierarchyShow() {
return performHierarchyShow;
}
/**
* 设置 行使层级名称（省级.省级，市级.市级，县级.县级，镇[乡 街道].镇[乡 街道]，村[社区]级.村[社区]级）
*
* @param performHierarchyShow
*/
public void setPerformHierarchyShow(String performHierarchyShow) {
this.performHierarchyShow = performHierarchyShow;
}
/**
* 获取 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
*
* @return String
*/
public String getPowerSourceShow() {
return powerSourceShow;
}
/**
* 设置 权力来源（法定本级行使.法定本级行使，上级下放.上级下放，上级授权.上级授权，同级授权.同级授权，上级委托.上级委托，同级委托.同级委托）
*
* @param powerSourceShow
*/
public void setPowerSourceShow(String powerSourceShow) {
this.powerSourceShow = powerSourceShow;
}
/**
* 获取 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
*
* @return String
*/
public String getPerformDeptTypeShow() {
return performDeptTypeShow;
}
/**
* 设置 实施主体性质（法定机关.法定机关，授权组织.授权组织，受委托组织.受委托组织）
*
* @param performDeptTypeShow
*/
public void setPerformDeptTypeShow(String performDeptTypeShow) {
this.performDeptTypeShow = performDeptTypeShow;
}
/**
* 获取 是否进驻中心（否.否，是.是）
*
* @return String
*/
public String getGoveServiceCenterShow() {
return goveServiceCenterShow;
}
/**
* 设置 是否进驻中心（否.否，是.是）
*
* @param goveServiceCenterShow
*/
public void setGoveServiceCenterShow(String goveServiceCenterShow) {
this.goveServiceCenterShow = goveServiceCenterShow;
}
/**
* 获取 是否纳入便民服务中心（否.否，是.是）
*
* @return String
*/
public String getIsConvenientCenterShow() {
return isConvenientCenterShow;
}
/**
* 设置 是否纳入便民服务中心（否.否，是.是）
*
* @param isConvenientCenterShow
*/
public void setIsConvenientCenterShow(String isConvenientCenterShow) {
this.isConvenientCenterShow = isConvenientCenterShow;
}
/**
* 获取 自助终端办理 （否.否，是.是）
*
* @return String
*/
public String getTerminalHandle() {
return terminalHandle;
}
/**
* 设置 自助终端办理 （否.否，是.是）
*
* @param terminalHandle
*/
public void setTerminalHandle(String terminalHandle) {
this.terminalHandle = terminalHandle;
}
/**
* 获取 是否网办 （否.否，是.是）
*
* @return String
*/
public String getIsOnline() {
return isOnline;
}
/**
* 设置 是否网办 （否.否，是.是）
*
* @param isOnline
*/
public void setIsOnline(String isOnline) {
this.isOnline = isOnline;
}
/**
* 获取 支持网上支付（否.否，是.是）
*
* @return String
*/
public String getIsOnlinePayShow() {
return isOnlinePayShow;
}
/**
* 设置 支持网上支付（否.否，是.是）
*
* @param isOnlinePayShow
*/
public void setIsOnlinePayShow(String isOnlinePayShow) {
this.isOnlinePayShow = isOnlinePayShow;
}
/**
* 获取 委托部门（否.否，是.是）
*
* @return String
*/
public String getEntrustmentDepartmen() {
return entrustmentDepartmen;
}
/**
* 设置 委托部门（否.否，是.是）
*
* @param entrustmentDepartmen
*/
public void setEntrustmentDepartmen(String entrustmentDepartmen) {
this.entrustmentDepartmen = entrustmentDepartmen;
}
/**
* 获取 联办机构
*
* @return String
*/
public String getJointInfoShow() {
return jointInfoShow;
}
/**
* 设置 联办机构
*
* @param jointInfoShow
*/
public void setJointInfoShow(String jointInfoShow) {
this.jointInfoShow = jointInfoShow;
}
/**
* 获取 事项状态（停用.停用，在用.在用）
*
* @return String
*/
public String getMatterStatus() {
return matterStatus;
}
/**
* 设置 事项状态（停用.停用，在用.在用）
*
* @param matterStatus
*/
public void setMatterStatus(String matterStatus) {
this.matterStatus = matterStatus;
}
/**
* 获取 数量限制
*
* @return Long
*/
public Long getNumberLimit() {
return numberLimit;
}
/**
* 设置 数量限制
*
* @param numberLimit
*/
public void setNumberLimit(Long numberLimit) {
this.numberLimit = numberLimit;
}
/**
* 获取 主题类型
*
* @return String
*/
public String getType() {
return type;
}
/**
* 设置 主题类型
*
* @param type
*/
public void setType(String type) {
this.type = type;
}
/**
* 获取 基本编码
*
* @return String
*/
public String getBaseCode() {
return baseCode;
}
/**
* 设置 基本编码
*
* @param baseCode
*/
public void setBaseCode(String baseCode) {
this.baseCode = baseCode;
}
/**
* 获取 实施编码
*
* @return String
*/
public String getImplementCode() {
return implementCode;
}
/**
* 设置 实施编码
*
* @param implementCode
*/
public void setImplementCode(String implementCode) {
this.implementCode = implementCode;
}
/**
* 获取 实施主体编码
*
* @return String
*/
public String getImplementBodyCode() {
return implementBodyCode;
}
/**
* 设置 实施主体编码
*
* @param implementBodyCode
*/
public void setImplementBodyCode(String implementBodyCode) {
this.implementBodyCode = implementBodyCode;
}
/**
* 获取 办理项编码
*
* @return String
*/
public String getOperateItemCode() {
return operateItemCode;
}
/**
* 设置 办理项编码
*
* @param operateItemCode
*/
public void setOperateItemCode(String operateItemCode) {
this.operateItemCode = operateItemCode;
}
/**
* 获取 乡镇街道名称
*
* @return String
*/
public String getTownshipName() {
return townshipName;
}
/**
* 设置 乡镇街道名称
*
* @param townshipName
*/
public void setTownshipName(String townshipName) {
this.townshipName = townshipName;
}
/**
* 获取 乡镇街道代码
*
* @return String
*/
public String getTownshipCode() {
return townshipCode;
}
/**
* 设置 乡镇街道代码
*
* @param townshipCode
*/
public void setTownshipCode(String townshipCode) {
this.townshipCode = townshipCode;
}
/**
* 获取 村居社区名称
*
* @return String
*/
public String getVillageName() {
return villageName;
}
/**
* 设置 村居社区名称
*
* @param villageName
*/
public void setVillageName(String villageName) {
this.villageName = villageName;
}
/**
* 获取 村居社区代码
*
* @return String
*/
public String getVillageCode() {
return villageCode;
}
/**
* 设置 村居社区代码
*
* @param villageCode
*/
public void setVillageCode(String villageCode) {
this.villageCode = villageCode;
}
/**
* 获取 办理时间
*
* @return String
*/
public String getOperateTime() {
return operateTime;
}
/**
* 设置 办理时间
*
* @param operateTime
*/
public void setOperateTime(String operateTime) {
this.operateTime = operateTime;
}
/**
* 获取 办理地点
*
* @return String
*/
public String getOperateSite() {
return operateSite;
}
/**
* 设置 办理地点
*
* @param operateSite
*/
public void setOperateSite(String operateSite) {
this.operateSite = operateSite;
}
/**
* 获取 咨询方式
*
* @return String
*/
public String getCousultingShow() {
return cousultingShow;
}
/**
* 设置 咨询方式
*
* @param cousultingShow
*/
public void setCousultingShow(String cousultingShow) {
this.cousultingShow = cousultingShow;
}
/**
* 获取 咨询电话
*
* @return String
*/
public String getCousultingTelephoneShow() {
return cousultingTelephoneShow;
}
/**
* 设置 咨询电话
*
* @param cousultingTelephoneShow
*/
public void setCousultingTelephoneShow(String cousultingTelephoneShow) {
this.cousultingTelephoneShow = cousultingTelephoneShow;
}
/**
* 获取 监督投诉方式
*
* @return String
*/
public String getSuperviseShow() {
return superviseShow;
}
/**
* 设置 监督投诉方式
*
* @param superviseShow
*/
public void setSuperviseShow(String superviseShow) {
this.superviseShow = superviseShow;
}
/**
* 获取 排序
*
* @return Integer
*/
public Integer getSort() {
return sort;
}
/**
* 设置 排序
*
* @param sort
*/
public void setSort(Integer sort) {
this.sort = sort;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
*
* @return Integer
*/
public Integer getSource() {
return source;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
*
* @param source
*/
public void setSource(Integer source) {
this.source = source;
}
/**
* 获取 评价地址
*
* @return String
*/
public String getEvaluationUrl() {
return evaluationUrl;
}
/**
* 设置 评价地址
*
* @param evaluationUrl
*/
public void setEvaluationUrl(String evaluationUrl) {
this.evaluationUrl = evaluationUrl;
}
/**
* 获取 申请地址
*
* @return String
*/
public String getNetApplyUrl() {
return netApplyUrl;
}
/**
* 设置 申请地址
*
* @param netApplyUrl
*/
public void setNetApplyUrl(String netApplyUrl) {
this.netApplyUrl = netApplyUrl;
}
@Override
public int hashCode() {
return Objects.hash(this.areaCode, this.matterNo);
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterPdu) {
MatterPdu tmp = (MatterPdu) obj;
if ((this.getAreaCode()+this.matterNo).equals(tmp.getAreaCode()+tmp.matterNo)) {
return true;
}
}
return false;
}
public String toString() {
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",tid:").append(getTid());
sb.append(",tcode:").append(getTcode());
sb.append(",tname:").append(getTname());
sb.append(",matterName:").append(getMatterName());
sb.append(",englishName:").append(getEnglishName());
sb.append(",matterNo:").append(getMatterNo());
sb.append(",areaCode:").append(getAreaCode());
sb.append(",deptCode:").append(getDeptCode());
sb.append(",deptName:").append(getDeptName());
sb.append(",powerCode:").append(getPowerCode());
sb.append(",themeCode:").append(getThemeCode());
sb.append(",usertypeCode:").append(getUsertypeCode());
sb.append(",groupName:").append(getGroupName());
sb.append(",url:").append(getUrl());
sb.append(",haveGetMatterInfo:").append(getHaveGetMatterInfo());
sb.append(",belongDept:").append(getBelongDept());
sb.append(",appoveObjectShow:").append(getAppoveObjectShow());
sb.append(",operatScopeShow:").append(getOperatScopeShow());
sb.append(",appoveTimeLimitShow:").append(getAppoveTimeLimitShow());
sb.append(",handleType:").append(getHandleType());
sb.append(",legalTimeLimitShow:").append(getLegalTimeLimitShow());
sb.append(",legalEndExplain:").append(getLegalEndExplain());
sb.append(",promiseTimeLimitShow:").append(getPromiseTimeLimitShow());
sb.append(",promiseEndExplain:").append(getPromiseEndExplain());
sb.append(",isChargesShow:").append(getIsChargesShow());
sb.append(",certificationLevelsShow:").append(getCertificationLevelsShow());
sb.append(",planTakeTime:").append(getPlanTakeTime());
sb.append(",promiseTakeTime:").append(getPromiseTakeTime());
sb.append(",specialProcedure:").append(getSpecialProcedure());
sb.append(",windowToTheSceneNum:").append(getWindowToTheSceneNum());
sb.append(",isOnlineSubscribeShow:").append(getIsOnlineSubscribeShow());
sb.append(",isExpressTakeShow:").append(getIsExpressTakeShow());
sb.append(",isProvinceAcquisitionShow:").append(getIsProvinceAcquisitionShow());
sb.append(",isApplyProvinceShow:").append(getIsApplyProvinceShow());
sb.append(",mustSceneExplain:").append(getMustSceneExplain());
sb.append(",onlineType:").append(getOnlineType());
sb.append(",onlineToTheSceneNum:").append(getOnlineToTheSceneNum());
sb.append(",onlineOperatDeep:").append(getOnlineOperatDeep());
sb.append(",isExpressTakeOnlineShow:").append(getIsExpressTakeOnlineShow());
sb.append(",isDoorTakeShow:").append(getIsDoorTakeShow());
sb.append(",onlineMustSceneExplain:").append(getOnlineMustSceneExplain());
sb.append(",performDeptType:").append(getPerformDeptType());
sb.append(",matterEdition:").append(getMatterEdition());
sb.append(",eventTypeShow:").append(getEventTypeShow());
sb.append(",performHierarchyShow:").append(getPerformHierarchyShow());
sb.append(",powerSourceShow:").append(getPowerSourceShow());
sb.append(",performDeptTypeShow:").append(getPerformDeptTypeShow());
sb.append(",goveServiceCenterShow:").append(getGoveServiceCenterShow());
sb.append(",isConvenientCenterShow:").append(getIsConvenientCenterShow());
sb.append(",terminalHandle:").append(getTerminalHandle());
sb.append(",isOnline:").append(getIsOnline());
sb.append(",isOnlinePayShow:").append(getIsOnlinePayShow());
sb.append(",entrustmentDepartmen:").append(getEntrustmentDepartmen());
sb.append(",jointInfoShow:").append(getJointInfoShow());
sb.append(",matterStatus:").append(getMatterStatus());
sb.append(",numberLimit:").append(getNumberLimit());
sb.append(",type:").append(getType());
sb.append(",baseCode:").append(getBaseCode());
sb.append(",implementCode:").append(getImplementCode());
sb.append(",implementBodyCode:").append(getImplementBodyCode());
sb.append(",operateItemCode:").append(getOperateItemCode());
sb.append(",townshipName:").append(getTownshipName());
sb.append(",townshipCode:").append(getTownshipCode());
sb.append(",villageName:").append(getVillageName());
sb.append(",villageCode:").append(getVillageCode());
sb.append(",operateTime:").append(getOperateTime());
sb.append(",operateSite:").append(getOperateSite());
sb.append(",cousultingShow:").append(getCousultingShow());
sb.append(",cousultingTelephoneShow:").append(getCousultingTelephoneShow());
sb.append(",superviseShow:").append(getSuperviseShow());
sb.append(",sort:").append(getSort());
sb.append(",source:").append(getSource());
sb.append(",evaluationUrl:").append(getEvaluationUrl());
sb.append(",netApplyUrl:").append(getNetApplyUrl());
return sb.toString();
}
public void initAttrValue() {
this.siteId = -1L;
this.tid = "";
this.tcode = "";
this.tname = "";
this.matterName = "";
this.englishName = "";
this.matterNo = "";
this.areaCode = "";
this.deptCode = "";
this.deptName = "";
this.powerCode = "";
this.themeCode = "";
this.usertypeCode = "";
this.groupName = "";
this.url = "";
this.haveGetMatterInfo = "false";
this.belongDept = "";
this.appoveObjectShow = "事业法人";
this.operatScopeShow = "无";
this.appoveTimeLimitShow = "网络办件";
this.handleType = "窗口办理";
this.legalTimeLimitShow = "";
this.legalEndExplain = "";
this.promiseTimeLimitShow = "";
this.promiseEndExplain = "";
this.isChargesShow = "否";
this.certificationLevelsShow = "实名认证";
this.planTakeTime = null;
this.promiseTakeTime = null;
this.specialProcedure = "";
this.windowToTheSceneNum = null;
this.isOnlineSubscribeShow = "否";
this.isExpressTakeShow = "否";
this.isProvinceAcquisitionShow = "否";
this.isApplyProvinceShow = "否";
this.mustSceneExplain = "";
this.onlineType = "原件预审";
this.onlineToTheSceneNum = 0;
this.onlineOperatDeep = "互联网咨询";
this.isExpressTakeOnlineShow = "";
this.isDoorTakeShow = "否";
this.onlineMustSceneExplain = "";
this.performDeptType = "";
this.matterEdition = "";
this.eventTypeShow = "行政许可";
this.performHierarchyShow = "";
this.powerSourceShow = "";
this.performDeptTypeShow = "";
this.goveServiceCenterShow = "否";
this.isConvenientCenterShow = "否";
this.terminalHandle = "是";
this.isOnline = "是";
this.isOnlinePayShow = "是";
this.entrustmentDepartmen = "是";
this.jointInfoShow = "";
this.matterStatus = "在用";
this.numberLimit = null;
this.type = "";
this.baseCode = "";
this.implementCode = "";
this.implementBodyCode = "";
this.operateItemCode = "";
this.townshipName = "";
this.townshipCode = "";
this.villageName = "";
this.villageCode = "";
this.operateTime = "";
this.operateSite = "";
this.cousultingShow = "";
this.cousultingTelephoneShow = "";
this.superviseShow = "";
this.sort = 0;
this.source = 1;
this.evaluationUrl = "";
this.netApplyUrl = "";
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterQuestionPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
public class MatterQuestionPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 事项基础表matter id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 问题
*/
private String question;
/**
* 常见问题
*/
private String answer;
/**
* 事项来源，(0.政务网，1.自定义)
*/
private Integer source;
public MatterQuestionPdu(){}
/**
* 获取 事项基础表matter id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 问题
* @return String
*/
public String getQuestion(){
return question;
}
/**
* 设置 问题
* @param question
*/
public void setQuestion(String question){
this.question = question;
}
/**
* 获取 常见问题
* @return String
*/
public String getAnswer(){
return answer;
}
/**
* 设置 常见问题
* @param answer
*/
public void setAnswer(String answer){
this.answer = answer;
}
/**
* 获取 事项来源，(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源，(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterQuestionPdu) {
MatterQuestionPdu tmp = (MatterQuestionPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",question:").append(getQuestion());
sb.append(",answer:").append(getAnswer());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = 0L;
this.matterCode = "";
this.matterName = "";
this.question = "";
this.answer = "";
this.source = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/matter/MatterSetbasePdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.matter;
import com.mortals.framework.model.BaseEntityLong;
public class MatterSetbasePdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 事项matter id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 法规标题
*/
private String policyName;
/**
* 法规类型，(法律.法律，行政法规.行政法规，地方法规.地方法规，部门规章.部门规章，其他.其他，政府规章.政府规章，规范性文件.规范性文件)
*/
private String policyType;
/**
* 条例
*/
private String policyitem;
/**
* 条款内容
*/
private String content;
/**
* 事项来源，(0.政务网，1.自定义)
*/
private Integer source;
public MatterSetbasePdu(){}
/**
* 获取 事项matter id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项matter id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 法规标题
* @return String
*/
public String getPolicyName(){
return policyName;
}
/**
* 设置 法规标题
* @param policyName
*/
public void setPolicyName(String policyName){
this.policyName = policyName;
}
/**
* 获取 法规类型，(法律.法律，行政法规.行政法规，地方法规.地方法规，部门规章.部门规章，其他.其他，政府规章.政府规章，规范性文件.规范性文件)
* @return String
*/
public String getPolicyType(){
return policyType;
}
/**
* 设置 法规类型，(法律.法律，行政法规.行政法规，地方法规.地方法规，部门规章.部门规章，其他.其他，政府规章.政府规章，规范性文件.规范性文件)
* @param policyType
*/
public void setPolicyType(String policyType){
this.policyType = policyType;
}
/**
* 获取 条例
* @return String
*/
public String getPolicyitem(){
return policyitem;
}
/**
* 设置 条例
* @param policyitem
*/
public void setPolicyitem(String policyitem){
this.policyitem = policyitem;
}
/**
* 获取 条款内容
* @return String
*/
public String getContent(){
return content;
}
/**
* 设置 条款内容
* @param content
*/
public void setContent(String content){
this.content = content;
}
/**
* 获取 事项来源，(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源，(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterSetbasePdu) {
MatterSetbasePdu tmp = (MatterSetbasePdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",policyName:").append(getPolicyName());
sb.append(",policyType:").append(getPolicyType());
sb.append(",policyitem:").append(getPolicyitem());
sb.append(",content:").append(getContent());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = 0L;
this.matterCode = "";
this.matterName = "";
this.policyName = "";
this.policyType = "法律";
this.policyitem = "";
this.content = "";
this.source = 0;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/site/SiteMatterPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.site;
import com.mortals.framework.model.BaseEntityLong;
import java.util.List;
/**
* 站点事项Pdu对象
*
* @author zxfei
* @date 2023-02-17
*/
public class SiteMatterPdu extends BaseEntityLong {
private static final long serialVersionUID = 12L;
/**
* 站点ID
*/
private Long siteId;
/**
* 站点名称
*/
private String siteName;
/**
* 事项ID
*/
private Long matterId;
/**
* 事项名称
*/
private String matterName;
/**
* 事项编码
*/
private String matterCode;
/**
* 部门ID
*/
private Long deptId;
/**
* 部门名称
*/
private String deptName;
private String areaCode;
/**
* 事项类型
*/
private String eventTypeShow;
/**
* 事项来源
*/
private Integer source;
/**
* 部门编号
*/
private String deptCode;
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 开始 站点ID */
private Long siteIdStart;
/** 结束 站点ID */
private Long siteIdEnd;
/** 增加 站点ID */
private Long siteIdIncrement;
/** 站点ID列表 */
private List <Long> siteIdList;
/** 站点名称 */
private List<String> siteNameList;
/** 开始 事项ID */
private Long matterIdStart;
/** 结束 事项ID */
private Long matterIdEnd;
/** 增加 事项ID */
private Long matterIdIncrement;
/** 事项ID列表 */
private List <Long> matterIdList;
/** 事项名称 */
private List<String> matterNameList;
/** 事项编码 */
private List<String> matterCodeList;
/** 开始 部门ID */
private Long deptIdStart;
/** 结束 部门ID */
private Long deptIdEnd;
/** 增加 部门ID */
private Long deptIdIncrement;
/** 部门ID列表 */
private List <Long> deptIdList;
/** 部门名称 */
private List<String> deptNameList;
/** 事项类型 */
private List<String> eventTypeShowList;
/** 开始 事项来源 */
private Integer sourceStart;
/** 结束 事项来源 */
private Integer sourceEnd;
/** 增加 事项来源 */
private Integer sourceIncrement;
/** 事项来源列表 */
private List <Integer> sourceList;
/** 部门编号 */
private List<String> deptCodeList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 开始 修改时间 */
private String updateTimeStart;
/** 结束 修改时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<SiteMatterPdu> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<SiteMatterPdu> andConditionList;
public String getAreaCode() {
return areaCode;
}
public void setAreaCode(String areaCode) {
this.areaCode = areaCode;
}
public SiteMatterPdu(){}
/**
* 获取 站点ID
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点ID
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 站点名称
* @return String
*/
public String getSiteName(){
return siteName;
}
/**
* 设置 站点名称
* @param siteName
*/
public void setSiteName(String siteName){
this.siteName = siteName;
}
/**
* 获取 事项ID
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项ID
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 部门ID
* @return Long
*/
public Long getDeptId(){
return deptId;
}
/**
* 设置 部门ID
* @param deptId
*/
public void setDeptId(Long deptId){
this.deptId = deptId;
}
/**
* 获取 部门名称
* @return String
*/
public String getDeptName(){
return deptName;
}
/**
* 设置 部门名称
* @param deptName
*/
public void setDeptName(String deptName){
this.deptName = deptName;
}
/**
* 获取 事项类型
* @return String
*/
public String getEventTypeShow(){
return eventTypeShow;
}
/**
* 设置 事项类型
* @param eventTypeShow
*/
public void setEventTypeShow(String eventTypeShow){
this.eventTypeShow = eventTypeShow;
}
/**
* 获取 事项来源
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
/**
* 获取 部门编号
* @return String
*/
public String getDeptCode(){
return deptCode;
}
/**
* 设置 部门编号
* @param deptCode
*/
public void setDeptCode(String deptCode){
this.deptCode = deptCode;
}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 开始 站点ID
* @return siteIdStart
*/
public Long getSiteIdStart(){
return this.siteIdStart;
}
/**
* 设置 开始 站点ID
* @param siteIdStart
*/
public void setSiteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
}
/**
* 获取 结束 站点ID
* @return $siteIdEnd
*/
public Long getSiteIdEnd(){
return this.siteIdEnd;
}
/**
* 设置 结束 站点ID
* @param siteIdEnd
*/
public void setSiteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
}
/**
* 获取 增加 站点ID
* @return siteIdIncrement
*/
public Long getSiteIdIncrement(){
return this.siteIdIncrement;
}
/**
* 设置 增加 站点ID
* @param siteIdIncrement
*/
public void setSiteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
}
/**
* 获取 站点ID
* @return siteIdList
*/
public List<Long> getSiteIdList(){
return this.siteIdList;
}
/**
* 设置 站点ID
* @param siteIdList
*/
public void setSiteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
}
/**
* 获取 站点名称
* @return siteNameList
*/
public List<String> getSiteNameList(){
return this.siteNameList;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public void setSiteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
}
/**
* 获取 开始 事项ID
* @return matterIdStart
*/
public Long getMatterIdStart(){
return this.matterIdStart;
}
/**
* 设置 开始 事项ID
* @param matterIdStart
*/
public void setMatterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
}
/**
* 获取 结束 事项ID
* @return $matterIdEnd
*/
public Long getMatterIdEnd(){
return this.matterIdEnd;
}
/**
* 设置 结束 事项ID
* @param matterIdEnd
*/
public void setMatterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
}
/**
* 获取 增加 事项ID
* @return matterIdIncrement
*/
public Long getMatterIdIncrement(){
return this.matterIdIncrement;
}
/**
* 设置 增加 事项ID
* @param matterIdIncrement
*/
public void setMatterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
}
/**
* 获取 事项ID
* @return matterIdList
*/
public List<Long> getMatterIdList(){
return this.matterIdList;
}
/**
* 设置 事项ID
* @param matterIdList
*/
public void setMatterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
}
/**
* 获取 事项名称
* @return matterNameList
*/
public List<String> getMatterNameList(){
return this.matterNameList;
}
/**
* 设置 事项名称
* @param matterNameList
*/
public void setMatterNameList(List<String> matterNameList){
this.matterNameList = matterNameList;
}
/**
* 获取 事项编码
* @return matterCodeList
*/
public List<String> getMatterCodeList(){
return this.matterCodeList;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public void setMatterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
}
/**
* 获取 开始 部门ID
* @return deptIdStart
*/
public Long getDeptIdStart(){
return this.deptIdStart;
}
/**
* 设置 开始 部门ID
* @param deptIdStart
*/
public void setDeptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
}
/**
* 获取 结束 部门ID
* @return $deptIdEnd
*/
public Long getDeptIdEnd(){
return this.deptIdEnd;
}
/**
* 设置 结束 部门ID
* @param deptIdEnd
*/
public void setDeptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
}
/**
* 获取 增加 部门ID
* @return deptIdIncrement
*/
public Long getDeptIdIncrement(){
return this.deptIdIncrement;
}
/**
* 设置 增加 部门ID
* @param deptIdIncrement
*/
public void setDeptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
}
/**
* 获取 部门ID
* @return deptIdList
*/
public List<Long> getDeptIdList(){
return this.deptIdList;
}
/**
* 设置 部门ID
* @param deptIdList
*/
public void setDeptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
}
/**
* 获取 部门名称
* @return deptNameList
*/
public List<String> getDeptNameList(){
return this.deptNameList;
}
/**
* 设置 部门名称
* @param deptNameList
*/
public void setDeptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
}
/**
* 获取 事项类型
* @return eventTypeShowList
*/
public List<String> getEventTypeShowList(){
return this.eventTypeShowList;
}
/**
* 设置 事项类型
* @param eventTypeShowList
*/
public void setEventTypeShowList(List<String> eventTypeShowList){
this.eventTypeShowList = eventTypeShowList;
}
/**
* 获取 开始 事项来源
* @return sourceStart
*/
public Integer getSourceStart(){
return this.sourceStart;
}
/**
* 设置 开始 事项来源
* @param sourceStart
*/
public void setSourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
}
/**
* 获取 结束 事项来源
* @return $sourceEnd
*/
public Integer getSourceEnd(){
return this.sourceEnd;
}
/**
* 设置 结束 事项来源
* @param sourceEnd
*/
public void setSourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
}
/**
* 获取 增加 事项来源
* @return sourceIncrement
*/
public Integer getSourceIncrement(){
return this.sourceIncrement;
}
/**
* 设置 增加 事项来源
* @param sourceIncrement
*/
public void setSourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
}
/**
* 获取 事项来源
* @return sourceList
*/
public List<Integer> getSourceList(){
return this.sourceList;
}
/**
* 设置 事项来源
* @param sourceList
*/
public void setSourceList(List<Integer> sourceList){
this.sourceList = sourceList;
}
/**
* 获取 部门编号
* @return deptCodeList
*/
public List<String> getDeptCodeList(){
return this.deptCodeList;
}
/**
* 设置 部门编号
* @param deptCodeList
*/
public void setDeptCodeList(List<String> deptCodeList){
this.deptCodeList = deptCodeList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 开始 修改时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 修改时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 修改时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 修改时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public SiteMatterPdu id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public SiteMatterPdu idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public SiteMatterPdu idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public SiteMatterPdu idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public SiteMatterPdu idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 站点ID
* @param siteId
*/
public SiteMatterPdu siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点ID
* @param siteIdStart
*/
public SiteMatterPdu siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点ID
* @param siteIdEnd
*/
public SiteMatterPdu siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点ID
* @param siteIdIncrement
*/
public SiteMatterPdu siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点ID
* @param siteIdList
*/
public SiteMatterPdu siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点名称
* @param siteName
*/
public SiteMatterPdu siteName(String siteName){
setSiteName(siteName);
return this;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public SiteMatterPdu siteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
return this;
}
/**
* 设置 事项ID
* @param matterId
*/
public SiteMatterPdu matterId(Long matterId){
setMatterId(matterId);
return this;
}
/**
* 设置 开始 事项ID
* @param matterIdStart
*/
public SiteMatterPdu matterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
return this;
}
/**
* 设置 结束 事项ID
* @param matterIdEnd
*/
public SiteMatterPdu matterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
return this;
}
/**
* 设置 增加 事项ID
* @param matterIdIncrement
*/
public SiteMatterPdu matterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
return this;
}
/**
* 设置 事项ID
* @param matterIdList
*/
public SiteMatterPdu matterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
return this;
}
/**
* 设置 事项名称
* @param matterName
*/
public SiteMatterPdu matterName(String matterName){
setMatterName(matterName);
return this;
}
/**
* 设置 事项名称
* @param matterNameList
*/
public SiteMatterPdu matterNameList(List<String> matterNameList){
this.matterNameList = matterNameList;
return this;
}
/**
* 设置 事项编码
* @param matterCode
*/
public SiteMatterPdu matterCode(String matterCode){
setMatterCode(matterCode);
return this;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public SiteMatterPdu matterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
return this;
}
/**
* 设置 部门ID
* @param deptId
*/
public SiteMatterPdu deptId(Long deptId){
setDeptId(deptId);
return this;
}
/**
* 设置 开始 部门ID
* @param deptIdStart
*/
public SiteMatterPdu deptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
return this;
}
/**
* 设置 结束 部门ID
* @param deptIdEnd
*/
public SiteMatterPdu deptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
return this;
}
/**
* 设置 增加 部门ID
* @param deptIdIncrement
*/
public SiteMatterPdu deptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
return this;
}
/**
* 设置 部门ID
* @param deptIdList
*/
public SiteMatterPdu deptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
return this;
}
/**
* 设置 部门名称
* @param deptName
*/
public SiteMatterPdu deptName(String deptName){
setDeptName(deptName);
return this;
}
/**
* 设置 部门名称
* @param deptNameList
*/
public SiteMatterPdu deptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
return this;
}
/**
* 设置 事项类型
* @param eventTypeShow
*/
public SiteMatterPdu eventTypeShow(String eventTypeShow){
setEventTypeShow(eventTypeShow);
return this;
}
/**
* 设置 事项类型
* @param eventTypeShowList
*/
public SiteMatterPdu eventTypeShowList(List<String> eventTypeShowList){
this.eventTypeShowList = eventTypeShowList;
return this;
}
/**
* 设置 事项来源
* @param source
*/
public SiteMatterPdu source(Integer source){
setSource(source);
return this;
}
/**
* 设置 开始 事项来源
* @param sourceStart
*/
public SiteMatterPdu sourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
return this;
}
/**
* 设置 结束 事项来源
* @param sourceEnd
*/
public SiteMatterPdu sourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
return this;
}
/**
* 设置 增加 事项来源
* @param sourceIncrement
*/
public SiteMatterPdu sourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
return this;
}
/**
* 设置 事项来源
* @param sourceList
*/
public SiteMatterPdu sourceList(List<Integer> sourceList){
this.sourceList = sourceList;
return this;
}
/**
* 设置 部门编号
* @param deptCode
*/
public SiteMatterPdu deptCode(String deptCode){
setDeptCode(deptCode);
return this;
}
/**
* 设置 部门编号
* @param deptCodeList
*/
public SiteMatterPdu deptCodeList(List<String> deptCodeList){
this.deptCodeList = deptCodeList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public SiteMatterPdu createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public SiteMatterPdu createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public SiteMatterPdu createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public SiteMatterPdu createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public SiteMatterPdu createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<SiteMatterPdu> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<SiteMatterPdu> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<SiteMatterPdu> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<SiteMatterPdu> andConditionList){
this.andConditionList = andConditionList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof SiteMatterPdu) {
SiteMatterPdu tmp = (SiteMatterPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.siteId = null;
this.siteName = null;
this.matterId = null;
this.matterName = null;
this.matterCode = null;
this.deptId = null;
this.deptName = null;
this.eventTypeShow = null;
this.source = null;
this.deptCode = null;
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/common/pdu/site/SiteThemeMatterPdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.site;
import com.mortals.framework.model.BaseEntityLong;
public class SiteThemeMatterPdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 站点ID
*/
private Long siteId;
/**
* 站点名称
*/
private String siteName;
/**
* 事项ID
*/
private Long matterId;
/**
* 事项名称
*/
private String matterName;
/**
* 事项编码
*/
private String matterCode;
/**
* 服务类型（1.公共服务，2.个人服务，3.法人服务）
*/
private String userType;
/**
* 主题编码
*/
private String themeCode;
/**
* 主题名称
*/
private String themeName;
/**
* 事项来源
*/
private Integer source;
public SiteThemeMatterPdu(){}
/**
* 获取 站点ID
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点ID
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 站点名称
* @return String
*/
public String getSiteName(){
return siteName;
}
/**
* 设置 站点名称
* @param siteName
*/
public void setSiteName(String siteName){
this.siteName = siteName;
}
/**
* 获取 事项ID
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项ID
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 服务类型（1.公共服务，2.个人服务，3.法人服务）
* @return String
*/
public String getUserType(){
return userType;
}
/**
* 设置 服务类型（1.公共服务，2.个人服务，3.法人服务）
* @param userType
*/
public void setUserType(String userType){
this.userType = userType;
}
/**
* 获取 主题编码
* @return String
*/
public String getThemeCode(){
return themeCode;
}
/**
* 设置 主题编码
* @param themeCode
*/
public void setThemeCode(String themeCode){
this.themeCode = themeCode;
}
/**
* 获取 主题名称
* @return String
*/
public String getThemeName(){
return themeName;
}
/**
* 设置 主题名称
* @param themeName
*/
public void setThemeName(String themeName){
this.themeName = themeName;
}
/**
* 获取 事项来源
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof SiteThemeMatterPdu) {
SiteThemeMatterPdu tmp = (SiteThemeMatterPdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",siteName:").append(getSiteName());
sb.append(",matterId:").append(getMatterId());
sb.append(",matterName:").append(getMatterName());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",userType:").append(getUserType());
sb.append(",themeCode:").append(getThemeCode());
sb.append(",themeName:").append(getThemeName());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.siteId = null;
this.siteName = null;
this.matterId = null;
this.matterName = null;
this.matterCode = null;
this.userType = null;
this.themeCode = null;
this.themeName = null;
this.source = null;
}
}
common-lib/src/main/java/com/mortals/xhx/common/pdu/site/SiteThemePdu.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.pdu.site;
import com.mortals.framework.model.BaseEntityLong;
public class SiteThemePdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 服务类型编号
*/
private String userType;
/**
* 主题编号
*/
private String themeCode;
/**
* 主题名称
*/
private String themeName;
public SiteThemePdu(){}
/**
* 获取 站点id
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点id
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 服务类型编号
* @return String
*/
public String getUserType(){
return userType;
}
/**
* 设置 服务类型编号
* @param userType
*/
public void setUserType(String userType){
this.userType = userType;
}
/**
* 获取 主题编号
* @return String
*/
public String getThemeCode(){
return themeCode;
}
/**
* 设置 主题编号
* @param themeCode
*/
public void setThemeCode(String themeCode){
this.themeCode = themeCode;
}
/**
* 获取 主题名称
* @return String
*/
public String getThemeName(){
return themeName;
}
/**
* 设置 主题名称
* @param themeName
*/
public void setThemeName(String themeName){
this.themeName = themeName;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof SiteThemePdu) {
SiteThemePdu tmp = (SiteThemePdu) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",userType:").append(getUserType());
sb.append(",themeCode:").append(getThemeCode());
sb.append(",themeName:").append(getThemeName());
return sb.toString();
}
public void initAttrValue(){
this.siteId = null;
this.userType = null;
this.themeCode = null;
this.themeName = null;
}
}
common-lib/src/main/java/com/mortals/xhx/feign/dept/IDeptFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.dept;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.dept.DeptPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = DeptFeignFallbackFactory.class)
public interface IDeptFeign extends IFeign {
/**
* 查看部门列表
*
* @param deptPdu
* @return
*/
@PostMapping(value = "/dept/list")
Rest<RespData<List<DeptPdu>>> list(@RequestBody DeptPdu deptPdu);
/**
* 查看部门
*
* @param id
* @return
*/
@GetMapping(value = "/dept/info")
Rest<DeptPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class DeptFeignFallbackFactory implements FallbackFactory<IDeptFeign> {
@Override
public IDeptFeign create(Throwable t) {
return new IDeptFeign() {
@Override
public Rest<RespData<List<DeptPdu>>> list(DeptPdu deptPdu) {
return Rest.fail("暂时无法获取部门列表，请稍后再试!");
}
@Override
public Rest<DeptPdu> info(Long id) {
return Rest.fail("暂时无法获取部门，请稍后再试!");
}
};
}
}
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterAcceptFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterAcceptPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterAcceptFallbackFactory.class)
public interface IMatterAcceptFeign extends IFeign {
/**
* 查看事项受理条件列表
*
* @param matterAcceptPdu
* @return
*/
@PostMapping(value = "/matter/accept/list")
Rest<RespData<List<MatterAcceptPdu>>> list(@RequestBody MatterAcceptPdu matterAcceptPdu);
/**
* 查看事项受理条件
*
* @param id
* @return
*/
@GetMapping(value = "/matter/accept/info")
Rest<MatterAcceptPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterAcceptFallbackFactory implements FallbackFactory<IMatterAcceptFeign> {
@Override
public IMatterAcceptFeign create(Throwable throwable) {
return new IMatterAcceptFeign(){
@Override
public Rest<RespData<List<MatterAcceptPdu>>> list(MatterAcceptPdu matterAcceptPdu) {
return Rest.fail("暂时无法获取事项受理条件列表，请稍后再试!");
}
@Override
public Rest<MatterAcceptPdu> info(Long id) {
return Rest.fail("暂时无法获取事项受理条件，请稍后再试!");
}
};
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterChargesFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterChargesPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterChargesFallbackFactory.class)
public interface IMatterChargesFeign extends IFeign {
/**
* 查看事项收费标准列表
*
* @param matterChargesPdu
* @return
*/
@PostMapping(value = "/matter/charges/list")
Rest<RespData<List<MatterChargesPdu>>> list(@RequestBody MatterChargesPdu matterChargesPdu);
/**
* 查看事项收费标准
*
* @param id
* @return
*/
@GetMapping(value = "/matter/charges/info")
Rest<MatterChargesPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterChargesFallbackFactory implements FallbackFactory<IMatterChargesFeign> {
@Override
public IMatterChargesFeign create(Throwable throwable) {
return new IMatterChargesFeign(){
@Override
public Rest<RespData<List<MatterChargesPdu>>> list(MatterChargesPdu matterChargesPdu) {
return Rest.fail("暂时无法获取事项收费标准列表，请稍后再试!");
}
@Override
public Rest<MatterChargesPdu> info(Long id) {
return Rest.fail("暂时无法获取事项收费标准列表，请稍后再试!");
}
};
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterDatumFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterDatumPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterDatumFallbackFactory.class)
public interface IMatterDatumFeign extends IFeign {
/**
* 查看事项申请材料业务列表
*
* @param matterDatumPdu
* @return
*/
@PostMapping(value = "/matter/datum/list")
Rest<RespData<List<MatterDatumPdu>>> list(@RequestBody MatterDatumPdu matterDatumPdu);
/**
* 查看事项申请材料业务
*
* @param id
* @return
*/
@GetMapping(value = "/matter/datum/info")
Rest<MatterDatumPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterDatumFallbackFactory implements FallbackFactory<IMatterDatumFeign> {
@Override
public IMatterDatumFeign create(Throwable throwable) {
return new IMatterDatumFeign(){
@Override
public Rest<RespData<List<MatterDatumPdu>>> list(MatterDatumPdu matterDatumPdu) {
return Rest.fail("暂时无法获取事项申请材料业务列表，请稍后再试!");
}
@Override
public Rest<MatterDatumPdu> info(Long id) {
return Rest.fail("暂时无法获取事项申请材料业务详细，请稍后再试!");
}
};
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterDatumFileFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterDatumFilePdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterDatumFileFallbackFactory.class)
public interface IMatterDatumFileFeign extends IFeign {
/**
* 查看材料附件业务列表
*
* @param matterDatumFilePdu
* @return
*/
@PostMapping(value = "/matter/datum/file/list")
Rest<RespData<List<MatterDatumFilePdu>>> list(@RequestBody MatterDatumFilePdu matterDatumFilePdu);
/**
* 查看材料附件业务
*
* @param id
* @return
*/
@GetMapping(value = "/matter/datum/file/info")
Rest<MatterDatumFilePdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterDatumFileFallbackFactory implements FallbackFactory<IMatterDatumFileFeign> {
@Override
public IMatterDatumFileFeign create(Throwable throwable) {
return new IMatterDatumFileFeign(){
@Override
public Rest<RespData<List<MatterDatumFilePdu>>> list(MatterDatumFilePdu matterDatumFilePdu) {
return Rest.fail("暂时无法获取材料附件业务列表，请稍后再试!");
}
@Override
public Rest<MatterDatumFilePdu> info(Long id) {
return Rest.fail("暂时无法获取材料附件业务详细，请稍后再试!");
}
};
}
}
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterFallbackFactory.class)
public interface IMatterFeign extends IFeign {
/**
* 查看基础事项列表
*
* @param matterPdu
* @return
*/
@PostMapping(value = "/matter/list")
Rest<RespData<List<MatterPdu>>> list(@RequestBody MatterPdu matterPdu);
/**
* 查看基础事项
*
* @param id
* @return
*/
@GetMapping(value = "/matter/info")
Rest<MatterPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterFallbackFactory implements FallbackFactory<IMatterFeign> {
@Override
public IMatterFeign create(Throwable throwable) {
return new IMatterFeign(){
@Override
public Rest<RespData<List<MatterPdu>>> list(MatterPdu matterPdu) {
return Rest.fail("暂时无法获取基础事项列表，请稍后再试!");
}
@Override
public Rest<MatterPdu> info(Long id) {
return Rest.fail("暂时无法获取基础事项，请稍后再试!");
}
};
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterFlowlimitFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterFlowlimitPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterFlowlimitFallbackFactory.class)
public interface IMatterFlowlimitFeign extends IFeign {
/**
* 查看事项办理流程列表
*
* @param matterFlowlimitPdu
* @return
*/
@PostMapping(value = "/matter/flowlimit/list")
Rest<RespData<List<MatterFlowlimitPdu>>> list(@RequestBody MatterFlowlimitPdu matterFlowlimitPdu);
/**
* 查看事项办理流程
*
* @param id
* @return
*/
@GetMapping(value = "/matter/flowlimit/info")
Rest<MatterFlowlimitPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterFlowlimitFallbackFactory implements FallbackFactory<IMatterFlowlimitFeign> {
@Override
public IMatterFlowlimitFeign create(Throwable throwable) {
return new IMatterFlowlimitFeign(){
@Override
public Rest<RespData<List<MatterFlowlimitPdu>>> list(MatterFlowlimitPdu matterFlowlimitPdu) {
return Rest.fail("暂时无法获取事项办理流程列表，请稍后再试!");
}
@Override
public Rest<MatterFlowlimitPdu> info(Long id) {
return Rest.fail("暂时无法获取事项办理流程，请稍后再试!");
}
};
}
}
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterIntermediaryFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterIntermediaryPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterIntermediaryFallbackFactory.class)
public interface IMatterIntermediaryFeign extends IFeign {
/**
* 查看事项中介服务列表
*
* @param matterIntermediaryPdu
* @return
*/
@PostMapping(value = "/matter/intermediary/list")
Rest<RespData<List<MatterIntermediaryPdu>>> list(@RequestBody MatterIntermediaryPdu matterIntermediaryPdu);
/**
* 查看事项中介服务
*
* @param id
* @return
*/
@GetMapping(value = "/matter/intermediary/info")
Rest<MatterIntermediaryPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterIntermediaryFallbackFactory implements FallbackFactory<IMatterIntermediaryFeign> {
@Override
public IMatterIntermediaryFeign create(Throwable throwable) {
return new IMatterIntermediaryFeign(){
@Override
public Rest<RespData<List<MatterIntermediaryPdu>>> list(MatterIntermediaryPdu matterIntermediaryPdu) {
return Rest.fail("暂时无法获取事项中介服务列表，请稍后再试!");
}
@Override
public Rest<MatterIntermediaryPdu> info(Long id) {
return Rest.fail("暂时无法获取事项中介服务，请稍后再试!");
}
};
}
}
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterQuestionFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterQuestionPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterQuestionFallbackFactory.class)
public interface IMatterQuestionFeign extends IFeign {
/**
* 查看事项常见问题列表
*
* @param matterQuestionPdu
* @return
*/
@PostMapping(value = "/matter/question/list")
Rest<RespData<List<MatterQuestionPdu>>> list(@RequestBody MatterQuestionPdu matterQuestionPdu);
/**
* 查看事项常见问题
*
* @param id
* @return
*/
@GetMapping(value = "/matter/question/info")
Rest<MatterQuestionPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterQuestionFallbackFactory implements FallbackFactory<IMatterQuestionFeign> {
@Override
public IMatterQuestionFeign create(Throwable throwable) {
return new IMatterQuestionFeign(){
@Override
public Rest<RespData<List<MatterQuestionPdu>>> list(MatterQuestionPdu matterQuestionPdu) {
return Rest.fail("暂时无法获取事项常见问题列表，请稍后再试!");
}
@Override
public Rest<MatterQuestionPdu> info(Long id) {
return Rest.fail("暂时无法获取事项常见问题，请稍后再试!");
}
};
}
}
common-lib/src/main/java/com/mortals/xhx/feign/matter/IMatterSetbaseFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.matter;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterSetbasePdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = MatterSetbaseFallbackFactory.class)
public interface IMatterSetbaseFeign extends IFeign {
/**
* 查看事项设定依据列表
*
* @param matterSetbasePdu
* @return
*/
@PostMapping(value = "/matter/setbase/list")
Rest<RespData<List<MatterSetbasePdu>>> list(@RequestBody MatterSetbasePdu matterSetbasePdu);
/**
* 查看事项设定依据
*
* @param id
* @return
*/
@GetMapping(value = "/matter/setbase/info")
Rest<MatterSetbasePdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class MatterSetbaseFallbackFactory implements FallbackFactory<IMatterSetbaseFeign> {
@Override
public IMatterSetbaseFeign create(Throwable throwable) {
return new IMatterSetbaseFeign(){
@Override
public Rest<RespData<List<MatterSetbasePdu>>> list(MatterSetbasePdu matterSetbasePdu) {
return Rest.fail("暂时无法获取事项设定依据列表，请稍后再试!");
}
@Override
public Rest<MatterSetbasePdu> info(Long id) {
return Rest.fail("暂时无法获取事项设定依据，请稍后再试!");
}
};
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/feign/site/ISiteMatterFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.site;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.site.SiteMatterPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 站点事项 Feign接口
* @author zxfei
* @date 2023-02-17
*/
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = SiteMatterFeignFallbackFactory.class)
public interface ISiteMatterFeign extends IFeign {
/**
* 查看站点事项列表
*
* @param siteMatterPdu
* @return
*/
@PostMapping(value = "/site/matter/list")
Rest<RespData<List<SiteMatterPdu>>> list(@RequestBody SiteMatterPdu siteMatterPdu);
/**
* 查看站点事项
*
* @param id
* @return
*/
@GetMapping(value = "/site/matter/info")
Rest<SiteMatterPdu> info(@RequestParam(value = "id") Long id);
/**
* 删除站点事项
*
* @param ids
* @return
*/
@GetMapping(value = "/site/matter/delete")
Rest<Void> delete(Long[] ids,@RequestHeader("Authorization") String authorization);
/**
* 站点事项保存更新
*
* @param siteMatterPdu
* @return
*/
@PostMapping(value = "/site/matter/save")
Rest<RespData<SiteMatterPdu>> save(@RequestBody SiteMatterPdu siteMatterPdu, @RequestHeader("Authorization") String authorization);
}
@Slf4j
@Component
class SiteMatterFeignFallbackFactory implements FallbackFactory<ISiteMatterFeign> {
@Override
public ISiteMatterFeign create(Throwable t) {
return new ISiteMatterFeign() {
@Override
public Rest<RespData<List<SiteMatterPdu>>> list(SiteMatterPdu siteMatterPdu) {
return Rest.fail("暂时无法获取站点事项列表，请稍后再试!");
}
@Override
public Rest<SiteMatterPdu> info(Long id) {
return Rest.fail("暂时无法获取站点事项详细，请稍后再试!");
}
@Override
public Rest<Void> delete(Long[] ids, String authorization) {
return Rest.fail("暂时无法删除站点事项，请稍后再试!");
}
@Override
public Rest<RespData<SiteMatterPdu>> save(SiteMatterPdu siteMatterPdu, String authorization) {
return Rest.fail("暂时无法保存站点事项，请稍后再试!");
}
};
}
}
common-lib/src/main/java/com/mortals/xhx/feign/site/ISiteThemeFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.site;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.site.SiteThemePdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = SiteThemeFallbackFactory.class)
public interface ISiteThemeFeign extends IFeign {
/**
* 查看事项主题列表
*
* @param siteThemePdu
* @return
*/
@PostMapping(value = "/site/theme/list")
Rest<RespData<List<SiteThemePdu>>> list(@RequestBody SiteThemePdu siteThemePdu);
/**
* 查看事项主题
*
* @param id
* @return
*/
@GetMapping(value = "/site/theme/info")
Rest<SiteThemePdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class SiteThemeFallbackFactory implements FallbackFactory<ISiteThemeFeign> {
@Override
public ISiteThemeFeign create(Throwable throwable) {
return new ISiteThemeFeign(){
@Override
public Rest<RespData<List<SiteThemePdu>>> list(SiteThemePdu siteThemePdu) {
return Rest.fail("暂时无法获取事项主题列表，请稍后再试!");
}
@Override
public Rest<SiteThemePdu> info(Long id) {
return Rest.fail("暂时无法获取事项主题，请稍后再试!");
}
};
}
}
\ No newline at end of file
common-lib/src/main/java/com/mortals/xhx/feign/site/ISiteThemeMatterFeign.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.feign.site;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.site.SiteThemeMatterPdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = SiteThemeMatterFallbackFactory.class)
public interface ISiteThemeMatterFeign extends IFeign {
/**
* 查看站点主题事项列表
*
* @param siteThemeMatterPdu
* @return
*/
@PostMapping(value = "/site/theme/matter/list")
Rest<RespData<List<SiteThemeMatterPdu>>> list(@RequestBody SiteThemeMatterPdu siteThemeMatterPdu);
/**
* 查看站点主题事项
*
* @param id
* @return
*/
@GetMapping(value = "/site/theme/matter/info")
Rest<SiteThemeMatterPdu> info(@RequestParam(value = "id") Long id);
}
@Slf4j
@Component
class SiteThemeMatterFallbackFactory implements FallbackFactory<ISiteThemeMatterFeign> {
@Override
public ISiteThemeMatterFeign create(Throwable throwable) {
return new ISiteThemeMatterFeign(){
@Override
public Rest<RespData<List<SiteThemeMatterPdu>>> list(SiteThemeMatterPdu siteThemeMatterPdu) {
return Rest.fail("暂时无法获取站点主题事项列表，请稍后再试!");
}
@Override
public Rest<SiteThemeMatterPdu> info(Long id) {
return Rest.fail("暂时无法获取站点主题事项，请稍后再试!");
}
};
}
}
sst-manager/doc/api.md
View file @ 9c5b55e7
...@@ -1906,4 +1906,1697 @@ msg|String|消息|- ...@@ -1906,4 +1906,1697 @@ msg|String|消息|-
} }
``` ```
## 申报事项
### 查询申报事项列表
**请求URL:** matter/apply/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询申报事项
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
siteName|String|否|站点名称,字段前后添加%%模糊查询
source|Integer|否|事项来源
govUrl|String|否|政务网地址,字段前后添加%%模糊查询
**请求样例:**
```
{
"siteName":"715rjt",
"source":1762,
"govUrl":"xltor7",
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;per_page|Integer|每页条数
&emsp;total|Integer|总条数
&emsp;last_page|Integer|总页数
&emsp;current_page|Integer|当前页
&emsp;data|array|结果集列表|数组
&emsp;&emsp;id|Long|序号，主键，自增长
&emsp;&emsp;siteId|Long|站点id
&emsp;&emsp;siteName|String|站点名称
&emsp;&emsp;siteMatterId|Long|站点事项id
&emsp;&emsp;matterId|Long|事项ID
&emsp;&emsp;matterName|String|事项名称
&emsp;&emsp;matterCode|String|事项编码
&emsp;&emsp;deptId|Long|部门ID
&emsp;&emsp;deptName|String|部门名称
&emsp;&emsp;deptCode|String|部门编码
&emsp;&emsp;themeCode|String|事项主题
&emsp;&emsp;themeName|String|事项主题
&emsp;&emsp;source|Integer|事项来源
&emsp;&emsp;reportCount|Integer|申报次数
&emsp;&emsp;datumCount|Integer|材料数量
&emsp;&emsp;govUrl|String|政务网地址
&emsp;&emsp;isConvert|Integer|是否生成本地附件
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;updateUserId|Long|更新用户
&emsp;&emsp;updateTime|Date|更新时间
dict|object|字典对象
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看申报事项
**请求URL:** matter/apply/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看申报事项，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/matter/apply/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|序号，主键，自增长
&emsp;siteId|Long|站点id
&emsp;siteName|String|站点名称
&emsp;siteMatterId|Long|站点事项id
&emsp;matterId|Long|事项ID
&emsp;matterName|String|事项名称
&emsp;matterCode|String|事项编码
&emsp;deptId|Long|部门ID
&emsp;deptName|String|部门名称
&emsp;deptCode|String|部门编码
&emsp;themeCode|String|事项主题
&emsp;themeName|String|事项主题
&emsp;source|Integer|事项来源
&emsp;reportCount|Integer|申报次数
&emsp;datumCount|Integer|材料数量
&emsp;govUrl|String|政务网地址
&emsp;isConvert|Integer|是否生成本地附件
&emsp;createUserId|Long|创建用户
&emsp;createTime|Date|创建时间
&emsp;updateUserId|Long|更新用户
&emsp;updateTime|Date|更新时间
dict|object|字典对象
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":629,
"siteId":1126,
"siteName":"7elmxe",
"siteMatterId":522,
"matterId":7745,
"matterName":"m0a0xx",
"matterCode":"wdgskw",
"deptId":2232,
"deptName":"vnigtd",
"deptCode":"nxakme",
"themeCode":"tiq9vu",
"themeName":"kf6o1h",
"source":6260,
"reportCount":4350,
"datumCount":9099,
"govUrl":"cdx2x5",
"isConvert":8011,
"createUserId":8971,
"createTime":"2023-04-07",
"updateUserId":5756,
"updateTime":"2023-04-07"
}
}
```
### 保存更新申报事项
**请求URL:** matter/apply/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新申报事项：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteId|Long|否|站点id
siteName|String|否|站点名称
siteMatterId|Long|否|站点事项id
matterId|Long|否|事项ID
matterName|String|否|事项名称
matterCode|String|否|事项编码
deptId|Long|否|部门ID
deptName|String|否|部门名称
deptCode|String|否|部门编码
themeCode|String|否|事项主题
themeName|String|否|事项主题
source|Integer|否|事项来源
reportCount|Integer|否|申报次数
datumCount|Integer|否|材料数量
govUrl|String|否|政务网地址
isConvert|Integer|否|是否生成本地附件
**请求样例:**
```
{
"siteId":2598,
"siteName":"z0cr5s",
"siteMatterId":2454,
"matterId":3582,
"matterName":"f663l7",
"matterCode":"fyfzu7",
"deptId":653,
"deptName":"4cwulr",
"deptCode":"qh8ud3",
"themeCode":"blhmdu",
"themeName":"hnl4q5",
"source":6426,
"reportCount":5312,
"datumCount":5112,
"govUrl":"9kqpo1",
"isConvert":3293,
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|保存后主键id
&emsp;entity|object|保存更新实体
&emsp;&emsp;id|Long|序号，主键，自增长
&emsp;&emsp;siteId|Long|站点id
&emsp;&emsp;siteName|String|站点名称
&emsp;&emsp;siteMatterId|Long|站点事项id
&emsp;&emsp;matterId|Long|事项ID
&emsp;&emsp;matterName|String|事项名称
&emsp;&emsp;matterCode|String|事项编码
&emsp;&emsp;deptId|Long|部门ID
&emsp;&emsp;deptName|String|部门名称
&emsp;&emsp;deptCode|String|部门编码
&emsp;&emsp;themeCode|String|事项主题
&emsp;&emsp;themeName|String|事项主题
&emsp;&emsp;source|Integer|事项来源
&emsp;&emsp;reportCount|Integer|申报次数
&emsp;&emsp;datumCount|Integer|材料数量
&emsp;&emsp;govUrl|String|政务网地址
&emsp;&emsp;isConvert|Integer|是否生成本地附件
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;updateUserId|Long|更新用户
&emsp;&emsp;updateTime|Date|更新时间
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除申报事项
**请求URL:** matter/apply/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除申报事项
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/matter/apply/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## 事项申请材料业务
### 查询事项申请材料业务列表
**请求URL:** matter/datum/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询事项申请材料业务
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
**请求样例:**
```
{
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;per_page|Integer|每页条数
&emsp;total|Integer|总条数
&emsp;last_page|Integer|总页数
&emsp;current_page|Integer|当前页
&emsp;data|array|结果集列表|数组
&emsp;&emsp;id|Long|主键，自增长
&emsp;&emsp;matterId|Long|事项基础表matter id
&emsp;&emsp;materialName|String|材料名
&emsp;&emsp;isMust|String|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
&emsp;&emsp;materialType|String|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
&emsp;&emsp;materialProperty|String|材料形式（1.纸质，2.电子，3.纸质|电子）
&emsp;&emsp;electronicgs|String|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
&emsp;&emsp;materialSource|String|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
&emsp;&emsp;paperNum|Integer|纸质材料份数
&emsp;&emsp;paperGg|String|纸质材料规格
&emsp;&emsp;jianmMs|String|减免模式（1.无，2.减，3.免）
&emsp;&emsp;sealWay|String|盖章方式
&emsp;&emsp;isjianm|String|是否减免（0.否，1.是）
&emsp;&emsp;isLack|String|材料是否容缺（1.必要，2.非必要）
&emsp;&emsp;ybUrl|String|材料地址
&emsp;&emsp;materialSourceSm|String|来源渠道说明
&emsp;&emsp;remarkSub|String|填报须知
&emsp;&emsp;clauseContent|String|要求提供材料的依据
&emsp;&emsp;summary|String|受理标准
&emsp;&emsp;remark|String|备注
&emsp;&emsp;source|Integer|事项来源(0.政务网，1.自定义)
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;updateTime|Date|修改时间
dict|object|字典对象
&emsp;isMust|object|字典属性对象，详见附录
&emsp;materialProperty|object|字典属性对象，详见附录
&emsp;electronicgs|object|字典属性对象，详见附录
&emsp;materialSource|object|字典属性对象，详见附录
&emsp;jianmMs|object|字典属性对象，详见附录
&emsp;isjianm|object|字典属性对象，详见附录
&emsp;isLack|object|字典属性对象，详见附录
&emsp;source|object|字典属性对象，详见附录
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看事项申请材料业务
**请求URL:** matter/datum/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看事项申请材料业务，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/matter/datum/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|主键，自增长
&emsp;matterId|Long|事项基础表matter id
&emsp;materialName|String|材料名
&emsp;isMust|String|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
&emsp;materialType|String|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
&emsp;materialProperty|String|材料形式（1.纸质，2.电子，3.纸质|电子）
&emsp;electronicgs|String|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
&emsp;materialSource|String|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
&emsp;paperNum|Integer|纸质材料份数
&emsp;paperGg|String|纸质材料规格
&emsp;jianmMs|String|减免模式（1.无，2.减，3.免）
&emsp;sealWay|String|盖章方式
&emsp;isjianm|String|是否减免（0.否，1.是）
&emsp;isLack|String|材料是否容缺（1.必要，2.非必要）
&emsp;ybUrl|String|材料地址
&emsp;materialSourceSm|String|来源渠道说明
&emsp;remarkSub|String|填报须知
&emsp;clauseContent|String|要求提供材料的依据
&emsp;summary|String|受理标准
&emsp;remark|String|备注
&emsp;source|Integer|事项来源(0.政务网，1.自定义)
&emsp;createTime|Date|创建时间
&emsp;createUserId|Long|创建用户
&emsp;updateTime|Date|修改时间
dict|object|字典对象
&emsp;isMust|object|字典属性对象，详见附录
&emsp;materialProperty|object|字典属性对象，详见附录
&emsp;electronicgs|object|字典属性对象，详见附录
&emsp;materialSource|object|字典属性对象，详见附录
&emsp;jianmMs|object|字典属性对象，详见附录
&emsp;isjianm|object|字典属性对象，详见附录
&emsp;isLack|object|字典属性对象，详见附录
&emsp;source|object|字典属性对象，详见附录
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":4859,
"matterId":8423,
"materialName":"ddllax",
"isMust":"y4ip3c",
"materialType":"870of6",
"materialProperty":"oqhyl5",
"electronicgs":"efp787",
"materialSource":"2f9h5d",
"paperNum":1595,
"paperGg":"64cqc7",
"jianmMs":"ea8unr",
"sealWay":"098joa",
"isjianm":"312dlm",
"isLack":"r52a51",
"ybUrl":"hjhjlo",
"materialSourceSm":"t39sag",
"remarkSub":"f3v26l",
"clauseContent":"1gp9f0",
"summary":"7tozai",
"remark":"9ea1mg",
"source":5179,
"createTime":"2023-04-07",
"createUserId":614,
"updateTime":"2023-04-07"
}
}
```
### 保存更新事项申请材料业务
**请求URL:** matter/datum/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新事项申请材料业务：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
matterId|Long|否|事项基础表matter id
materialName|String|是|材料名
isMust|String|否|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
materialType|String|否|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
materialProperty|String|否|材料形式（1.纸质，2.电子，3.纸质|电子）
electronicgs|String|否|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
materialSource|String|否|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
paperNum|Integer|否|纸质材料份数
paperGg|String|否|纸质材料规格
jianmMs|String|否|减免模式（1.无，2.减，3.免）
sealWay|String|否|盖章方式
isjianm|String|否|是否减免（0.否，1.是）
isLack|String|否|材料是否容缺（1.必要，2.非必要）
ybUrl|String|否|材料地址
materialSourceSm|String|否|来源渠道说明
remarkSub|String|否|填报须知
clauseContent|String|否|要求提供材料的依据
summary|String|否|受理标准
remark|String|否|备注
source|Integer|否|事项来源(0.政务网，1.自定义)
**请求样例:**
```
{
"matterId":1119,
"materialName":"ztn9ot",
"isMust":"i2l7vr",
"materialType":"iv5h7d",
"materialProperty":"boih87",
"electronicgs":"of4i3y",
"materialSource":"4b4r25",
"paperNum":9597,
"paperGg":"om5raz",
"jianmMs":"sbthqt",
"sealWay":"o6wwj3",
"isjianm":"g756gb",
"isLack":"92foxp",
"ybUrl":"iiov1b",
"materialSourceSm":"xobx70",
"remarkSub":"qs8rmp",
"clauseContent":"bea56k",
"summary":"nxm12u",
"remark":"d0ykgp",
"source":9622,
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|保存后主键id
&emsp;entity|object|保存更新实体
&emsp;&emsp;id|Long|主键，自增长
&emsp;&emsp;matterId|Long|事项基础表matter id
&emsp;&emsp;materialName|String|材料名
&emsp;&emsp;isMust|String|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
&emsp;&emsp;materialType|String|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
&emsp;&emsp;materialProperty|String|材料形式（1.纸质，2.电子，3.纸质|电子）
&emsp;&emsp;electronicgs|String|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
&emsp;&emsp;materialSource|String|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
&emsp;&emsp;paperNum|Integer|纸质材料份数
&emsp;&emsp;paperGg|String|纸质材料规格
&emsp;&emsp;jianmMs|String|减免模式（1.无，2.减，3.免）
&emsp;&emsp;sealWay|String|盖章方式
&emsp;&emsp;isjianm|String|是否减免（0.否，1.是）
&emsp;&emsp;isLack|String|材料是否容缺（1.必要，2.非必要）
&emsp;&emsp;ybUrl|String|材料地址
&emsp;&emsp;materialSourceSm|String|来源渠道说明
&emsp;&emsp;remarkSub|String|填报须知
&emsp;&emsp;clauseContent|String|要求提供材料的依据
&emsp;&emsp;summary|String|受理标准
&emsp;&emsp;remark|String|备注
&emsp;&emsp;source|Integer|事项来源(0.政务网，1.自定义)
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;updateTime|Date|修改时间
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除事项申请材料业务
**请求URL:** matter/datum/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除事项申请材料业务
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/matter/datum/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## 材料附件业务
### 查询材料附件业务列表
**请求URL:** matter/datum/file/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询材料附件业务
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
**请求样例:**
```
{
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;per_page|Integer|每页条数
&emsp;total|Integer|总条数
&emsp;last_page|Integer|总页数
&emsp;current_page|Integer|当前页
&emsp;data|array|结果集列表|数组
&emsp;&emsp;id|Long|主键，自增长
&emsp;&emsp;datumId|Long|材料id
&emsp;&emsp;matterId|Long|事项基础表matter id
&emsp;&emsp;matterCode|String|事项编码
&emsp;&emsp;materialName|String|材料名
&emsp;&emsp;fileName|String|附件名称
&emsp;&emsp;fileUrl|String|附件下载地址
&emsp;&emsp;filetype|Integer|附件类型 (1.示例样表，2.空白表格)
&emsp;&emsp;source|Integer|附件来源 (0.政务网，1.自定义)
&emsp;&emsp;localFileUrl|String|本地文件地址
&emsp;&emsp;previewUrl|String|文件预览地址
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;updateTime|Date|修改时间
dict|object|字典对象
&emsp;filetype|object|字典属性对象，详见附录
&emsp;source|object|字典属性对象，详见附录
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看材料附件业务
**请求URL:** matter/datum/file/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看材料附件业务，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/matter/datum/file/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|主键，自增长
&emsp;datumId|Long|材料id
&emsp;matterId|Long|事项基础表matter id
&emsp;matterCode|String|事项编码
&emsp;materialName|String|材料名
&emsp;fileName|String|附件名称
&emsp;fileUrl|String|附件下载地址
&emsp;filetype|Integer|附件类型 (1.示例样表，2.空白表格)
&emsp;source|Integer|附件来源 (0.政务网，1.自定义)
&emsp;localFileUrl|String|本地文件地址
&emsp;previewUrl|String|文件预览地址
&emsp;createTime|Date|创建时间
&emsp;createUserId|Long|创建用户
&emsp;updateTime|Date|修改时间
dict|object|字典对象
&emsp;filetype|object|字典属性对象，详见附录
&emsp;source|object|字典属性对象，详见附录
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":9366,
"datumId":1274,
"matterId":6185,
"matterCode":"lywskc",
"materialName":"mt83yz",
"fileName":"btpana",
"fileUrl":"22qhns",
"filetype":6195,
"source":881,
"localFileUrl":"s70j49",
"previewUrl":"3f7vtt",
"createTime":"2023-04-07",
"createUserId":7695,
"updateTime":"2023-04-07"
}
}
```
### 保存更新材料附件业务
**请求URL:** matter/datum/file/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新材料附件业务：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
datumId|Long|是|材料id
matterId|Long|否|事项基础表matter id
matterCode|String|否|事项编码
materialName|String|是|材料名
fileName|String|否|附件名称
fileUrl|String|否|附件下载地址
filetype|Integer|否|附件类型 (1.示例样表，2.空白表格)
source|Integer|否|附件来源 (0.政务网，1.自定义)
localFileUrl|String|否|本地文件地址
previewUrl|String|否|文件预览地址
**请求样例:**
```
{
"datumId":291,
"matterId":4505,
"matterCode":"qx8ir9",
"materialName":"ikflg6",
"fileName":"pxfdjc",
"fileUrl":"8lkek6",
"filetype":7055,
"source":9237,
"localFileUrl":"leob4v",
"previewUrl":"y9sqi2",
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|保存后主键id
&emsp;entity|object|保存更新实体
&emsp;&emsp;id|Long|主键，自增长
&emsp;&emsp;datumId|Long|材料id
&emsp;&emsp;matterId|Long|事项基础表matter id
&emsp;&emsp;matterCode|String|事项编码
&emsp;&emsp;materialName|String|材料名
&emsp;&emsp;fileName|String|附件名称
&emsp;&emsp;fileUrl|String|附件下载地址
&emsp;&emsp;filetype|Integer|附件类型 (1.示例样表，2.空白表格)
&emsp;&emsp;source|Integer|附件来源 (0.政务网，1.自定义)
&emsp;&emsp;localFileUrl|String|本地文件地址
&emsp;&emsp;previewUrl|String|文件预览地址
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;updateTime|Date|修改时间
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除材料附件业务
**请求URL:** matter/datum/file/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除材料附件业务
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/matter/datum/file/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## 站点材料公共库
### 查询站点材料公共库列表
**请求URL:** datum/library/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点材料公共库
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
siteName|String|否|站点名称,字段前后添加%%模糊查询
**请求样例:**
```
{
"siteName":"5xykn9",
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;per_page|Integer|每页条数
&emsp;total|Integer|总条数
&emsp;last_page|Integer|总页数
&emsp;current_page|Integer|当前页
&emsp;data|array|结果集列表|数组
&emsp;&emsp;id|Long|主键，自增长
&emsp;&emsp;siteId|Long|站点id
&emsp;&emsp;siteName|String|站点名称
&emsp;&emsp;datumId|Long|材料id
&emsp;&emsp;matterId|Long|事项基础表matter id
&emsp;&emsp;matterCode|String|事项编码
&emsp;&emsp;matterName|String|事项名称
&emsp;&emsp;materialName|String|材料名
&emsp;&emsp;isMust|String|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
&emsp;&emsp;materialType|String|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
&emsp;&emsp;materialProperty|String|材料形式（1.纸质，2.电子，3.纸质|电子）
&emsp;&emsp;electronicgs|String|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
&emsp;&emsp;materialSource|String|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
&emsp;&emsp;paperNum|Integer|纸质材料份数
&emsp;&emsp;paperGg|String|纸质材料规格
&emsp;&emsp;jianmMs|String|减免模式（1.无，2.减，3.免）
&emsp;&emsp;sealWay|String|盖章方式
&emsp;&emsp;isjianm|String|是否减免（0.否，1.是）
&emsp;&emsp;isLack|String|材料是否容缺（1.必要，2.非必要）
&emsp;&emsp;ybUrl|String|材料地址
&emsp;&emsp;materialSourceSm|String|来源渠道说明
&emsp;&emsp;remarkSub|String|填报须知
&emsp;&emsp;clauseContent|String|要求提供材料的依据
&emsp;&emsp;summary|String|受理标准
&emsp;&emsp;remark|String|备注
&emsp;&emsp;source|Integer|事项来源(0.政务网，1.自定义)
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;updateTime|Date|修改时间
dict|object|字典对象
&emsp;isMust|object|字典属性对象，详见附录
&emsp;materialProperty|object|字典属性对象，详见附录
&emsp;electronicgs|object|字典属性对象，详见附录
&emsp;materialSource|object|字典属性对象，详见附录
&emsp;jianmMs|object|字典属性对象，详见附录
&emsp;isjianm|object|字典属性对象，详见附录
&emsp;isLack|object|字典属性对象，详见附录
&emsp;source|object|字典属性对象，详见附录
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看站点材料公共库
**请求URL:** datum/library/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看站点材料公共库，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/datum/library/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|主键，自增长
&emsp;siteId|Long|站点id
&emsp;siteName|String|站点名称
&emsp;datumId|Long|材料id
&emsp;matterId|Long|事项基础表matter id
&emsp;matterCode|String|事项编码
&emsp;matterName|String|事项名称
&emsp;materialName|String|材料名
&emsp;isMust|String|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
&emsp;materialType|String|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
&emsp;materialProperty|String|材料形式（1.纸质，2.电子，3.纸质|电子）
&emsp;electronicgs|String|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
&emsp;materialSource|String|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
&emsp;paperNum|Integer|纸质材料份数
&emsp;paperGg|String|纸质材料规格
&emsp;jianmMs|String|减免模式（1.无，2.减，3.免）
&emsp;sealWay|String|盖章方式
&emsp;isjianm|String|是否减免（0.否，1.是）
&emsp;isLack|String|材料是否容缺（1.必要，2.非必要）
&emsp;ybUrl|String|材料地址
&emsp;materialSourceSm|String|来源渠道说明
&emsp;remarkSub|String|填报须知
&emsp;clauseContent|String|要求提供材料的依据
&emsp;summary|String|受理标准
&emsp;remark|String|备注
&emsp;source|Integer|事项来源(0.政务网，1.自定义)
&emsp;createTime|Date|创建时间
&emsp;createUserId|Long|创建用户
&emsp;updateTime|Date|修改时间
dict|object|字典对象
&emsp;isMust|object|字典属性对象，详见附录
&emsp;materialProperty|object|字典属性对象，详见附录
&emsp;electronicgs|object|字典属性对象，详见附录
&emsp;materialSource|object|字典属性对象，详见附录
&emsp;jianmMs|object|字典属性对象，详见附录
&emsp;isjianm|object|字典属性对象，详见附录
&emsp;isLack|object|字典属性对象，详见附录
&emsp;source|object|字典属性对象，详见附录
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":6834,
"siteId":5454,
"siteName":"82g15f",
"datumId":3495,
"matterId":554,
"matterCode":"l0a8qy",
"matterName":"uuw4p3",
"materialName":"dpptsw",
"isMust":"txjjnd",
"materialType":"ra108j",
"materialProperty":"edkjc3",
"electronicgs":"ymkml0",
"materialSource":"r1cj3x",
"paperNum":348,
"paperGg":"ht3o1g",
"jianmMs":"4plgr5",
"sealWay":"k22ru8",
"isjianm":"20r64n",
"isLack":"5r3f4k",
"ybUrl":"e6yqvi",
"materialSourceSm":"ccr6z7",
"remarkSub":"p0sweq",
"clauseContent":"q9h7gu",
"summary":"xnyznn",
"remark":"9d3ose",
"source":4557,
"createTime":"2023-04-07",
"createUserId":7762,
"updateTime":"2023-04-07"
}
}
```
### 保存更新站点材料公共库
**请求URL:** datum/library/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新站点材料公共库：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteId|Long|否|站点id
siteName|String|否|站点名称
datumId|Long|否|材料id
matterId|Long|否|事项基础表matter id
matterCode|String|否|事项编码
matterName|String|否|事项名称
materialName|String|是|材料名
isMust|String|否|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
materialType|String|否|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
materialProperty|String|否|材料形式（1.纸质，2.电子，3.纸质|电子）
electronicgs|String|否|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
materialSource|String|否|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
paperNum|Integer|否|纸质材料份数
paperGg|String|否|纸质材料规格
jianmMs|String|否|减免模式（1.无，2.减，3.免）
sealWay|String|否|盖章方式
isjianm|String|否|是否减免（0.否，1.是）
isLack|String|否|材料是否容缺（1.必要，2.非必要）
ybUrl|String|否|材料地址
materialSourceSm|String|否|来源渠道说明
remarkSub|String|否|填报须知
clauseContent|String|否|要求提供材料的依据
summary|String|否|受理标准
remark|String|否|备注
source|Integer|否|事项来源(0.政务网，1.自定义)
**请求样例:**
```
{
"siteId":1281,
"siteName":"9ohrie",
"datumId":8950,
"matterId":1309,
"matterCode":"kl1i7h",
"matterName":"so6p9w",
"materialName":"5omzar",
"isMust":"si1y51",
"materialType":"ppbsqo",
"materialProperty":"1mwnn5",
"electronicgs":"o9s7y8",
"materialSource":"xcp14s",
"paperNum":5232,
"paperGg":"iq63ep",
"jianmMs":"ntf8ud",
"sealWay":"sxjk20",
"isjianm":"c0wevw",
"isLack":"bj7kzi",
"ybUrl":"xaa4qt",
"materialSourceSm":"tqt5qr",
"remarkSub":"cngny6",
"clauseContent":"c3pqwa",
"summary":"r98n4m",
"remark":"99vspw",
"source":5759,
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;id|Long|保存后主键id
&emsp;entity|object|保存更新实体
&emsp;&emsp;id|Long|主键，自增长
&emsp;&emsp;siteId|Long|站点id
&emsp;&emsp;siteName|String|站点名称
&emsp;&emsp;datumId|Long|材料id
&emsp;&emsp;matterId|Long|事项基础表matter id
&emsp;&emsp;matterCode|String|事项编码
&emsp;&emsp;matterName|String|事项名称
&emsp;&emsp;materialName|String|材料名
&emsp;&emsp;isMust|String|必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
&emsp;&emsp;materialType|String|材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
&emsp;&emsp;materialProperty|String|材料形式（1.纸质，2.电子，3.纸质|电子）
&emsp;&emsp;electronicgs|String|电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
&emsp;&emsp;materialSource|String|材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
&emsp;&emsp;paperNum|Integer|纸质材料份数
&emsp;&emsp;paperGg|String|纸质材料规格
&emsp;&emsp;jianmMs|String|减免模式（1.无，2.减，3.免）
&emsp;&emsp;sealWay|String|盖章方式
&emsp;&emsp;isjianm|String|是否减免（0.否，1.是）
&emsp;&emsp;isLack|String|材料是否容缺（1.必要，2.非必要）
&emsp;&emsp;ybUrl|String|材料地址
&emsp;&emsp;materialSourceSm|String|来源渠道说明
&emsp;&emsp;remarkSub|String|填报须知
&emsp;&emsp;clauseContent|String|要求提供材料的依据
&emsp;&emsp;summary|String|受理标准
&emsp;&emsp;remark|String|备注
&emsp;&emsp;source|Integer|事项来源(0.政务网，1.自定义)
&emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;updateTime|Date|修改时间
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除站点材料公共库
**请求URL:** datum/library/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除站点材料公共库
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/datum/library/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
--------------------------------
## 后台管理接口
### 查询部门列表
**请求URL:** dept/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteId|Long|是|站点ID
name|String|否|部门名称
page|int|是|页码
size|int|是|每页显示数
**请求样例:**
```
{
"siteId": 2,
"size": 5,
"page": 1
}
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
### 查询站点事项列表
**请求URL:** site/matter/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteId|Long|是|站点ID
matterId|Long|否|事项基础表matter id
matterName|String|否|事项名称
deptId|Long|否|部门id
page|int|是|页码
size|int|是|每页显示数
**请求样例:**
```
{
"siteId": 2,
"size": 5,
"page": 1
}
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
### 查询事项主题列表
**请求URL:** site/theme/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteId|Long|是|站点ID
themeName|String|否|主题名称
page|int|是|页码
size|int|是|每页显示数
**请求样例:**
```
{
"siteId": 2,
"size": 5,
"page": 1
}
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
### 站点事项加入申请事项
**请求URL:** site/matter/addToAssist
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteMatterIds|String|是|站点事项ID
**请求样例:**
```
{
"siteMatterIds":"1,2,3,4"
}
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
### 公共库加入材料
**请求URL:** datum/library/addToMatterDatum
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
libraryIds|String|是|公共库ID
**请求样例:**
```
{
"libraryIds":"1,2,3,4"
}
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
### 材料加入公共库
**请求URL:** matter/datum/addToLibrary
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
datumIds|String|是|公共库ID
siteId|Long|是|站点ID
**请求样例:**
```
{
"datumIds": "19,20",
"siteId": 1
}
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
### 查询站点基础事项详情
**请求URL:** base/matter/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
matterId|Long|是|基础事项ID
**请求样例:**
```
http://localhost:17217/sst/base/matter/info?matterId=1
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
&emsp;matterInfo|object|事项信息
&emsp;matterAccept|object|事项受理条件
&emsp;matterIntermediary|object|事项中介服务表
&emsp;matterSetbase|object|事项设定依据表
&emsp;matterQuestion|object|事项常见问题
&emsp;matterFlowlimit|object|事项办理流程
&emsp;matterCharges|object|事项收费标准
**响应消息样例:**
```
{
"code": 1,
"data": {
"matterCharges": [
{
"content": "",
"createTime": 1680871452000,
"createUserId": 1,
"deleted": 0,
"id": 42,
"matterCode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterId": 1,
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"source": 0
}
],
"matterFlowlimit": [
{
"createTime": 1680871452000,
"createUserId": 1,
"deleted": 0,
"flowDesc": "无",
"flowLimit": "0个工作日",
"flowName": "审查",
"flowTime": "0个工作日",
"id": 22,
"matterCode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterId": 1,
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"source": 0
},
{
"createTime": 1680871452000,
"createUserId": 1,
"deleted": 0,
"flowDesc": "",
"flowLimit": "0个工作日",
"flowName": "决定",
"flowTime": "0个工作日",
"id": 23,
"matterCode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterId": 1,
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"source": 0
},
{
"createTime": 1680871452000,
"createUserId": 1,
"deleted": 0,
"flowDesc": "",
"flowLimit": "",
"flowName": "",
"flowTime": "",
"id": 24,
"matterCode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterId": 1,
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"source": 0
}
],
"matterQuestion": [],
"matterSetbase": [
{
"content": "单位或者个人有下列行为之一，由县级以上档案主管部门、有关机关对直接负责的主管人员和其他直接责任人员依法给予处分：（一）丢失属于国家所有的档案的；（二）擅自提供、抄录、复制、公布属于国家所有的档案的；（三）买卖或者非法转让属于国家所有的档案的；（四）篡改、损毁、伪造档案或者擅自销毁档案的；（五）将档案出卖、赠送给外国人或者外国组织的；（六）不按规定归档或者不按期移交档案，被责令改正而拒不改正的；（七）不按规定向社会开放、提供利用档案的；（八）明知存在档案安全隐患而不采取补救措施，造成档案损毁、灭失，或者存在档案安全隐患被责令限期整改而逾期未整改的；（九）发生档案安全事故后，不采取抢救措施或者隐瞒不报、拒绝调查的；（十）档案工作人员玩忽职守，造成档案损毁、灭失的。",
"createTime": 1680871452000,
"createUserId": 1,
"deleted": 0,
"id": 81,
"matterCode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterId": 1,
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"policyName": "中华人民共和国档案法",
"policyType": "法律",
"policyitem": "第四十八条",
"source": 0
}
],
"matterIntermediary": [],
"matterAccept": [
{
"content": "",
"createTime": 1680871452000,
"createUserId": 1,
"deleted": 0,
"id": 42,
"matterCode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterId": 1,
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"source": 0
}
],
"matterInfo": {
"appoveObjectShow": "事业法人",
"appoveTimeLimitShow": "网络办件",
"areaCode": "511500000000",
"baseCode": "511075017000",
"belongDept": "",
"certificationLevelsShow": "实名认证",
"cousultingShow": "",
"cousultingTelephoneShow": "",
"deleted": 0,
"deptCode": "4106381986208358400",
"deptName": "",
"englishName": "",
"entrustmentDepartmen": "是",
"evaluationUrl": "",
"eventTypeShow": "其他行政权力",
"goveServiceCenterShow": "否",
"groupName": "",
"handleType": "窗口办理",
"haveGetMatterInfo": "true",
"id": 1,
"implementBodyCode": "11511200731635085N",
"implementCode": "11511200731635085N3511075017000",
"isApplyProvinceShow": "否",
"isChargesShow": "否",
"isConvenientCenterShow": "否",
"isDoorTakeShow": "否",
"isExpressTakeOnlineShow": "",
"isExpressTakeShow": "否",
"isOnline": "是",
"isOnlinePayShow": "是",
"isOnlineSubscribeShow": "否",
"isProvinceAcquisitionShow": "否",
"jointInfoShow": "",
"legalEndExplain": "",
"legalTimeLimitShow": "",
"matterEdition": "2",
"matterName": "对不按规定向社会开放、提供利用档案的行为的查处",
"matterNo": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"matterStatus": "在用",
"mustSceneExplain": "",
"netApplyUrl": "",
"onlineMustSceneExplain": "",
"onlineOperatDeep": "互联网咨询",
"onlineToTheSceneNum": 0,
"onlineType": "原件预审",
"operatScopeShow": "无",
"operateItemCode": "11511200731635085N351107501700002",
"operateSite": "",
"operateTime": "",
"performDeptType": "中国共产党宜宾市委员会办公室",
"performDeptTypeShow": "法定机关",
"performHierarchyShow": "市级",
"powerCode": "",
"powerSourceShow": "法定本级行使",
"promiseEndExplain": "",
"promiseTimeLimitShow": "",
"siteId": -1,
"sort": 0,
"source": 0,
"specialProcedure": "",
"superviseShow": "",
"tcode": "511Z75017001-511500000000-000-11511200731635085N-1-00",
"terminalHandle": "是",
"themeCode": "",
"tid": "",
"tname": "对不按规定向社会开放、提供利用档案的行为的查处",
"townshipCode": "",
"townshipName": "",
"type": "",
"url": "http://www.sczwfw.gov.cn/jiq/front/transition/ysqToDetail?areaCode=511500000000&itemCode=511Z75017001-511500000000-000-11511200731635085N-1-00&taskType=10&deptCode=4106381986208358400",
"usertypeCode": "",
"villageCode": "",
"villageName": ""
}
}
}
```
### 申报事项增加申报次数
**请求URL:** matter/apply/addReport
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询站点事项列表
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
id|Long|是|申报事项ID
**请求样例:**
```
http://localhost:17217/sst/matter/apply/addReport?id=21
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## 字典附录 ## 字典附录
sst-manager/pom.xml
View file @ 9c5b55e7
...@@ -143,6 +143,18 @@ ...@@ -143,6 +143,18 @@
<artifactId>freemarker</artifactId> <artifactId>freemarker</artifactId>
<version>2.3.31</version> <version>2.3.31</version>
</dependency> </dependency>
<dependency>
<groupId>com.aspose.words</groupId>
<artifactId>aspose-words</artifactId>
<version>19.2</version>
<classifier>jdk16</classifier>
</dependency>
<dependency>
<groupId>org.apache.pdfbox</groupId>
<artifactId>pdfbox</artifactId>
<version>2.0.27</version>
</dependency>
</dependencies> </dependencies>
......
sst-manager/src/main/java/com/mortals/xhx/common/utils/HttpDownloadUtil.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.utils;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* 下载网络文件至本地
*
* @Author: haoyalei
* @CreateTime: 2021-06-04 10:10
* @Description: HttpDownload
*/
public class HttpDownloadUtil {
/**
* 从网络Url中下载文件
* @param urlStr
* @param fileName
* @param savePath
* @throws IOException
*/
public static void downLoadFromUrl(String urlStr,String fileName,String savePath) throws IOException{
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection)url.openConnection();
//设置超时间为3秒
conn.setConnectTimeout(5*1000);
//防止屏蔽程序抓取而返回403错误
// conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
// conn.setRequestProperty("lfwywxqyh_token",toekn);
//得到输入流
InputStream inputStream = conn.getInputStream();
//获取自己数组
byte[] getData = readInputStream(inputStream);
//文件保存位置
File saveDir = new File(savePath);
if(!saveDir.exists()){
saveDir.mkdir();
}
File file = new File(saveDir+File.separator+fileName);
FileOutputStream fos = new FileOutputStream(file);
fos.write(getData);
if(fos!=null){
fos.close();
}
if(inputStream!=null){
inputStream.close();
}
//System.out.println("info:"+url+" download success");
}
/**
* 从输入流中获取字节数组
* @param inputStream
* @return
* @throws IOException
*/
public static byte[] readInputStream(InputStream inputStream) throws IOException {
byte[] buffer = new byte[1024];
int len = 0;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while((len = inputStream.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
bos.close();
return bos.toByteArray();
}
public static void main(String[] args) throws IOException {
String url="http://www.sczwfw.gov.cn//materialibraryui/meterialibraryCatFile/openDownload/4226078996281143296/0";
HttpDownloadUtil.downLoadFromUrl(url,"中国税收居民证明材料.docx","D:\\mortals\\app\\data\\file\\fileupload");
System.out.println("下载完成");
}
}
sst-manager/src/main/java/com/mortals/xhx/common/utils/WordUtil.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.common.utils;
/**
* @author: zxfei
* @date: 2021/10/14 15:44
* @description:
**/
import com.aspose.words.Document;
import com.aspose.words.ImageSaveOptions;
import com.aspose.words.SaveFormat;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.util.DateUtils;
import freemarker.template.Configuration;
import freemarker.template.Template;
import lombok.extern.slf4j.Slf4j;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;
import javax.imageio.ImageIO;
import javax.imageio.stream.ImageInputStream;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Slf4j
public class WordUtil {
private Configuration configure = null;
public Configuration getConfigure() {
return configure;
}
public void setConfigure(Configuration configure) {
this.configure = configure;
}
public WordUtil() {
configure = new Configuration();
configure.setDefaultEncoding("utf-8");
}
/**
* 根据word模板生成word文件
*
* @param dataMap ： 数据
* @param outFilePath ： 输出word文件地址
* @return
*/
public boolean createWord(Map<String, Object> dataMap, String inputFilePath, String outFilePath) {
boolean flag = false;
try {
// 指定路径方式（根据某个类的相对路径指定）
configure.setClassForTemplateLoading(this.getClass(), "/test");
// 以utf-8的编码读取ftl文件
Template template = configure.getTemplate(inputFilePath, "utf-8");
Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outFilePath)), "utf-8"),
10240);
template.process(dataMap, out);
out.close();
flag = true;
} catch (Exception e) {
e.printStackTrace();
}
return flag;
}
public static String convertWordToJPEG(String inputFile, String jpegPath) {
try {
log.info("word to jpg文件转换开始,inputFile:{},jepgPath:{}：{}", inputFile, jpegPath, DateUtils.getCurrStrDateTime());
// 转换开始前时间
long old = System.currentTimeMillis();
// 新建的PDF文件路径
File file = new File(jpegPath);
//FileOutputStream os = new FileOutputStream(file);
// 要转换的word文档的路径
Document doc = new Document(inputFile);
// 全面支持DOC, DOCX, OOXML, RTF HTML, OpenDocument, PDF, EPUB, XPS, SWF 相互转换
//doc.save(os, SaveFormat.JPEG);
ImageSaveOptions options = new ImageSaveOptions(SaveFormat.JPEG);
options.setPrettyFormat(true);
options.setUseAntiAliasing(true);
options.setUseHighQualityRendering(true);
int pageCount = doc.getPageCount();
List<BufferedImage> imageList = new ArrayList<BufferedImage>();
for (int i = 0; i < pageCount; i++) {
OutputStream output = new ByteArrayOutputStream();
options.setPageIndex(i);
doc.save(output, options);
ImageInputStream imageInputStream = ImageIO.createImageInputStream(parse(output));
imageList.add(ImageIO.read(imageInputStream));
}
BufferedImage mergeImage = mergeImage(false, imageList);
ImageIO.write(mergeImage, "jpg", file);
// 转换结束后时间
/* doc.save(jpegPath);*/
doc.cleanup();
long now = System.currentTimeMillis();
log.info("文件转换结束,共耗时：" + ((now - old) / 1000.0) + "秒");
return jpegPath;
} catch (Exception e) {
log.error("文件转换异常!", e);
throw new AppException(String.format("文件转换异常! %s", e.getMessage()));
}
}
public static Integer getPageByDoc(String inputFile) {
try {
//FileOutputStream os = new FileOutputStream(file);
// 要转换的word文档的路径
Document doc = new Document(inputFile);
return doc.getPageCount();
} catch (Exception e) {
log.error("获取doc异常!", e);
return 0;
}
}
public static void pdfToImages(String filePath, String jpegPath) {
log.info(String.format("pdf to images文件转换开始：%s", DateUtils.getCurrStrDateTime()));
// 转换开始前时间
long old = System.currentTimeMillis();
File file = new File(jpegPath);
List<BufferedImage> imageInfoList = new ArrayList<>();
try (PDDocument doc = PDDocument.load(new File(filePath))) {
PDFRenderer renderer = new PDFRenderer(doc);
int pageCount = doc.getNumberOfPages();
for (int i = 0; i < pageCount; i++) {
BufferedImage image = renderer.renderImage(i);
imageInfoList.add(image);
}
BufferedImage mergeImage = mergeImage(false, imageInfoList);
ImageIO.write(mergeImage, "png", file);
// 转换结束后时间
long now = System.currentTimeMillis();
//os.close();
log.info("文件转换结束,共耗时：" + ((now - old) / 1000.0) + "秒");
} catch (IOException e) {
log.error("生成预览图片异常:", e);
throw new AppException("生成预览图片异常");
}
}
/**
* 合并任数量的图片成一张图片
*
* @param isHorizontal true代表水平合并，fasle代表垂直合并
* @param imgs 待合并的图片数组
* @return
* @throws IOException
*/
public static BufferedImage mergeImage(boolean isHorizontal, List<BufferedImage> imgs) throws IOException {
// 生成新图片
BufferedImage destImage = null;
// 计算新图片的长和高
int allw = 0, allh = 0, allwMax = 0, allhMax = 0;
// 获取总长、总宽、最长、最宽
for (int i = 0; i < imgs.size(); i++) {
BufferedImage img = imgs.get(i);
allw += img.getWidth();
if (imgs.size() != i + 1) {
allh += img.getHeight() + 5;
} else {
allh += img.getHeight();
}
if (img.getWidth() > allwMax) {
allwMax = img.getWidth();
}
if (img.getHeight() > allhMax) {
allhMax = img.getHeight();
}
}
// 创建新图片
if (isHorizontal) {
destImage = new BufferedImage(allw, allhMax, BufferedImage.TYPE_INT_RGB);
} else {
destImage = new BufferedImage(allwMax, allh, BufferedImage.TYPE_INT_RGB);
}
Graphics2D g2 = (Graphics2D) destImage.getGraphics();
g2.setBackground(Color.LIGHT_GRAY);
g2.clearRect(0, 0, allw, allh);
g2.setPaint(Color.RED);
// 合并所有子图片到新图片
int wx = 0, wy = 0;
for (int i = 0; i < imgs.size(); i++) {
BufferedImage img = imgs.get(i);
int w1 = img.getWidth();
int h1 = img.getHeight();
// 从图片中读取RGB
int[] ImageArrayOne = new int[w1 * h1];
// 逐行扫描图像中各个像素的RGB到数组中
ImageArrayOne = img.getRGB(0, 0, w1, h1, ImageArrayOne, 0, w1);
if (isHorizontal) {
// 水平方向合并
// 设置上半部分或左半部分的RGB
destImage.setRGB(wx, 0, w1, h1, ImageArrayOne, 0, w1);
} else {
// 垂直方向合并
// 设置上半部分或左半部分的RGB
destImage.setRGB(0, wy, w1, h1, ImageArrayOne, 0, w1);
}
wx += w1;
wy += h1 + 5;
}
return destImage;
}
public static ByteArrayInputStream parse(OutputStream out) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos = (ByteArrayOutputStream) out;
ByteArrayInputStream swapStream = new ByteArrayInputStream(baos.toByteArray());
return swapStream;
}
public static void main(String[] args) {
String docPath = "E:\\pic\\doc\\2.docx";
String jpgPath = "E:\\pic\\doc\\2.jpg";
WordUtil.convertWordToJPEG(docPath, jpgPath);
/*
String pdfPath = "E:\\pic\\pdf\\1.pdf";
String jpgPath = "E:\\pic\\jpg\\1.jpg";
WordUtil.pdfToImages(pdfPath, jpgPath);
*/
}
}
sst-manager/src/main/java/com/mortals/xhx/daemon/task/MatterDatumConvertTaskImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.daemon.task;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.RandomUtil;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.service.ITask;
import com.mortals.framework.service.ITaskExcuteService;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterDatumFilePdu;
import com.mortals.xhx.common.pdu.matter.MatterDatumPdu;
import com.mortals.xhx.common.utils.BeanUtil;
import com.mortals.xhx.common.utils.HttpDownloadUtil;
import com.mortals.xhx.common.utils.StringUtils;
import com.mortals.xhx.common.utils.WordUtil;
import com.mortals.xhx.feign.matter.IMatterDatumFeign;
import com.mortals.xhx.feign.matter.IMatterDatumFileFeign;
import com.mortals.xhx.module.matter.model.*;
import com.mortals.xhx.module.matter.service.MatterApplyService;
import com.mortals.xhx.module.matter.service.MatterDatumFileService;
import com.mortals.xhx.module.matter.service.MatterDatumService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
/**
* 事项材料附件本地转换
*/
@Slf4j
@Service("MatterDatumConvertTask")
public class MatterDatumConvertTaskImpl implements ITaskExcuteService {
@Autowired
private MatterApplyService matterApplyService;
@Autowired
private MatterDatumService matterDatumService;
@Autowired
private MatterDatumFileService matterDatumFileService;
@Autowired
private IMatterDatumFeign matterDatumFeign;
@Autowired
private IMatterDatumFileFeign matterDatumFileFeign;
@Value("${upload.path}")
private String filePath;
public static String word[] = {"doc", "dot", "wps", "wpt", "docx", "dotx", "docm", "dotm"};
public static String imgs[] = {"jpg", "png", "jpeg", "gif"};
public static String pdf[] = {"pdf"};
@Override
public void excuteTask(ITask task) throws AppException {
log.info("事项材料处理...");
MatterApplyQuery siteMatterQuery = new MatterApplyQuery();
siteMatterQuery.setIsConvert(0);
List<MatterApplyEntity> siteMatterEntities = matterApplyService.find(siteMatterQuery);
if(CollectionUtils.isNotEmpty(siteMatterEntities)){
List<Long> matterIds = new ArrayList<>();
for(MatterApplyEntity siteMatterEntity:siteMatterEntities){
matterIds.add(siteMatterEntity.getMatterId());
}
MatterDatumPdu matterDatumQuery = new MatterDatumPdu();
matterDatumQuery.setMatterIdList(matterIds);
matterDatumQuery.setSize(-1);
List<MatterDatumPdu> matterDatumPduList = null;
List<MatterDatumEntity> matterDatumList = new ArrayList<>();
Rest<RespData<List<MatterDatumPdu>>> matterDatumPduRest = matterDatumFeign.list(matterDatumQuery);
if(matterDatumPduRest.getCode()==1 && matterDatumPduRest.getData()!=null){
matterDatumPduList = matterDatumPduRest.getData().getData();
}
List<Long> convertIdList = new ArrayList<>();
if(CollectionUtils.isNotEmpty(matterDatumPduList)){
for(MatterDatumPdu datumPdu:matterDatumPduList){
MatterDatumEntity matterDatumEntity = BeanUtil.covert(datumPdu,MatterDatumEntity.class);
MatterDatumFilePdu fileQuery = new MatterDatumFilePdu();
fileQuery.setDatumId(datumPdu.getId());
fileQuery.setSize(-1);
List<MatterDatumFilePdu> datumFilePduList = null;
List<MatterDatumFileEntity> datumFileList = new ArrayList<>();
Rest<RespData<List<MatterDatumFilePdu>>> datumFileRest = matterDatumFileFeign.list(fileQuery);
if(datumFileRest.getCode()==1 && datumFileRest.getData()!=null){
datumFilePduList = datumFileRest.getData().getData();
convertIdList.add(datumPdu.getMatterId());
}
if(CollectionUtils.isNotEmpty(datumFilePduList)){
String rootPath = this.filePath.endsWith("/") ? this.filePath : this.filePath + "/";
String prePath = "file/preview/";
String savePath = "file/uploadfile/";
for(MatterDatumFilePdu datumFilePdu:datumFilePduList){
if(StringUtils.isEmpty(datumFilePdu.getFileUrl())|| StringUtils.isNotEmpty(datumFilePdu.getLocalFileUrl())){
continue;
}
String fileName = datumFilePdu.getFileName();
String fileUrl = datumFilePdu.getFileUrl();
try {
File pathDir = new File(rootPath + savePath);
if (!pathDir.exists()) {
pathDir.mkdirs();
}
HttpDownloadUtil.downLoadFromUrl(fileUrl,fileName,rootPath + savePath);
}catch (Exception e){
log.error("DatumId:"+datumFilePdu.getDatumId()+",文件下载失败...",e);
continue;
}
MatterDatumFileEntity matterDatumFile = BeanUtil.covert(datumFilePdu,MatterDatumFileEntity.class);
matterDatumFile.setLocalFileUrl(savePath+fileName);
String newName = genPreviewPath(rootPath, prePath, savePath+fileName);
matterDatumFile.setPreviewUrl(prePath+newName);
datumFileList.add(matterDatumFile);
}
}
matterDatumEntity.setMatterDatumFileList(datumFileList);
matterDatumList.add(matterDatumEntity);
}
}
if(convertIdList.size()>0){
MatterApplyQuery matterQuery = new MatterApplyQuery();
matterQuery.setMatterIdList(convertIdList);
List<MatterApplyEntity> matterEntities = matterApplyService.find(matterQuery);
for(MatterApplyEntity matterEntity:matterEntities){
MatterApplyEntity updateEntity = new MatterApplyEntity();
updateEntity.setId(matterEntity.getId());
updateEntity.setIsConvert(1);
matterApplyService.update(updateEntity);
}
if(CollectionUtils.isNotEmpty(matterDatumList)) {
for (MatterDatumEntity matterDatumEntity : matterDatumList) {
matterDatumService.save(matterDatumEntity);
}
}
}
}
}
@Override
public void stopTask(ITask task) throws AppException {
}
private String genPreviewPath(String rootPath, String prePath, String tempPath) {
//生成样表预览图片
String samplePath = rootPath + tempPath;
String filePath = rootPath + prePath;
File pathDir = new File(filePath);
if (!pathDir.exists()) {
pathDir.mkdirs();
}
String newName = RandomUtil.randomNumbers(12) + ".jpg";
String filePathAll = filePath + newName;
//判断文件类型是否为doc pdf jpg png 等
String extName = FileUtil.getSuffix(samplePath);
if (this.isExsitArry(extName, word)) {
WordUtil.convertWordToJPEG(samplePath, filePathAll);
} else if (this.isExsitArry(extName, pdf)) {
WordUtil.pdfToImages(samplePath, filePathAll);
} else if (this.isExsitArry(extName, imgs)) {
try {
com.mortals.framework.util.FileUtil.copyFile(samplePath, filePathAll);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
return newName;
}
public boolean isExsitArry(String chex, String arry[]) {
for (String ex : arry) {
if (chex.equalsIgnoreCase(ex)) {
return true;
}
}
return false;
}
}
sst-manager/src/main/java/com/mortals/xhx/module/dept/web/DeptController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.dept.web;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseJsonBodyController;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.dept.DeptPdu;
import com.mortals.xhx.feign.dept.IDeptFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("dept")
public class DeptController extends BaseJsonBodyController {
@Autowired
private IDeptFeign deptFeign;
@PostMapping({"list"})
@UnAuth
public Rest<Object> list(@RequestBody DeptPdu query) {
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "查询部门列表";
int code;
try {
Rest<RespData<List<DeptPdu>>> result = deptFeign.list(query);
code = result.getCode();
if(code > 0) {
model.put("data", result.getData().getData());
model.put("pageInfo", result.getData().getPageInfo());
model.put("dict", result.getData().getDict());
}
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/DatumLibraryDao.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
import java.util.List;
/**
* 站点材料公共库Dao
* 站点材料公共库 DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface DatumLibraryDao extends ICRUDDao<DatumLibraryEntity,Long>{
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/MatterApplyDao.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
import java.util.List;
/**
* 申报事项Dao
* 申报事项 DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface MatterApplyDao extends ICRUDDao<MatterApplyEntity,Long>{
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/MatterDatumDao.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.matter.model.MatterDatumEntity;
import java.util.List;
/**
* 事项申请材料业务Dao
* 事项申请材料业务 DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface MatterDatumDao extends ICRUDDao<MatterDatumEntity,Long>{
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/MatterDatumFileDao.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import java.util.List;
/**
* 材料附件业务Dao
* 材料附件业务 DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface MatterDatumFileDao extends ICRUDDao<MatterDatumFileEntity,Long>{
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/ibatis/DatumLibraryDaoImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.matter.dao.DatumLibraryDao;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 站点材料公共库DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
@Repository("datumLibraryDao")
public class DatumLibraryDaoImpl extends BaseCRUDDaoMybatis<DatumLibraryEntity,Long> implements DatumLibraryDao {
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/ibatis/MatterApplyDaoImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.matter.dao.MatterApplyDao;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 申报事项DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
@Repository("matterApplyDao")
public class MatterApplyDaoImpl extends BaseCRUDDaoMybatis<MatterApplyEntity,Long> implements MatterApplyDao {
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/ibatis/MatterDatumDaoImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.matter.dao.MatterDatumDao;
import com.mortals.xhx.module.matter.model.MatterDatumEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 事项申请材料业务DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
@Repository("matterDatumDao")
public class MatterDatumDaoImpl extends BaseCRUDDaoMybatis<MatterDatumEntity,Long> implements MatterDatumDao {
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/dao/ibatis/MatterDatumFileDaoImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.matter.dao.MatterDatumFileDao;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 材料附件业务DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-07
*/
@Repository("matterDatumFileDao")
public class MatterDatumFileDaoImpl extends BaseCRUDDaoMybatis<MatterDatumFileEntity,Long> implements MatterDatumFileDao {
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/DatumLibraryEntity.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.vo.DatumLibraryVo;
/**
* 站点材料公共库实体对象
*
* @author zxfei
* @date 2023-04-07
*/
public class DatumLibraryEntity extends DatumLibraryVo {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 站点名称
*/
private String siteName;
/**
* 材料id
*/
private Long datumId;
/**
* 事项基础表matter id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 事项名称
*/
private String matterName;
/**
* 材料名
*/
private String materialName;
/**
* 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
*/
private String isMust;
/**
* 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
*/
private String materialType;
/**
* 材料形式（1.纸质，2.电子，3.纸质|电子）
*/
private String materialProperty;
/**
* 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
*/
private String electronicgs;
/**
* 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
*/
private String materialSource;
/**
* 纸质材料份数
*/
private Integer paperNum;
/**
* 纸质材料规格
*/
private String paperGg;
/**
* 减免模式（1.无，2.减，3.免）
*/
private String jianmMs;
/**
* 盖章方式
*/
private String sealWay;
/**
* 是否减免（0.否，1.是）
*/
private String isjianm;
/**
* 材料是否容缺（1.必要，2.非必要）
*/
private String isLack;
/**
* 材料地址
*/
private String ybUrl;
/**
* 来源渠道说明
*/
private String materialSourceSm;
/**
* 填报须知
*/
private String remarkSub;
/**
* 要求提供材料的依据
*/
private String clauseContent;
/**
* 受理标准
*/
private String summary;
/**
* 备注
*/
private String remark;
/**
* 事项来源(0.政务网，1.自定义)
*/
private Integer source;
public DatumLibraryEntity(){}
/**
* 获取 站点id
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点id
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 站点名称
* @return String
*/
public String getSiteName(){
return siteName;
}
/**
* 设置 站点名称
* @param siteName
*/
public void setSiteName(String siteName){
this.siteName = siteName;
}
/**
* 获取 材料id
* @return Long
*/
public Long getDatumId(){
return datumId;
}
/**
* 设置 材料id
* @param datumId
*/
public void setDatumId(Long datumId){
this.datumId = datumId;
}
/**
* 获取 事项基础表matter id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 材料名
* @return String
*/
public String getMaterialName(){
return materialName;
}
/**
* 设置 材料名
* @param materialName
*/
public void setMaterialName(String materialName){
this.materialName = materialName;
}
/**
* 获取 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @return String
*/
public String getIsMust(){
return isMust;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMust
*/
public void setIsMust(String isMust){
this.isMust = isMust;
}
/**
* 获取 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @return String
*/
public String getMaterialType(){
return materialType;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialType
*/
public void setMaterialType(String materialType){
this.materialType = materialType;
}
/**
* 获取 材料形式（1.纸质，2.电子，3.纸质|电子）
* @return String
*/
public String getMaterialProperty(){
return materialProperty;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialProperty
*/
public void setMaterialProperty(String materialProperty){
this.materialProperty = materialProperty;
}
/**
* 获取 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @return String
*/
public String getElectronicgs(){
return electronicgs;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgs
*/
public void setElectronicgs(String electronicgs){
this.electronicgs = electronicgs;
}
/**
* 获取 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @return String
*/
public String getMaterialSource(){
return materialSource;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSource
*/
public void setMaterialSource(String materialSource){
this.materialSource = materialSource;
}
/**
* 获取 纸质材料份数
* @return Integer
*/
public Integer getPaperNum(){
return paperNum;
}
/**
* 设置 纸质材料份数
* @param paperNum
*/
public void setPaperNum(Integer paperNum){
this.paperNum = paperNum;
}
/**
* 获取 纸质材料规格
* @return String
*/
public String getPaperGg(){
return paperGg;
}
/**
* 设置 纸质材料规格
* @param paperGg
*/
public void setPaperGg(String paperGg){
this.paperGg = paperGg;
}
/**
* 获取 减免模式（1.无，2.减，3.免）
* @return String
*/
public String getJianmMs(){
return jianmMs;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMs
*/
public void setJianmMs(String jianmMs){
this.jianmMs = jianmMs;
}
/**
* 获取 盖章方式
* @return String
*/
public String getSealWay(){
return sealWay;
}
/**
* 设置 盖章方式
* @param sealWay
*/
public void setSealWay(String sealWay){
this.sealWay = sealWay;
}
/**
* 获取 是否减免（0.否，1.是）
* @return String
*/
public String getIsjianm(){
return isjianm;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianm
*/
public void setIsjianm(String isjianm){
this.isjianm = isjianm;
}
/**
* 获取 材料是否容缺（1.必要，2.非必要）
* @return String
*/
public String getIsLack(){
return isLack;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLack
*/
public void setIsLack(String isLack){
this.isLack = isLack;
}
/**
* 获取 材料地址
* @return String
*/
public String getYbUrl(){
return ybUrl;
}
/**
* 设置 材料地址
* @param ybUrl
*/
public void setYbUrl(String ybUrl){
this.ybUrl = ybUrl;
}
/**
* 获取 来源渠道说明
* @return String
*/
public String getMaterialSourceSm(){
return materialSourceSm;
}
/**
* 设置 来源渠道说明
* @param materialSourceSm
*/
public void setMaterialSourceSm(String materialSourceSm){
this.materialSourceSm = materialSourceSm;
}
/**
* 获取 填报须知
* @return String
*/
public String getRemarkSub(){
return remarkSub;
}
/**
* 设置 填报须知
* @param remarkSub
*/
public void setRemarkSub(String remarkSub){
this.remarkSub = remarkSub;
}
/**
* 获取 要求提供材料的依据
* @return String
*/
public String getClauseContent(){
return clauseContent;
}
/**
* 设置 要求提供材料的依据
* @param clauseContent
*/
public void setClauseContent(String clauseContent){
this.clauseContent = clauseContent;
}
/**
* 获取 受理标准
* @return String
*/
public String getSummary(){
return summary;
}
/**
* 设置 受理标准
* @param summary
*/
public void setSummary(String summary){
this.summary = summary;
}
/**
* 获取 备注
* @return String
*/
public String getRemark(){
return remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark){
this.remark = remark;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof DatumLibraryEntity) {
DatumLibraryEntity tmp = (DatumLibraryEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",siteName:").append(getSiteName());
sb.append(",datumId:").append(getDatumId());
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",matterName:").append(getMatterName());
sb.append(",materialName:").append(getMaterialName());
sb.append(",isMust:").append(getIsMust());
sb.append(",materialType:").append(getMaterialType());
sb.append(",materialProperty:").append(getMaterialProperty());
sb.append(",electronicgs:").append(getElectronicgs());
sb.append(",materialSource:").append(getMaterialSource());
sb.append(",paperNum:").append(getPaperNum());
sb.append(",paperGg:").append(getPaperGg());
sb.append(",jianmMs:").append(getJianmMs());
sb.append(",sealWay:").append(getSealWay());
sb.append(",isjianm:").append(getIsjianm());
sb.append(",isLack:").append(getIsLack());
sb.append(",ybUrl:").append(getYbUrl());
sb.append(",materialSourceSm:").append(getMaterialSourceSm());
sb.append(",remarkSub:").append(getRemarkSub());
sb.append(",clauseContent:").append(getClauseContent());
sb.append(",summary:").append(getSummary());
sb.append(",remark:").append(getRemark());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.siteId = null;
this.siteName = "";
this.datumId = null;
this.matterId = null;
this.matterCode = "";
this.matterName = "";
this.materialName = "";
this.isMust = "1";
this.materialType = "1";
this.materialProperty = "1";
this.electronicgs = "1";
this.materialSource = "1";
this.paperNum = 1;
this.paperGg = "";
this.jianmMs = "1";
this.sealWay = "";
this.isjianm = "1";
this.isLack = "1";
this.ybUrl = "";
this.materialSourceSm = "";
this.remarkSub = "";
this.clauseContent = "";
this.summary = "";
this.remark = "";
this.source = 0;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/DatumLibraryQuery.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
/**
* 站点材料公共库查询对象
*
* @author zxfei
* @date 2023-04-07
*/
public class DatumLibraryQuery extends DatumLibraryEntity {
/** 开始 主键，自增长 */
private Long idStart;
/** 结束 主键，自增长 */
private Long idEnd;
/** 增加 主键，自增长 */
private Long idIncrement;
/** 主键，自增长列表 */
private List <Long> idList;
/** 主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 站点id */
private Long siteIdStart;
/** 结束 站点id */
private Long siteIdEnd;
/** 增加 站点id */
private Long siteIdIncrement;
/** 站点id列表 */
private List <Long> siteIdList;
/** 站点id排除列表 */
private List <Long> siteIdNotList;
/** 站点名称 */
private List<String> siteNameList;
/** 站点名称排除列表 */
private List <String> siteNameNotList;
/** 开始 材料id */
private Long datumIdStart;
/** 结束 材料id */
private Long datumIdEnd;
/** 增加 材料id */
private Long datumIdIncrement;
/** 材料id列表 */
private List <Long> datumIdList;
/** 材料id排除列表 */
private List <Long> datumIdNotList;
/** 开始 事项基础表matter id */
private Long matterIdStart;
/** 结束 事项基础表matter id */
private Long matterIdEnd;
/** 增加 事项基础表matter id */
private Long matterIdIncrement;
/** 事项基础表matter id列表 */
private List <Long> matterIdList;
/** 事项基础表matter id排除列表 */
private List <Long> matterIdNotList;
/** 事项编码 */
private List<String> matterCodeList;
/** 事项编码排除列表 */
private List <String> matterCodeNotList;
/** 事项名称 */
private List<String> matterNameList;
/** 事项名称排除列表 */
private List <String> matterNameNotList;
/** 材料名 */
private List<String> materialNameList;
/** 材料名排除列表 */
private List <String> materialNameNotList;
/** 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补） */
private List<String> isMustList;
/** 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）排除列表 */
private List <String> isMustNotList;
/** 材料类型（1.无，2.原件，3.复印件，4.原件和复印件) */
private List<String> materialTypeList;
/** 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)排除列表 */
private List <String> materialTypeNotList;
/** 材料形式（1.纸质，2.电子，3.纸质|电子） */
private List<String> materialPropertyList;
/** 材料形式（1.纸质，2.电子，3.纸质|电子）排除列表 */
private List <String> materialPropertyNotList;
/** 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg） */
private List<String> electronicgsList;
/** 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）排除列表 */
private List <String> electronicgsNotList;
/** 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他） */
private List<String> materialSourceList;
/** 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）排除列表 */
private List <String> materialSourceNotList;
/** 开始 纸质材料份数 */
private Integer paperNumStart;
/** 结束 纸质材料份数 */
private Integer paperNumEnd;
/** 增加 纸质材料份数 */
private Integer paperNumIncrement;
/** 纸质材料份数列表 */
private List <Integer> paperNumList;
/** 纸质材料份数排除列表 */
private List <Integer> paperNumNotList;
/** 纸质材料规格 */
private List<String> paperGgList;
/** 纸质材料规格排除列表 */
private List <String> paperGgNotList;
/** 减免模式（1.无，2.减，3.免） */
private List<String> jianmMsList;
/** 减免模式（1.无，2.减，3.免）排除列表 */
private List <String> jianmMsNotList;
/** 盖章方式 */
private List<String> sealWayList;
/** 盖章方式排除列表 */
private List <String> sealWayNotList;
/** 是否减免（0.否，1.是） */
private List<String> isjianmList;
/** 是否减免（0.否，1.是）排除列表 */
private List <String> isjianmNotList;
/** 材料是否容缺（1.必要，2.非必要） */
private List<String> isLackList;
/** 材料是否容缺（1.必要，2.非必要）排除列表 */
private List <String> isLackNotList;
/** 材料地址 */
private List<String> ybUrlList;
/** 材料地址排除列表 */
private List <String> ybUrlNotList;
/** 来源渠道说明 */
private List<String> materialSourceSmList;
/** 来源渠道说明排除列表 */
private List <String> materialSourceSmNotList;
/** 填报须知 */
private List<String> remarkSubList;
/** 填报须知排除列表 */
private List <String> remarkSubNotList;
/** 要求提供材料的依据 */
private List<String> clauseContentList;
/** 要求提供材料的依据排除列表 */
private List <String> clauseContentNotList;
/** 受理标准 */
private List<String> summaryList;
/** 受理标准排除列表 */
private List <String> summaryNotList;
/** 备注 */
private List<String> remarkList;
/** 备注排除列表 */
private List <String> remarkNotList;
/** 开始 事项来源(0.政务网，1.自定义) */
private Integer sourceStart;
/** 结束 事项来源(0.政务网，1.自定义) */
private Integer sourceEnd;
/** 增加 事项来源(0.政务网，1.自定义) */
private Integer sourceIncrement;
/** 事项来源(0.政务网，1.自定义)列表 */
private List <Integer> sourceList;
/** 事项来源(0.政务网，1.自定义)排除列表 */
private List <Integer> sourceNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 修改时间 */
private String updateTimeStart;
/** 结束 修改时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<DatumLibraryQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<DatumLibraryQuery> andConditionList;
public DatumLibraryQuery(){}
/**
* 获取 开始 主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
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
*/
public Long getSiteIdStart(){
return this.siteIdStart;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public void setSiteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
}
/**
* 获取 结束 站点id
* @return $siteIdEnd
*/
public Long getSiteIdEnd(){
return this.siteIdEnd;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public void setSiteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
}
/**
* 获取 增加 站点id
* @return siteIdIncrement
*/
public Long getSiteIdIncrement(){
return this.siteIdIncrement;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public void setSiteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
}
/**
* 获取 站点id
* @return siteIdList
*/
public List<Long> getSiteIdList(){
return this.siteIdList;
}
/**
* 设置 站点id
* @param siteIdList
*/
public void setSiteIdList(List<Long> siteIdList){
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;
}
/**
* 获取 站点名称
* @return siteNameList
*/
public List<String> getSiteNameList(){
return this.siteNameList;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public void setSiteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
}
/**
* 获取 站点名称
* @return siteNameNotList
*/
public List<String> getSiteNameNotList(){
return this.siteNameNotList;
}
/**
* 设置 站点名称
* @param siteNameNotList
*/
public void setSiteNameNotList(List<String> siteNameNotList){
this.siteNameNotList = siteNameNotList;
}
/**
* 获取 开始 材料id
* @return datumIdStart
*/
public Long getDatumIdStart(){
return this.datumIdStart;
}
/**
* 设置 开始 材料id
* @param datumIdStart
*/
public void setDatumIdStart(Long datumIdStart){
this.datumIdStart = datumIdStart;
}
/**
* 获取 结束 材料id
* @return $datumIdEnd
*/
public Long getDatumIdEnd(){
return this.datumIdEnd;
}
/**
* 设置 结束 材料id
* @param datumIdEnd
*/
public void setDatumIdEnd(Long datumIdEnd){
this.datumIdEnd = datumIdEnd;
}
/**
* 获取 增加 材料id
* @return datumIdIncrement
*/
public Long getDatumIdIncrement(){
return this.datumIdIncrement;
}
/**
* 设置 增加 材料id
* @param datumIdIncrement
*/
public void setDatumIdIncrement(Long datumIdIncrement){
this.datumIdIncrement = datumIdIncrement;
}
/**
* 获取 材料id
* @return datumIdList
*/
public List<Long> getDatumIdList(){
return this.datumIdList;
}
/**
* 设置 材料id
* @param datumIdList
*/
public void setDatumIdList(List<Long> datumIdList){
this.datumIdList = datumIdList;
}
/**
* 获取 材料id
* @return datumIdNotList
*/
public List<Long> getDatumIdNotList(){
return this.datumIdNotList;
}
/**
* 设置 材料id
* @param datumIdNotList
*/
public void setDatumIdNotList(List<Long> datumIdNotList){
this.datumIdNotList = datumIdNotList;
}
/**
* 获取 开始 事项基础表matter id
* @return matterIdStart
*/
public Long getMatterIdStart(){
return this.matterIdStart;
}
/**
* 设置 开始 事项基础表matter id
* @param matterIdStart
*/
public void setMatterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
}
/**
* 获取 结束 事项基础表matter id
* @return $matterIdEnd
*/
public Long getMatterIdEnd(){
return this.matterIdEnd;
}
/**
* 设置 结束 事项基础表matter id
* @param matterIdEnd
*/
public void setMatterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
}
/**
* 获取 增加 事项基础表matter id
* @return matterIdIncrement
*/
public Long getMatterIdIncrement(){
return this.matterIdIncrement;
}
/**
* 设置 增加 事项基础表matter id
* @param matterIdIncrement
*/
public void setMatterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
}
/**
* 获取 事项基础表matter id
* @return matterIdList
*/
public List<Long> getMatterIdList(){
return this.matterIdList;
}
/**
* 设置 事项基础表matter id
* @param matterIdList
*/
public void setMatterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
}
/**
* 获取 事项基础表matter id
* @return matterIdNotList
*/
public List<Long> getMatterIdNotList(){
return this.matterIdNotList;
}
/**
* 设置 事项基础表matter id
* @param matterIdNotList
*/
public void setMatterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
}
/**
* 获取 事项编码
* @return matterCodeList
*/
public List<String> getMatterCodeList(){
return this.matterCodeList;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public void setMatterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
}
/**
* 获取 事项编码
* @return matterCodeNotList
*/
public List<String> getMatterCodeNotList(){
return this.matterCodeNotList;
}
/**
* 设置 事项编码
* @param matterCodeNotList
*/
public void setMatterCodeNotList(List<String> matterCodeNotList){
this.matterCodeNotList = matterCodeNotList;
}
/**
* 获取 事项名称
* @return matterNameList
*/
public List<String> getMatterNameList(){
return this.matterNameList;
}
/**
* 设置 事项名称
* @param matterNameList
*/
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 materialNameList
*/
public List<String> getMaterialNameList(){
return this.materialNameList;
}
/**
* 设置 材料名
* @param materialNameList
*/
public void setMaterialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
}
/**
* 获取 材料名
* @return materialNameNotList
*/
public List<String> getMaterialNameNotList(){
return this.materialNameNotList;
}
/**
* 设置 材料名
* @param materialNameNotList
*/
public void setMaterialNameNotList(List<String> materialNameNotList){
this.materialNameNotList = materialNameNotList;
}
/**
* 获取 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @return isMustList
*/
public List<String> getIsMustList(){
return this.isMustList;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMustList
*/
public void setIsMustList(List<String> isMustList){
this.isMustList = isMustList;
}
/**
* 获取 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @return isMustNotList
*/
public List<String> getIsMustNotList(){
return this.isMustNotList;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMustNotList
*/
public void setIsMustNotList(List<String> isMustNotList){
this.isMustNotList = isMustNotList;
}
/**
* 获取 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @return materialTypeList
*/
public List<String> getMaterialTypeList(){
return this.materialTypeList;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialTypeList
*/
public void setMaterialTypeList(List<String> materialTypeList){
this.materialTypeList = materialTypeList;
}
/**
* 获取 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @return materialTypeNotList
*/
public List<String> getMaterialTypeNotList(){
return this.materialTypeNotList;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialTypeNotList
*/
public void setMaterialTypeNotList(List<String> materialTypeNotList){
this.materialTypeNotList = materialTypeNotList;
}
/**
* 获取 材料形式（1.纸质，2.电子，3.纸质|电子）
* @return materialPropertyList
*/
public List<String> getMaterialPropertyList(){
return this.materialPropertyList;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialPropertyList
*/
public void setMaterialPropertyList(List<String> materialPropertyList){
this.materialPropertyList = materialPropertyList;
}
/**
* 获取 材料形式（1.纸质，2.电子，3.纸质|电子）
* @return materialPropertyNotList
*/
public List<String> getMaterialPropertyNotList(){
return this.materialPropertyNotList;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialPropertyNotList
*/
public void setMaterialPropertyNotList(List<String> materialPropertyNotList){
this.materialPropertyNotList = materialPropertyNotList;
}
/**
* 获取 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @return electronicgsList
*/
public List<String> getElectronicgsList(){
return this.electronicgsList;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgsList
*/
public void setElectronicgsList(List<String> electronicgsList){
this.electronicgsList = electronicgsList;
}
/**
* 获取 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @return electronicgsNotList
*/
public List<String> getElectronicgsNotList(){
return this.electronicgsNotList;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgsNotList
*/
public void setElectronicgsNotList(List<String> electronicgsNotList){
this.electronicgsNotList = electronicgsNotList;
}
/**
* 获取 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @return materialSourceList
*/
public List<String> getMaterialSourceList(){
return this.materialSourceList;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSourceList
*/
public void setMaterialSourceList(List<String> materialSourceList){
this.materialSourceList = materialSourceList;
}
/**
* 获取 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @return materialSourceNotList
*/
public List<String> getMaterialSourceNotList(){
return this.materialSourceNotList;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSourceNotList
*/
public void setMaterialSourceNotList(List<String> materialSourceNotList){
this.materialSourceNotList = materialSourceNotList;
}
/**
* 获取 开始 纸质材料份数
* @return paperNumStart
*/
public Integer getPaperNumStart(){
return this.paperNumStart;
}
/**
* 设置 开始 纸质材料份数
* @param paperNumStart
*/
public void setPaperNumStart(Integer paperNumStart){
this.paperNumStart = paperNumStart;
}
/**
* 获取 结束 纸质材料份数
* @return $paperNumEnd
*/
public Integer getPaperNumEnd(){
return this.paperNumEnd;
}
/**
* 设置 结束 纸质材料份数
* @param paperNumEnd
*/
public void setPaperNumEnd(Integer paperNumEnd){
this.paperNumEnd = paperNumEnd;
}
/**
* 获取 增加 纸质材料份数
* @return paperNumIncrement
*/
public Integer getPaperNumIncrement(){
return this.paperNumIncrement;
}
/**
* 设置 增加 纸质材料份数
* @param paperNumIncrement
*/
public void setPaperNumIncrement(Integer paperNumIncrement){
this.paperNumIncrement = paperNumIncrement;
}
/**
* 获取 纸质材料份数
* @return paperNumList
*/
public List<Integer> getPaperNumList(){
return this.paperNumList;
}
/**
* 设置 纸质材料份数
* @param paperNumList
*/
public void setPaperNumList(List<Integer> paperNumList){
this.paperNumList = paperNumList;
}
/**
* 获取 纸质材料份数
* @return paperNumNotList
*/
public List<Integer> getPaperNumNotList(){
return this.paperNumNotList;
}
/**
* 设置 纸质材料份数
* @param paperNumNotList
*/
public void setPaperNumNotList(List<Integer> paperNumNotList){
this.paperNumNotList = paperNumNotList;
}
/**
* 获取 纸质材料规格
* @return paperGgList
*/
public List<String> getPaperGgList(){
return this.paperGgList;
}
/**
* 设置 纸质材料规格
* @param paperGgList
*/
public void setPaperGgList(List<String> paperGgList){
this.paperGgList = paperGgList;
}
/**
* 获取 纸质材料规格
* @return paperGgNotList
*/
public List<String> getPaperGgNotList(){
return this.paperGgNotList;
}
/**
* 设置 纸质材料规格
* @param paperGgNotList
*/
public void setPaperGgNotList(List<String> paperGgNotList){
this.paperGgNotList = paperGgNotList;
}
/**
* 获取 减免模式（1.无，2.减，3.免）
* @return jianmMsList
*/
public List<String> getJianmMsList(){
return this.jianmMsList;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMsList
*/
public void setJianmMsList(List<String> jianmMsList){
this.jianmMsList = jianmMsList;
}
/**
* 获取 减免模式（1.无，2.减，3.免）
* @return jianmMsNotList
*/
public List<String> getJianmMsNotList(){
return this.jianmMsNotList;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMsNotList
*/
public void setJianmMsNotList(List<String> jianmMsNotList){
this.jianmMsNotList = jianmMsNotList;
}
/**
* 获取 盖章方式
* @return sealWayList
*/
public List<String> getSealWayList(){
return this.sealWayList;
}
/**
* 设置 盖章方式
* @param sealWayList
*/
public void setSealWayList(List<String> sealWayList){
this.sealWayList = sealWayList;
}
/**
* 获取 盖章方式
* @return sealWayNotList
*/
public List<String> getSealWayNotList(){
return this.sealWayNotList;
}
/**
* 设置 盖章方式
* @param sealWayNotList
*/
public void setSealWayNotList(List<String> sealWayNotList){
this.sealWayNotList = sealWayNotList;
}
/**
* 获取 是否减免（0.否，1.是）
* @return isjianmList
*/
public List<String> getIsjianmList(){
return this.isjianmList;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianmList
*/
public void setIsjianmList(List<String> isjianmList){
this.isjianmList = isjianmList;
}
/**
* 获取 是否减免（0.否，1.是）
* @return isjianmNotList
*/
public List<String> getIsjianmNotList(){
return this.isjianmNotList;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianmNotList
*/
public void setIsjianmNotList(List<String> isjianmNotList){
this.isjianmNotList = isjianmNotList;
}
/**
* 获取 材料是否容缺（1.必要，2.非必要）
* @return isLackList
*/
public List<String> getIsLackList(){
return this.isLackList;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLackList
*/
public void setIsLackList(List<String> isLackList){
this.isLackList = isLackList;
}
/**
* 获取 材料是否容缺（1.必要，2.非必要）
* @return isLackNotList
*/
public List<String> getIsLackNotList(){
return this.isLackNotList;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLackNotList
*/
public void setIsLackNotList(List<String> isLackNotList){
this.isLackNotList = isLackNotList;
}
/**
* 获取 材料地址
* @return ybUrlList
*/
public List<String> getYbUrlList(){
return this.ybUrlList;
}
/**
* 设置 材料地址
* @param ybUrlList
*/
public void setYbUrlList(List<String> ybUrlList){
this.ybUrlList = ybUrlList;
}
/**
* 获取 材料地址
* @return ybUrlNotList
*/
public List<String> getYbUrlNotList(){
return this.ybUrlNotList;
}
/**
* 设置 材料地址
* @param ybUrlNotList
*/
public void setYbUrlNotList(List<String> ybUrlNotList){
this.ybUrlNotList = ybUrlNotList;
}
/**
* 获取 来源渠道说明
* @return materialSourceSmList
*/
public List<String> getMaterialSourceSmList(){
return this.materialSourceSmList;
}
/**
* 设置 来源渠道说明
* @param materialSourceSmList
*/
public void setMaterialSourceSmList(List<String> materialSourceSmList){
this.materialSourceSmList = materialSourceSmList;
}
/**
* 获取 来源渠道说明
* @return materialSourceSmNotList
*/
public List<String> getMaterialSourceSmNotList(){
return this.materialSourceSmNotList;
}
/**
* 设置 来源渠道说明
* @param materialSourceSmNotList
*/
public void setMaterialSourceSmNotList(List<String> materialSourceSmNotList){
this.materialSourceSmNotList = materialSourceSmNotList;
}
/**
* 获取 填报须知
* @return remarkSubList
*/
public List<String> getRemarkSubList(){
return this.remarkSubList;
}
/**
* 设置 填报须知
* @param remarkSubList
*/
public void setRemarkSubList(List<String> remarkSubList){
this.remarkSubList = remarkSubList;
}
/**
* 获取 填报须知
* @return remarkSubNotList
*/
public List<String> getRemarkSubNotList(){
return this.remarkSubNotList;
}
/**
* 设置 填报须知
* @param remarkSubNotList
*/
public void setRemarkSubNotList(List<String> remarkSubNotList){
this.remarkSubNotList = remarkSubNotList;
}
/**
* 获取 要求提供材料的依据
* @return clauseContentList
*/
public List<String> getClauseContentList(){
return this.clauseContentList;
}
/**
* 设置 要求提供材料的依据
* @param clauseContentList
*/
public void setClauseContentList(List<String> clauseContentList){
this.clauseContentList = clauseContentList;
}
/**
* 获取 要求提供材料的依据
* @return clauseContentNotList
*/
public List<String> getClauseContentNotList(){
return this.clauseContentNotList;
}
/**
* 设置 要求提供材料的依据
* @param clauseContentNotList
*/
public void setClauseContentNotList(List<String> clauseContentNotList){
this.clauseContentNotList = clauseContentNotList;
}
/**
* 获取 受理标准
* @return summaryList
*/
public List<String> getSummaryList(){
return this.summaryList;
}
/**
* 设置 受理标准
* @param summaryList
*/
public void setSummaryList(List<String> summaryList){
this.summaryList = summaryList;
}
/**
* 获取 受理标准
* @return summaryNotList
*/
public List<String> getSummaryNotList(){
return this.summaryNotList;
}
/**
* 设置 受理标准
* @param summaryNotList
*/
public void setSummaryNotList(List<String> summaryNotList){
this.summaryNotList = summaryNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 事项来源(0.政务网，1.自定义)
* @return sourceStart
*/
public Integer getSourceStart(){
return this.sourceStart;
}
/**
* 设置 开始 事项来源(0.政务网，1.自定义)
* @param sourceStart
*/
public void setSourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
}
/**
* 获取 结束 事项来源(0.政务网，1.自定义)
* @return $sourceEnd
*/
public Integer getSourceEnd(){
return this.sourceEnd;
}
/**
* 设置 结束 事项来源(0.政务网，1.自定义)
* @param sourceEnd
*/
public void setSourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
}
/**
* 获取 增加 事项来源(0.政务网，1.自定义)
* @return sourceIncrement
*/
public Integer getSourceIncrement(){
return this.sourceIncrement;
}
/**
* 设置 增加 事项来源(0.政务网，1.自定义)
* @param sourceIncrement
*/
public void setSourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
* @return sourceList
*/
public List<Integer> getSourceList(){
return this.sourceList;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param sourceList
*/
public void setSourceList(List<Integer> sourceList){
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
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
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
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 修改时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 修改时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 修改时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 主键，自增长
* @param id
*/
public DatumLibraryQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 主键，自增长
* @param idStart
*/
public DatumLibraryQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 主键，自增长
* @param idEnd
*/
public DatumLibraryQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 主键，自增长
* @param idIncrement
*/
public DatumLibraryQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 主键，自增长
* @param idList
*/
public DatumLibraryQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 主键，自增长
* @param idNotList
*/
public DatumLibraryQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 站点id
* @param siteId
*/
public DatumLibraryQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public DatumLibraryQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public DatumLibraryQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public DatumLibraryQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点id
* @param siteIdList
*/
public DatumLibraryQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点id
* @param siteIdNotList
*/
public DatumLibraryQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
/**
* 设置 站点名称
* @param siteName
*/
public DatumLibraryQuery siteName(String siteName){
setSiteName(siteName);
return this;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public DatumLibraryQuery siteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
return this;
}
/**
* 设置 材料id
* @param datumId
*/
public DatumLibraryQuery datumId(Long datumId){
setDatumId(datumId);
return this;
}
/**
* 设置 开始 材料id
* @param datumIdStart
*/
public DatumLibraryQuery datumIdStart(Long datumIdStart){
this.datumIdStart = datumIdStart;
return this;
}
/**
* 设置 结束 材料id
* @param datumIdEnd
*/
public DatumLibraryQuery datumIdEnd(Long datumIdEnd){
this.datumIdEnd = datumIdEnd;
return this;
}
/**
* 设置 增加 材料id
* @param datumIdIncrement
*/
public DatumLibraryQuery datumIdIncrement(Long datumIdIncrement){
this.datumIdIncrement = datumIdIncrement;
return this;
}
/**
* 设置 材料id
* @param datumIdList
*/
public DatumLibraryQuery datumIdList(List<Long> datumIdList){
this.datumIdList = datumIdList;
return this;
}
/**
* 设置 材料id
* @param datumIdNotList
*/
public DatumLibraryQuery datumIdNotList(List<Long> datumIdNotList){
this.datumIdNotList = datumIdNotList;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public DatumLibraryQuery matterId(Long matterId){
setMatterId(matterId);
return this;
}
/**
* 设置 开始 事项基础表matter id
* @param matterIdStart
*/
public DatumLibraryQuery matterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
return this;
}
/**
* 设置 结束 事项基础表matter id
* @param matterIdEnd
*/
public DatumLibraryQuery matterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
return this;
}
/**
* 设置 增加 事项基础表matter id
* @param matterIdIncrement
*/
public DatumLibraryQuery matterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterIdList
*/
public DatumLibraryQuery matterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterIdNotList
*/
public DatumLibraryQuery matterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
return this;
}
/**
* 设置 事项编码
* @param matterCode
*/
public DatumLibraryQuery matterCode(String matterCode){
setMatterCode(matterCode);
return this;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public DatumLibraryQuery matterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
return this;
}
/**
* 设置 事项名称
* @param matterName
*/
public DatumLibraryQuery matterName(String matterName){
setMatterName(matterName);
return this;
}
/**
* 设置 事项名称
* @param matterNameList
*/
public DatumLibraryQuery matterNameList(List<String> matterNameList){
this.matterNameList = matterNameList;
return this;
}
/**
* 设置 材料名
* @param materialName
*/
public DatumLibraryQuery materialName(String materialName){
setMaterialName(materialName);
return this;
}
/**
* 设置 材料名
* @param materialNameList
*/
public DatumLibraryQuery materialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
return this;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMust
*/
public DatumLibraryQuery isMust(String isMust){
setIsMust(isMust);
return this;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMustList
*/
public DatumLibraryQuery isMustList(List<String> isMustList){
this.isMustList = isMustList;
return this;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialType
*/
public DatumLibraryQuery materialType(String materialType){
setMaterialType(materialType);
return this;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialTypeList
*/
public DatumLibraryQuery materialTypeList(List<String> materialTypeList){
this.materialTypeList = materialTypeList;
return this;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialProperty
*/
public DatumLibraryQuery materialProperty(String materialProperty){
setMaterialProperty(materialProperty);
return this;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialPropertyList
*/
public DatumLibraryQuery materialPropertyList(List<String> materialPropertyList){
this.materialPropertyList = materialPropertyList;
return this;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgs
*/
public DatumLibraryQuery electronicgs(String electronicgs){
setElectronicgs(electronicgs);
return this;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgsList
*/
public DatumLibraryQuery electronicgsList(List<String> electronicgsList){
this.electronicgsList = electronicgsList;
return this;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSource
*/
public DatumLibraryQuery materialSource(String materialSource){
setMaterialSource(materialSource);
return this;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSourceList
*/
public DatumLibraryQuery materialSourceList(List<String> materialSourceList){
this.materialSourceList = materialSourceList;
return this;
}
/**
* 设置 纸质材料份数
* @param paperNum
*/
public DatumLibraryQuery paperNum(Integer paperNum){
setPaperNum(paperNum);
return this;
}
/**
* 设置 开始 纸质材料份数
* @param paperNumStart
*/
public DatumLibraryQuery paperNumStart(Integer paperNumStart){
this.paperNumStart = paperNumStart;
return this;
}
/**
* 设置 结束 纸质材料份数
* @param paperNumEnd
*/
public DatumLibraryQuery paperNumEnd(Integer paperNumEnd){
this.paperNumEnd = paperNumEnd;
return this;
}
/**
* 设置 增加 纸质材料份数
* @param paperNumIncrement
*/
public DatumLibraryQuery paperNumIncrement(Integer paperNumIncrement){
this.paperNumIncrement = paperNumIncrement;
return this;
}
/**
* 设置 纸质材料份数
* @param paperNumList
*/
public DatumLibraryQuery paperNumList(List<Integer> paperNumList){
this.paperNumList = paperNumList;
return this;
}
/**
* 设置 纸质材料份数
* @param paperNumNotList
*/
public DatumLibraryQuery paperNumNotList(List<Integer> paperNumNotList){
this.paperNumNotList = paperNumNotList;
return this;
}
/**
* 设置 纸质材料规格
* @param paperGg
*/
public DatumLibraryQuery paperGg(String paperGg){
setPaperGg(paperGg);
return this;
}
/**
* 设置 纸质材料规格
* @param paperGgList
*/
public DatumLibraryQuery paperGgList(List<String> paperGgList){
this.paperGgList = paperGgList;
return this;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMs
*/
public DatumLibraryQuery jianmMs(String jianmMs){
setJianmMs(jianmMs);
return this;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMsList
*/
public DatumLibraryQuery jianmMsList(List<String> jianmMsList){
this.jianmMsList = jianmMsList;
return this;
}
/**
* 设置 盖章方式
* @param sealWay
*/
public DatumLibraryQuery sealWay(String sealWay){
setSealWay(sealWay);
return this;
}
/**
* 设置 盖章方式
* @param sealWayList
*/
public DatumLibraryQuery sealWayList(List<String> sealWayList){
this.sealWayList = sealWayList;
return this;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianm
*/
public DatumLibraryQuery isjianm(String isjianm){
setIsjianm(isjianm);
return this;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianmList
*/
public DatumLibraryQuery isjianmList(List<String> isjianmList){
this.isjianmList = isjianmList;
return this;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLack
*/
public DatumLibraryQuery isLack(String isLack){
setIsLack(isLack);
return this;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLackList
*/
public DatumLibraryQuery isLackList(List<String> isLackList){
this.isLackList = isLackList;
return this;
}
/**
* 设置 材料地址
* @param ybUrl
*/
public DatumLibraryQuery ybUrl(String ybUrl){
setYbUrl(ybUrl);
return this;
}
/**
* 设置 材料地址
* @param ybUrlList
*/
public DatumLibraryQuery ybUrlList(List<String> ybUrlList){
this.ybUrlList = ybUrlList;
return this;
}
/**
* 设置 来源渠道说明
* @param materialSourceSm
*/
public DatumLibraryQuery materialSourceSm(String materialSourceSm){
setMaterialSourceSm(materialSourceSm);
return this;
}
/**
* 设置 来源渠道说明
* @param materialSourceSmList
*/
public DatumLibraryQuery materialSourceSmList(List<String> materialSourceSmList){
this.materialSourceSmList = materialSourceSmList;
return this;
}
/**
* 设置 填报须知
* @param remarkSub
*/
public DatumLibraryQuery remarkSub(String remarkSub){
setRemarkSub(remarkSub);
return this;
}
/**
* 设置 填报须知
* @param remarkSubList
*/
public DatumLibraryQuery remarkSubList(List<String> remarkSubList){
this.remarkSubList = remarkSubList;
return this;
}
/**
* 设置 要求提供材料的依据
* @param clauseContent
*/
public DatumLibraryQuery clauseContent(String clauseContent){
setClauseContent(clauseContent);
return this;
}
/**
* 设置 要求提供材料的依据
* @param clauseContentList
*/
public DatumLibraryQuery clauseContentList(List<String> clauseContentList){
this.clauseContentList = clauseContentList;
return this;
}
/**
* 设置 受理标准
* @param summary
*/
public DatumLibraryQuery summary(String summary){
setSummary(summary);
return this;
}
/**
* 设置 受理标准
* @param summaryList
*/
public DatumLibraryQuery summaryList(List<String> summaryList){
this.summaryList = summaryList;
return this;
}
/**
* 设置 备注
* @param remark
*/
public DatumLibraryQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public DatumLibraryQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param source
*/
public DatumLibraryQuery source(Integer source){
setSource(source);
return this;
}
/**
* 设置 开始 事项来源(0.政务网，1.自定义)
* @param sourceStart
*/
public DatumLibraryQuery sourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
return this;
}
/**
* 设置 结束 事项来源(0.政务网，1.自定义)
* @param sourceEnd
*/
public DatumLibraryQuery sourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
return this;
}
/**
* 设置 增加 事项来源(0.政务网，1.自定义)
* @param sourceIncrement
*/
public DatumLibraryQuery sourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
return this;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param sourceList
*/
public DatumLibraryQuery sourceList(List<Integer> sourceList){
this.sourceList = sourceList;
return this;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param sourceNotList
*/
public DatumLibraryQuery sourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public DatumLibraryQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public DatumLibraryQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public DatumLibraryQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public DatumLibraryQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public DatumLibraryQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public DatumLibraryQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<DatumLibraryQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<DatumLibraryQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<DatumLibraryQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<DatumLibraryQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterApplyEntity.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.vo.MatterApplyVo;
/**
* 申报事项实体对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterApplyEntity extends MatterApplyVo {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 站点名称
*/
private String siteName;
/**
* 站点事项id
*/
private Long siteMatterId;
/**
* 事项ID
*/
private Long matterId;
/**
* 事项名称
*/
private String matterName;
/**
* 事项编码
*/
private String matterCode;
/**
* 部门ID
*/
private Long deptId;
/**
* 部门名称
*/
private String deptName;
/**
* 部门编码
*/
private String deptCode;
/**
* 事项主题名称
*/
private String themeName;
/**
* 事项来源
*/
private Integer source;
/**
* 申报次数
*/
private Integer reportCount;
/**
* 材料数量
*/
private Integer datumCount;
/**
* 政务网地址
*/
private String govUrl;
/**
* 是否生成本地附件
*/
private Integer isConvert;
/**
* 事项主题编码
*/
private String themeCode;
public MatterApplyEntity(){}
/**
* 获取 站点id
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点id
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 站点名称
* @return String
*/
public String getSiteName(){
return siteName;
}
/**
* 设置 站点名称
* @param siteName
*/
public void setSiteName(String siteName){
this.siteName = siteName;
}
/**
* 获取 站点事项id
* @return Long
*/
public Long getSiteMatterId(){
return siteMatterId;
}
/**
* 设置 站点事项id
* @param siteMatterId
*/
public void setSiteMatterId(Long siteMatterId){
this.siteMatterId = siteMatterId;
}
/**
* 获取 事项ID
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项ID
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项名称
* @return String
*/
public String getMatterName(){
return matterName;
}
/**
* 设置 事项名称
* @param matterName
*/
public void setMatterName(String matterName){
this.matterName = matterName;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 部门ID
* @return Long
*/
public Long getDeptId(){
return deptId;
}
/**
* 设置 部门ID
* @param deptId
*/
public void setDeptId(Long deptId){
this.deptId = deptId;
}
/**
* 获取 部门名称
* @return String
*/
public String getDeptName(){
return deptName;
}
/**
* 设置 部门名称
* @param deptName
*/
public void setDeptName(String deptName){
this.deptName = deptName;
}
/**
* 获取 部门编码
* @return String
*/
public String getDeptCode(){
return deptCode;
}
/**
* 设置 部门编码
* @param deptCode
*/
public void setDeptCode(String deptCode){
this.deptCode = deptCode;
}
/**
* 获取 事项主题名称
* @return String
*/
public String getThemeName(){
return themeName;
}
/**
* 设置 事项主题名称
* @param themeName
*/
public void setThemeName(String themeName){
this.themeName = themeName;
}
/**
* 获取 事项来源
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
/**
* 获取 申报次数
* @return Integer
*/
public Integer getReportCount(){
return reportCount;
}
/**
* 设置 申报次数
* @param reportCount
*/
public void setReportCount(Integer reportCount){
this.reportCount = reportCount;
}
/**
* 获取 材料数量
* @return Integer
*/
public Integer getDatumCount(){
return datumCount;
}
/**
* 设置 材料数量
* @param datumCount
*/
public void setDatumCount(Integer datumCount){
this.datumCount = datumCount;
}
/**
* 获取 政务网地址
* @return String
*/
public String getGovUrl(){
return govUrl;
}
/**
* 设置 政务网地址
* @param govUrl
*/
public void setGovUrl(String govUrl){
this.govUrl = govUrl;
}
/**
* 获取 是否生成本地附件
* @return Integer
*/
public Integer getIsConvert(){
return isConvert;
}
/**
* 设置 是否生成本地附件
* @param isConvert
*/
public void setIsConvert(Integer isConvert){
this.isConvert = isConvert;
}
/**
* 获取 事项主题编码
* @return String
*/
public String getThemeCode(){
return themeCode;
}
/**
* 设置 事项主题编码
* @param themeCode
*/
public void setThemeCode(String themeCode){
this.themeCode = themeCode;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterApplyEntity) {
MatterApplyEntity tmp = (MatterApplyEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",siteName:").append(getSiteName());
sb.append(",siteMatterId:").append(getSiteMatterId());
sb.append(",matterId:").append(getMatterId());
sb.append(",matterName:").append(getMatterName());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",deptId:").append(getDeptId());
sb.append(",deptName:").append(getDeptName());
sb.append(",deptCode:").append(getDeptCode());
sb.append(",themeName:").append(getThemeName());
sb.append(",source:").append(getSource());
sb.append(",reportCount:").append(getReportCount());
sb.append(",datumCount:").append(getDatumCount());
sb.append(",govUrl:").append(getGovUrl());
sb.append(",isConvert:").append(getIsConvert());
sb.append(",themeCode:").append(getThemeCode());
return sb.toString();
}
public void initAttrValue(){
this.siteId = null;
this.siteName = "";
this.siteMatterId = null;
this.matterId = null;
this.matterName = "";
this.matterCode = "";
this.deptId = null;
this.deptName = "";
this.deptCode = "";
this.themeName = "";
this.source = null;
this.reportCount = 0;
this.datumCount = 0;
this.govUrl = "";
this.isConvert = 0;
this.themeCode = "";
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterApplyQuery.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
/**
* 申报事项查询对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterApplyQuery extends MatterApplyEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 序号，主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 站点id */
private Long siteIdStart;
/** 结束 站点id */
private Long siteIdEnd;
/** 增加 站点id */
private Long siteIdIncrement;
/** 站点id列表 */
private List <Long> siteIdList;
/** 站点id排除列表 */
private List <Long> siteIdNotList;
/** 站点名称 */
private List<String> siteNameList;
/** 站点名称排除列表 */
private List <String> siteNameNotList;
/** 开始 站点事项id */
private Long siteMatterIdStart;
/** 结束 站点事项id */
private Long siteMatterIdEnd;
/** 增加 站点事项id */
private Long siteMatterIdIncrement;
/** 站点事项id列表 */
private List <Long> siteMatterIdList;
/** 站点事项id排除列表 */
private List <Long> siteMatterIdNotList;
/** 开始 事项ID */
private Long matterIdStart;
/** 结束 事项ID */
private Long matterIdEnd;
/** 增加 事项ID */
private Long matterIdIncrement;
/** 事项ID列表 */
private List <Long> matterIdList;
/** 事项ID排除列表 */
private List <Long> matterIdNotList;
/** 事项名称 */
private List<String> matterNameList;
/** 事项名称排除列表 */
private List <String> matterNameNotList;
/** 事项编码 */
private List<String> matterCodeList;
/** 事项编码排除列表 */
private List <String> matterCodeNotList;
/** 开始 部门ID */
private Long deptIdStart;
/** 结束 部门ID */
private Long deptIdEnd;
/** 增加 部门ID */
private Long deptIdIncrement;
/** 部门ID列表 */
private List <Long> deptIdList;
/** 部门ID排除列表 */
private List <Long> deptIdNotList;
/** 部门名称 */
private List<String> deptNameList;
/** 部门名称排除列表 */
private List <String> deptNameNotList;
/** 部门编码 */
private List<String> deptCodeList;
/** 部门编码排除列表 */
private List <String> deptCodeNotList;
/** 事项主题名称 */
private List<String> themeNameList;
/** 事项主题名称排除列表 */
private List <String> themeNameNotList;
/** 开始 事项来源 */
private Integer sourceStart;
/** 结束 事项来源 */
private Integer sourceEnd;
/** 增加 事项来源 */
private Integer sourceIncrement;
/** 事项来源列表 */
private List <Integer> sourceList;
/** 事项来源排除列表 */
private List <Integer> sourceNotList;
/** 开始 申报次数 */
private Integer reportCountStart;
/** 结束 申报次数 */
private Integer reportCountEnd;
/** 增加 申报次数 */
private Integer reportCountIncrement;
/** 申报次数列表 */
private List <Integer> reportCountList;
/** 申报次数排除列表 */
private List <Integer> reportCountNotList;
/** 开始 材料数量 */
private Integer datumCountStart;
/** 结束 材料数量 */
private Integer datumCountEnd;
/** 增加 材料数量 */
private Integer datumCountIncrement;
/** 材料数量列表 */
private List <Integer> datumCountList;
/** 材料数量排除列表 */
private List <Integer> datumCountNotList;
/** 政务网地址 */
private List<String> govUrlList;
/** 政务网地址排除列表 */
private List <String> govUrlNotList;
/** 开始 是否生成本地附件 */
private Integer isConvertStart;
/** 结束 是否生成本地附件 */
private Integer isConvertEnd;
/** 增加 是否生成本地附件 */
private Integer isConvertIncrement;
/** 是否生成本地附件列表 */
private List <Integer> isConvertList;
/** 是否生成本地附件排除列表 */
private List <Integer> isConvertNotList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** 事项主题编码 */
private List<String> themeCodeList;
/** 事项主题编码排除列表 */
private List <String> themeCodeNotList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MatterApplyQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MatterApplyQuery> andConditionList;
public MatterApplyQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
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
*/
public Long getSiteIdStart(){
return this.siteIdStart;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public void setSiteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
}
/**
* 获取 结束 站点id
* @return $siteIdEnd
*/
public Long getSiteIdEnd(){
return this.siteIdEnd;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public void setSiteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
}
/**
* 获取 增加 站点id
* @return siteIdIncrement
*/
public Long getSiteIdIncrement(){
return this.siteIdIncrement;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public void setSiteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
}
/**
* 获取 站点id
* @return siteIdList
*/
public List<Long> getSiteIdList(){
return this.siteIdList;
}
/**
* 设置 站点id
* @param siteIdList
*/
public void setSiteIdList(List<Long> siteIdList){
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;
}
/**
* 获取 站点名称
* @return siteNameList
*/
public List<String> getSiteNameList(){
return this.siteNameList;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public void setSiteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
}
/**
* 获取 站点名称
* @return siteNameNotList
*/
public List<String> getSiteNameNotList(){
return this.siteNameNotList;
}
/**
* 设置 站点名称
* @param siteNameNotList
*/
public void setSiteNameNotList(List<String> siteNameNotList){
this.siteNameNotList = siteNameNotList;
}
/**
* 获取 开始 站点事项id
* @return siteMatterIdStart
*/
public Long getSiteMatterIdStart(){
return this.siteMatterIdStart;
}
/**
* 设置 开始 站点事项id
* @param siteMatterIdStart
*/
public void setSiteMatterIdStart(Long siteMatterIdStart){
this.siteMatterIdStart = siteMatterIdStart;
}
/**
* 获取 结束 站点事项id
* @return $siteMatterIdEnd
*/
public Long getSiteMatterIdEnd(){
return this.siteMatterIdEnd;
}
/**
* 设置 结束 站点事项id
* @param siteMatterIdEnd
*/
public void setSiteMatterIdEnd(Long siteMatterIdEnd){
this.siteMatterIdEnd = siteMatterIdEnd;
}
/**
* 获取 增加 站点事项id
* @return siteMatterIdIncrement
*/
public Long getSiteMatterIdIncrement(){
return this.siteMatterIdIncrement;
}
/**
* 设置 增加 站点事项id
* @param siteMatterIdIncrement
*/
public void setSiteMatterIdIncrement(Long siteMatterIdIncrement){
this.siteMatterIdIncrement = siteMatterIdIncrement;
}
/**
* 获取 站点事项id
* @return siteMatterIdList
*/
public List<Long> getSiteMatterIdList(){
return this.siteMatterIdList;
}
/**
* 设置 站点事项id
* @param siteMatterIdList
*/
public void setSiteMatterIdList(List<Long> siteMatterIdList){
this.siteMatterIdList = siteMatterIdList;
}
/**
* 获取 站点事项id
* @return siteMatterIdNotList
*/
public List<Long> getSiteMatterIdNotList(){
return this.siteMatterIdNotList;
}
/**
* 设置 站点事项id
* @param siteMatterIdNotList
*/
public void setSiteMatterIdNotList(List<Long> siteMatterIdNotList){
this.siteMatterIdNotList = siteMatterIdNotList;
}
/**
* 获取 开始 事项ID
* @return matterIdStart
*/
public Long getMatterIdStart(){
return this.matterIdStart;
}
/**
* 设置 开始 事项ID
* @param matterIdStart
*/
public void setMatterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
}
/**
* 获取 结束 事项ID
* @return $matterIdEnd
*/
public Long getMatterIdEnd(){
return this.matterIdEnd;
}
/**
* 设置 结束 事项ID
* @param matterIdEnd
*/
public void setMatterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
}
/**
* 获取 增加 事项ID
* @return matterIdIncrement
*/
public Long getMatterIdIncrement(){
return this.matterIdIncrement;
}
/**
* 设置 增加 事项ID
* @param matterIdIncrement
*/
public void setMatterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
}
/**
* 获取 事项ID
* @return matterIdList
*/
public List<Long> getMatterIdList(){
return this.matterIdList;
}
/**
* 设置 事项ID
* @param matterIdList
*/
public void setMatterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
}
/**
* 获取 事项ID
* @return matterIdNotList
*/
public List<Long> getMatterIdNotList(){
return this.matterIdNotList;
}
/**
* 设置 事项ID
* @param matterIdNotList
*/
public void setMatterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
}
/**
* 获取 事项名称
* @return matterNameList
*/
public List<String> getMatterNameList(){
return this.matterNameList;
}
/**
* 设置 事项名称
* @param matterNameList
*/
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 matterCodeList
*/
public List<String> getMatterCodeList(){
return this.matterCodeList;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public void setMatterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
}
/**
* 获取 事项编码
* @return matterCodeNotList
*/
public List<String> getMatterCodeNotList(){
return this.matterCodeNotList;
}
/**
* 设置 事项编码
* @param matterCodeNotList
*/
public void setMatterCodeNotList(List<String> matterCodeNotList){
this.matterCodeNotList = matterCodeNotList;
}
/**
* 获取 开始 部门ID
* @return deptIdStart
*/
public Long getDeptIdStart(){
return this.deptIdStart;
}
/**
* 设置 开始 部门ID
* @param deptIdStart
*/
public void setDeptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
}
/**
* 获取 结束 部门ID
* @return $deptIdEnd
*/
public Long getDeptIdEnd(){
return this.deptIdEnd;
}
/**
* 设置 结束 部门ID
* @param deptIdEnd
*/
public void setDeptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
}
/**
* 获取 增加 部门ID
* @return deptIdIncrement
*/
public Long getDeptIdIncrement(){
return this.deptIdIncrement;
}
/**
* 设置 增加 部门ID
* @param deptIdIncrement
*/
public void setDeptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
}
/**
* 获取 部门ID
* @return deptIdList
*/
public List<Long> getDeptIdList(){
return this.deptIdList;
}
/**
* 设置 部门ID
* @param deptIdList
*/
public void setDeptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
}
/**
* 获取 部门ID
* @return deptIdNotList
*/
public List<Long> getDeptIdNotList(){
return this.deptIdNotList;
}
/**
* 设置 部门ID
* @param deptIdNotList
*/
public void setDeptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
}
/**
* 获取 部门名称
* @return deptNameList
*/
public List<String> getDeptNameList(){
return this.deptNameList;
}
/**
* 设置 部门名称
* @param deptNameList
*/
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 deptCodeList
*/
public List<String> getDeptCodeList(){
return this.deptCodeList;
}
/**
* 设置 部门编码
* @param deptCodeList
*/
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 themeNameList
*/
public List<String> getThemeNameList(){
return this.themeNameList;
}
/**
* 设置 事项主题名称
* @param themeNameList
*/
public void setThemeNameList(List<String> themeNameList){
this.themeNameList = themeNameList;
}
/**
* 获取 事项主题名称
* @return themeNameNotList
*/
public List<String> getThemeNameNotList(){
return this.themeNameNotList;
}
/**
* 设置 事项主题名称
* @param themeNameNotList
*/
public void setThemeNameNotList(List<String> themeNameNotList){
this.themeNameNotList = themeNameNotList;
}
/**
* 获取 开始 事项来源
* @return sourceStart
*/
public Integer getSourceStart(){
return this.sourceStart;
}
/**
* 设置 开始 事项来源
* @param sourceStart
*/
public void setSourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
}
/**
* 获取 结束 事项来源
* @return $sourceEnd
*/
public Integer getSourceEnd(){
return this.sourceEnd;
}
/**
* 设置 结束 事项来源
* @param sourceEnd
*/
public void setSourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
}
/**
* 获取 增加 事项来源
* @return sourceIncrement
*/
public Integer getSourceIncrement(){
return this.sourceIncrement;
}
/**
* 设置 增加 事项来源
* @param sourceIncrement
*/
public void setSourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
}
/**
* 获取 事项来源
* @return sourceList
*/
public List<Integer> getSourceList(){
return this.sourceList;
}
/**
* 设置 事项来源
* @param sourceList
*/
public void setSourceList(List<Integer> sourceList){
this.sourceList = sourceList;
}
/**
* 获取 事项来源
* @return sourceNotList
*/
public List<Integer> getSourceNotList(){
return this.sourceNotList;
}
/**
* 设置 事项来源
* @param sourceNotList
*/
public void setSourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
}
/**
* 获取 开始 申报次数
* @return reportCountStart
*/
public Integer getReportCountStart(){
return this.reportCountStart;
}
/**
* 设置 开始 申报次数
* @param reportCountStart
*/
public void setReportCountStart(Integer reportCountStart){
this.reportCountStart = reportCountStart;
}
/**
* 获取 结束 申报次数
* @return $reportCountEnd
*/
public Integer getReportCountEnd(){
return this.reportCountEnd;
}
/**
* 设置 结束 申报次数
* @param reportCountEnd
*/
public void setReportCountEnd(Integer reportCountEnd){
this.reportCountEnd = reportCountEnd;
}
/**
* 获取 增加 申报次数
* @return reportCountIncrement
*/
public Integer getReportCountIncrement(){
return this.reportCountIncrement;
}
/**
* 设置 增加 申报次数
* @param reportCountIncrement
*/
public void setReportCountIncrement(Integer reportCountIncrement){
this.reportCountIncrement = reportCountIncrement;
}
/**
* 获取 申报次数
* @return reportCountList
*/
public List<Integer> getReportCountList(){
return this.reportCountList;
}
/**
* 设置 申报次数
* @param reportCountList
*/
public void setReportCountList(List<Integer> reportCountList){
this.reportCountList = reportCountList;
}
/**
* 获取 申报次数
* @return reportCountNotList
*/
public List<Integer> getReportCountNotList(){
return this.reportCountNotList;
}
/**
* 设置 申报次数
* @param reportCountNotList
*/
public void setReportCountNotList(List<Integer> reportCountNotList){
this.reportCountNotList = reportCountNotList;
}
/**
* 获取 开始 材料数量
* @return datumCountStart
*/
public Integer getDatumCountStart(){
return this.datumCountStart;
}
/**
* 设置 开始 材料数量
* @param datumCountStart
*/
public void setDatumCountStart(Integer datumCountStart){
this.datumCountStart = datumCountStart;
}
/**
* 获取 结束 材料数量
* @return $datumCountEnd
*/
public Integer getDatumCountEnd(){
return this.datumCountEnd;
}
/**
* 设置 结束 材料数量
* @param datumCountEnd
*/
public void setDatumCountEnd(Integer datumCountEnd){
this.datumCountEnd = datumCountEnd;
}
/**
* 获取 增加 材料数量
* @return datumCountIncrement
*/
public Integer getDatumCountIncrement(){
return this.datumCountIncrement;
}
/**
* 设置 增加 材料数量
* @param datumCountIncrement
*/
public void setDatumCountIncrement(Integer datumCountIncrement){
this.datumCountIncrement = datumCountIncrement;
}
/**
* 获取 材料数量
* @return datumCountList
*/
public List<Integer> getDatumCountList(){
return this.datumCountList;
}
/**
* 设置 材料数量
* @param datumCountList
*/
public void setDatumCountList(List<Integer> datumCountList){
this.datumCountList = datumCountList;
}
/**
* 获取 材料数量
* @return datumCountNotList
*/
public List<Integer> getDatumCountNotList(){
return this.datumCountNotList;
}
/**
* 设置 材料数量
* @param datumCountNotList
*/
public void setDatumCountNotList(List<Integer> datumCountNotList){
this.datumCountNotList = datumCountNotList;
}
/**
* 获取 政务网地址
* @return govUrlList
*/
public List<String> getGovUrlList(){
return this.govUrlList;
}
/**
* 设置 政务网地址
* @param govUrlList
*/
public void setGovUrlList(List<String> govUrlList){
this.govUrlList = govUrlList;
}
/**
* 获取 政务网地址
* @return govUrlNotList
*/
public List<String> getGovUrlNotList(){
return this.govUrlNotList;
}
/**
* 设置 政务网地址
* @param govUrlNotList
*/
public void setGovUrlNotList(List<String> govUrlNotList){
this.govUrlNotList = govUrlNotList;
}
/**
* 获取 开始 是否生成本地附件
* @return isConvertStart
*/
public Integer getIsConvertStart(){
return this.isConvertStart;
}
/**
* 设置 开始 是否生成本地附件
* @param isConvertStart
*/
public void setIsConvertStart(Integer isConvertStart){
this.isConvertStart = isConvertStart;
}
/**
* 获取 结束 是否生成本地附件
* @return $isConvertEnd
*/
public Integer getIsConvertEnd(){
return this.isConvertEnd;
}
/**
* 设置 结束 是否生成本地附件
* @param isConvertEnd
*/
public void setIsConvertEnd(Integer isConvertEnd){
this.isConvertEnd = isConvertEnd;
}
/**
* 获取 增加 是否生成本地附件
* @return isConvertIncrement
*/
public Integer getIsConvertIncrement(){
return this.isConvertIncrement;
}
/**
* 设置 增加 是否生成本地附件
* @param isConvertIncrement
*/
public void setIsConvertIncrement(Integer isConvertIncrement){
this.isConvertIncrement = isConvertIncrement;
}
/**
* 获取 是否生成本地附件
* @return isConvertList
*/
public List<Integer> getIsConvertList(){
return this.isConvertList;
}
/**
* 设置 是否生成本地附件
* @param isConvertList
*/
public void setIsConvertList(List<Integer> isConvertList){
this.isConvertList = isConvertList;
}
/**
* 获取 是否生成本地附件
* @return isConvertNotList
*/
public List<Integer> getIsConvertNotList(){
return this.isConvertNotList;
}
/**
* 设置 是否生成本地附件
* @param isConvertNotList
*/
public void setIsConvertNotList(List<Integer> isConvertNotList){
this.isConvertNotList = isConvertNotList;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 事项主题编码
* @return themeCodeList
*/
public List<String> getThemeCodeList(){
return this.themeCodeList;
}
/**
* 设置 事项主题编码
* @param themeCodeList
*/
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;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public MatterApplyQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public MatterApplyQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public MatterApplyQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public MatterApplyQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public MatterApplyQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public MatterApplyQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 站点id
* @param siteId
*/
public MatterApplyQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public MatterApplyQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public MatterApplyQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public MatterApplyQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点id
* @param siteIdList
*/
public MatterApplyQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点id
* @param siteIdNotList
*/
public MatterApplyQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
/**
* 设置 站点名称
* @param siteName
*/
public MatterApplyQuery siteName(String siteName){
setSiteName(siteName);
return this;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public MatterApplyQuery siteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
return this;
}
/**
* 设置 站点事项id
* @param siteMatterId
*/
public MatterApplyQuery siteMatterId(Long siteMatterId){
setSiteMatterId(siteMatterId);
return this;
}
/**
* 设置 开始 站点事项id
* @param siteMatterIdStart
*/
public MatterApplyQuery siteMatterIdStart(Long siteMatterIdStart){
this.siteMatterIdStart = siteMatterIdStart;
return this;
}
/**
* 设置 结束 站点事项id
* @param siteMatterIdEnd
*/
public MatterApplyQuery siteMatterIdEnd(Long siteMatterIdEnd){
this.siteMatterIdEnd = siteMatterIdEnd;
return this;
}
/**
* 设置 增加 站点事项id
* @param siteMatterIdIncrement
*/
public MatterApplyQuery siteMatterIdIncrement(Long siteMatterIdIncrement){
this.siteMatterIdIncrement = siteMatterIdIncrement;
return this;
}
/**
* 设置 站点事项id
* @param siteMatterIdList
*/
public MatterApplyQuery siteMatterIdList(List<Long> siteMatterIdList){
this.siteMatterIdList = siteMatterIdList;
return this;
}
/**
* 设置 站点事项id
* @param siteMatterIdNotList
*/
public MatterApplyQuery siteMatterIdNotList(List<Long> siteMatterIdNotList){
this.siteMatterIdNotList = siteMatterIdNotList;
return this;
}
/**
* 设置 事项ID
* @param matterId
*/
public MatterApplyQuery matterId(Long matterId){
setMatterId(matterId);
return this;
}
/**
* 设置 开始 事项ID
* @param matterIdStart
*/
public MatterApplyQuery matterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
return this;
}
/**
* 设置 结束 事项ID
* @param matterIdEnd
*/
public MatterApplyQuery matterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
return this;
}
/**
* 设置 增加 事项ID
* @param matterIdIncrement
*/
public MatterApplyQuery matterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
return this;
}
/**
* 设置 事项ID
* @param matterIdList
*/
public MatterApplyQuery matterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
return this;
}
/**
* 设置 事项ID
* @param matterIdNotList
*/
public MatterApplyQuery matterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
return this;
}
/**
* 设置 事项名称
* @param matterName
*/
public MatterApplyQuery matterName(String matterName){
setMatterName(matterName);
return this;
}
/**
* 设置 事项名称
* @param matterNameList
*/
public MatterApplyQuery matterNameList(List<String> matterNameList){
this.matterNameList = matterNameList;
return this;
}
/**
* 设置 事项编码
* @param matterCode
*/
public MatterApplyQuery matterCode(String matterCode){
setMatterCode(matterCode);
return this;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public MatterApplyQuery matterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
return this;
}
/**
* 设置 部门ID
* @param deptId
*/
public MatterApplyQuery deptId(Long deptId){
setDeptId(deptId);
return this;
}
/**
* 设置 开始 部门ID
* @param deptIdStart
*/
public MatterApplyQuery deptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
return this;
}
/**
* 设置 结束 部门ID
* @param deptIdEnd
*/
public MatterApplyQuery deptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
return this;
}
/**
* 设置 增加 部门ID
* @param deptIdIncrement
*/
public MatterApplyQuery deptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
return this;
}
/**
* 设置 部门ID
* @param deptIdList
*/
public MatterApplyQuery deptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
return this;
}
/**
* 设置 部门ID
* @param deptIdNotList
*/
public MatterApplyQuery deptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
return this;
}
/**
* 设置 部门名称
* @param deptName
*/
public MatterApplyQuery deptName(String deptName){
setDeptName(deptName);
return this;
}
/**
* 设置 部门名称
* @param deptNameList
*/
public MatterApplyQuery deptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
return this;
}
/**
* 设置 部门编码
* @param deptCode
*/
public MatterApplyQuery deptCode(String deptCode){
setDeptCode(deptCode);
return this;
}
/**
* 设置 部门编码
* @param deptCodeList
*/
public MatterApplyQuery deptCodeList(List<String> deptCodeList){
this.deptCodeList = deptCodeList;
return this;
}
/**
* 设置 事项主题名称
* @param themeName
*/
public MatterApplyQuery themeName(String themeName){
setThemeName(themeName);
return this;
}
/**
* 设置 事项主题名称
* @param themeNameList
*/
public MatterApplyQuery themeNameList(List<String> themeNameList){
this.themeNameList = themeNameList;
return this;
}
/**
* 设置 事项来源
* @param source
*/
public MatterApplyQuery source(Integer source){
setSource(source);
return this;
}
/**
* 设置 开始 事项来源
* @param sourceStart
*/
public MatterApplyQuery sourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
return this;
}
/**
* 设置 结束 事项来源
* @param sourceEnd
*/
public MatterApplyQuery sourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
return this;
}
/**
* 设置 增加 事项来源
* @param sourceIncrement
*/
public MatterApplyQuery sourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
return this;
}
/**
* 设置 事项来源
* @param sourceList
*/
public MatterApplyQuery sourceList(List<Integer> sourceList){
this.sourceList = sourceList;
return this;
}
/**
* 设置 事项来源
* @param sourceNotList
*/
public MatterApplyQuery sourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
return this;
}
/**
* 设置 申报次数
* @param reportCount
*/
public MatterApplyQuery reportCount(Integer reportCount){
setReportCount(reportCount);
return this;
}
/**
* 设置 开始 申报次数
* @param reportCountStart
*/
public MatterApplyQuery reportCountStart(Integer reportCountStart){
this.reportCountStart = reportCountStart;
return this;
}
/**
* 设置 结束 申报次数
* @param reportCountEnd
*/
public MatterApplyQuery reportCountEnd(Integer reportCountEnd){
this.reportCountEnd = reportCountEnd;
return this;
}
/**
* 设置 增加 申报次数
* @param reportCountIncrement
*/
public MatterApplyQuery reportCountIncrement(Integer reportCountIncrement){
this.reportCountIncrement = reportCountIncrement;
return this;
}
/**
* 设置 申报次数
* @param reportCountList
*/
public MatterApplyQuery reportCountList(List<Integer> reportCountList){
this.reportCountList = reportCountList;
return this;
}
/**
* 设置 申报次数
* @param reportCountNotList
*/
public MatterApplyQuery reportCountNotList(List<Integer> reportCountNotList){
this.reportCountNotList = reportCountNotList;
return this;
}
/**
* 设置 材料数量
* @param datumCount
*/
public MatterApplyQuery datumCount(Integer datumCount){
setDatumCount(datumCount);
return this;
}
/**
* 设置 开始 材料数量
* @param datumCountStart
*/
public MatterApplyQuery datumCountStart(Integer datumCountStart){
this.datumCountStart = datumCountStart;
return this;
}
/**
* 设置 结束 材料数量
* @param datumCountEnd
*/
public MatterApplyQuery datumCountEnd(Integer datumCountEnd){
this.datumCountEnd = datumCountEnd;
return this;
}
/**
* 设置 增加 材料数量
* @param datumCountIncrement
*/
public MatterApplyQuery datumCountIncrement(Integer datumCountIncrement){
this.datumCountIncrement = datumCountIncrement;
return this;
}
/**
* 设置 材料数量
* @param datumCountList
*/
public MatterApplyQuery datumCountList(List<Integer> datumCountList){
this.datumCountList = datumCountList;
return this;
}
/**
* 设置 材料数量
* @param datumCountNotList
*/
public MatterApplyQuery datumCountNotList(List<Integer> datumCountNotList){
this.datumCountNotList = datumCountNotList;
return this;
}
/**
* 设置 政务网地址
* @param govUrl
*/
public MatterApplyQuery govUrl(String govUrl){
setGovUrl(govUrl);
return this;
}
/**
* 设置 政务网地址
* @param govUrlList
*/
public MatterApplyQuery govUrlList(List<String> govUrlList){
this.govUrlList = govUrlList;
return this;
}
/**
* 设置 是否生成本地附件
* @param isConvert
*/
public MatterApplyQuery isConvert(Integer isConvert){
setIsConvert(isConvert);
return this;
}
/**
* 设置 开始 是否生成本地附件
* @param isConvertStart
*/
public MatterApplyQuery isConvertStart(Integer isConvertStart){
this.isConvertStart = isConvertStart;
return this;
}
/**
* 设置 结束 是否生成本地附件
* @param isConvertEnd
*/
public MatterApplyQuery isConvertEnd(Integer isConvertEnd){
this.isConvertEnd = isConvertEnd;
return this;
}
/**
* 设置 增加 是否生成本地附件
* @param isConvertIncrement
*/
public MatterApplyQuery isConvertIncrement(Integer isConvertIncrement){
this.isConvertIncrement = isConvertIncrement;
return this;
}
/**
* 设置 是否生成本地附件
* @param isConvertList
*/
public MatterApplyQuery isConvertList(List<Integer> isConvertList){
this.isConvertList = isConvertList;
return this;
}
/**
* 设置 是否生成本地附件
* @param isConvertNotList
*/
public MatterApplyQuery isConvertNotList(List<Integer> isConvertNotList){
this.isConvertNotList = isConvertNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MatterApplyQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MatterApplyQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MatterApplyQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MatterApplyQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MatterApplyQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MatterApplyQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public MatterApplyQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public MatterApplyQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public MatterApplyQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public MatterApplyQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public MatterApplyQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public MatterApplyQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 设置 事项主题编码
* @param themeCode
*/
public MatterApplyQuery themeCode(String themeCode){
setThemeCode(themeCode);
return this;
}
/**
* 设置 事项主题编码
* @param themeCodeList
*/
public MatterApplyQuery themeCodeList(List<String> themeCodeList){
this.themeCodeList = themeCodeList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MatterApplyQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<MatterApplyQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<MatterApplyQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<MatterApplyQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterDatumEntity.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.vo.MatterDatumVo;
/**
* 事项申请材料业务实体对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterDatumEntity extends MatterDatumVo {
private static final long serialVersionUID = 1L;
/**
* 事项基础表matter id
*/
private Long matterId;
/**
* 材料名
*/
private String materialName;
/**
* 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
*/
private String isMust;
/**
* 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
*/
private String materialType;
/**
* 材料形式（1.纸质，2.电子，3.纸质|电子）
*/
private String materialProperty;
/**
* 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
*/
private String electronicgs;
/**
* 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
*/
private String materialSource;
/**
* 纸质材料份数
*/
private Integer paperNum;
/**
* 纸质材料规格
*/
private String paperGg;
/**
* 减免模式（1.无，2.减，3.免）
*/
private String jianmMs;
/**
* 盖章方式
*/
private String sealWay;
/**
* 是否减免（0.否，1.是）
*/
private String isjianm;
/**
* 材料是否容缺（1.必要，2.非必要）
*/
private String isLack;
/**
* 材料地址
*/
private String ybUrl;
/**
* 来源渠道说明
*/
private String materialSourceSm;
/**
* 填报须知
*/
private String remarkSub;
/**
* 要求提供材料的依据
*/
private String clauseContent;
/**
* 受理标准
*/
private String summary;
/**
* 备注
*/
private String remark;
/**
* 事项来源(0.政务网，1.自定义)
*/
private Integer source;
public MatterDatumEntity(){}
/**
* 获取 事项基础表matter id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 材料名
* @return String
*/
public String getMaterialName(){
return materialName;
}
/**
* 设置 材料名
* @param materialName
*/
public void setMaterialName(String materialName){
this.materialName = materialName;
}
/**
* 获取 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @return String
*/
public String getIsMust(){
return isMust;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMust
*/
public void setIsMust(String isMust){
this.isMust = isMust;
}
/**
* 获取 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @return String
*/
public String getMaterialType(){
return materialType;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialType
*/
public void setMaterialType(String materialType){
this.materialType = materialType;
}
/**
* 获取 材料形式（1.纸质，2.电子，3.纸质|电子）
* @return String
*/
public String getMaterialProperty(){
return materialProperty;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialProperty
*/
public void setMaterialProperty(String materialProperty){
this.materialProperty = materialProperty;
}
/**
* 获取 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @return String
*/
public String getElectronicgs(){
return electronicgs;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgs
*/
public void setElectronicgs(String electronicgs){
this.electronicgs = electronicgs;
}
/**
* 获取 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @return String
*/
public String getMaterialSource(){
return materialSource;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSource
*/
public void setMaterialSource(String materialSource){
this.materialSource = materialSource;
}
/**
* 获取 纸质材料份数
* @return Integer
*/
public Integer getPaperNum(){
return paperNum;
}
/**
* 设置 纸质材料份数
* @param paperNum
*/
public void setPaperNum(Integer paperNum){
this.paperNum = paperNum;
}
/**
* 获取 纸质材料规格
* @return String
*/
public String getPaperGg(){
return paperGg;
}
/**
* 设置 纸质材料规格
* @param paperGg
*/
public void setPaperGg(String paperGg){
this.paperGg = paperGg;
}
/**
* 获取 减免模式（1.无，2.减，3.免）
* @return String
*/
public String getJianmMs(){
return jianmMs;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMs
*/
public void setJianmMs(String jianmMs){
this.jianmMs = jianmMs;
}
/**
* 获取 盖章方式
* @return String
*/
public String getSealWay(){
return sealWay;
}
/**
* 设置 盖章方式
* @param sealWay
*/
public void setSealWay(String sealWay){
this.sealWay = sealWay;
}
/**
* 获取 是否减免（0.否，1.是）
* @return String
*/
public String getIsjianm(){
return isjianm;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianm
*/
public void setIsjianm(String isjianm){
this.isjianm = isjianm;
}
/**
* 获取 材料是否容缺（1.必要，2.非必要）
* @return String
*/
public String getIsLack(){
return isLack;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLack
*/
public void setIsLack(String isLack){
this.isLack = isLack;
}
/**
* 获取 材料地址
* @return String
*/
public String getYbUrl(){
return ybUrl;
}
/**
* 设置 材料地址
* @param ybUrl
*/
public void setYbUrl(String ybUrl){
this.ybUrl = ybUrl;
}
/**
* 获取 来源渠道说明
* @return String
*/
public String getMaterialSourceSm(){
return materialSourceSm;
}
/**
* 设置 来源渠道说明
* @param materialSourceSm
*/
public void setMaterialSourceSm(String materialSourceSm){
this.materialSourceSm = materialSourceSm;
}
/**
* 获取 填报须知
* @return String
*/
public String getRemarkSub(){
return remarkSub;
}
/**
* 设置 填报须知
* @param remarkSub
*/
public void setRemarkSub(String remarkSub){
this.remarkSub = remarkSub;
}
/**
* 获取 要求提供材料的依据
* @return String
*/
public String getClauseContent(){
return clauseContent;
}
/**
* 设置 要求提供材料的依据
* @param clauseContent
*/
public void setClauseContent(String clauseContent){
this.clauseContent = clauseContent;
}
/**
* 获取 受理标准
* @return String
*/
public String getSummary(){
return summary;
}
/**
* 设置 受理标准
* @param summary
*/
public void setSummary(String summary){
this.summary = summary;
}
/**
* 获取 备注
* @return String
*/
public String getRemark(){
return remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark){
this.remark = remark;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterDatumEntity) {
MatterDatumEntity tmp = (MatterDatumEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",matterId:").append(getMatterId());
sb.append(",materialName:").append(getMaterialName());
sb.append(",isMust:").append(getIsMust());
sb.append(",materialType:").append(getMaterialType());
sb.append(",materialProperty:").append(getMaterialProperty());
sb.append(",electronicgs:").append(getElectronicgs());
sb.append(",materialSource:").append(getMaterialSource());
sb.append(",paperNum:").append(getPaperNum());
sb.append(",paperGg:").append(getPaperGg());
sb.append(",jianmMs:").append(getJianmMs());
sb.append(",sealWay:").append(getSealWay());
sb.append(",isjianm:").append(getIsjianm());
sb.append(",isLack:").append(getIsLack());
sb.append(",ybUrl:").append(getYbUrl());
sb.append(",materialSourceSm:").append(getMaterialSourceSm());
sb.append(",remarkSub:").append(getRemarkSub());
sb.append(",clauseContent:").append(getClauseContent());
sb.append(",summary:").append(getSummary());
sb.append(",remark:").append(getRemark());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.matterId = null;
this.materialName = "";
this.isMust = "1";
this.materialType = "1";
this.materialProperty = "1";
this.electronicgs = "1";
this.materialSource = "1";
this.paperNum = 1;
this.paperGg = "";
this.jianmMs = "1";
this.sealWay = "";
this.isjianm = "1";
this.isLack = "1";
this.ybUrl = "";
this.materialSourceSm = "";
this.remarkSub = "";
this.clauseContent = "";
this.summary = "";
this.remark = "";
this.source = 0;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterDatumFileEntity.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.vo.MatterDatumFileVo;
/**
* 材料附件业务实体对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterDatumFileEntity extends MatterDatumFileVo {
private static final long serialVersionUID = 1L;
/**
* 材料id
*/
private Long datumId;
/**
* 事项基础表matter id
*/
private Long matterId;
/**
* 事项编码
*/
private String matterCode;
/**
* 材料名
*/
private String materialName;
/**
* 附件名称
*/
private String fileName;
/**
* 附件下载地址
*/
private String fileUrl;
/**
* 附件类型 (1.示例样表，2.空白表格)
*/
private Integer filetype;
/**
* 附件来源 (0.政务网，1.自定义)
*/
private Integer source;
/**
* 本地文件地址
*/
private String localFileUrl;
/**
* 文件预览地址
*/
private String previewUrl;
public MatterDatumFileEntity(){}
/**
* 获取 材料id
* @return Long
*/
public Long getDatumId(){
return datumId;
}
/**
* 设置 材料id
* @param datumId
*/
public void setDatumId(Long datumId){
this.datumId = datumId;
}
/**
* 获取 事项基础表matter id
* @return Long
*/
public Long getMatterId(){
return matterId;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public void setMatterId(Long matterId){
this.matterId = matterId;
}
/**
* 获取 事项编码
* @return String
*/
public String getMatterCode(){
return matterCode;
}
/**
* 设置 事项编码
* @param matterCode
*/
public void setMatterCode(String matterCode){
this.matterCode = matterCode;
}
/**
* 获取 材料名
* @return String
*/
public String getMaterialName(){
return materialName;
}
/**
* 设置 材料名
* @param materialName
*/
public void setMaterialName(String materialName){
this.materialName = materialName;
}
/**
* 获取 附件名称
* @return String
*/
public String getFileName(){
return fileName;
}
/**
* 设置 附件名称
* @param fileName
*/
public void setFileName(String fileName){
this.fileName = fileName;
}
/**
* 获取 附件下载地址
* @return String
*/
public String getFileUrl(){
return fileUrl;
}
/**
* 设置 附件下载地址
* @param fileUrl
*/
public void setFileUrl(String fileUrl){
this.fileUrl = fileUrl;
}
/**
* 获取 附件类型 (1.示例样表，2.空白表格)
* @return Integer
*/
public Integer getFiletype(){
return filetype;
}
/**
* 设置 附件类型 (1.示例样表，2.空白表格)
* @param filetype
*/
public void setFiletype(Integer filetype){
this.filetype = filetype;
}
/**
* 获取 附件来源 (0.政务网，1.自定义)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 附件来源 (0.政务网，1.自定义)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
/**
* 获取 本地文件地址
* @return String
*/
public String getLocalFileUrl(){
return localFileUrl;
}
/**
* 设置 本地文件地址
* @param localFileUrl
*/
public void setLocalFileUrl(String localFileUrl){
this.localFileUrl = localFileUrl;
}
/**
* 获取 文件预览地址
* @return String
*/
public String getPreviewUrl(){
return previewUrl;
}
/**
* 设置 文件预览地址
* @param previewUrl
*/
public void setPreviewUrl(String previewUrl){
this.previewUrl = previewUrl;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterDatumFileEntity) {
MatterDatumFileEntity tmp = (MatterDatumFileEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",datumId:").append(getDatumId());
sb.append(",matterId:").append(getMatterId());
sb.append(",matterCode:").append(getMatterCode());
sb.append(",materialName:").append(getMaterialName());
sb.append(",fileName:").append(getFileName());
sb.append(",fileUrl:").append(getFileUrl());
sb.append(",filetype:").append(getFiletype());
sb.append(",source:").append(getSource());
sb.append(",localFileUrl:").append(getLocalFileUrl());
sb.append(",previewUrl:").append(getPreviewUrl());
return sb.toString();
}
public void initAttrValue(){
this.datumId = null;
this.matterId = null;
this.matterCode = "";
this.materialName = "";
this.fileName = "";
this.fileUrl = "";
this.filetype = 1;
this.source = 0;
this.localFileUrl = "";
this.previewUrl = "";
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterDatumFileQuery.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
/**
* 材料附件业务查询对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterDatumFileQuery extends MatterDatumFileEntity {
/** 开始 主键，自增长 */
private Long idStart;
/** 结束 主键，自增长 */
private Long idEnd;
/** 增加 主键，自增长 */
private Long idIncrement;
/** 主键，自增长列表 */
private List <Long> idList;
/** 主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 材料id */
private Long datumIdStart;
/** 结束 材料id */
private Long datumIdEnd;
/** 增加 材料id */
private Long datumIdIncrement;
/** 材料id列表 */
private List <Long> datumIdList;
/** 材料id排除列表 */
private List <Long> datumIdNotList;
/** 开始 事项基础表matter id */
private Long matterIdStart;
/** 结束 事项基础表matter id */
private Long matterIdEnd;
/** 增加 事项基础表matter id */
private Long matterIdIncrement;
/** 事项基础表matter id列表 */
private List <Long> matterIdList;
/** 事项基础表matter id排除列表 */
private List <Long> matterIdNotList;
/** 事项编码 */
private List<String> matterCodeList;
/** 事项编码排除列表 */
private List <String> matterCodeNotList;
/** 材料名 */
private List<String> materialNameList;
/** 材料名排除列表 */
private List <String> materialNameNotList;
/** 附件名称 */
private List<String> fileNameList;
/** 附件名称排除列表 */
private List <String> fileNameNotList;
/** 附件下载地址 */
private List<String> fileUrlList;
/** 附件下载地址排除列表 */
private List <String> fileUrlNotList;
/** 开始 附件类型 (1.示例样表，2.空白表格) */
private Integer filetypeStart;
/** 结束 附件类型 (1.示例样表，2.空白表格) */
private Integer filetypeEnd;
/** 增加 附件类型 (1.示例样表，2.空白表格) */
private Integer filetypeIncrement;
/** 附件类型 (1.示例样表，2.空白表格)列表 */
private List <Integer> filetypeList;
/** 附件类型 (1.示例样表，2.空白表格)排除列表 */
private List <Integer> filetypeNotList;
/** 开始 附件来源 (0.政务网，1.自定义) */
private Integer sourceStart;
/** 结束 附件来源 (0.政务网，1.自定义) */
private Integer sourceEnd;
/** 增加 附件来源 (0.政务网，1.自定义) */
private Integer sourceIncrement;
/** 附件来源 (0.政务网，1.自定义)列表 */
private List <Integer> sourceList;
/** 附件来源 (0.政务网，1.自定义)排除列表 */
private List <Integer> sourceNotList;
/** 本地文件地址 */
private List<String> localFileUrlList;
/** 本地文件地址排除列表 */
private List <String> localFileUrlNotList;
/** 文件预览地址 */
private List<String> previewUrlList;
/** 文件预览地址排除列表 */
private List <String> previewUrlNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 修改时间 */
private String updateTimeStart;
/** 结束 修改时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MatterDatumFileQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MatterDatumFileQuery> andConditionList;
public MatterDatumFileQuery(){}
/**
* 获取 开始 主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
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 datumIdStart
*/
public Long getDatumIdStart(){
return this.datumIdStart;
}
/**
* 设置 开始 材料id
* @param datumIdStart
*/
public void setDatumIdStart(Long datumIdStart){
this.datumIdStart = datumIdStart;
}
/**
* 获取 结束 材料id
* @return $datumIdEnd
*/
public Long getDatumIdEnd(){
return this.datumIdEnd;
}
/**
* 设置 结束 材料id
* @param datumIdEnd
*/
public void setDatumIdEnd(Long datumIdEnd){
this.datumIdEnd = datumIdEnd;
}
/**
* 获取 增加 材料id
* @return datumIdIncrement
*/
public Long getDatumIdIncrement(){
return this.datumIdIncrement;
}
/**
* 设置 增加 材料id
* @param datumIdIncrement
*/
public void setDatumIdIncrement(Long datumIdIncrement){
this.datumIdIncrement = datumIdIncrement;
}
/**
* 获取 材料id
* @return datumIdList
*/
public List<Long> getDatumIdList(){
return this.datumIdList;
}
/**
* 设置 材料id
* @param datumIdList
*/
public void setDatumIdList(List<Long> datumIdList){
this.datumIdList = datumIdList;
}
/**
* 获取 材料id
* @return datumIdNotList
*/
public List<Long> getDatumIdNotList(){
return this.datumIdNotList;
}
/**
* 设置 材料id
* @param datumIdNotList
*/
public void setDatumIdNotList(List<Long> datumIdNotList){
this.datumIdNotList = datumIdNotList;
}
/**
* 获取 开始 事项基础表matter id
* @return matterIdStart
*/
public Long getMatterIdStart(){
return this.matterIdStart;
}
/**
* 设置 开始 事项基础表matter id
* @param matterIdStart
*/
public void setMatterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
}
/**
* 获取 结束 事项基础表matter id
* @return $matterIdEnd
*/
public Long getMatterIdEnd(){
return this.matterIdEnd;
}
/**
* 设置 结束 事项基础表matter id
* @param matterIdEnd
*/
public void setMatterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
}
/**
* 获取 增加 事项基础表matter id
* @return matterIdIncrement
*/
public Long getMatterIdIncrement(){
return this.matterIdIncrement;
}
/**
* 设置 增加 事项基础表matter id
* @param matterIdIncrement
*/
public void setMatterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
}
/**
* 获取 事项基础表matter id
* @return matterIdList
*/
public List<Long> getMatterIdList(){
return this.matterIdList;
}
/**
* 设置 事项基础表matter id
* @param matterIdList
*/
public void setMatterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
}
/**
* 获取 事项基础表matter id
* @return matterIdNotList
*/
public List<Long> getMatterIdNotList(){
return this.matterIdNotList;
}
/**
* 设置 事项基础表matter id
* @param matterIdNotList
*/
public void setMatterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
}
/**
* 获取 事项编码
* @return matterCodeList
*/
public List<String> getMatterCodeList(){
return this.matterCodeList;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public void setMatterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
}
/**
* 获取 事项编码
* @return matterCodeNotList
*/
public List<String> getMatterCodeNotList(){
return this.matterCodeNotList;
}
/**
* 设置 事项编码
* @param matterCodeNotList
*/
public void setMatterCodeNotList(List<String> matterCodeNotList){
this.matterCodeNotList = matterCodeNotList;
}
/**
* 获取 材料名
* @return materialNameList
*/
public List<String> getMaterialNameList(){
return this.materialNameList;
}
/**
* 设置 材料名
* @param materialNameList
*/
public void setMaterialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
}
/**
* 获取 材料名
* @return materialNameNotList
*/
public List<String> getMaterialNameNotList(){
return this.materialNameNotList;
}
/**
* 设置 材料名
* @param materialNameNotList
*/
public void setMaterialNameNotList(List<String> materialNameNotList){
this.materialNameNotList = materialNameNotList;
}
/**
* 获取 附件名称
* @return fileNameList
*/
public List<String> getFileNameList(){
return this.fileNameList;
}
/**
* 设置 附件名称
* @param fileNameList
*/
public void setFileNameList(List<String> fileNameList){
this.fileNameList = fileNameList;
}
/**
* 获取 附件名称
* @return fileNameNotList
*/
public List<String> getFileNameNotList(){
return this.fileNameNotList;
}
/**
* 设置 附件名称
* @param fileNameNotList
*/
public void setFileNameNotList(List<String> fileNameNotList){
this.fileNameNotList = fileNameNotList;
}
/**
* 获取 附件下载地址
* @return fileUrlList
*/
public List<String> getFileUrlList(){
return this.fileUrlList;
}
/**
* 设置 附件下载地址
* @param fileUrlList
*/
public void setFileUrlList(List<String> fileUrlList){
this.fileUrlList = fileUrlList;
}
/**
* 获取 附件下载地址
* @return fileUrlNotList
*/
public List<String> getFileUrlNotList(){
return this.fileUrlNotList;
}
/**
* 设置 附件下载地址
* @param fileUrlNotList
*/
public void setFileUrlNotList(List<String> fileUrlNotList){
this.fileUrlNotList = fileUrlNotList;
}
/**
* 获取 开始 附件类型 (1.示例样表，2.空白表格)
* @return filetypeStart
*/
public Integer getFiletypeStart(){
return this.filetypeStart;
}
/**
* 设置 开始 附件类型 (1.示例样表，2.空白表格)
* @param filetypeStart
*/
public void setFiletypeStart(Integer filetypeStart){
this.filetypeStart = filetypeStart;
}
/**
* 获取 结束 附件类型 (1.示例样表，2.空白表格)
* @return $filetypeEnd
*/
public Integer getFiletypeEnd(){
return this.filetypeEnd;
}
/**
* 设置 结束 附件类型 (1.示例样表，2.空白表格)
* @param filetypeEnd
*/
public void setFiletypeEnd(Integer filetypeEnd){
this.filetypeEnd = filetypeEnd;
}
/**
* 获取 增加 附件类型 (1.示例样表，2.空白表格)
* @return filetypeIncrement
*/
public Integer getFiletypeIncrement(){
return this.filetypeIncrement;
}
/**
* 设置 增加 附件类型 (1.示例样表，2.空白表格)
* @param filetypeIncrement
*/
public void setFiletypeIncrement(Integer filetypeIncrement){
this.filetypeIncrement = filetypeIncrement;
}
/**
* 获取 附件类型 (1.示例样表，2.空白表格)
* @return filetypeList
*/
public List<Integer> getFiletypeList(){
return this.filetypeList;
}
/**
* 设置 附件类型 (1.示例样表，2.空白表格)
* @param filetypeList
*/
public void setFiletypeList(List<Integer> filetypeList){
this.filetypeList = filetypeList;
}
/**
* 获取 附件类型 (1.示例样表，2.空白表格)
* @return filetypeNotList
*/
public List<Integer> getFiletypeNotList(){
return this.filetypeNotList;
}
/**
* 设置 附件类型 (1.示例样表，2.空白表格)
* @param filetypeNotList
*/
public void setFiletypeNotList(List<Integer> filetypeNotList){
this.filetypeNotList = filetypeNotList;
}
/**
* 获取 开始 附件来源 (0.政务网，1.自定义)
* @return sourceStart
*/
public Integer getSourceStart(){
return this.sourceStart;
}
/**
* 设置 开始 附件来源 (0.政务网，1.自定义)
* @param sourceStart
*/
public void setSourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
}
/**
* 获取 结束 附件来源 (0.政务网，1.自定义)
* @return $sourceEnd
*/
public Integer getSourceEnd(){
return this.sourceEnd;
}
/**
* 设置 结束 附件来源 (0.政务网，1.自定义)
* @param sourceEnd
*/
public void setSourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
}
/**
* 获取 增加 附件来源 (0.政务网，1.自定义)
* @return sourceIncrement
*/
public Integer getSourceIncrement(){
return this.sourceIncrement;
}
/**
* 设置 增加 附件来源 (0.政务网，1.自定义)
* @param sourceIncrement
*/
public void setSourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
}
/**
* 获取 附件来源 (0.政务网，1.自定义)
* @return sourceList
*/
public List<Integer> getSourceList(){
return this.sourceList;
}
/**
* 设置 附件来源 (0.政务网，1.自定义)
* @param sourceList
*/
public void setSourceList(List<Integer> sourceList){
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 localFileUrlList
*/
public List<String> getLocalFileUrlList(){
return this.localFileUrlList;
}
/**
* 设置 本地文件地址
* @param localFileUrlList
*/
public void setLocalFileUrlList(List<String> localFileUrlList){
this.localFileUrlList = localFileUrlList;
}
/**
* 获取 本地文件地址
* @return localFileUrlNotList
*/
public List<String> getLocalFileUrlNotList(){
return this.localFileUrlNotList;
}
/**
* 设置 本地文件地址
* @param localFileUrlNotList
*/
public void setLocalFileUrlNotList(List<String> localFileUrlNotList){
this.localFileUrlNotList = localFileUrlNotList;
}
/**
* 获取 文件预览地址
* @return previewUrlList
*/
public List<String> getPreviewUrlList(){
return this.previewUrlList;
}
/**
* 设置 文件预览地址
* @param previewUrlList
*/
public void setPreviewUrlList(List<String> previewUrlList){
this.previewUrlList = previewUrlList;
}
/**
* 获取 文件预览地址
* @return previewUrlNotList
*/
public List<String> getPreviewUrlNotList(){
return this.previewUrlNotList;
}
/**
* 设置 文件预览地址
* @param previewUrlNotList
*/
public void setPreviewUrlNotList(List<String> previewUrlNotList){
this.previewUrlNotList = previewUrlNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
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
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 修改时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 修改时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 修改时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 主键，自增长
* @param id
*/
public MatterDatumFileQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 主键，自增长
* @param idStart
*/
public MatterDatumFileQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 主键，自增长
* @param idEnd
*/
public MatterDatumFileQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 主键，自增长
* @param idIncrement
*/
public MatterDatumFileQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 主键，自增长
* @param idList
*/
public MatterDatumFileQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 主键，自增长
* @param idNotList
*/
public MatterDatumFileQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 材料id
* @param datumId
*/
public MatterDatumFileQuery datumId(Long datumId){
setDatumId(datumId);
return this;
}
/**
* 设置 开始 材料id
* @param datumIdStart
*/
public MatterDatumFileQuery datumIdStart(Long datumIdStart){
this.datumIdStart = datumIdStart;
return this;
}
/**
* 设置 结束 材料id
* @param datumIdEnd
*/
public MatterDatumFileQuery datumIdEnd(Long datumIdEnd){
this.datumIdEnd = datumIdEnd;
return this;
}
/**
* 设置 增加 材料id
* @param datumIdIncrement
*/
public MatterDatumFileQuery datumIdIncrement(Long datumIdIncrement){
this.datumIdIncrement = datumIdIncrement;
return this;
}
/**
* 设置 材料id
* @param datumIdList
*/
public MatterDatumFileQuery datumIdList(List<Long> datumIdList){
this.datumIdList = datumIdList;
return this;
}
/**
* 设置 材料id
* @param datumIdNotList
*/
public MatterDatumFileQuery datumIdNotList(List<Long> datumIdNotList){
this.datumIdNotList = datumIdNotList;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public MatterDatumFileQuery matterId(Long matterId){
setMatterId(matterId);
return this;
}
/**
* 设置 开始 事项基础表matter id
* @param matterIdStart
*/
public MatterDatumFileQuery matterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
return this;
}
/**
* 设置 结束 事项基础表matter id
* @param matterIdEnd
*/
public MatterDatumFileQuery matterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
return this;
}
/**
* 设置 增加 事项基础表matter id
* @param matterIdIncrement
*/
public MatterDatumFileQuery matterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterIdList
*/
public MatterDatumFileQuery matterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterIdNotList
*/
public MatterDatumFileQuery matterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
return this;
}
/**
* 设置 事项编码
* @param matterCode
*/
public MatterDatumFileQuery matterCode(String matterCode){
setMatterCode(matterCode);
return this;
}
/**
* 设置 事项编码
* @param matterCodeList
*/
public MatterDatumFileQuery matterCodeList(List<String> matterCodeList){
this.matterCodeList = matterCodeList;
return this;
}
/**
* 设置 材料名
* @param materialName
*/
public MatterDatumFileQuery materialName(String materialName){
setMaterialName(materialName);
return this;
}
/**
* 设置 材料名
* @param materialNameList
*/
public MatterDatumFileQuery materialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
return this;
}
/**
* 设置 附件名称
* @param fileName
*/
public MatterDatumFileQuery fileName(String fileName){
setFileName(fileName);
return this;
}
/**
* 设置 附件名称
* @param fileNameList
*/
public MatterDatumFileQuery fileNameList(List<String> fileNameList){
this.fileNameList = fileNameList;
return this;
}
/**
* 设置 附件下载地址
* @param fileUrl
*/
public MatterDatumFileQuery fileUrl(String fileUrl){
setFileUrl(fileUrl);
return this;
}
/**
* 设置 附件下载地址
* @param fileUrlList
*/
public MatterDatumFileQuery fileUrlList(List<String> fileUrlList){
this.fileUrlList = fileUrlList;
return this;
}
/**
* 设置 附件类型 (1.示例样表，2.空白表格)
* @param filetype
*/
public MatterDatumFileQuery filetype(Integer filetype){
setFiletype(filetype);
return this;
}
/**
* 设置 开始 附件类型 (1.示例样表，2.空白表格)
* @param filetypeStart
*/
public MatterDatumFileQuery filetypeStart(Integer filetypeStart){
this.filetypeStart = filetypeStart;
return this;
}
/**
* 设置 结束 附件类型 (1.示例样表，2.空白表格)
* @param filetypeEnd
*/
public MatterDatumFileQuery filetypeEnd(Integer filetypeEnd){
this.filetypeEnd = filetypeEnd;
return this;
}
/**
* 设置 增加 附件类型 (1.示例样表，2.空白表格)
* @param filetypeIncrement
*/
public MatterDatumFileQuery filetypeIncrement(Integer filetypeIncrement){
this.filetypeIncrement = filetypeIncrement;
return this;
}
/**
* 设置 附件类型 (1.示例样表，2.空白表格)
* @param filetypeList
*/
public MatterDatumFileQuery filetypeList(List<Integer> filetypeList){
this.filetypeList = filetypeList;
return this;
}
/**
* 设置 附件类型 (1.示例样表，2.空白表格)
* @param filetypeNotList
*/
public MatterDatumFileQuery filetypeNotList(List<Integer> filetypeNotList){
this.filetypeNotList = filetypeNotList;
return this;
}
/**
* 设置 附件来源 (0.政务网，1.自定义)
* @param source
*/
public MatterDatumFileQuery source(Integer source){
setSource(source);
return this;
}
/**
* 设置 开始 附件来源 (0.政务网，1.自定义)
* @param sourceStart
*/
public MatterDatumFileQuery sourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
return this;
}
/**
* 设置 结束 附件来源 (0.政务网，1.自定义)
* @param sourceEnd
*/
public MatterDatumFileQuery sourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
return this;
}
/**
* 设置 增加 附件来源 (0.政务网，1.自定义)
* @param sourceIncrement
*/
public MatterDatumFileQuery sourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
return this;
}
/**
* 设置 附件来源 (0.政务网，1.自定义)
* @param sourceList
*/
public MatterDatumFileQuery sourceList(List<Integer> sourceList){
this.sourceList = sourceList;
return this;
}
/**
* 设置 附件来源 (0.政务网，1.自定义)
* @param sourceNotList
*/
public MatterDatumFileQuery sourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
return this;
}
/**
* 设置 本地文件地址
* @param localFileUrl
*/
public MatterDatumFileQuery localFileUrl(String localFileUrl){
setLocalFileUrl(localFileUrl);
return this;
}
/**
* 设置 本地文件地址
* @param localFileUrlList
*/
public MatterDatumFileQuery localFileUrlList(List<String> localFileUrlList){
this.localFileUrlList = localFileUrlList;
return this;
}
/**
* 设置 文件预览地址
* @param previewUrl
*/
public MatterDatumFileQuery previewUrl(String previewUrl){
setPreviewUrl(previewUrl);
return this;
}
/**
* 设置 文件预览地址
* @param previewUrlList
*/
public MatterDatumFileQuery previewUrlList(List<String> previewUrlList){
this.previewUrlList = previewUrlList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MatterDatumFileQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MatterDatumFileQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MatterDatumFileQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MatterDatumFileQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MatterDatumFileQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MatterDatumFileQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MatterDatumFileQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<MatterDatumFileQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<MatterDatumFileQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<MatterDatumFileQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/MatterDatumQuery.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model;
import java.util.List;
import com.mortals.xhx.module.matter.model.MatterDatumEntity;
/**
* 事项申请材料业务查询对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterDatumQuery extends MatterDatumEntity {
/** 开始 主键，自增长 */
private Long idStart;
/** 结束 主键，自增长 */
private Long idEnd;
/** 增加 主键，自增长 */
private Long idIncrement;
/** 主键，自增长列表 */
private List <Long> idList;
/** 主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 事项基础表matter id */
private Long matterIdStart;
/** 结束 事项基础表matter id */
private Long matterIdEnd;
/** 增加 事项基础表matter id */
private Long matterIdIncrement;
/** 事项基础表matter id列表 */
private List <Long> matterIdList;
/** 事项基础表matter id排除列表 */
private List <Long> matterIdNotList;
/** 材料名 */
private List<String> materialNameList;
/** 材料名排除列表 */
private List <String> materialNameNotList;
/** 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补） */
private List<String> isMustList;
/** 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）排除列表 */
private List <String> isMustNotList;
/** 材料类型（1.无，2.原件，3.复印件，4.原件和复印件) */
private List<String> materialTypeList;
/** 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)排除列表 */
private List <String> materialTypeNotList;
/** 材料形式（1.纸质，2.电子，3.纸质|电子） */
private List<String> materialPropertyList;
/** 材料形式（1.纸质，2.电子，3.纸质|电子）排除列表 */
private List <String> materialPropertyNotList;
/** 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg） */
private List<String> electronicgsList;
/** 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）排除列表 */
private List <String> electronicgsNotList;
/** 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他） */
private List<String> materialSourceList;
/** 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）排除列表 */
private List <String> materialSourceNotList;
/** 开始 纸质材料份数 */
private Integer paperNumStart;
/** 结束 纸质材料份数 */
private Integer paperNumEnd;
/** 增加 纸质材料份数 */
private Integer paperNumIncrement;
/** 纸质材料份数列表 */
private List <Integer> paperNumList;
/** 纸质材料份数排除列表 */
private List <Integer> paperNumNotList;
/** 纸质材料规格 */
private List<String> paperGgList;
/** 纸质材料规格排除列表 */
private List <String> paperGgNotList;
/** 减免模式（1.无，2.减，3.免） */
private List<String> jianmMsList;
/** 减免模式（1.无，2.减，3.免）排除列表 */
private List <String> jianmMsNotList;
/** 盖章方式 */
private List<String> sealWayList;
/** 盖章方式排除列表 */
private List <String> sealWayNotList;
/** 是否减免（0.否，1.是） */
private List<String> isjianmList;
/** 是否减免（0.否，1.是）排除列表 */
private List <String> isjianmNotList;
/** 材料是否容缺（1.必要，2.非必要） */
private List<String> isLackList;
/** 材料是否容缺（1.必要，2.非必要）排除列表 */
private List <String> isLackNotList;
/** 材料地址 */
private List<String> ybUrlList;
/** 材料地址排除列表 */
private List <String> ybUrlNotList;
/** 来源渠道说明 */
private List<String> materialSourceSmList;
/** 来源渠道说明排除列表 */
private List <String> materialSourceSmNotList;
/** 填报须知 */
private List<String> remarkSubList;
/** 填报须知排除列表 */
private List <String> remarkSubNotList;
/** 要求提供材料的依据 */
private List<String> clauseContentList;
/** 要求提供材料的依据排除列表 */
private List <String> clauseContentNotList;
/** 受理标准 */
private List<String> summaryList;
/** 受理标准排除列表 */
private List <String> summaryNotList;
/** 备注 */
private List<String> remarkList;
/** 备注排除列表 */
private List <String> remarkNotList;
/** 开始 事项来源(0.政务网，1.自定义) */
private Integer sourceStart;
/** 结束 事项来源(0.政务网，1.自定义) */
private Integer sourceEnd;
/** 增加 事项来源(0.政务网，1.自定义) */
private Integer sourceIncrement;
/** 事项来源(0.政务网，1.自定义)列表 */
private List <Integer> sourceList;
/** 事项来源(0.政务网，1.自定义)排除列表 */
private List <Integer> sourceNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 修改时间 */
private String updateTimeStart;
/** 结束 修改时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MatterDatumQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MatterDatumQuery> andConditionList;
public MatterDatumQuery(){}
/**
* 获取 开始 主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 事项基础表matter id
* @return matterIdStart
*/
public Long getMatterIdStart(){
return this.matterIdStart;
}
/**
* 设置 开始 事项基础表matter id
* @param matterIdStart
*/
public void setMatterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
}
/**
* 获取 结束 事项基础表matter id
* @return $matterIdEnd
*/
public Long getMatterIdEnd(){
return this.matterIdEnd;
}
/**
* 设置 结束 事项基础表matter id
* @param matterIdEnd
*/
public void setMatterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
}
/**
* 获取 增加 事项基础表matter id
* @return matterIdIncrement
*/
public Long getMatterIdIncrement(){
return this.matterIdIncrement;
}
/**
* 设置 增加 事项基础表matter id
* @param matterIdIncrement
*/
public void setMatterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
}
/**
* 获取 事项基础表matter id
* @return matterIdList
*/
public List<Long> getMatterIdList(){
return this.matterIdList;
}
/**
* 设置 事项基础表matter id
* @param matterIdList
*/
public void setMatterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
}
/**
* 获取 事项基础表matter id
* @return matterIdNotList
*/
public List<Long> getMatterIdNotList(){
return this.matterIdNotList;
}
/**
* 设置 事项基础表matter id
* @param matterIdNotList
*/
public void setMatterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
}
/**
* 获取 材料名
* @return materialNameList
*/
public List<String> getMaterialNameList(){
return this.materialNameList;
}
/**
* 设置 材料名
* @param materialNameList
*/
public void setMaterialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
}
/**
* 获取 材料名
* @return materialNameNotList
*/
public List<String> getMaterialNameNotList(){
return this.materialNameNotList;
}
/**
* 设置 材料名
* @param materialNameNotList
*/
public void setMaterialNameNotList(List<String> materialNameNotList){
this.materialNameNotList = materialNameNotList;
}
/**
* 获取 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @return isMustList
*/
public List<String> getIsMustList(){
return this.isMustList;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMustList
*/
public void setIsMustList(List<String> isMustList){
this.isMustList = isMustList;
}
/**
* 获取 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @return isMustNotList
*/
public List<String> getIsMustNotList(){
return this.isMustNotList;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMustNotList
*/
public void setIsMustNotList(List<String> isMustNotList){
this.isMustNotList = isMustNotList;
}
/**
* 获取 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @return materialTypeList
*/
public List<String> getMaterialTypeList(){
return this.materialTypeList;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialTypeList
*/
public void setMaterialTypeList(List<String> materialTypeList){
this.materialTypeList = materialTypeList;
}
/**
* 获取 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @return materialTypeNotList
*/
public List<String> getMaterialTypeNotList(){
return this.materialTypeNotList;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialTypeNotList
*/
public void setMaterialTypeNotList(List<String> materialTypeNotList){
this.materialTypeNotList = materialTypeNotList;
}
/**
* 获取 材料形式（1.纸质，2.电子，3.纸质|电子）
* @return materialPropertyList
*/
public List<String> getMaterialPropertyList(){
return this.materialPropertyList;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialPropertyList
*/
public void setMaterialPropertyList(List<String> materialPropertyList){
this.materialPropertyList = materialPropertyList;
}
/**
* 获取 材料形式（1.纸质，2.电子，3.纸质|电子）
* @return materialPropertyNotList
*/
public List<String> getMaterialPropertyNotList(){
return this.materialPropertyNotList;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialPropertyNotList
*/
public void setMaterialPropertyNotList(List<String> materialPropertyNotList){
this.materialPropertyNotList = materialPropertyNotList;
}
/**
* 获取 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @return electronicgsList
*/
public List<String> getElectronicgsList(){
return this.electronicgsList;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgsList
*/
public void setElectronicgsList(List<String> electronicgsList){
this.electronicgsList = electronicgsList;
}
/**
* 获取 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @return electronicgsNotList
*/
public List<String> getElectronicgsNotList(){
return this.electronicgsNotList;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgsNotList
*/
public void setElectronicgsNotList(List<String> electronicgsNotList){
this.electronicgsNotList = electronicgsNotList;
}
/**
* 获取 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @return materialSourceList
*/
public List<String> getMaterialSourceList(){
return this.materialSourceList;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSourceList
*/
public void setMaterialSourceList(List<String> materialSourceList){
this.materialSourceList = materialSourceList;
}
/**
* 获取 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @return materialSourceNotList
*/
public List<String> getMaterialSourceNotList(){
return this.materialSourceNotList;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSourceNotList
*/
public void setMaterialSourceNotList(List<String> materialSourceNotList){
this.materialSourceNotList = materialSourceNotList;
}
/**
* 获取 开始 纸质材料份数
* @return paperNumStart
*/
public Integer getPaperNumStart(){
return this.paperNumStart;
}
/**
* 设置 开始 纸质材料份数
* @param paperNumStart
*/
public void setPaperNumStart(Integer paperNumStart){
this.paperNumStart = paperNumStart;
}
/**
* 获取 结束 纸质材料份数
* @return $paperNumEnd
*/
public Integer getPaperNumEnd(){
return this.paperNumEnd;
}
/**
* 设置 结束 纸质材料份数
* @param paperNumEnd
*/
public void setPaperNumEnd(Integer paperNumEnd){
this.paperNumEnd = paperNumEnd;
}
/**
* 获取 增加 纸质材料份数
* @return paperNumIncrement
*/
public Integer getPaperNumIncrement(){
return this.paperNumIncrement;
}
/**
* 设置 增加 纸质材料份数
* @param paperNumIncrement
*/
public void setPaperNumIncrement(Integer paperNumIncrement){
this.paperNumIncrement = paperNumIncrement;
}
/**
* 获取 纸质材料份数
* @return paperNumList
*/
public List<Integer> getPaperNumList(){
return this.paperNumList;
}
/**
* 设置 纸质材料份数
* @param paperNumList
*/
public void setPaperNumList(List<Integer> paperNumList){
this.paperNumList = paperNumList;
}
/**
* 获取 纸质材料份数
* @return paperNumNotList
*/
public List<Integer> getPaperNumNotList(){
return this.paperNumNotList;
}
/**
* 设置 纸质材料份数
* @param paperNumNotList
*/
public void setPaperNumNotList(List<Integer> paperNumNotList){
this.paperNumNotList = paperNumNotList;
}
/**
* 获取 纸质材料规格
* @return paperGgList
*/
public List<String> getPaperGgList(){
return this.paperGgList;
}
/**
* 设置 纸质材料规格
* @param paperGgList
*/
public void setPaperGgList(List<String> paperGgList){
this.paperGgList = paperGgList;
}
/**
* 获取 纸质材料规格
* @return paperGgNotList
*/
public List<String> getPaperGgNotList(){
return this.paperGgNotList;
}
/**
* 设置 纸质材料规格
* @param paperGgNotList
*/
public void setPaperGgNotList(List<String> paperGgNotList){
this.paperGgNotList = paperGgNotList;
}
/**
* 获取 减免模式（1.无，2.减，3.免）
* @return jianmMsList
*/
public List<String> getJianmMsList(){
return this.jianmMsList;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMsList
*/
public void setJianmMsList(List<String> jianmMsList){
this.jianmMsList = jianmMsList;
}
/**
* 获取 减免模式（1.无，2.减，3.免）
* @return jianmMsNotList
*/
public List<String> getJianmMsNotList(){
return this.jianmMsNotList;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMsNotList
*/
public void setJianmMsNotList(List<String> jianmMsNotList){
this.jianmMsNotList = jianmMsNotList;
}
/**
* 获取 盖章方式
* @return sealWayList
*/
public List<String> getSealWayList(){
return this.sealWayList;
}
/**
* 设置 盖章方式
* @param sealWayList
*/
public void setSealWayList(List<String> sealWayList){
this.sealWayList = sealWayList;
}
/**
* 获取 盖章方式
* @return sealWayNotList
*/
public List<String> getSealWayNotList(){
return this.sealWayNotList;
}
/**
* 设置 盖章方式
* @param sealWayNotList
*/
public void setSealWayNotList(List<String> sealWayNotList){
this.sealWayNotList = sealWayNotList;
}
/**
* 获取 是否减免（0.否，1.是）
* @return isjianmList
*/
public List<String> getIsjianmList(){
return this.isjianmList;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianmList
*/
public void setIsjianmList(List<String> isjianmList){
this.isjianmList = isjianmList;
}
/**
* 获取 是否减免（0.否，1.是）
* @return isjianmNotList
*/
public List<String> getIsjianmNotList(){
return this.isjianmNotList;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianmNotList
*/
public void setIsjianmNotList(List<String> isjianmNotList){
this.isjianmNotList = isjianmNotList;
}
/**
* 获取 材料是否容缺（1.必要，2.非必要）
* @return isLackList
*/
public List<String> getIsLackList(){
return this.isLackList;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLackList
*/
public void setIsLackList(List<String> isLackList){
this.isLackList = isLackList;
}
/**
* 获取 材料是否容缺（1.必要，2.非必要）
* @return isLackNotList
*/
public List<String> getIsLackNotList(){
return this.isLackNotList;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLackNotList
*/
public void setIsLackNotList(List<String> isLackNotList){
this.isLackNotList = isLackNotList;
}
/**
* 获取 材料地址
* @return ybUrlList
*/
public List<String> getYbUrlList(){
return this.ybUrlList;
}
/**
* 设置 材料地址
* @param ybUrlList
*/
public void setYbUrlList(List<String> ybUrlList){
this.ybUrlList = ybUrlList;
}
/**
* 获取 材料地址
* @return ybUrlNotList
*/
public List<String> getYbUrlNotList(){
return this.ybUrlNotList;
}
/**
* 设置 材料地址
* @param ybUrlNotList
*/
public void setYbUrlNotList(List<String> ybUrlNotList){
this.ybUrlNotList = ybUrlNotList;
}
/**
* 获取 来源渠道说明
* @return materialSourceSmList
*/
public List<String> getMaterialSourceSmList(){
return this.materialSourceSmList;
}
/**
* 设置 来源渠道说明
* @param materialSourceSmList
*/
public void setMaterialSourceSmList(List<String> materialSourceSmList){
this.materialSourceSmList = materialSourceSmList;
}
/**
* 获取 来源渠道说明
* @return materialSourceSmNotList
*/
public List<String> getMaterialSourceSmNotList(){
return this.materialSourceSmNotList;
}
/**
* 设置 来源渠道说明
* @param materialSourceSmNotList
*/
public void setMaterialSourceSmNotList(List<String> materialSourceSmNotList){
this.materialSourceSmNotList = materialSourceSmNotList;
}
/**
* 获取 填报须知
* @return remarkSubList
*/
public List<String> getRemarkSubList(){
return this.remarkSubList;
}
/**
* 设置 填报须知
* @param remarkSubList
*/
public void setRemarkSubList(List<String> remarkSubList){
this.remarkSubList = remarkSubList;
}
/**
* 获取 填报须知
* @return remarkSubNotList
*/
public List<String> getRemarkSubNotList(){
return this.remarkSubNotList;
}
/**
* 设置 填报须知
* @param remarkSubNotList
*/
public void setRemarkSubNotList(List<String> remarkSubNotList){
this.remarkSubNotList = remarkSubNotList;
}
/**
* 获取 要求提供材料的依据
* @return clauseContentList
*/
public List<String> getClauseContentList(){
return this.clauseContentList;
}
/**
* 设置 要求提供材料的依据
* @param clauseContentList
*/
public void setClauseContentList(List<String> clauseContentList){
this.clauseContentList = clauseContentList;
}
/**
* 获取 要求提供材料的依据
* @return clauseContentNotList
*/
public List<String> getClauseContentNotList(){
return this.clauseContentNotList;
}
/**
* 设置 要求提供材料的依据
* @param clauseContentNotList
*/
public void setClauseContentNotList(List<String> clauseContentNotList){
this.clauseContentNotList = clauseContentNotList;
}
/**
* 获取 受理标准
* @return summaryList
*/
public List<String> getSummaryList(){
return this.summaryList;
}
/**
* 设置 受理标准
* @param summaryList
*/
public void setSummaryList(List<String> summaryList){
this.summaryList = summaryList;
}
/**
* 获取 受理标准
* @return summaryNotList
*/
public List<String> getSummaryNotList(){
return this.summaryNotList;
}
/**
* 设置 受理标准
* @param summaryNotList
*/
public void setSummaryNotList(List<String> summaryNotList){
this.summaryNotList = summaryNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 事项来源(0.政务网，1.自定义)
* @return sourceStart
*/
public Integer getSourceStart(){
return this.sourceStart;
}
/**
* 设置 开始 事项来源(0.政务网，1.自定义)
* @param sourceStart
*/
public void setSourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
}
/**
* 获取 结束 事项来源(0.政务网，1.自定义)
* @return $sourceEnd
*/
public Integer getSourceEnd(){
return this.sourceEnd;
}
/**
* 设置 结束 事项来源(0.政务网，1.自定义)
* @param sourceEnd
*/
public void setSourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
}
/**
* 获取 增加 事项来源(0.政务网，1.自定义)
* @return sourceIncrement
*/
public Integer getSourceIncrement(){
return this.sourceIncrement;
}
/**
* 设置 增加 事项来源(0.政务网，1.自定义)
* @param sourceIncrement
*/
public void setSourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
}
/**
* 获取 事项来源(0.政务网，1.自定义)
* @return sourceList
*/
public List<Integer> getSourceList(){
return this.sourceList;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param sourceList
*/
public void setSourceList(List<Integer> sourceList){
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
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
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
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 修改时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 修改时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 修改时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 主键，自增长
* @param id
*/
public MatterDatumQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 主键，自增长
* @param idStart
*/
public MatterDatumQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 主键，自增长
* @param idEnd
*/
public MatterDatumQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 主键，自增长
* @param idIncrement
*/
public MatterDatumQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 主键，自增长
* @param idList
*/
public MatterDatumQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 主键，自增长
* @param idNotList
*/
public MatterDatumQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterId
*/
public MatterDatumQuery matterId(Long matterId){
setMatterId(matterId);
return this;
}
/**
* 设置 开始 事项基础表matter id
* @param matterIdStart
*/
public MatterDatumQuery matterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
return this;
}
/**
* 设置 结束 事项基础表matter id
* @param matterIdEnd
*/
public MatterDatumQuery matterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
return this;
}
/**
* 设置 增加 事项基础表matter id
* @param matterIdIncrement
*/
public MatterDatumQuery matterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterIdList
*/
public MatterDatumQuery matterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
return this;
}
/**
* 设置 事项基础表matter id
* @param matterIdNotList
*/
public MatterDatumQuery matterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
return this;
}
/**
* 设置 材料名
* @param materialName
*/
public MatterDatumQuery materialName(String materialName){
setMaterialName(materialName);
return this;
}
/**
* 设置 材料名
* @param materialNameList
*/
public MatterDatumQuery materialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
return this;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMust
*/
public MatterDatumQuery isMust(String isMust){
setIsMust(isMust);
return this;
}
/**
* 设置 必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）
* @param isMustList
*/
public MatterDatumQuery isMustList(List<String> isMustList){
this.isMustList = isMustList;
return this;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialType
*/
public MatterDatumQuery materialType(String materialType){
setMaterialType(materialType);
return this;
}
/**
* 设置 材料类型（1.无，2.原件，3.复印件，4.原件和复印件)
* @param materialTypeList
*/
public MatterDatumQuery materialTypeList(List<String> materialTypeList){
this.materialTypeList = materialTypeList;
return this;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialProperty
*/
public MatterDatumQuery materialProperty(String materialProperty){
setMaterialProperty(materialProperty);
return this;
}
/**
* 设置 材料形式（1.纸质，2.电子，3.纸质|电子）
* @param materialPropertyList
*/
public MatterDatumQuery materialPropertyList(List<String> materialPropertyList){
this.materialPropertyList = materialPropertyList;
return this;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgs
*/
public MatterDatumQuery electronicgs(String electronicgs){
setElectronicgs(electronicgs);
return this;
}
/**
* 设置 电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）
* @param electronicgsList
*/
public MatterDatumQuery electronicgsList(List<String> electronicgsList){
this.electronicgsList = electronicgsList;
return this;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSource
*/
public MatterDatumQuery materialSource(String materialSource){
setMaterialSource(materialSource);
return this;
}
/**
* 设置 材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）
* @param materialSourceList
*/
public MatterDatumQuery materialSourceList(List<String> materialSourceList){
this.materialSourceList = materialSourceList;
return this;
}
/**
* 设置 纸质材料份数
* @param paperNum
*/
public MatterDatumQuery paperNum(Integer paperNum){
setPaperNum(paperNum);
return this;
}
/**
* 设置 开始 纸质材料份数
* @param paperNumStart
*/
public MatterDatumQuery paperNumStart(Integer paperNumStart){
this.paperNumStart = paperNumStart;
return this;
}
/**
* 设置 结束 纸质材料份数
* @param paperNumEnd
*/
public MatterDatumQuery paperNumEnd(Integer paperNumEnd){
this.paperNumEnd = paperNumEnd;
return this;
}
/**
* 设置 增加 纸质材料份数
* @param paperNumIncrement
*/
public MatterDatumQuery paperNumIncrement(Integer paperNumIncrement){
this.paperNumIncrement = paperNumIncrement;
return this;
}
/**
* 设置 纸质材料份数
* @param paperNumList
*/
public MatterDatumQuery paperNumList(List<Integer> paperNumList){
this.paperNumList = paperNumList;
return this;
}
/**
* 设置 纸质材料份数
* @param paperNumNotList
*/
public MatterDatumQuery paperNumNotList(List<Integer> paperNumNotList){
this.paperNumNotList = paperNumNotList;
return this;
}
/**
* 设置 纸质材料规格
* @param paperGg
*/
public MatterDatumQuery paperGg(String paperGg){
setPaperGg(paperGg);
return this;
}
/**
* 设置 纸质材料规格
* @param paperGgList
*/
public MatterDatumQuery paperGgList(List<String> paperGgList){
this.paperGgList = paperGgList;
return this;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMs
*/
public MatterDatumQuery jianmMs(String jianmMs){
setJianmMs(jianmMs);
return this;
}
/**
* 设置 减免模式（1.无，2.减，3.免）
* @param jianmMsList
*/
public MatterDatumQuery jianmMsList(List<String> jianmMsList){
this.jianmMsList = jianmMsList;
return this;
}
/**
* 设置 盖章方式
* @param sealWay
*/
public MatterDatumQuery sealWay(String sealWay){
setSealWay(sealWay);
return this;
}
/**
* 设置 盖章方式
* @param sealWayList
*/
public MatterDatumQuery sealWayList(List<String> sealWayList){
this.sealWayList = sealWayList;
return this;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianm
*/
public MatterDatumQuery isjianm(String isjianm){
setIsjianm(isjianm);
return this;
}
/**
* 设置 是否减免（0.否，1.是）
* @param isjianmList
*/
public MatterDatumQuery isjianmList(List<String> isjianmList){
this.isjianmList = isjianmList;
return this;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLack
*/
public MatterDatumQuery isLack(String isLack){
setIsLack(isLack);
return this;
}
/**
* 设置 材料是否容缺（1.必要，2.非必要）
* @param isLackList
*/
public MatterDatumQuery isLackList(List<String> isLackList){
this.isLackList = isLackList;
return this;
}
/**
* 设置 材料地址
* @param ybUrl
*/
public MatterDatumQuery ybUrl(String ybUrl){
setYbUrl(ybUrl);
return this;
}
/**
* 设置 材料地址
* @param ybUrlList
*/
public MatterDatumQuery ybUrlList(List<String> ybUrlList){
this.ybUrlList = ybUrlList;
return this;
}
/**
* 设置 来源渠道说明
* @param materialSourceSm
*/
public MatterDatumQuery materialSourceSm(String materialSourceSm){
setMaterialSourceSm(materialSourceSm);
return this;
}
/**
* 设置 来源渠道说明
* @param materialSourceSmList
*/
public MatterDatumQuery materialSourceSmList(List<String> materialSourceSmList){
this.materialSourceSmList = materialSourceSmList;
return this;
}
/**
* 设置 填报须知
* @param remarkSub
*/
public MatterDatumQuery remarkSub(String remarkSub){
setRemarkSub(remarkSub);
return this;
}
/**
* 设置 填报须知
* @param remarkSubList
*/
public MatterDatumQuery remarkSubList(List<String> remarkSubList){
this.remarkSubList = remarkSubList;
return this;
}
/**
* 设置 要求提供材料的依据
* @param clauseContent
*/
public MatterDatumQuery clauseContent(String clauseContent){
setClauseContent(clauseContent);
return this;
}
/**
* 设置 要求提供材料的依据
* @param clauseContentList
*/
public MatterDatumQuery clauseContentList(List<String> clauseContentList){
this.clauseContentList = clauseContentList;
return this;
}
/**
* 设置 受理标准
* @param summary
*/
public MatterDatumQuery summary(String summary){
setSummary(summary);
return this;
}
/**
* 设置 受理标准
* @param summaryList
*/
public MatterDatumQuery summaryList(List<String> summaryList){
this.summaryList = summaryList;
return this;
}
/**
* 设置 备注
* @param remark
*/
public MatterDatumQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public MatterDatumQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param source
*/
public MatterDatumQuery source(Integer source){
setSource(source);
return this;
}
/**
* 设置 开始 事项来源(0.政务网，1.自定义)
* @param sourceStart
*/
public MatterDatumQuery sourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
return this;
}
/**
* 设置 结束 事项来源(0.政务网，1.自定义)
* @param sourceEnd
*/
public MatterDatumQuery sourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
return this;
}
/**
* 设置 增加 事项来源(0.政务网，1.自定义)
* @param sourceIncrement
*/
public MatterDatumQuery sourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
return this;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param sourceList
*/
public MatterDatumQuery sourceList(List<Integer> sourceList){
this.sourceList = sourceList;
return this;
}
/**
* 设置 事项来源(0.政务网，1.自定义)
* @param sourceNotList
*/
public MatterDatumQuery sourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MatterDatumQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MatterDatumQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MatterDatumQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MatterDatumQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MatterDatumQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MatterDatumQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MatterDatumQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<MatterDatumQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<MatterDatumQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<MatterDatumQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/vo/DatumLibraryVo.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
/**
* 站点材料公共库视图对象
*
* @author zxfei
* @date 2023-04-07
*/
@Data
public class DatumLibraryVo extends BaseEntityLong {
private List<MatterDatumFileEntity> matterDatumFileList;
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/vo/MatterApplyVo.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
/**
* 申报事项视图对象
*
* @author zxfei
* @date 2023-04-07
*/
@Data
public class MatterApplyVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/vo/MatterDatumFileVo.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import java.util.ArrayList;
import java.util.List;
/**
* 材料附件业务视图对象
*
* @author zxfei
* @date 2023-04-07
*/
public class MatterDatumFileVo extends BaseEntityLong {
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/model/vo/MatterDatumVo.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.matter.model.MatterDatumEntity;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
/**
* 事项申请材料业务视图对象
*
* @author zxfei
* @date 2023-04-07
*/
@Data
public class MatterDatumVo extends BaseEntityLong {
private List<MatterDatumFileEntity> matterDatumFileList;
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/DatumLibraryService.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
/**
* DatumLibraryService
*
* 站点材料公共库 service接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface DatumLibraryService extends ICRUDService<DatumLibraryEntity,Long>{
/**
* 添加公共库到材料
*
* @param libraryIds
* @param context
*/
Rest<String> addToMatterDatum(String libraryIds, Context context);
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/MatterApplyService.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
/**
* MatterApplyService
*
* 申报事项 service接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface MatterApplyService extends ICRUDService<MatterApplyEntity,Long>{
/**
* 添加事项到申报事项
*
* @param siteMatterIds
* @param context
*/
Rest<String> addToAssist(String siteMatterIds, Context context);
/**
* 增加申报次数
* @param id
*/
void addReportCount(Long id);
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/MatterDatumFileService.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
/**
* MatterDatumFileService
*
* 材料附件业务 service接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface MatterDatumFileService extends ICRUDService<MatterDatumFileEntity,Long>{
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/MatterDatumService.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.matter.model.MatterDatumEntity;
/**
* MatterDatumService
*
* 事项申请材料业务 service接口
*
* @author zxfei
* @date 2023-04-07
*/
public interface MatterDatumService extends ICRUDService<MatterDatumEntity,Long>{
/**
* 添加材料到公共库
*
* @param datumIds
* @param siteId
* @param context
*/
Rest<String> addToLibrary(String datumIds, Long siteId, Context context);
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/impl/DatumLibraryServiceImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service.impl;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.PageInfo;
import com.mortals.xhx.common.utils.BeanUtil;
import com.mortals.xhx.module.matter.model.*;
import com.mortals.xhx.module.matter.service.MatterApplyService;
import com.mortals.xhx.module.matter.service.MatterDatumFileService;
import com.mortals.xhx.module.matter.service.MatterDatumService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.matter.dao.DatumLibraryDao;
import com.mortals.xhx.module.matter.service.DatumLibraryService;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* DatumLibraryService
* 站点材料公共库 service实现
*
* @author zxfei
* @date 2023-04-07
*/
@Service("datumLibraryService")
public class DatumLibraryServiceImpl extends AbstractCRUDServiceImpl<DatumLibraryDao, DatumLibraryEntity, Long> implements DatumLibraryService {
@Autowired
private MatterApplyService matterApplyService;
@Autowired
private MatterDatumService matterDatumService;
@Autowired
private MatterDatumFileService matterDatumFileService;
@Override
protected void findAfter(DatumLibraryEntity params, Context context, List<DatumLibraryEntity> list) throws AppException {
list.stream().peek(item->{
List<MatterDatumFileEntity> matterDatumFileEntities = matterDatumFileService.find(new MatterDatumFileQuery().datumId(item.getDatumId()));
item.setMatterDatumFileList(matterDatumFileEntities);
}).count();
super.findAfter(params, context, list);
}
@Override
protected void findAfter(DatumLibraryEntity params, PageInfo pageInfo, Context context, List<DatumLibraryEntity> list) throws AppException {
list.stream().peek(item->{
List<MatterDatumFileEntity> matterDatumFileEntities = matterDatumFileService.find(new MatterDatumFileQuery().datumId(item.getDatumId()));
item.setMatterDatumFileList(matterDatumFileEntities);
}).count();
super.findAfter(params, pageInfo,context, list);
}
@Override
public Rest<String> addToMatterDatum(String libraryIds, Context context) {
// if (ObjectUtils.isEmpty(matterId)) {
// throw new AppException("请选择对应事项");
// }
List<Long> libraryIdList = Arrays.asList(libraryIds.split(",")).stream().map(Long::parseLong).collect(Collectors.toList());
DatumLibraryQuery query = new DatumLibraryQuery();
query.setIdList(libraryIdList);
List<DatumLibraryEntity> entities = this.find(query);
int success = 0;
int fail = 0;
List<MatterDatumEntity> addEntities = new ArrayList<>();
for (DatumLibraryEntity library : entities) {
MatterDatumEntity datum = updateOrSave(library, context);
//SiteMatterEntity siteMatterEntity = updateOrSave(matterEntity, siteId, context);
if (!ObjectUtils.isEmpty(datum)) {
addEntities.add(datum);
success++;
} else {
fail++;
}
}
if (!ObjectUtils.isEmpty(addEntities)) {
matterDatumService.save(addEntities, context);
}
String msg = "当前加入材料已存在！";
if(CollectionUtils.isEmpty(entities)){
msg = "没有可以添加的数据！";
}
if (libraryIdList.size() == 1) {
if (success > 0) {
msg = "加入材料成功！";
}
} else if (libraryIdList.size() > 1) {
if (success > 0 && fail == 0) {
msg = String.format("加入材料成功%d条!", success);
} else if (success > 0 && fail > 0) {
msg = String.format("加入材料成功%d条，重复加入材料%d条！", success, fail);
} else if (success == 0 && fail > 0) {
msg = String.format("重复加入材料%d条！", fail);
}
}
return Rest.ok(msg);
}
private MatterDatumEntity updateOrSave(DatumLibraryEntity item, Context context) {
if(item.getDatumId()==null){
item.setDatumId(-1l);
}
MatterDatumEntity matterDatumEntity = matterDatumService.get(item.getDatumId());
if (ObjectUtils.isEmpty(matterDatumEntity)) {
MatterDatumEntity datumEntity = BeanUtil.covert(item,MatterDatumEntity.class);
datumEntity.setCreateTime(new Date());
if(context!=null&&context.getUser()!=null) {
datumEntity.setCreateUserId(context.getUser().getId());
}
datumEntity.setMatterId(matterDatumEntity.getMatterId());
return datumEntity;
}
return null;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/impl/MatterApplyServiceImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service.impl;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.MatterDatumPdu;
import com.mortals.xhx.common.pdu.matter.MatterPdu;
import com.mortals.xhx.common.pdu.site.SiteMatterPdu;
import com.mortals.xhx.common.pdu.site.SiteThemeMatterPdu;
import com.mortals.xhx.common.utils.BeanUtil;
import com.mortals.xhx.feign.matter.IMatterDatumFeign;
import com.mortals.xhx.feign.matter.IMatterFeign;
import com.mortals.xhx.feign.site.ISiteMatterFeign;
import com.mortals.xhx.feign.site.ISiteThemeMatterFeign;
import com.mortals.xhx.module.matter.model.MatterApplyQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.matter.dao.MatterApplyDao;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
import com.mortals.xhx.module.matter.service.MatterApplyService;
import org.springframework.util.ObjectUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* MatterApplyService
* 申报事项 service实现
*
* @author zxfei
* @date 2023-04-07
*/
@Service("matterApplyService")
public class MatterApplyServiceImpl extends AbstractCRUDServiceImpl<MatterApplyDao, MatterApplyEntity, Long> implements MatterApplyService {
@Autowired
private ISiteMatterFeign siteMatterFeign;
@Autowired
private IMatterFeign matterFeign;
@Autowired
private ISiteThemeMatterFeign siteThemeMatterFeign;
@Autowired
private IMatterDatumFeign matterDatumFeign;
@Override
public void addReportCount(Long id) {
Map<String,Object> data = new HashMap<>();
data.put("reportCountIncrement",1);
Map<String,Object> condition = new HashMap<>();
condition.put("id",id);
dao.update(data,condition);
}
@Override
public Rest<String> addToAssist(String siteMatterIds, Context context) {
List<Long> matterIdList = Arrays.asList(siteMatterIds.split(",")).stream().map(Long::parseLong).collect(Collectors.toList());
SiteMatterPdu matterQuery = new SiteMatterPdu();
matterQuery.setIdList(matterIdList);
matterQuery.setSize(-1);
Rest<RespData<List<SiteMatterPdu>>> result = siteMatterFeign.list(matterQuery);
if(result.getCode()==1){
List<SiteMatterPdu> matterEntities = result.getData().getData();
int success = 0;
int fail = 0;
List<MatterApplyEntity> singelMatterEntities = new ArrayList<>();
for (SiteMatterPdu matterEntity : matterEntities) {
MatterApplyEntity singelMatterEntity = updateOrSave(matterEntity, context);
if (!ObjectUtils.isEmpty(singelMatterEntity)) {
singelMatterEntities.add(singelMatterEntity);
success++;
} else {
fail++;
}
}
if (!ObjectUtils.isEmpty(singelMatterEntities)) {
this.save(singelMatterEntities, context);
}
String msg = "当前加入事项已存在！";
if (matterIdList.size() == 1) {
if (success > 0) {
msg = "加入事项成功！";
}
} else if (matterIdList.size() > 1) {
if (success > 0 && fail == 0) {
msg = String.format("加入事项成功%d条!", success);
} else if (success > 0 && fail > 0) {
msg = String.format("加入事项成功%d条，重复加入事项%d条！", success, fail);
} else if (success == 0 && fail > 0) {
msg = String.format("重复加入事项%d条！", fail);
}
}
return Rest.ok(msg);
}else {
return Rest.fail("添加失败");
}
}
private MatterApplyEntity updateOrSave(SiteMatterPdu item, Context context) {
MatterApplyEntity singleMatterEntity = this.selectOne(new MatterApplyQuery().siteMatterId(item.getId()));
if (ObjectUtils.isEmpty(singleMatterEntity)) {
MatterApplyEntity singleEntity = BeanUtil.covert(item,MatterApplyEntity.class);
singleEntity.setDatumCount(0);
singleEntity.setReportCount(0);
singleEntity.setIsConvert(0);
singleEntity.setCreateTime(new Date());
if(context!=null&&context.getUser()!=null) {
singleEntity.setCreateUserId(context.getUser().getId());
}
singleEntity.setSiteMatterId(item.getId());
// singleEntity.setGovUrl(item.getUrl());
Rest<MatterPdu> matterPduRest = matterFeign.info(item.getMatterId());
if(matterPduRest.getCode()==1 && matterPduRest.getData()!=null){
singleEntity.setGovUrl(matterPduRest.getData().getUrl());
SiteThemeMatterPdu query = new SiteThemeMatterPdu();
query.setMatterId(item.getMatterId());
query.setSiteId(item.getSiteId());
query.setSize(-1);
Rest<RespData<List<SiteThemeMatterPdu>>> siteThemeMatterList = siteThemeMatterFeign.list(query);
if(siteThemeMatterList.getCode()==1 && siteThemeMatterList.getData()!=null){
Map<String,String> themeMap = new HashMap<>();
for(SiteThemeMatterPdu themeMatterPdu:siteThemeMatterList.getData().getData()){
themeMap.put(themeMatterPdu.getThemeCode(),themeMatterPdu.getThemeName());
}
String themeCode = "";
String themeName = "";
for (Map.Entry<String, String> entry : themeMap.entrySet()) {
themeCode += entry.getKey() + ",";
themeName += entry.getValue() + ",";
}
singleEntity.setThemeCode(themeCode.endsWith(",")?themeCode.substring(0,themeCode.indexOf(",")):themeCode);
singleEntity.setThemeName(themeName.endsWith(",")?themeName.substring(0,themeName.indexOf(",")):themeName);
}
MatterDatumPdu datumPdu = new MatterDatumPdu();
datumPdu.setMatterId(item.getMatterId());
datumPdu.setSize(-1);
Rest<RespData<List<MatterDatumPdu>>> datumlist = matterDatumFeign.list(datumPdu);
if(datumlist.getCode()==1 && datumlist.getData()!=null){
singleEntity.setDatumCount(datumlist.getData().getData().size());
}
}
return singleEntity;
}else {
return null;
}
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/impl/MatterDatumFileServiceImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service.impl;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.matter.dao.MatterDatumFileDao;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import com.mortals.xhx.module.matter.service.MatterDatumFileService;
/**
* MatterDatumFileService
* 材料附件业务 service实现
*
* @author zxfei
* @date 2023-04-07
*/
@Service("matterDatumFileService")
public class MatterDatumFileServiceImpl extends AbstractCRUDServiceImpl<MatterDatumFileDao, MatterDatumFileEntity, Long> implements MatterDatumFileService {
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/service/impl/MatterDatumServiceImpl.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.service.impl;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.PageInfo;
import com.mortals.xhx.base.system.upload.service.UploadService;
import com.mortals.xhx.common.utils.BeanUtil;
import com.mortals.xhx.module.matter.model.*;
import com.mortals.xhx.module.matter.service.DatumLibraryService;
import com.mortals.xhx.module.matter.service.MatterDatumFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.matter.dao.MatterDatumDao;
import com.mortals.xhx.module.matter.service.MatterDatumService;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
/**
* MatterDatumService
* 事项申请材料业务 service实现
*
* @author zxfei
* @date 2023-04-07
*/
@Service("matterDatumService")
public class MatterDatumServiceImpl extends AbstractCRUDServiceImpl<MatterDatumDao, MatterDatumEntity, Long> implements MatterDatumService {
@Autowired
private MatterDatumFileService matterDatumFileService;
@Autowired
private UploadService uploadService;
@Autowired
private DatumLibraryService datumLibraryService;
@Override
protected void findAfter(MatterDatumEntity params, Context context, List<MatterDatumEntity> list) throws AppException {
list.stream().peek(item->{
List<MatterDatumFileEntity> matterDatumFileEntities = matterDatumFileService.find(new MatterDatumFileQuery().datumId(item.getId()));
item.setMatterDatumFileList(matterDatumFileEntities);
}).count();
super.findAfter(params, context, list);
}
@Override
protected void findAfter(MatterDatumEntity params, PageInfo pageInfo, Context context, List<MatterDatumEntity> list) throws AppException {
list.stream().peek(item->{
List<MatterDatumFileEntity> matterDatumFileEntities = matterDatumFileService.find(new MatterDatumFileQuery().datumId(item.getId()));
item.setMatterDatumFileList(matterDatumFileEntities);
}).count();
super.findAfter(params, context, list);
}
@Override
protected void saveAfter(MatterDatumEntity entity, Context context) throws AppException {
if (!ObjectUtils.isEmpty(entity.getMatterDatumFileList())) {
entity.getMatterDatumFileList().stream().peek(item -> {
item.setDatumId(entity.getId());
}).count();
matterDatumFileService.save(entity.getMatterDatumFileList());
}
super.saveAfter(entity, context);
}
@Override
protected void updateAfter(MatterDatumEntity entity, Context context) throws AppException {
if (!ObjectUtils.isEmpty(entity.getMatterDatumFileList())) {
//先删除后新增
Long[] fileIds = matterDatumFileService.find(new MatterDatumFileQuery().datumId(entity.getId())).stream()
.map(item -> {
uploadService.deleteFile(item.getFileUrl());
return item.getId();
}).toArray(Long[]::new);
matterDatumFileService.remove(fileIds, context);
entity.getMatterDatumFileList().stream().peek(item -> {
item.setDatumId(entity.getId());
}).count();
matterDatumFileService.save(entity.getMatterDatumFileList());
}
super.updateAfter(entity, context);
}
@Override
public Rest<String> addToLibrary(String datumIds, Long siteId, Context context) {
if (ObjectUtils.isEmpty(siteId)) {
throw new AppException("请选择对应站点");
}
List<Long> datumIdList = Arrays.asList(datumIds.split(",")).stream().map(Long::parseLong).collect(Collectors.toList());
MatterDatumQuery datumQuery = new MatterDatumQuery();
datumQuery.setIdList(datumIdList);
List<MatterDatumEntity> entities = this.find(datumQuery);
int success = 0;
int fail = 0;
List<DatumLibraryEntity> addEntities = new ArrayList<>();
for (MatterDatumEntity datum : entities) {
DatumLibraryEntity datumLibrary = updateOrSave(datum, siteId, context);
//SiteMatterEntity siteMatterEntity = updateOrSave(matterEntity, siteId, context);
if (!ObjectUtils.isEmpty(datumLibrary)) {
addEntities.add(datumLibrary);
success++;
} else {
fail++;
}
}
if (!ObjectUtils.isEmpty(addEntities)) {
datumLibraryService.save(addEntities, context);
}
String msg = "当前加入材料已存在！";
if(CollectionUtils.isEmpty(entities)){
msg = "没有可以添加的数据！";
}
if (datumIdList.size() == 1) {
if (success > 0) {
msg = "加入材料成功！";
}
} else if (datumIdList.size() > 1) {
if (success > 0 && fail == 0) {
msg = String.format("加入材料成功%d条!", success);
} else if (success > 0 && fail > 0) {
msg = String.format("加入材料成功%d条，重复加入材料%d条！", success, fail);
} else if (success == 0 && fail > 0) {
msg = String.format("重复加入材料%d条！", fail);
}
}
return Rest.ok(msg);
}
private DatumLibraryEntity updateOrSave(MatterDatumEntity item, Long siteId, Context context) {
DatumLibraryEntity siteDatumLibraryEntity = datumLibraryService.selectOne(new DatumLibraryQuery().siteId(siteId).datumId(item.getId()));
if (ObjectUtils.isEmpty(siteDatumLibraryEntity)) {
DatumLibraryEntity datumLibraryEntity = BeanUtil.covert(item,DatumLibraryEntity.class);
datumLibraryEntity.setDatumId(item.getId());
datumLibraryEntity.setSiteId(siteId);
datumLibraryEntity.setCreateTime(new Date());
if(context!=null&&context.getUser()!=null) {
datumLibraryEntity.setCreateUserId(context.getUser().getId());
}
return datumLibraryEntity;
}
return null;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/web/DatumLibraryController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.web;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.util.DataUtil;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
import com.mortals.xhx.module.matter.service.DatumLibraryService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 站点材料公共库
*
* @author zxfei
* @date 2023-04-07
*/
@RestController
@RequestMapping("datum/library")
public class DatumLibraryController extends BaseCRUDJsonBodyMappingController<DatumLibraryService,DatumLibraryEntity,Long> {
@Autowired
private ParamService paramService;
public DatumLibraryController(){
super.setModuleDesc( "站点材料公共库");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "isMust", paramService.getParamBySecondOrganize("DatumLibrary","isMust"));
this.addDict(model, "materialType", paramService.getParamBySecondOrganize("DatumLibrary","materialType"));
this.addDict(model, "materialProperty", paramService.getParamBySecondOrganize("DatumLibrary","materialProperty"));
this.addDict(model, "electronicgs", paramService.getParamBySecondOrganize("DatumLibrary","electronicgs"));
this.addDict(model, "materialSource", paramService.getParamBySecondOrganize("DatumLibrary","materialSource"));
this.addDict(model, "paperNum", paramService.getParamBySecondOrganize("DatumLibrary","paperNum"));
this.addDict(model, "jianmMs", paramService.getParamBySecondOrganize("DatumLibrary","jianmMs"));
this.addDict(model, "isjianm", paramService.getParamBySecondOrganize("DatumLibrary","isjianm"));
this.addDict(model, "isLack", paramService.getParamBySecondOrganize("DatumLibrary","isLack"));
this.addDict(model, "source", paramService.getParamBySecondOrganize("DatumLibrary","source"));
super.init(model, context);
}
/**
* 添加公共库到材料
*/
@PostMapping(value = "addToMatterDatum")
public String addToMatterDatum(@RequestBody Map<String, Object> map) {
JSONObject jsonObject = new JSONObject();
Map<String, Object> model = new HashMap<String, Object>();
String libraryIds = "";
if(map.containsKey("libraryIds")){
libraryIds = (String) map.get("libraryIds");
}
try {
Rest<String> rest = this.service.addToMatterDatum(libraryIds, getContext());
jsonObject.put(KEY_RESULT_MSG, rest.getMsg());
jsonObject.put(KEY_RESULT_DATA, model);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
this.recordSysLog(this.request, rest.getMsg());
} catch (Exception e) {
log.error("获取异常", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/web/MatterApplyController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.web;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.module.matter.model.DatumLibraryEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.matter.model.MatterApplyEntity;
import com.mortals.xhx.module.matter.service.MatterApplyService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 申报事项
*
* @author zxfei
* @date 2023-04-07
*/
@RestController
@RequestMapping("matter/apply")
public class MatterApplyController extends BaseCRUDJsonBodyMappingController<MatterApplyService,MatterApplyEntity,Long> {
@Autowired
private ParamService paramService;
public MatterApplyController(){
super.setModuleDesc( "申报事项");
}
@Override
protected void doListBefore(MatterApplyEntity query, Map<String, Object> model, Context context) throws AppException {
Map<String,String> orderMap = new HashMap<>();
orderMap.put("datumCount","DESC");
orderMap.put("reportCount","DESC");
query.setOrderCols(orderMap);
super.doListBefore(query,model,context);
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "source", paramService.getParamBySecondOrganize("MatterApply","source"));
this.addDict(model, "isConvert", paramService.getParamBySecondOrganize("MatterApply","isConvert"));
super.init(model, context);
}
/**
* 增加申报次数
* @param id
* @return
*/
@RequestMapping(value = {"addReport"},method = {RequestMethod.POST, RequestMethod.GET})
@UnAuth
public String addReport(Long id) {
Map<String, Object> model = new HashMap();
if (id == null) {
return this.createFailJsonResp("请选择待查看" + this.getModuleDesc() + "信息");
} else {
JSONObject ret = new JSONObject();
String busiDesc = "查看" + this.getModuleDesc();
Context context = this.getContext();
try {
MatterApplyEntity entity = this.service.get(id, context);
if (entity == null) {
throw new Exception(busiDesc + "，不存在或已被删除");
}
service.addReportCount(id);
model.put("message_info","操作成功");
model.putAll(model);
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var8) {
this.doException(this.request, busiDesc, model, var8);
Object msg = model.get("message_info");
return this.createFailJsonResp(msg == null ? "系统异常" : msg.toString());
}
this.init(model, context);
ret.put("data", model);
ret.put("code", 1);
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/web/MatterController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.web;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseJsonBodyController;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.matter.*;
import com.mortals.xhx.common.pdu.site.SiteMatterPdu;
import com.mortals.xhx.feign.matter.*;
import com.mortals.xhx.feign.site.ISiteMatterFeign;
import com.mortals.xhx.module.matter.service.MatterApplyService;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("base/matter")
public class MatterController extends BaseJsonBodyController {
@Autowired
private IMatterFeign matterFeign;
@Autowired
private IMatterAcceptFeign matterAcceptFeign;
@Autowired
private IMatterChargesFeign matterChargesFeign;
@Autowired
private IMatterFlowlimitFeign matterFlowlimitFeign;
@Autowired
private IMatterIntermediaryFeign matterIntermediaryFeign;
@Autowired
private IMatterQuestionFeign matterQuestionFeign;
@Autowired
private IMatterSetbaseFeign matterSetbaseFeign;
@RequestMapping(value = {"info"},method = {RequestMethod.POST, RequestMethod.GET})
@UnAuth
public String info(Long matterId) {
Map<String, Object> model = new HashMap();
Map<String, Object> data = new HashMap();
if (matterId == null) {
return this.createFailJsonResp("请选择待查看基础事项信息");
} else {
JSONObject ret = new JSONObject();
String busiDesc = "查看基础事项";
Context context = this.getContext();
try {
Rest<MatterPdu> matterPdu = matterFeign.info(matterId);
if(matterPdu.getCode()==1){
data.put("matterInfo",matterPdu.getData());
}
MatterAcceptPdu matterAcceptPdu = new MatterAcceptPdu();
matterAcceptPdu.setMatterId(matterId);
matterAcceptPdu.setSize(-1);
Rest<RespData<List<MatterAcceptPdu>>> matterAcceptlist = matterAcceptFeign.list(matterAcceptPdu);
if(matterAcceptlist.getCode()==1){
data.put("matterAccept",matterAcceptlist.getData().getData());
}
MatterChargesPdu matterChargesPdu = new MatterChargesPdu();
matterChargesPdu.setMatterId(matterId);
matterChargesPdu.setSize(-1);
Rest<RespData<List<MatterChargesPdu>>> matterChargeslist = matterChargesFeign.list(matterChargesPdu);
if(matterChargeslist.getCode()==1){
data.put("matterCharges",matterChargeslist.getData().getData());
}
MatterFlowlimitPdu matterFlowlimitPdu = new MatterFlowlimitPdu();
matterFlowlimitPdu.setMatterId(matterId);
matterFlowlimitPdu.setSize(-1);
Rest<RespData<List<MatterFlowlimitPdu>>> matterFlowlimitlist = matterFlowlimitFeign.list(matterFlowlimitPdu);
if(matterFlowlimitlist.getCode()==1){
data.put("matterFlowlimit",matterFlowlimitlist.getData().getData());
}
MatterIntermediaryPdu matterIntermediaryPdu = new MatterIntermediaryPdu();
matterIntermediaryPdu.setMatterId(matterId);
matterIntermediaryPdu.setSize(-1);
Rest<RespData<List<MatterIntermediaryPdu>>> matterIntermediarylist = matterIntermediaryFeign.list(matterIntermediaryPdu);
if(matterIntermediarylist.getCode()==1){
data.put("matterIntermediary",matterIntermediarylist.getData().getData());
}
MatterQuestionPdu matterQuestionPdu = new MatterQuestionPdu();
matterQuestionPdu.setMatterId(matterId);
matterQuestionPdu.setSize(-1);
Rest<RespData<List<MatterQuestionPdu>>> matterQuestionlist = matterQuestionFeign.list(matterQuestionPdu);
if(matterQuestionlist.getCode()==1){
data.put("matterQuestion",matterQuestionlist.getData().getData());
}
MatterSetbasePdu matterSetbasePdu = new MatterSetbasePdu();
matterSetbasePdu.setMatterId(matterId);
matterSetbasePdu.setSize(-1);
Rest<RespData<List<MatterSetbasePdu>>> matterSetbaselist = matterSetbaseFeign.list(matterSetbasePdu);
if(matterSetbaselist.getCode()==1){
data.put("matterSetbase",matterSetbaselist.getData().getData());
}
ret.put("data", data);
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var8) {
this.doException(this.request, busiDesc, model, var8);
Object msg = model.get("message_info");
return this.createFailJsonResp(msg == null ? "系统异常" : msg.toString());
}
ret.put("code", 1);
ret.put("msg", model.remove("message_info"));
ret.put("dict", model.remove("dict"));
return ret.toJSONString();
}
}
}
sst-manager/src/main/java/com/mortals/xhx/module/matter/web/MatterDatumController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.web;
import com.mortals.framework.common.Rest;
import com.mortals.framework.util.DataUtil;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.matter.model.MatterDatumEntity;
import com.mortals.xhx.module.matter.service.MatterDatumService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 事项申请材料业务
*
* @author zxfei
* @date 2023-04-07
*/
@RestController
@RequestMapping("matter/datum")
public class MatterDatumController extends BaseCRUDJsonBodyMappingController<MatterDatumService,MatterDatumEntity,Long> {
@Autowired
private ParamService paramService;
public MatterDatumController(){
super.setModuleDesc( "事项申请材料业务");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "isMust", paramService.getParamBySecondOrganize("MatterDatum","isMust"));
this.addDict(model, "materialType", paramService.getParamBySecondOrganize("MatterDatum","materialType"));
this.addDict(model, "materialProperty", paramService.getParamBySecondOrganize("MatterDatum","materialProperty"));
this.addDict(model, "electronicgs", paramService.getParamBySecondOrganize("MatterDatum","electronicgs"));
this.addDict(model, "materialSource", paramService.getParamBySecondOrganize("MatterDatum","materialSource"));
this.addDict(model, "paperNum", paramService.getParamBySecondOrganize("MatterDatum","paperNum"));
this.addDict(model, "jianmMs", paramService.getParamBySecondOrganize("MatterDatum","jianmMs"));
this.addDict(model, "isjianm", paramService.getParamBySecondOrganize("MatterDatum","isjianm"));
this.addDict(model, "isLack", paramService.getParamBySecondOrganize("MatterDatum","isLack"));
this.addDict(model, "source", paramService.getParamBySecondOrganize("MatterDatum","source"));
super.init(model, context);
}
/**
* 添加事项到站点
*/
@PostMapping(value = "addToLibrary")
public String addToLibrary(@RequestBody Map<String, Object> map) {
JSONObject jsonObject = new JSONObject();
Map<String, Object> model = new HashMap<String, Object>();
String datumIds = "";
if(map.containsKey("datumIds")){
datumIds = (String) map.get("datumIds");
}
Long siteId = 0l;
if(map.containsKey("siteId")) {
siteId = DataUtil.converStr2Long(map.get("siteId").toString(), 0L);
}
try {
Rest<String> rest = this.service.addToLibrary(datumIds, siteId, getContext());
jsonObject.put(KEY_RESULT_MSG, rest.getMsg());
jsonObject.put(KEY_RESULT_DATA, model);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
this.recordSysLog(this.request, rest.getMsg());
} catch (Exception e) {
log.error("获取异常", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/web/MatterDatumFileController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.web;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.matter.model.MatterDatumFileEntity;
import com.mortals.xhx.module.matter.service.MatterDatumFileService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 材料附件业务
*
* @author zxfei
* @date 2023-04-07
*/
@RestController
@RequestMapping("matter/datum/file")
public class MatterDatumFileController extends BaseCRUDJsonBodyMappingController<MatterDatumFileService,MatterDatumFileEntity,Long> {
@Autowired
private ParamService paramService;
public MatterDatumFileController(){
super.setModuleDesc( "材料附件业务");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "filetype", paramService.getParamBySecondOrganize("MatterDatumFile","filetype"));
this.addDict(model, "source", paramService.getParamBySecondOrganize("MatterDatumFile","source"));
super.init(model, context);
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/matter/web/SiteMatterController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.matter.web;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.model.PageInfo;
import com.mortals.framework.model.Result;
import com.mortals.framework.web.BaseJsonBodyController;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.site.SiteMatterPdu;
import com.mortals.xhx.feign.site.ISiteMatterFeign;
import com.mortals.xhx.module.matter.service.MatterApplyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("site/matter")
public class SiteMatterController extends BaseJsonBodyController {
@Autowired
private ISiteMatterFeign siteMatterFeign;
@Autowired
private MatterApplyService matterApplyService;
@PostMapping({"list"})
@UnAuth
public Rest<Object> list(@RequestBody SiteMatterPdu query) {
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "查询站点事项列表";
int code;
try {
Rest<RespData<List<SiteMatterPdu>>> result = siteMatterFeign.list(query);
code = result.getCode();
if(code > 0) {
model.put("data", result.getData().getData());
model.put("pageInfo", result.getData().getPageInfo());
model.put("dict", result.getData().getDict());
}
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
/**
* 添加事项到申报事项
*/
@PostMapping(value = "addToAssist")
public String addToAssist(@RequestBody Map<String, Object> map) {
JSONObject jsonObject = new JSONObject();
Map<String, Object> model = new HashMap<String, Object>();
String siteMatterIds = (String) map.get("siteMatterIds");
try {
Rest<String> rest = matterApplyService.addToAssist(siteMatterIds, getContext());
jsonObject.put(KEY_RESULT_MSG, rest.getMsg());
jsonObject.put(KEY_RESULT_DATA, model);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
this.recordSysLog(this.request, rest.getMsg());
} catch (Exception e) {
log.error("获取异常", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
}
sst-manager/src/main/java/com/mortals/xhx/module/site/web/SiteThemeController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.site.web;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseJsonBodyController;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.site.SiteThemePdu;
import com.mortals.xhx.feign.site.ISiteThemeFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("site/theme")
public class SiteThemeController extends BaseJsonBodyController {
@Autowired
private ISiteThemeFeign siteThemeFeign;
@PostMapping({"list"})
@UnAuth
public Rest<Object> list(@RequestBody SiteThemePdu query) {
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "查询主题列表";
int code;
try {
Rest<RespData<List<SiteThemePdu>>> result = siteThemeFeign.list(query);
code = result.getCode();
if(code > 0) {
model.put("data", result.getData().getData());
model.put("pageInfo", result.getData().getPageInfo());
model.put("dict", result.getData().getDict());
}
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
}
sst-manager/src/main/java/com/mortals/xhx/module/site/web/SiteThemeMatterController.java 0 → 100644
View file @ 9c5b55e7
package com.mortals.xhx.module.site.web;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseJsonBodyController;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.site.SiteThemeMatterPdu;
import com.mortals.xhx.feign.site.ISiteThemeMatterFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("site/theme/matter")
public class SiteThemeMatterController extends BaseJsonBodyController {
@Autowired
private ISiteThemeMatterFeign siteThemeMatterFeign;
@PostMapping({"list"})
@UnAuth
public Rest<Object> list(@RequestBody SiteThemeMatterPdu query) {
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "查询站点主题事项";
int code;
try {
Rest<RespData<List<SiteThemeMatterPdu>>> result = siteThemeMatterFeign.list(query);
code = result.getCode();
if(code > 0) {
model.put("data", result.getData().getData());
model.put("pageInfo", result.getData().getPageInfo());
model.put("dict", result.getData().getDict());
}
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
}
sst-manager/src/main/resources/sqlmap/module/matter/DatumLibraryMapper.xml 0 → 100644
View file @ 9c5b55e7
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.matter.dao.ibatis.DatumLibraryDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="DatumLibraryEntity" id="DatumLibraryEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="siteName" column="siteName" />
<result property="datumId" column="datumId" />
<result property="matterId" column="matterId" />
<result property="matterCode" column="matterCode" />
<result property="matterName" column="matterName" />
<result property="materialName" column="materialName" />
<result property="isMust" column="isMust" />
<result property="materialType" column="materialType" />
<result property="materialProperty" column="materialProperty" />
<result property="electronicgs" column="electronicgs" />
<result property="materialSource" column="materialSource" />
<result property="paperNum" column="paperNum" />
<result property="paperGg" column="paperGg" />
<result property="jianmMs" column="jianmMs" />
<result property="sealWay" column="sealWay" />
<result property="isjianm" column="isjianm" />
<result property="isLack" column="isLack" />
<result property="ybUrl" column="ybUrl" />
<result property="materialSourceSm" column="materialSourceSm" />
<result property="remarkSub" column="remarkSub" />
<result property="clauseContent" column="clauseContent" />
<result property="summary" column="summary" />
<result property="remark" column="remark" />
<result property="source" column="source" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
a.siteId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteName') or colPickMode == 1 and data.containsKey('siteName')))">
a.siteName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('datumId') or colPickMode == 1 and data.containsKey('datumId')))">
a.datumId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterId') or colPickMode == 1 and data.containsKey('matterId')))">
a.matterId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterCode') or colPickMode == 1 and data.containsKey('matterCode')))">
a.matterCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterName') or colPickMode == 1 and data.containsKey('matterName')))">
a.matterName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialName') or colPickMode == 1 and data.containsKey('materialName')))">
a.materialName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isMust') or colPickMode == 1 and data.containsKey('isMust')))">
a.isMust,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialType') or colPickMode == 1 and data.containsKey('materialType')))">
a.materialType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialProperty') or colPickMode == 1 and data.containsKey('materialProperty')))">
a.materialProperty,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('electronicgs') or colPickMode == 1 and data.containsKey('electronicgs')))">
a.electronicgs,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialSource') or colPickMode == 1 and data.containsKey('materialSource')))">
a.materialSource,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paperNum') or colPickMode == 1 and data.containsKey('paperNum')))">
a.paperNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paperGg') or colPickMode == 1 and data.containsKey('paperGg')))">
a.paperGg,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('jianmMs') or colPickMode == 1 and data.containsKey('jianmMs')))">
a.jianmMs,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sealWay') or colPickMode == 1 and data.containsKey('sealWay')))">
a.sealWay,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isjianm') or colPickMode == 1 and data.containsKey('isjianm')))">
a.isjianm,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isLack') or colPickMode == 1 and data.containsKey('isLack')))">
a.isLack,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ybUrl') or colPickMode == 1 and data.containsKey('ybUrl')))">
a.ybUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialSourceSm') or colPickMode == 1 and data.containsKey('materialSourceSm')))">
a.materialSourceSm,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remarkSub') or colPickMode == 1 and data.containsKey('remarkSub')))">
a.remarkSub,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('clauseContent') or colPickMode == 1 and data.containsKey('clauseContent')))">
a.clauseContent,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('summary') or colPickMode == 1 and data.containsKey('summary')))">
a.summary,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('source') or colPickMode == 1 and data.containsKey('source')))">
a.source,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="DatumLibraryEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_datum_library
(siteId,siteName,datumId,matterId,matterCode,matterName,materialName,isMust,materialType,materialProperty,electronicgs,materialSource,paperNum,paperGg,jianmMs,sealWay,isjianm,isLack,ybUrl,materialSourceSm,remarkSub,clauseContent,summary,remark,source,createTime,createUserId,updateTime)
VALUES
(#{siteId},#{siteName},#{datumId},#{matterId},#{matterCode},#{matterName},#{materialName},#{isMust},#{materialType},#{materialProperty},#{electronicgs},#{materialSource},#{paperNum},#{paperGg},#{jianmMs},#{sealWay},#{isjianm},#{isLack},#{ybUrl},#{materialSourceSm},#{remarkSub},#{clauseContent},#{summary},#{remark},#{source},#{createTime},#{createUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_datum_library
(siteId,siteName,datumId,matterId,matterCode,matterName,materialName,isMust,materialType,materialProperty,electronicgs,materialSource,paperNum,paperGg,jianmMs,sealWay,isjianm,isLack,ybUrl,materialSourceSm,remarkSub,clauseContent,summary,remark,source,createTime,createUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.siteName},#{item.datumId},#{item.matterId},#{item.matterCode},#{item.matterName},#{item.materialName},#{item.isMust},#{item.materialType},#{item.materialProperty},#{item.electronicgs},#{item.materialSource},#{item.paperNum},#{item.paperGg},#{item.jianmMs},#{item.sealWay},#{item.isjianm},#{item.isLack},#{item.ybUrl},#{item.materialSourceSm},#{item.remarkSub},#{item.clauseContent},#{item.summary},#{item.remark},#{item.source},#{item.createTime},#{item.createUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_sys_datum_library as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('siteId')) or (colPickMode==1 and !data.containsKey('siteId'))">
a.siteId=#{data.siteId},
</if>
<if test="(colPickMode==0 and data.containsKey('siteIdIncrement')) or (colPickMode==1 and !data.containsKey('siteIdIncrement'))">
a.siteId=ifnull(a.siteId,0) + #{data.siteIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('siteName')) or (colPickMode==1 and !data.containsKey('siteName'))">
a.siteName=#{data.siteName},
</if>
<if test="(colPickMode==0 and data.containsKey('datumId')) or (colPickMode==1 and !data.containsKey('datumId'))">
a.datumId=#{data.datumId},
</if>
<if test="(colPickMode==0 and data.containsKey('datumIdIncrement')) or (colPickMode==1 and !data.containsKey('datumIdIncrement'))">
a.datumId=ifnull(a.datumId,0) + #{data.datumIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('matterId')) or (colPickMode==1 and !data.containsKey('matterId'))">
a.matterId=#{data.matterId},
</if>
<if test="(colPickMode==0 and data.containsKey('matterIdIncrement')) or (colPickMode==1 and !data.containsKey('matterIdIncrement'))">
a.matterId=ifnull(a.matterId,0) + #{data.matterIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('matterCode')) or (colPickMode==1 and !data.containsKey('matterCode'))">
a.matterCode=#{data.matterCode},
</if>
<if test="(colPickMode==0 and data.containsKey('matterName')) or (colPickMode==1 and !data.containsKey('matterName'))">
a.matterName=#{data.matterName},
</if>
<if test="(colPickMode==0 and data.containsKey('materialName')) or (colPickMode==1 and !data.containsKey('materialName'))">
a.materialName=#{data.materialName},
</if>
<if test="(colPickMode==0 and data.containsKey('isMust')) or (colPickMode==1 and !data.containsKey('isMust'))">
a.isMust=#{data.isMust},
</if>
<if test="(colPickMode==0 and data.containsKey('materialType')) or (colPickMode==1 and !data.containsKey('materialType'))">
a.materialType=#{data.materialType},
</if>
<if test="(colPickMode==0 and data.containsKey('materialProperty')) or (colPickMode==1 and !data.containsKey('materialProperty'))">
a.materialProperty=#{data.materialProperty},
</if>
<if test="(colPickMode==0 and data.containsKey('electronicgs')) or (colPickMode==1 and !data.containsKey('electronicgs'))">
a.electronicgs=#{data.electronicgs},
</if>
<if test="(colPickMode==0 and data.containsKey('materialSource')) or (colPickMode==1 and !data.containsKey('materialSource'))">
a.materialSource=#{data.materialSource},
</if>
<if test="(colPickMode==0 and data.containsKey('paperNum')) or (colPickMode==1 and !data.containsKey('paperNum'))">
a.paperNum=#{data.paperNum},
</if>
<if test="(colPickMode==0 and data.containsKey('paperNumIncrement')) or (colPickMode==1 and !data.containsKey('paperNumIncrement'))">
a.paperNum=ifnull(a.paperNum,0) + #{data.paperNumIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('paperGg')) or (colPickMode==1 and !data.containsKey('paperGg'))">
a.paperGg=#{data.paperGg},
</if>
<if test="(colPickMode==0 and data.containsKey('jianmMs')) or (colPickMode==1 and !data.containsKey('jianmMs'))">
a.jianmMs=#{data.jianmMs},
</if>
<if test="(colPickMode==0 and data.containsKey('sealWay')) or (colPickMode==1 and !data.containsKey('sealWay'))">
a.sealWay=#{data.sealWay},
</if>
<if test="(colPickMode==0 and data.containsKey('isjianm')) or (colPickMode==1 and !data.containsKey('isjianm'))">
a.isjianm=#{data.isjianm},
</if>
<if test="(colPickMode==0 and data.containsKey('isLack')) or (colPickMode==1 and !data.containsKey('isLack'))">
a.isLack=#{data.isLack},
</if>
<if test="(colPickMode==0 and data.containsKey('ybUrl')) or (colPickMode==1 and !data.containsKey('ybUrl'))">
a.ybUrl=#{data.ybUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('materialSourceSm')) or (colPickMode==1 and !data.containsKey('materialSourceSm'))">
a.materialSourceSm=#{data.materialSourceSm},
</if>
<if test="(colPickMode==0 and data.containsKey('remarkSub')) or (colPickMode==1 and !data.containsKey('remarkSub'))">
a.remarkSub=#{data.remarkSub},
</if>
<if test="(colPickMode==0 and data.containsKey('clauseContent')) or (colPickMode==1 and !data.containsKey('clauseContent'))">
a.clauseContent=#{data.clauseContent},
</if>
<if test="(colPickMode==0 and data.containsKey('summary')) or (colPickMode==1 and !data.containsKey('summary'))">
a.summary=#{data.summary},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('source')) or (colPickMode==1 and !data.containsKey('source'))">
a.source=#{data.source},
</if>
<if test="(colPickMode==0 and data.containsKey('sourceIncrement')) or (colPickMode==1 and !data.containsKey('sourceIncrement'))">
a.source=ifnull(a.source,0) + #{data.sourceIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_sys_datum_library as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="siteId=(case" suffix="ELSE siteId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
when a.id=#{item.id} then #{item.siteId}
</when>
<when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="siteName=(case" suffix="ELSE siteName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('siteName')) or (colPickMode==1 and !item.containsKey('siteName'))">
when a.id=#{item.id} then #{item.siteName}
</if>
</foreach>
</trim>
<trim prefix="datumId=(case" suffix="ELSE datumId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('datumId')) or (colPickMode==1 and !item.containsKey('datumId'))">
when a.id=#{item.id} then #{item.datumId}
</when>
<when test="(colPickMode==0 and item.containsKey('datumIdIncrement')) or (colPickMode==1 and !item.containsKey('datumIdIncrement'))">
when a.id=#{item.id} then ifnull(a.datumId,0) + #{item.datumIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="matterId=(case" suffix="ELSE matterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('matterId')) or (colPickMode==1 and !item.containsKey('matterId'))">
when a.id=#{item.id} then #{item.matterId}
</when>
<when test="(colPickMode==0 and item.containsKey('matterIdIncrement')) or (colPickMode==1 and !item.containsKey('matterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.matterId,0) + #{item.matterIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="matterCode=(case" suffix="ELSE matterCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('matterCode')) or (colPickMode==1 and !item.containsKey('matterCode'))">
when a.id=#{item.id} then #{item.matterCode}
</if>
</foreach>
</trim>
<trim prefix="matterName=(case" suffix="ELSE matterName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('matterName')) or (colPickMode==1 and !item.containsKey('matterName'))">
when a.id=#{item.id} then #{item.matterName}
</if>
</foreach>
</trim>
<trim prefix="materialName=(case" suffix="ELSE materialName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialName')) or (colPickMode==1 and !item.containsKey('materialName'))">
when a.id=#{item.id} then #{item.materialName}
</if>
</foreach>
</trim>
<trim prefix="isMust=(case" suffix="ELSE isMust end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('isMust')) or (colPickMode==1 and !item.containsKey('isMust'))">
when a.id=#{item.id} then #{item.isMust}
</if>
</foreach>
</trim>
<trim prefix="materialType=(case" suffix="ELSE materialType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialType')) or (colPickMode==1 and !item.containsKey('materialType'))">
when a.id=#{item.id} then #{item.materialType}
</if>
</foreach>
</trim>
<trim prefix="materialProperty=(case" suffix="ELSE materialProperty end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialProperty')) or (colPickMode==1 and !item.containsKey('materialProperty'))">
when a.id=#{item.id} then #{item.materialProperty}
</if>
</foreach>
</trim>
<trim prefix="electronicgs=(case" suffix="ELSE electronicgs end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('electronicgs')) or (colPickMode==1 and !item.containsKey('electronicgs'))">
when a.id=#{item.id} then #{item.electronicgs}
</if>
</foreach>
</trim>
<trim prefix="materialSource=(case" suffix="ELSE materialSource end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialSource')) or (colPickMode==1 and !item.containsKey('materialSource'))">
when a.id=#{item.id} then #{item.materialSource}
</if>
</foreach>
</trim>
<trim prefix="paperNum=(case" suffix="ELSE paperNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('paperNum')) or (colPickMode==1 and !item.containsKey('paperNum'))">
when a.id=#{item.id} then #{item.paperNum}
</when>
<when test="(colPickMode==0 and item.containsKey('paperNumIncrement')) or (colPickMode==1 and !item.containsKey('paperNumIncrement'))">
when a.id=#{item.id} then ifnull(a.paperNum,0) + #{item.paperNumIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="paperGg=(case" suffix="ELSE paperGg end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paperGg')) or (colPickMode==1 and !item.containsKey('paperGg'))">
when a.id=#{item.id} then #{item.paperGg}
</if>
</foreach>
</trim>
<trim prefix="jianmMs=(case" suffix="ELSE jianmMs end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('jianmMs')) or (colPickMode==1 and !item.containsKey('jianmMs'))">
when a.id=#{item.id} then #{item.jianmMs}
</if>
</foreach>
</trim>
<trim prefix="sealWay=(case" suffix="ELSE sealWay end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('sealWay')) or (colPickMode==1 and !item.containsKey('sealWay'))">
when a.id=#{item.id} then #{item.sealWay}
</if>
</foreach>
</trim>
<trim prefix="isjianm=(case" suffix="ELSE isjianm end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('isjianm')) or (colPickMode==1 and !item.containsKey('isjianm'))">
when a.id=#{item.id} then #{item.isjianm}
</if>
</foreach>
</trim>
<trim prefix="isLack=(case" suffix="ELSE isLack end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('isLack')) or (colPickMode==1 and !item.containsKey('isLack'))">
when a.id=#{item.id} then #{item.isLack}
</if>
</foreach>
</trim>
<trim prefix="ybUrl=(case" suffix="ELSE ybUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ybUrl')) or (colPickMode==1 and !item.containsKey('ybUrl'))">
when a.id=#{item.id} then #{item.ybUrl}
</if>
</foreach>
</trim>
<trim prefix="materialSourceSm=(case" suffix="ELSE materialSourceSm end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialSourceSm')) or (colPickMode==1 and !item.containsKey('materialSourceSm'))">
when a.id=#{item.id} then #{item.materialSourceSm}
</if>
</foreach>
</trim>
<trim prefix="remarkSub=(case" suffix="ELSE remarkSub end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remarkSub')) or (colPickMode==1 and !item.containsKey('remarkSub'))">
when a.id=#{item.id} then #{item.remarkSub}
</if>
</foreach>
</trim>
<trim prefix="clauseContent=(case" suffix="ELSE clauseContent end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('clauseContent')) or (colPickMode==1 and !item.containsKey('clauseContent'))">
when a.id=#{item.id} then #{item.clauseContent}
</if>
</foreach>
</trim>
<trim prefix="summary=(case" suffix="ELSE summary end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('summary')) or (colPickMode==1 and !item.containsKey('summary'))">
when a.id=#{item.id} then #{item.summary}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="source=(case" suffix="ELSE source end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('source')) or (colPickMode==1 and !item.containsKey('source'))">
when a.id=#{item.id} then #{item.source}
</when>
<when test="(colPickMode==0 and item.containsKey('sourceIncrement')) or (colPickMode==1 and !item.containsKey('sourceIncrement'))">
when a.id=#{item.id} then ifnull(a.source,0) + #{item.sourceIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="DatumLibraryEntity-Map">
select <include refid="_columns"/>
from mortals_sys_datum_library as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_sys_datum_library as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_sys_datum_library where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_sys_datum_library where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_sys_datum_library where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_sys_datum_library as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="DatumLibraryEntity-Map">
select <include refid="_columns"/>
from mortals_sys_datum_library as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_sys_datum_library as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList')">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{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>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('siteName')">
<if test="conditionParamRef.siteName != null and conditionParamRef.siteName != ''">
${_conditionType_} a.siteName like #{${_conditionParam_}.siteName}
</if>
<if test="conditionParamRef.siteName == null">
${_conditionType_} a.siteName is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteNameList')">
${_conditionType_} a.siteName in
<foreach collection="conditionParamRef.siteNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteNameNotList')">
${_conditionType_} a.siteName not in
<foreach collection="conditionParamRef.siteNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumId')">
<if test="conditionParamRef.datumId != null ">
${_conditionType_} a.datumId = #{${_conditionParam_}.datumId}
</if>
<if test="conditionParamRef.datumId == null">
${_conditionType_} a.datumId is null
</if>
</if>
<if test="conditionParamRef.containsKey('datumIdList')">
${_conditionType_} a.datumId in
<foreach collection="conditionParamRef.datumIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumIdNotList')">
${_conditionType_} a.datumId not in
<foreach collection="conditionParamRef.datumIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumIdStart') and conditionParamRef.datumIdStart != null">
${_conditionType_} a.datumId <![CDATA[ >= ]]> #{${_conditionParam_}.datumIdStart}
</if>
<if test="conditionParamRef.containsKey('datumIdEnd') and conditionParamRef.datumIdEnd != null">
${_conditionType_} a.datumId <![CDATA[ <= ]]> #{${_conditionParam_}.datumIdEnd}
</if>
<if test="conditionParamRef.containsKey('matterId')">
<if test="conditionParamRef.matterId != null ">
${_conditionType_} a.matterId = #{${_conditionParam_}.matterId}
</if>
<if test="conditionParamRef.matterId == null">
${_conditionType_} a.matterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterIdList')">
${_conditionType_} a.matterId in
<foreach collection="conditionParamRef.matterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdNotList')">
${_conditionType_} a.matterId not in
<foreach collection="conditionParamRef.matterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdStart') and conditionParamRef.matterIdStart != null">
${_conditionType_} a.matterId <![CDATA[ >= ]]> #{${_conditionParam_}.matterIdStart}
</if>
<if test="conditionParamRef.containsKey('matterIdEnd') and conditionParamRef.matterIdEnd != null">
${_conditionType_} a.matterId <![CDATA[ <= ]]> #{${_conditionParam_}.matterIdEnd}
</if>
<if test="conditionParamRef.containsKey('matterCode')">
<if test="conditionParamRef.matterCode != null and conditionParamRef.matterCode != ''">
${_conditionType_} a.matterCode like #{${_conditionParam_}.matterCode}
</if>
<if test="conditionParamRef.matterCode == null">
${_conditionType_} a.matterCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterCodeList')">
${_conditionType_} a.matterCode in
<foreach collection="conditionParamRef.matterCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterCodeNotList')">
${_conditionType_} a.matterCode not in
<foreach collection="conditionParamRef.matterCodeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterName')">
<if test="conditionParamRef.matterName != null and conditionParamRef.matterName != ''">
${_conditionType_} a.matterName like #{${_conditionParam_}.matterName}
</if>
<if test="conditionParamRef.matterName == null">
${_conditionType_} a.matterName is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterNameList')">
${_conditionType_} a.matterName in
<foreach collection="conditionParamRef.matterNameList" open="(" close=")" index="index" item="item" separator=",">
#{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('materialName')">
<if test="conditionParamRef.materialName != null and conditionParamRef.materialName != ''">
${_conditionType_} a.materialName like #{${_conditionParam_}.materialName}
</if>
<if test="conditionParamRef.materialName == null">
${_conditionType_} a.materialName is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialNameList')">
${_conditionType_} a.materialName in
<foreach collection="conditionParamRef.materialNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialNameNotList')">
${_conditionType_} a.materialName not in
<foreach collection="conditionParamRef.materialNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isMust')">
<if test="conditionParamRef.isMust != null and conditionParamRef.isMust != ''">
${_conditionType_} a.isMust like #{${_conditionParam_}.isMust}
</if>
<if test="conditionParamRef.isMust == null">
${_conditionType_} a.isMust is null
</if>
</if>
<if test="conditionParamRef.containsKey('isMustList')">
${_conditionType_} a.isMust in
<foreach collection="conditionParamRef.isMustList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isMustNotList')">
${_conditionType_} a.isMust not in
<foreach collection="conditionParamRef.isMustNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialType')">
<if test="conditionParamRef.materialType != null and conditionParamRef.materialType != ''">
${_conditionType_} a.materialType like #{${_conditionParam_}.materialType}
</if>
<if test="conditionParamRef.materialType == null">
${_conditionType_} a.materialType is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialTypeList')">
${_conditionType_} a.materialType in
<foreach collection="conditionParamRef.materialTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialTypeNotList')">
${_conditionType_} a.materialType not in
<foreach collection="conditionParamRef.materialTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialProperty')">
<if test="conditionParamRef.materialProperty != null and conditionParamRef.materialProperty != ''">
${_conditionType_} a.materialProperty like #{${_conditionParam_}.materialProperty}
</if>
<if test="conditionParamRef.materialProperty == null">
${_conditionType_} a.materialProperty is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialPropertyList')">
${_conditionType_} a.materialProperty in
<foreach collection="conditionParamRef.materialPropertyList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialPropertyNotList')">
${_conditionType_} a.materialProperty not in
<foreach collection="conditionParamRef.materialPropertyNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('electronicgs')">
<if test="conditionParamRef.electronicgs != null and conditionParamRef.electronicgs != ''">
${_conditionType_} a.electronicgs like #{${_conditionParam_}.electronicgs}
</if>
<if test="conditionParamRef.electronicgs == null">
${_conditionType_} a.electronicgs is null
</if>
</if>
<if test="conditionParamRef.containsKey('electronicgsList')">
${_conditionType_} a.electronicgs in
<foreach collection="conditionParamRef.electronicgsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('electronicgsNotList')">
${_conditionType_} a.electronicgs not in
<foreach collection="conditionParamRef.electronicgsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSource')">
<if test="conditionParamRef.materialSource != null and conditionParamRef.materialSource != ''">
${_conditionType_} a.materialSource like #{${_conditionParam_}.materialSource}
</if>
<if test="conditionParamRef.materialSource == null">
${_conditionType_} a.materialSource is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialSourceList')">
${_conditionType_} a.materialSource in
<foreach collection="conditionParamRef.materialSourceList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSourceNotList')">
${_conditionType_} a.materialSource not in
<foreach collection="conditionParamRef.materialSourceNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperNum')">
<if test="conditionParamRef.paperNum != null ">
${_conditionType_} a.paperNum = #{${_conditionParam_}.paperNum}
</if>
<if test="conditionParamRef.paperNum == null">
${_conditionType_} a.paperNum is null
</if>
</if>
<if test="conditionParamRef.containsKey('paperNumList')">
${_conditionType_} a.paperNum in
<foreach collection="conditionParamRef.paperNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperNumNotList')">
${_conditionType_} a.paperNum not in
<foreach collection="conditionParamRef.paperNumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperNumStart') and conditionParamRef.paperNumStart != null">
${_conditionType_} a.paperNum <![CDATA[ >= ]]> #{${_conditionParam_}.paperNumStart}
</if>
<if test="conditionParamRef.containsKey('paperNumEnd') and conditionParamRef.paperNumEnd != null">
${_conditionType_} a.paperNum <![CDATA[ <= ]]> #{${_conditionParam_}.paperNumEnd}
</if>
<if test="conditionParamRef.containsKey('paperGg')">
<if test="conditionParamRef.paperGg != null and conditionParamRef.paperGg != ''">
${_conditionType_} a.paperGg like #{${_conditionParam_}.paperGg}
</if>
<if test="conditionParamRef.paperGg == null">
${_conditionType_} a.paperGg is null
</if>
</if>
<if test="conditionParamRef.containsKey('paperGgList')">
${_conditionType_} a.paperGg in
<foreach collection="conditionParamRef.paperGgList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperGgNotList')">
${_conditionType_} a.paperGg not in
<foreach collection="conditionParamRef.paperGgNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('jianmMs')">
<if test="conditionParamRef.jianmMs != null and conditionParamRef.jianmMs != ''">
${_conditionType_} a.jianmMs like #{${_conditionParam_}.jianmMs}
</if>
<if test="conditionParamRef.jianmMs == null">
${_conditionType_} a.jianmMs is null
</if>
</if>
<if test="conditionParamRef.containsKey('jianmMsList')">
${_conditionType_} a.jianmMs in
<foreach collection="conditionParamRef.jianmMsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('jianmMsNotList')">
${_conditionType_} a.jianmMs not in
<foreach collection="conditionParamRef.jianmMsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sealWay')">
<if test="conditionParamRef.sealWay != null and conditionParamRef.sealWay != ''">
${_conditionType_} a.sealWay like #{${_conditionParam_}.sealWay}
</if>
<if test="conditionParamRef.sealWay == null">
${_conditionType_} a.sealWay is null
</if>
</if>
<if test="conditionParamRef.containsKey('sealWayList')">
${_conditionType_} a.sealWay in
<foreach collection="conditionParamRef.sealWayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sealWayNotList')">
${_conditionType_} a.sealWay not in
<foreach collection="conditionParamRef.sealWayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isjianm')">
<if test="conditionParamRef.isjianm != null and conditionParamRef.isjianm != ''">
${_conditionType_} a.isjianm like #{${_conditionParam_}.isjianm}
</if>
<if test="conditionParamRef.isjianm == null">
${_conditionType_} a.isjianm is null
</if>
</if>
<if test="conditionParamRef.containsKey('isjianmList')">
${_conditionType_} a.isjianm in
<foreach collection="conditionParamRef.isjianmList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isjianmNotList')">
${_conditionType_} a.isjianm not in
<foreach collection="conditionParamRef.isjianmNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isLack')">
<if test="conditionParamRef.isLack != null and conditionParamRef.isLack != ''">
${_conditionType_} a.isLack like #{${_conditionParam_}.isLack}
</if>
<if test="conditionParamRef.isLack == null">
${_conditionType_} a.isLack is null
</if>
</if>
<if test="conditionParamRef.containsKey('isLackList')">
${_conditionType_} a.isLack in
<foreach collection="conditionParamRef.isLackList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isLackNotList')">
${_conditionType_} a.isLack not in
<foreach collection="conditionParamRef.isLackNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ybUrl')">
<if test="conditionParamRef.ybUrl != null and conditionParamRef.ybUrl != ''">
${_conditionType_} a.ybUrl like #{${_conditionParam_}.ybUrl}
</if>
<if test="conditionParamRef.ybUrl == null">
${_conditionType_} a.ybUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('ybUrlList')">
${_conditionType_} a.ybUrl in
<foreach collection="conditionParamRef.ybUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ybUrlNotList')">
${_conditionType_} a.ybUrl not in
<foreach collection="conditionParamRef.ybUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSourceSm')">
<if test="conditionParamRef.materialSourceSm != null and conditionParamRef.materialSourceSm != ''">
${_conditionType_} a.materialSourceSm like #{${_conditionParam_}.materialSourceSm}
</if>
<if test="conditionParamRef.materialSourceSm == null">
${_conditionType_} a.materialSourceSm is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialSourceSmList')">
${_conditionType_} a.materialSourceSm in
<foreach collection="conditionParamRef.materialSourceSmList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSourceSmNotList')">
${_conditionType_} a.materialSourceSm not in
<foreach collection="conditionParamRef.materialSourceSmNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkSub')">
<if test="conditionParamRef.remarkSub != null and conditionParamRef.remarkSub != ''">
${_conditionType_} a.remarkSub like #{${_conditionParam_}.remarkSub}
</if>
<if test="conditionParamRef.remarkSub == null">
${_conditionType_} a.remarkSub is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkSubList')">
${_conditionType_} a.remarkSub in
<foreach collection="conditionParamRef.remarkSubList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkSubNotList')">
${_conditionType_} a.remarkSub not in
<foreach collection="conditionParamRef.remarkSubNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('clauseContent')">
<if test="conditionParamRef.clauseContent != null and conditionParamRef.clauseContent != ''">
${_conditionType_} a.clauseContent like #{${_conditionParam_}.clauseContent}
</if>
<if test="conditionParamRef.clauseContent == null">
${_conditionType_} a.clauseContent is null
</if>
</if>
<if test="conditionParamRef.containsKey('clauseContentList')">
${_conditionType_} a.clauseContent in
<foreach collection="conditionParamRef.clauseContentList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('clauseContentNotList')">
${_conditionType_} a.clauseContent not in
<foreach collection="conditionParamRef.clauseContentNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('summary')">
<if test="conditionParamRef.summary != null and conditionParamRef.summary != ''">
${_conditionType_} a.summary like #{${_conditionParam_}.summary}
</if>
<if test="conditionParamRef.summary == null">
${_conditionType_} a.summary is null
</if>
</if>
<if test="conditionParamRef.containsKey('summaryList')">
${_conditionType_} a.summary in
<foreach collection="conditionParamRef.summaryList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('summaryNotList')">
${_conditionType_} a.summary not in
<foreach collection="conditionParamRef.summaryNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList')">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('source')">
<if test="conditionParamRef.source != null ">
${_conditionType_} a.source = #{${_conditionParam_}.source}
</if>
<if test="conditionParamRef.source == null">
${_conditionType_} a.source is null
</if>
</if>
<if test="conditionParamRef.containsKey('sourceList')">
${_conditionType_} a.source in
<foreach collection="conditionParamRef.sourceList" open="(" close=")" index="index" item="item" separator=",">
#{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>
<if test="conditionParamRef.containsKey('sourceEnd') and conditionParamRef.sourceEnd != null">
${_conditionType_} a.source <![CDATA[ <= ]]> #{${_conditionParam_}.sourceEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteId')">
a.siteId
<if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteName')">
a.siteName
<if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('datumId')">
a.datumId
<if test='orderCol.datumId != null and "DESC".equalsIgnoreCase(orderCol.datumId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterId')">
a.matterId
<if test='orderCol.matterId != null and "DESC".equalsIgnoreCase(orderCol.matterId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterCode')">
a.matterCode
<if test='orderCol.matterCode != null and "DESC".equalsIgnoreCase(orderCol.matterCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterName')">
a.matterName
<if test='orderCol.matterName != null and "DESC".equalsIgnoreCase(orderCol.matterName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialName')">
a.materialName
<if test='orderCol.materialName != null and "DESC".equalsIgnoreCase(orderCol.materialName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isMust')">
a.isMust
<if test='orderCol.isMust != null and "DESC".equalsIgnoreCase(orderCol.isMust)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialType')">
a.materialType
<if test='orderCol.materialType != null and "DESC".equalsIgnoreCase(orderCol.materialType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialProperty')">
a.materialProperty
<if test='orderCol.materialProperty != null and "DESC".equalsIgnoreCase(orderCol.materialProperty)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('electronicgs')">
a.electronicgs
<if test='orderCol.electronicgs != null and "DESC".equalsIgnoreCase(orderCol.electronicgs)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialSource')">
a.materialSource
<if test='orderCol.materialSource != null and "DESC".equalsIgnoreCase(orderCol.materialSource)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paperNum')">
a.paperNum
<if test='orderCol.paperNum != null and "DESC".equalsIgnoreCase(orderCol.paperNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paperGg')">
a.paperGg
<if test='orderCol.paperGg != null and "DESC".equalsIgnoreCase(orderCol.paperGg)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('jianmMs')">
a.jianmMs
<if test='orderCol.jianmMs != null and "DESC".equalsIgnoreCase(orderCol.jianmMs)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('sealWay')">
a.sealWay
<if test='orderCol.sealWay != null and "DESC".equalsIgnoreCase(orderCol.sealWay)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isjianm')">
a.isjianm
<if test='orderCol.isjianm != null and "DESC".equalsIgnoreCase(orderCol.isjianm)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isLack')">
a.isLack
<if test='orderCol.isLack != null and "DESC".equalsIgnoreCase(orderCol.isLack)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ybUrl')">
a.ybUrl
<if test='orderCol.ybUrl != null and "DESC".equalsIgnoreCase(orderCol.ybUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialSourceSm')">
a.materialSourceSm
<if test='orderCol.materialSourceSm != null and "DESC".equalsIgnoreCase(orderCol.materialSourceSm)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remarkSub')">
a.remarkSub
<if test='orderCol.remarkSub != null and "DESC".equalsIgnoreCase(orderCol.remarkSub)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('clauseContent')">
a.clauseContent
<if test='orderCol.clauseContent != null and "DESC".equalsIgnoreCase(orderCol.clauseContent)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('summary')">
a.summary
<if test='orderCol.summary != null and "DESC".equalsIgnoreCase(orderCol.summary)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('source')">
a.source
<if test='orderCol.source != null and "DESC".equalsIgnoreCase(orderCol.source)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
sst-manager/src/main/resources/sqlmap/module/matter/MatterApplyMapper.xml 0 → 100644
View file @ 9c5b55e7
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.matter.dao.ibatis.MatterApplyDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MatterApplyEntity" id="MatterApplyEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="siteName" column="siteName" />
<result property="siteMatterId" column="siteMatterId" />
<result property="matterId" column="matterId" />
<result property="matterName" column="matterName" />
<result property="matterCode" column="matterCode" />
<result property="deptId" column="deptId" />
<result property="deptName" column="deptName" />
<result property="deptCode" column="deptCode" />
<result property="themeName" column="themeName" />
<result property="source" column="source" />
<result property="reportCount" column="reportCount" />
<result property="datumCount" column="datumCount" />
<result property="govUrl" column="govUrl" />
<result property="isConvert" column="isConvert" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
<result property="themeCode" column="themeCode" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
a.siteId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteName') or colPickMode == 1 and data.containsKey('siteName')))">
a.siteName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteMatterId') or colPickMode == 1 and data.containsKey('siteMatterId')))">
a.siteMatterId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterId') or colPickMode == 1 and data.containsKey('matterId')))">
a.matterId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterName') or colPickMode == 1 and data.containsKey('matterName')))">
a.matterName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterCode') or colPickMode == 1 and data.containsKey('matterCode')))">
a.matterCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptId') or colPickMode == 1 and data.containsKey('deptId')))">
a.deptId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptName') or colPickMode == 1 and data.containsKey('deptName')))">
a.deptName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptCode') or colPickMode == 1 and data.containsKey('deptCode')))">
a.deptCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('themeName') or colPickMode == 1 and data.containsKey('themeName')))">
a.themeName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('source') or colPickMode == 1 and data.containsKey('source')))">
a.source,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('reportCount') or colPickMode == 1 and data.containsKey('reportCount')))">
a.reportCount,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('datumCount') or colPickMode == 1 and data.containsKey('datumCount')))">
a.datumCount,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('govUrl') or colPickMode == 1 and data.containsKey('govUrl')))">
a.govUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isConvert') or colPickMode == 1 and data.containsKey('isConvert')))">
a.isConvert,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('themeCode') or colPickMode == 1 and data.containsKey('themeCode')))">
a.themeCode,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MatterApplyEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_matter_apply
(siteId,siteName,siteMatterId,matterId,matterName,matterCode,deptId,deptName,deptCode,themeName,source,reportCount,datumCount,govUrl,isConvert,createUserId,createTime,updateUserId,updateTime,themeCode)
VALUES
(#{siteId},#{siteName},#{siteMatterId},#{matterId},#{matterName},#{matterCode},#{deptId},#{deptName},#{deptCode},#{themeName},#{source},#{reportCount},#{datumCount},#{govUrl},#{isConvert},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{themeCode})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_matter_apply
(siteId,siteName,siteMatterId,matterId,matterName,matterCode,deptId,deptName,deptCode,themeName,source,reportCount,datumCount,govUrl,isConvert,createUserId,createTime,updateUserId,updateTime,themeCode)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.siteName},#{item.siteMatterId},#{item.matterId},#{item.matterName},#{item.matterCode},#{item.deptId},#{item.deptName},#{item.deptCode},#{item.themeName},#{item.source},#{item.reportCount},#{item.datumCount},#{item.govUrl},#{item.isConvert},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.themeCode})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_sys_matter_apply as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('siteId')) or (colPickMode==1 and !data.containsKey('siteId'))">
a.siteId=#{data.siteId},
</if>
<if test="(colPickMode==0 and data.containsKey('siteIdIncrement')) or (colPickMode==1 and !data.containsKey('siteIdIncrement'))">
a.siteId=ifnull(a.siteId,0) + #{data.siteIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('siteName')) or (colPickMode==1 and !data.containsKey('siteName'))">
a.siteName=#{data.siteName},
</if>
<if test="(colPickMode==0 and data.containsKey('siteMatterId')) or (colPickMode==1 and !data.containsKey('siteMatterId'))">
a.siteMatterId=#{data.siteMatterId},
</if>
<if test="(colPickMode==0 and data.containsKey('siteMatterIdIncrement')) or (colPickMode==1 and !data.containsKey('siteMatterIdIncrement'))">
a.siteMatterId=ifnull(a.siteMatterId,0) + #{data.siteMatterIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('matterId')) or (colPickMode==1 and !data.containsKey('matterId'))">
a.matterId=#{data.matterId},
</if>
<if test="(colPickMode==0 and data.containsKey('matterIdIncrement')) or (colPickMode==1 and !data.containsKey('matterIdIncrement'))">
a.matterId=ifnull(a.matterId,0) + #{data.matterIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('matterName')) or (colPickMode==1 and !data.containsKey('matterName'))">
a.matterName=#{data.matterName},
</if>
<if test="(colPickMode==0 and data.containsKey('matterCode')) or (colPickMode==1 and !data.containsKey('matterCode'))">
a.matterCode=#{data.matterCode},
</if>
<if test="(colPickMode==0 and data.containsKey('deptId')) or (colPickMode==1 and !data.containsKey('deptId'))">
a.deptId=#{data.deptId},
</if>
<if test="(colPickMode==0 and data.containsKey('deptIdIncrement')) or (colPickMode==1 and !data.containsKey('deptIdIncrement'))">
a.deptId=ifnull(a.deptId,0) + #{data.deptIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('deptName')) or (colPickMode==1 and !data.containsKey('deptName'))">
a.deptName=#{data.deptName},
</if>
<if test="(colPickMode==0 and data.containsKey('deptCode')) or (colPickMode==1 and !data.containsKey('deptCode'))">
a.deptCode=#{data.deptCode},
</if>
<if test="(colPickMode==0 and data.containsKey('themeName')) or (colPickMode==1 and !data.containsKey('themeName'))">
a.themeName=#{data.themeName},
</if>
<if test="(colPickMode==0 and data.containsKey('source')) or (colPickMode==1 and !data.containsKey('source'))">
a.source=#{data.source},
</if>
<if test="(colPickMode==0 and data.containsKey('sourceIncrement')) or (colPickMode==1 and !data.containsKey('sourceIncrement'))">
a.source=ifnull(a.source,0) + #{data.sourceIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('reportCount')) or (colPickMode==1 and !data.containsKey('reportCount'))">
a.reportCount=#{data.reportCount},
</if>
<if test="(colPickMode==0 and data.containsKey('reportCountIncrement')) or (colPickMode==1 and !data.containsKey('reportCountIncrement'))">
a.reportCount=ifnull(a.reportCount,0) + #{data.reportCountIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('datumCount')) or (colPickMode==1 and !data.containsKey('datumCount'))">
a.datumCount=#{data.datumCount},
</if>
<if test="(colPickMode==0 and data.containsKey('datumCountIncrement')) or (colPickMode==1 and !data.containsKey('datumCountIncrement'))">
a.datumCount=ifnull(a.datumCount,0) + #{data.datumCountIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('govUrl')) or (colPickMode==1 and !data.containsKey('govUrl'))">
a.govUrl=#{data.govUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('isConvert')) or (colPickMode==1 and !data.containsKey('isConvert'))">
a.isConvert=#{data.isConvert},
</if>
<if test="(colPickMode==0 and data.containsKey('isConvertIncrement')) or (colPickMode==1 and !data.containsKey('isConvertIncrement'))">
a.isConvert=ifnull(a.isConvert,0) + #{data.isConvertIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
<if test="(colPickMode==0 and data.containsKey('themeCode')) or (colPickMode==1 and !data.containsKey('themeCode'))">
a.themeCode=#{data.themeCode},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_sys_matter_apply as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="siteId=(case" suffix="ELSE siteId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
when a.id=#{item.id} then #{item.siteId}
</when>
<when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="siteName=(case" suffix="ELSE siteName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('siteName')) or (colPickMode==1 and !item.containsKey('siteName'))">
when a.id=#{item.id} then #{item.siteName}
</if>
</foreach>
</trim>
<trim prefix="siteMatterId=(case" suffix="ELSE siteMatterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('siteMatterId')) or (colPickMode==1 and !item.containsKey('siteMatterId'))">
when a.id=#{item.id} then #{item.siteMatterId}
</when>
<when test="(colPickMode==0 and item.containsKey('siteMatterIdIncrement')) or (colPickMode==1 and !item.containsKey('siteMatterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.siteMatterId,0) + #{item.siteMatterIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="matterId=(case" suffix="ELSE matterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('matterId')) or (colPickMode==1 and !item.containsKey('matterId'))">
when a.id=#{item.id} then #{item.matterId}
</when>
<when test="(colPickMode==0 and item.containsKey('matterIdIncrement')) or (colPickMode==1 and !item.containsKey('matterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.matterId,0) + #{item.matterIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="matterName=(case" suffix="ELSE matterName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('matterName')) or (colPickMode==1 and !item.containsKey('matterName'))">
when a.id=#{item.id} then #{item.matterName}
</if>
</foreach>
</trim>
<trim prefix="matterCode=(case" suffix="ELSE matterCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('matterCode')) or (colPickMode==1 and !item.containsKey('matterCode'))">
when a.id=#{item.id} then #{item.matterCode}
</if>
</foreach>
</trim>
<trim prefix="deptId=(case" suffix="ELSE deptId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deptId')) or (colPickMode==1 and !item.containsKey('deptId'))">
when a.id=#{item.id} then #{item.deptId}
</when>
<when test="(colPickMode==0 and item.containsKey('deptIdIncrement')) or (colPickMode==1 and !item.containsKey('deptIdIncrement'))">
when a.id=#{item.id} then ifnull(a.deptId,0) + #{item.deptIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deptName=(case" suffix="ELSE deptName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deptName')) or (colPickMode==1 and !item.containsKey('deptName'))">
when a.id=#{item.id} then #{item.deptName}
</if>
</foreach>
</trim>
<trim prefix="deptCode=(case" suffix="ELSE deptCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deptCode')) or (colPickMode==1 and !item.containsKey('deptCode'))">
when a.id=#{item.id} then #{item.deptCode}
</if>
</foreach>
</trim>
<trim prefix="themeName=(case" suffix="ELSE themeName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('themeName')) or (colPickMode==1 and !item.containsKey('themeName'))">
when a.id=#{item.id} then #{item.themeName}
</if>
</foreach>
</trim>
<trim prefix="source=(case" suffix="ELSE source end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('source')) or (colPickMode==1 and !item.containsKey('source'))">
when a.id=#{item.id} then #{item.source}
</when>
<when test="(colPickMode==0 and item.containsKey('sourceIncrement')) or (colPickMode==1 and !item.containsKey('sourceIncrement'))">
when a.id=#{item.id} then ifnull(a.source,0) + #{item.sourceIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="reportCount=(case" suffix="ELSE reportCount end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('reportCount')) or (colPickMode==1 and !item.containsKey('reportCount'))">
when a.id=#{item.id} then #{item.reportCount}
</when>
<when test="(colPickMode==0 and item.containsKey('reportCountIncrement')) or (colPickMode==1 and !item.containsKey('reportCountIncrement'))">
when a.id=#{item.id} then ifnull(a.reportCount,0) + #{item.reportCountIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="datumCount=(case" suffix="ELSE datumCount end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('datumCount')) or (colPickMode==1 and !item.containsKey('datumCount'))">
when a.id=#{item.id} then #{item.datumCount}
</when>
<when test="(colPickMode==0 and item.containsKey('datumCountIncrement')) or (colPickMode==1 and !item.containsKey('datumCountIncrement'))">
when a.id=#{item.id} then ifnull(a.datumCount,0) + #{item.datumCountIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="govUrl=(case" suffix="ELSE govUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('govUrl')) or (colPickMode==1 and !item.containsKey('govUrl'))">
when a.id=#{item.id} then #{item.govUrl}
</if>
</foreach>
</trim>
<trim prefix="isConvert=(case" suffix="ELSE isConvert end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isConvert')) or (colPickMode==1 and !item.containsKey('isConvert'))">
when a.id=#{item.id} then #{item.isConvert}
</when>
<when test="(colPickMode==0 and item.containsKey('isConvertIncrement')) or (colPickMode==1 and !item.containsKey('isConvertIncrement'))">
when a.id=#{item.id} then ifnull(a.isConvert,0) + #{item.isConvertIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="themeCode=(case" suffix="ELSE themeCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('themeCode')) or (colPickMode==1 and !item.containsKey('themeCode'))">
when a.id=#{item.id} then #{item.themeCode}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MatterApplyEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_apply as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_sys_matter_apply as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_sys_matter_apply where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_sys_matter_apply where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_sys_matter_apply where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_sys_matter_apply as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MatterApplyEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_apply as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_sys_matter_apply as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList')">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{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>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('siteName')">
<if test="conditionParamRef.siteName != null and conditionParamRef.siteName != ''">
${_conditionType_} a.siteName like #{${_conditionParam_}.siteName}
</if>
<if test="conditionParamRef.siteName == null">
${_conditionType_} a.siteName is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteNameList')">
${_conditionType_} a.siteName in
<foreach collection="conditionParamRef.siteNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteNameNotList')">
${_conditionType_} a.siteName not in
<foreach collection="conditionParamRef.siteNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteMatterId')">
<if test="conditionParamRef.siteMatterId != null ">
${_conditionType_} a.siteMatterId = #{${_conditionParam_}.siteMatterId}
</if>
<if test="conditionParamRef.siteMatterId == null">
${_conditionType_} a.siteMatterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteMatterIdList')">
${_conditionType_} a.siteMatterId in
<foreach collection="conditionParamRef.siteMatterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteMatterIdNotList')">
${_conditionType_} a.siteMatterId not in
<foreach collection="conditionParamRef.siteMatterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteMatterIdStart') and conditionParamRef.siteMatterIdStart != null">
${_conditionType_} a.siteMatterId <![CDATA[ >= ]]> #{${_conditionParam_}.siteMatterIdStart}
</if>
<if test="conditionParamRef.containsKey('siteMatterIdEnd') and conditionParamRef.siteMatterIdEnd != null">
${_conditionType_} a.siteMatterId <![CDATA[ <= ]]> #{${_conditionParam_}.siteMatterIdEnd}
</if>
<if test="conditionParamRef.containsKey('matterId')">
<if test="conditionParamRef.matterId != null ">
${_conditionType_} a.matterId = #{${_conditionParam_}.matterId}
</if>
<if test="conditionParamRef.matterId == null">
${_conditionType_} a.matterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterIdList')">
${_conditionType_} a.matterId in
<foreach collection="conditionParamRef.matterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdNotList')">
${_conditionType_} a.matterId not in
<foreach collection="conditionParamRef.matterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdStart') and conditionParamRef.matterIdStart != null">
${_conditionType_} a.matterId <![CDATA[ >= ]]> #{${_conditionParam_}.matterIdStart}
</if>
<if test="conditionParamRef.containsKey('matterIdEnd') and conditionParamRef.matterIdEnd != null">
${_conditionType_} a.matterId <![CDATA[ <= ]]> #{${_conditionParam_}.matterIdEnd}
</if>
<if test="conditionParamRef.containsKey('matterName')">
<if test="conditionParamRef.matterName != null and conditionParamRef.matterName != ''">
${_conditionType_} a.matterName like #{${_conditionParam_}.matterName}
</if>
<if test="conditionParamRef.matterName == null">
${_conditionType_} a.matterName is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterNameList')">
${_conditionType_} a.matterName in
<foreach collection="conditionParamRef.matterNameList" open="(" close=")" index="index" item="item" separator=",">
#{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('matterCode')">
<if test="conditionParamRef.matterCode != null and conditionParamRef.matterCode != ''">
${_conditionType_} a.matterCode like #{${_conditionParam_}.matterCode}
</if>
<if test="conditionParamRef.matterCode == null">
${_conditionType_} a.matterCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterCodeList')">
${_conditionType_} a.matterCode in
<foreach collection="conditionParamRef.matterCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterCodeNotList')">
${_conditionType_} a.matterCode not in
<foreach collection="conditionParamRef.matterCodeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptId')">
<if test="conditionParamRef.deptId != null ">
${_conditionType_} a.deptId = #{${_conditionParam_}.deptId}
</if>
<if test="conditionParamRef.deptId == null">
${_conditionType_} a.deptId is null
</if>
</if>
<if test="conditionParamRef.containsKey('deptIdList')">
${_conditionType_} a.deptId in
<foreach collection="conditionParamRef.deptIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptIdNotList')">
${_conditionType_} a.deptId not in
<foreach collection="conditionParamRef.deptIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptIdStart') and conditionParamRef.deptIdStart != null">
${_conditionType_} a.deptId <![CDATA[ >= ]]> #{${_conditionParam_}.deptIdStart}
</if>
<if test="conditionParamRef.containsKey('deptIdEnd') and conditionParamRef.deptIdEnd != null">
${_conditionType_} a.deptId <![CDATA[ <= ]]> #{${_conditionParam_}.deptIdEnd}
</if>
<if test="conditionParamRef.containsKey('deptName')">
<if test="conditionParamRef.deptName != null and conditionParamRef.deptName != ''">
${_conditionType_} a.deptName like #{${_conditionParam_}.deptName}
</if>
<if test="conditionParamRef.deptName == null">
${_conditionType_} a.deptName is null
</if>
</if>
<if test="conditionParamRef.containsKey('deptNameList')">
${_conditionType_} a.deptName in
<foreach collection="conditionParamRef.deptNameList" open="(" close=")" index="index" item="item" separator=",">
#{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('deptCode')">
<if test="conditionParamRef.deptCode != null and conditionParamRef.deptCode != ''">
${_conditionType_} a.deptCode like #{${_conditionParam_}.deptCode}
</if>
<if test="conditionParamRef.deptCode == null">
${_conditionType_} a.deptCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('deptCodeList')">
${_conditionType_} a.deptCode in
<foreach collection="conditionParamRef.deptCodeList" open="(" close=")" index="index" item="item" separator=",">
#{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('themeName')">
<if test="conditionParamRef.themeName != null and conditionParamRef.themeName != ''">
${_conditionType_} a.themeName like #{${_conditionParam_}.themeName}
</if>
<if test="conditionParamRef.themeName == null">
${_conditionType_} a.themeName is null
</if>
</if>
<if test="conditionParamRef.containsKey('themeNameList')">
${_conditionType_} a.themeName in
<foreach collection="conditionParamRef.themeNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('themeNameNotList')">
${_conditionType_} a.themeName not in
<foreach collection="conditionParamRef.themeNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('source')">
<if test="conditionParamRef.source != null ">
${_conditionType_} a.source = #{${_conditionParam_}.source}
</if>
<if test="conditionParamRef.source == null">
${_conditionType_} a.source is null
</if>
</if>
<if test="conditionParamRef.containsKey('sourceList')">
${_conditionType_} a.source in
<foreach collection="conditionParamRef.sourceList" open="(" close=")" index="index" item="item" separator=",">
#{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>
<if test="conditionParamRef.containsKey('sourceEnd') and conditionParamRef.sourceEnd != null">
${_conditionType_} a.source <![CDATA[ <= ]]> #{${_conditionParam_}.sourceEnd}
</if>
<if test="conditionParamRef.containsKey('reportCount')">
<if test="conditionParamRef.reportCount != null ">
${_conditionType_} a.reportCount = #{${_conditionParam_}.reportCount}
</if>
<if test="conditionParamRef.reportCount == null">
${_conditionType_} a.reportCount is null
</if>
</if>
<if test="conditionParamRef.containsKey('reportCountList')">
${_conditionType_} a.reportCount in
<foreach collection="conditionParamRef.reportCountList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('reportCountNotList')">
${_conditionType_} a.reportCount not in
<foreach collection="conditionParamRef.reportCountNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('reportCountStart') and conditionParamRef.reportCountStart != null">
${_conditionType_} a.reportCount <![CDATA[ >= ]]> #{${_conditionParam_}.reportCountStart}
</if>
<if test="conditionParamRef.containsKey('reportCountEnd') and conditionParamRef.reportCountEnd != null">
${_conditionType_} a.reportCount <![CDATA[ <= ]]> #{${_conditionParam_}.reportCountEnd}
</if>
<if test="conditionParamRef.containsKey('datumCount')">
<if test="conditionParamRef.datumCount != null ">
${_conditionType_} a.datumCount = #{${_conditionParam_}.datumCount}
</if>
<if test="conditionParamRef.datumCount == null">
${_conditionType_} a.datumCount is null
</if>
</if>
<if test="conditionParamRef.containsKey('datumCountList')">
${_conditionType_} a.datumCount in
<foreach collection="conditionParamRef.datumCountList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumCountNotList')">
${_conditionType_} a.datumCount not in
<foreach collection="conditionParamRef.datumCountNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumCountStart') and conditionParamRef.datumCountStart != null">
${_conditionType_} a.datumCount <![CDATA[ >= ]]> #{${_conditionParam_}.datumCountStart}
</if>
<if test="conditionParamRef.containsKey('datumCountEnd') and conditionParamRef.datumCountEnd != null">
${_conditionType_} a.datumCount <![CDATA[ <= ]]> #{${_conditionParam_}.datumCountEnd}
</if>
<if test="conditionParamRef.containsKey('govUrl')">
<if test="conditionParamRef.govUrl != null and conditionParamRef.govUrl != ''">
${_conditionType_} a.govUrl like #{${_conditionParam_}.govUrl}
</if>
<if test="conditionParamRef.govUrl == null">
${_conditionType_} a.govUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('govUrlList')">
${_conditionType_} a.govUrl in
<foreach collection="conditionParamRef.govUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('govUrlNotList')">
${_conditionType_} a.govUrl not in
<foreach collection="conditionParamRef.govUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isConvert')">
<if test="conditionParamRef.isConvert != null ">
${_conditionType_} a.isConvert = #{${_conditionParam_}.isConvert}
</if>
<if test="conditionParamRef.isConvert == null">
${_conditionType_} a.isConvert is null
</if>
</if>
<if test="conditionParamRef.containsKey('isConvertList')">
${_conditionType_} a.isConvert in
<foreach collection="conditionParamRef.isConvertList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isConvertNotList')">
${_conditionType_} a.isConvert not in
<foreach collection="conditionParamRef.isConvertNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isConvertStart') and conditionParamRef.isConvertStart != null">
${_conditionType_} a.isConvert <![CDATA[ >= ]]> #{${_conditionParam_}.isConvertStart}
</if>
<if test="conditionParamRef.containsKey('isConvertEnd') and conditionParamRef.isConvertEnd != null">
${_conditionType_} a.isConvert <![CDATA[ <= ]]> #{${_conditionParam_}.isConvertEnd}
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList')">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('themeCode')">
<if test="conditionParamRef.themeCode != null and conditionParamRef.themeCode != ''">
${_conditionType_} a.themeCode like #{${_conditionParam_}.themeCode}
</if>
<if test="conditionParamRef.themeCode == null">
${_conditionType_} a.themeCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('themeCodeList')">
${_conditionType_} a.themeCode in
<foreach collection="conditionParamRef.themeCodeList" open="(" close=")" index="index" item="item" separator=",">
#{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>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteId')">
a.siteId
<if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteName')">
a.siteName
<if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteMatterId')">
a.siteMatterId
<if test='orderCol.siteMatterId != null and "DESC".equalsIgnoreCase(orderCol.siteMatterId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterId')">
a.matterId
<if test='orderCol.matterId != null and "DESC".equalsIgnoreCase(orderCol.matterId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterName')">
a.matterName
<if test='orderCol.matterName != null and "DESC".equalsIgnoreCase(orderCol.matterName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterCode')">
a.matterCode
<if test='orderCol.matterCode != null and "DESC".equalsIgnoreCase(orderCol.matterCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deptId')">
a.deptId
<if test='orderCol.deptId != null and "DESC".equalsIgnoreCase(orderCol.deptId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deptName')">
a.deptName
<if test='orderCol.deptName != null and "DESC".equalsIgnoreCase(orderCol.deptName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deptCode')">
a.deptCode
<if test='orderCol.deptCode != null and "DESC".equalsIgnoreCase(orderCol.deptCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('themeName')">
a.themeName
<if test='orderCol.themeName != null and "DESC".equalsIgnoreCase(orderCol.themeName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('source')">
a.source
<if test='orderCol.source != null and "DESC".equalsIgnoreCase(orderCol.source)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('reportCount')">
a.reportCount
<if test='orderCol.reportCount != null and "DESC".equalsIgnoreCase(orderCol.reportCount)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('datumCount')">
a.datumCount
<if test='orderCol.datumCount != null and "DESC".equalsIgnoreCase(orderCol.datumCount)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('govUrl')">
a.govUrl
<if test='orderCol.govUrl != null and "DESC".equalsIgnoreCase(orderCol.govUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isConvert')">
a.isConvert
<if test='orderCol.isConvert != null and "DESC".equalsIgnoreCase(orderCol.isConvert)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('themeCode')">
a.themeCode
<if test='orderCol.themeCode != null and "DESC".equalsIgnoreCase(orderCol.themeCode)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
sst-manager/src/main/resources/sqlmap/module/matter/MatterDatumFileMapper.xml 0 → 100644
View file @ 9c5b55e7
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.matter.dao.ibatis.MatterDatumFileDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MatterDatumFileEntity" id="MatterDatumFileEntity-Map">
<id property="id" column="id" />
<result property="datumId" column="datumId" />
<result property="matterId" column="matterId" />
<result property="matterCode" column="matterCode" />
<result property="materialName" column="materialName" />
<result property="fileName" column="fileName" />
<result property="fileUrl" column="fileUrl" />
<result property="filetype" column="filetype" />
<result property="source" column="source" />
<result property="localFileUrl" column="localFileUrl" />
<result property="previewUrl" column="previewUrl" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('datumId') or colPickMode == 1 and data.containsKey('datumId')))">
a.datumId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterId') or colPickMode == 1 and data.containsKey('matterId')))">
a.matterId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterCode') or colPickMode == 1 and data.containsKey('matterCode')))">
a.matterCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialName') or colPickMode == 1 and data.containsKey('materialName')))">
a.materialName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fileName') or colPickMode == 1 and data.containsKey('fileName')))">
a.fileName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fileUrl') or colPickMode == 1 and data.containsKey('fileUrl')))">
a.fileUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('filetype') or colPickMode == 1 and data.containsKey('filetype')))">
a.filetype,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('source') or colPickMode == 1 and data.containsKey('source')))">
a.source,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('localFileUrl') or colPickMode == 1 and data.containsKey('localFileUrl')))">
a.localFileUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('previewUrl') or colPickMode == 1 and data.containsKey('previewUrl')))">
a.previewUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MatterDatumFileEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_matter_datum_file
(datumId,matterId,matterCode,materialName,fileName,fileUrl,filetype,source,localFileUrl,previewUrl,createTime,createUserId,updateTime)
VALUES
(#{datumId},#{matterId},#{matterCode},#{materialName},#{fileName},#{fileUrl},#{filetype},#{source},#{localFileUrl},#{previewUrl},#{createTime},#{createUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_matter_datum_file
(datumId,matterId,matterCode,materialName,fileName,fileUrl,filetype,source,localFileUrl,previewUrl,createTime,createUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.datumId},#{item.matterId},#{item.matterCode},#{item.materialName},#{item.fileName},#{item.fileUrl},#{item.filetype},#{item.source},#{item.localFileUrl},#{item.previewUrl},#{item.createTime},#{item.createUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_sys_matter_datum_file as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('datumId')) or (colPickMode==1 and !data.containsKey('datumId'))">
a.datumId=#{data.datumId},
</if>
<if test="(colPickMode==0 and data.containsKey('datumIdIncrement')) or (colPickMode==1 and !data.containsKey('datumIdIncrement'))">
a.datumId=ifnull(a.datumId,0) + #{data.datumIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('matterId')) or (colPickMode==1 and !data.containsKey('matterId'))">
a.matterId=#{data.matterId},
</if>
<if test="(colPickMode==0 and data.containsKey('matterIdIncrement')) or (colPickMode==1 and !data.containsKey('matterIdIncrement'))">
a.matterId=ifnull(a.matterId,0) + #{data.matterIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('matterCode')) or (colPickMode==1 and !data.containsKey('matterCode'))">
a.matterCode=#{data.matterCode},
</if>
<if test="(colPickMode==0 and data.containsKey('materialName')) or (colPickMode==1 and !data.containsKey('materialName'))">
a.materialName=#{data.materialName},
</if>
<if test="(colPickMode==0 and data.containsKey('fileName')) or (colPickMode==1 and !data.containsKey('fileName'))">
a.fileName=#{data.fileName},
</if>
<if test="(colPickMode==0 and data.containsKey('fileUrl')) or (colPickMode==1 and !data.containsKey('fileUrl'))">
a.fileUrl=#{data.fileUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('filetype')) or (colPickMode==1 and !data.containsKey('filetype'))">
a.filetype=#{data.filetype},
</if>
<if test="(colPickMode==0 and data.containsKey('filetypeIncrement')) or (colPickMode==1 and !data.containsKey('filetypeIncrement'))">
a.filetype=ifnull(a.filetype,0) + #{data.filetypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('source')) or (colPickMode==1 and !data.containsKey('source'))">
a.source=#{data.source},
</if>
<if test="(colPickMode==0 and data.containsKey('sourceIncrement')) or (colPickMode==1 and !data.containsKey('sourceIncrement'))">
a.source=ifnull(a.source,0) + #{data.sourceIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('localFileUrl')) or (colPickMode==1 and !data.containsKey('localFileUrl'))">
a.localFileUrl=#{data.localFileUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('previewUrl')) or (colPickMode==1 and !data.containsKey('previewUrl'))">
a.previewUrl=#{data.previewUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_sys_matter_datum_file as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="datumId=(case" suffix="ELSE datumId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('datumId')) or (colPickMode==1 and !item.containsKey('datumId'))">
when a.id=#{item.id} then #{item.datumId}
</when>
<when test="(colPickMode==0 and item.containsKey('datumIdIncrement')) or (colPickMode==1 and !item.containsKey('datumIdIncrement'))">
when a.id=#{item.id} then ifnull(a.datumId,0) + #{item.datumIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="matterId=(case" suffix="ELSE matterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('matterId')) or (colPickMode==1 and !item.containsKey('matterId'))">
when a.id=#{item.id} then #{item.matterId}
</when>
<when test="(colPickMode==0 and item.containsKey('matterIdIncrement')) or (colPickMode==1 and !item.containsKey('matterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.matterId,0) + #{item.matterIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="matterCode=(case" suffix="ELSE matterCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('matterCode')) or (colPickMode==1 and !item.containsKey('matterCode'))">
when a.id=#{item.id} then #{item.matterCode}
</if>
</foreach>
</trim>
<trim prefix="materialName=(case" suffix="ELSE materialName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialName')) or (colPickMode==1 and !item.containsKey('materialName'))">
when a.id=#{item.id} then #{item.materialName}
</if>
</foreach>
</trim>
<trim prefix="fileName=(case" suffix="ELSE fileName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('fileName')) or (colPickMode==1 and !item.containsKey('fileName'))">
when a.id=#{item.id} then #{item.fileName}
</if>
</foreach>
</trim>
<trim prefix="fileUrl=(case" suffix="ELSE fileUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('fileUrl')) or (colPickMode==1 and !item.containsKey('fileUrl'))">
when a.id=#{item.id} then #{item.fileUrl}
</if>
</foreach>
</trim>
<trim prefix="filetype=(case" suffix="ELSE filetype end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('filetype')) or (colPickMode==1 and !item.containsKey('filetype'))">
when a.id=#{item.id} then #{item.filetype}
</when>
<when test="(colPickMode==0 and item.containsKey('filetypeIncrement')) or (colPickMode==1 and !item.containsKey('filetypeIncrement'))">
when a.id=#{item.id} then ifnull(a.filetype,0) + #{item.filetypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="source=(case" suffix="ELSE source end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('source')) or (colPickMode==1 and !item.containsKey('source'))">
when a.id=#{item.id} then #{item.source}
</when>
<when test="(colPickMode==0 and item.containsKey('sourceIncrement')) or (colPickMode==1 and !item.containsKey('sourceIncrement'))">
when a.id=#{item.id} then ifnull(a.source,0) + #{item.sourceIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="localFileUrl=(case" suffix="ELSE localFileUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('localFileUrl')) or (colPickMode==1 and !item.containsKey('localFileUrl'))">
when a.id=#{item.id} then #{item.localFileUrl}
</if>
</foreach>
</trim>
<trim prefix="previewUrl=(case" suffix="ELSE previewUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('previewUrl')) or (colPickMode==1 and !item.containsKey('previewUrl'))">
when a.id=#{item.id} then #{item.previewUrl}
</if>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MatterDatumFileEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_datum_file as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_sys_matter_datum_file as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_sys_matter_datum_file where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_sys_matter_datum_file where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_sys_matter_datum_file where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_sys_matter_datum_file as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MatterDatumFileEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_datum_file as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_sys_matter_datum_file as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('datumId')">
<if test="conditionParamRef.datumId != null ">
${_conditionType_} a.datumId = #{${_conditionParam_}.datumId}
</if>
<if test="conditionParamRef.datumId == null">
${_conditionType_} a.datumId is null
</if>
</if>
<if test="conditionParamRef.containsKey('datumIdList')">
${_conditionType_} a.datumId in
<foreach collection="conditionParamRef.datumIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumIdNotList')">
${_conditionType_} a.datumId not in
<foreach collection="conditionParamRef.datumIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumIdStart') and conditionParamRef.datumIdStart != null">
${_conditionType_} a.datumId <![CDATA[ >= ]]> #{${_conditionParam_}.datumIdStart}
</if>
<if test="conditionParamRef.containsKey('datumIdEnd') and conditionParamRef.datumIdEnd != null">
${_conditionType_} a.datumId <![CDATA[ <= ]]> #{${_conditionParam_}.datumIdEnd}
</if>
<if test="conditionParamRef.containsKey('matterId')">
<if test="conditionParamRef.matterId != null ">
${_conditionType_} a.matterId = #{${_conditionParam_}.matterId}
</if>
<if test="conditionParamRef.matterId == null">
${_conditionType_} a.matterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterIdList')">
${_conditionType_} a.matterId in
<foreach collection="conditionParamRef.matterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdNotList')">
${_conditionType_} a.matterId not in
<foreach collection="conditionParamRef.matterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdStart') and conditionParamRef.matterIdStart != null">
${_conditionType_} a.matterId <![CDATA[ >= ]]> #{${_conditionParam_}.matterIdStart}
</if>
<if test="conditionParamRef.containsKey('matterIdEnd') and conditionParamRef.matterIdEnd != null">
${_conditionType_} a.matterId <![CDATA[ <= ]]> #{${_conditionParam_}.matterIdEnd}
</if>
<if test="conditionParamRef.containsKey('matterCode')">
<if test="conditionParamRef.matterCode != null and conditionParamRef.matterCode != ''">
${_conditionType_} a.matterCode like #{${_conditionParam_}.matterCode}
</if>
<if test="conditionParamRef.matterCode == null">
${_conditionType_} a.matterCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterCodeList')">
${_conditionType_} a.matterCode in
<foreach collection="conditionParamRef.matterCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterCodeNotList')">
${_conditionType_} a.matterCode not in
<foreach collection="conditionParamRef.matterCodeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialName')">
<if test="conditionParamRef.materialName != null and conditionParamRef.materialName != ''">
${_conditionType_} a.materialName like #{${_conditionParam_}.materialName}
</if>
<if test="conditionParamRef.materialName == null">
${_conditionType_} a.materialName is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialNameList')">
${_conditionType_} a.materialName in
<foreach collection="conditionParamRef.materialNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialNameNotList')">
${_conditionType_} a.materialName not in
<foreach collection="conditionParamRef.materialNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileName')">
<if test="conditionParamRef.fileName != null and conditionParamRef.fileName != ''">
${_conditionType_} a.fileName like #{${_conditionParam_}.fileName}
</if>
<if test="conditionParamRef.fileName == null">
${_conditionType_} a.fileName is null
</if>
</if>
<if test="conditionParamRef.containsKey('fileNameList')">
${_conditionType_} a.fileName in
<foreach collection="conditionParamRef.fileNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileNameNotList')">
${_conditionType_} a.fileName not in
<foreach collection="conditionParamRef.fileNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileUrl')">
<if test="conditionParamRef.fileUrl != null and conditionParamRef.fileUrl != ''">
${_conditionType_} a.fileUrl like #{${_conditionParam_}.fileUrl}
</if>
<if test="conditionParamRef.fileUrl == null">
${_conditionType_} a.fileUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('fileUrlList')">
${_conditionType_} a.fileUrl in
<foreach collection="conditionParamRef.fileUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileUrlNotList')">
${_conditionType_} a.fileUrl not in
<foreach collection="conditionParamRef.fileUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('filetype')">
<if test="conditionParamRef.filetype != null ">
${_conditionType_} a.filetype = #{${_conditionParam_}.filetype}
</if>
<if test="conditionParamRef.filetype == null">
${_conditionType_} a.filetype is null
</if>
</if>
<if test="conditionParamRef.containsKey('filetypeList')">
${_conditionType_} a.filetype in
<foreach collection="conditionParamRef.filetypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('filetypeNotList')">
${_conditionType_} a.filetype not in
<foreach collection="conditionParamRef.filetypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('filetypeStart') and conditionParamRef.filetypeStart != null">
${_conditionType_} a.filetype <![CDATA[ >= ]]> #{${_conditionParam_}.filetypeStart}
</if>
<if test="conditionParamRef.containsKey('filetypeEnd') and conditionParamRef.filetypeEnd != null">
${_conditionType_} a.filetype <![CDATA[ <= ]]> #{${_conditionParam_}.filetypeEnd}
</if>
<if test="conditionParamRef.containsKey('source')">
<if test="conditionParamRef.source != null ">
${_conditionType_} a.source = #{${_conditionParam_}.source}
</if>
<if test="conditionParamRef.source == null">
${_conditionType_} a.source is null
</if>
</if>
<if test="conditionParamRef.containsKey('sourceList')">
${_conditionType_} a.source in
<foreach collection="conditionParamRef.sourceList" open="(" close=")" index="index" item="item" separator=",">
#{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>
<if test="conditionParamRef.containsKey('sourceEnd') and conditionParamRef.sourceEnd != null">
${_conditionType_} a.source <![CDATA[ <= ]]> #{${_conditionParam_}.sourceEnd}
</if>
<if test="conditionParamRef.containsKey('localFileUrl')">
<if test="conditionParamRef.localFileUrl != null and conditionParamRef.localFileUrl != ''">
${_conditionType_} a.localFileUrl like #{${_conditionParam_}.localFileUrl}
</if>
<if test="conditionParamRef.localFileUrl == null">
${_conditionType_} a.localFileUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('localFileUrlList')">
${_conditionType_} a.localFileUrl in
<foreach collection="conditionParamRef.localFileUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('localFileUrlNotList')">
${_conditionType_} a.localFileUrl not in
<foreach collection="conditionParamRef.localFileUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('previewUrl')">
<if test="conditionParamRef.previewUrl != null and conditionParamRef.previewUrl != ''">
${_conditionType_} a.previewUrl like #{${_conditionParam_}.previewUrl}
</if>
<if test="conditionParamRef.previewUrl == null">
${_conditionType_} a.previewUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('previewUrlList')">
${_conditionType_} a.previewUrl in
<foreach collection="conditionParamRef.previewUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('previewUrlNotList')">
${_conditionType_} a.previewUrl not in
<foreach collection="conditionParamRef.previewUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('datumId')">
a.datumId
<if test='orderCol.datumId != null and "DESC".equalsIgnoreCase(orderCol.datumId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterId')">
a.matterId
<if test='orderCol.matterId != null and "DESC".equalsIgnoreCase(orderCol.matterId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterCode')">
a.matterCode
<if test='orderCol.matterCode != null and "DESC".equalsIgnoreCase(orderCol.matterCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialName')">
a.materialName
<if test='orderCol.materialName != null and "DESC".equalsIgnoreCase(orderCol.materialName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('fileName')">
a.fileName
<if test='orderCol.fileName != null and "DESC".equalsIgnoreCase(orderCol.fileName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('fileUrl')">
a.fileUrl
<if test='orderCol.fileUrl != null and "DESC".equalsIgnoreCase(orderCol.fileUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('filetype')">
a.filetype
<if test='orderCol.filetype != null and "DESC".equalsIgnoreCase(orderCol.filetype)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('source')">
a.source
<if test='orderCol.source != null and "DESC".equalsIgnoreCase(orderCol.source)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('localFileUrl')">
a.localFileUrl
<if test='orderCol.localFileUrl != null and "DESC".equalsIgnoreCase(orderCol.localFileUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('previewUrl')">
a.previewUrl
<if test='orderCol.previewUrl != null and "DESC".equalsIgnoreCase(orderCol.previewUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
sst-manager/src/main/resources/sqlmap/module/matter/MatterDatumMapper.xml 0 → 100644
View file @ 9c5b55e7
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.matter.dao.ibatis.MatterDatumDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MatterDatumEntity" id="MatterDatumEntity-Map">
<id property="id" column="id" />
<result property="matterId" column="matterId" />
<result property="materialName" column="materialName" />
<result property="isMust" column="isMust" />
<result property="materialType" column="materialType" />
<result property="materialProperty" column="materialProperty" />
<result property="electronicgs" column="electronicgs" />
<result property="materialSource" column="materialSource" />
<result property="paperNum" column="paperNum" />
<result property="paperGg" column="paperGg" />
<result property="jianmMs" column="jianmMs" />
<result property="sealWay" column="sealWay" />
<result property="isjianm" column="isjianm" />
<result property="isLack" column="isLack" />
<result property="ybUrl" column="ybUrl" />
<result property="materialSourceSm" column="materialSourceSm" />
<result property="remarkSub" column="remarkSub" />
<result property="clauseContent" column="clauseContent" />
<result property="summary" column="summary" />
<result property="remark" column="remark" />
<result property="source" column="source" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('matterId') or colPickMode == 1 and data.containsKey('matterId')))">
a.matterId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialName') or colPickMode == 1 and data.containsKey('materialName')))">
a.materialName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isMust') or colPickMode == 1 and data.containsKey('isMust')))">
a.isMust,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialType') or colPickMode == 1 and data.containsKey('materialType')))">
a.materialType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialProperty') or colPickMode == 1 and data.containsKey('materialProperty')))">
a.materialProperty,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('electronicgs') or colPickMode == 1 and data.containsKey('electronicgs')))">
a.electronicgs,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialSource') or colPickMode == 1 and data.containsKey('materialSource')))">
a.materialSource,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paperNum') or colPickMode == 1 and data.containsKey('paperNum')))">
a.paperNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paperGg') or colPickMode == 1 and data.containsKey('paperGg')))">
a.paperGg,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('jianmMs') or colPickMode == 1 and data.containsKey('jianmMs')))">
a.jianmMs,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sealWay') or colPickMode == 1 and data.containsKey('sealWay')))">
a.sealWay,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isjianm') or colPickMode == 1 and data.containsKey('isjianm')))">
a.isjianm,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isLack') or colPickMode == 1 and data.containsKey('isLack')))">
a.isLack,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ybUrl') or colPickMode == 1 and data.containsKey('ybUrl')))">
a.ybUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('materialSourceSm') or colPickMode == 1 and data.containsKey('materialSourceSm')))">
a.materialSourceSm,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remarkSub') or colPickMode == 1 and data.containsKey('remarkSub')))">
a.remarkSub,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('clauseContent') or colPickMode == 1 and data.containsKey('clauseContent')))">
a.clauseContent,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('summary') or colPickMode == 1 and data.containsKey('summary')))">
a.summary,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('source') or colPickMode == 1 and data.containsKey('source')))">
a.source,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MatterDatumEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_matter_datum
(matterId,materialName,isMust,materialType,materialProperty,electronicgs,materialSource,paperNum,paperGg,jianmMs,sealWay,isjianm,isLack,ybUrl,materialSourceSm,remarkSub,clauseContent,summary,remark,source,createTime,createUserId,updateTime)
VALUES
(#{matterId},#{materialName},#{isMust},#{materialType},#{materialProperty},#{electronicgs},#{materialSource},#{paperNum},#{paperGg},#{jianmMs},#{sealWay},#{isjianm},#{isLack},#{ybUrl},#{materialSourceSm},#{remarkSub},#{clauseContent},#{summary},#{remark},#{source},#{createTime},#{createUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_matter_datum
(matterId,materialName,isMust,materialType,materialProperty,electronicgs,materialSource,paperNum,paperGg,jianmMs,sealWay,isjianm,isLack,ybUrl,materialSourceSm,remarkSub,clauseContent,summary,remark,source,createTime,createUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.matterId},#{item.materialName},#{item.isMust},#{item.materialType},#{item.materialProperty},#{item.electronicgs},#{item.materialSource},#{item.paperNum},#{item.paperGg},#{item.jianmMs},#{item.sealWay},#{item.isjianm},#{item.isLack},#{item.ybUrl},#{item.materialSourceSm},#{item.remarkSub},#{item.clauseContent},#{item.summary},#{item.remark},#{item.source},#{item.createTime},#{item.createUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_sys_matter_datum as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('matterId')) or (colPickMode==1 and !data.containsKey('matterId'))">
a.matterId=#{data.matterId},
</if>
<if test="(colPickMode==0 and data.containsKey('matterIdIncrement')) or (colPickMode==1 and !data.containsKey('matterIdIncrement'))">
a.matterId=ifnull(a.matterId,0) + #{data.matterIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('materialName')) or (colPickMode==1 and !data.containsKey('materialName'))">
a.materialName=#{data.materialName},
</if>
<if test="(colPickMode==0 and data.containsKey('isMust')) or (colPickMode==1 and !data.containsKey('isMust'))">
a.isMust=#{data.isMust},
</if>
<if test="(colPickMode==0 and data.containsKey('materialType')) or (colPickMode==1 and !data.containsKey('materialType'))">
a.materialType=#{data.materialType},
</if>
<if test="(colPickMode==0 and data.containsKey('materialProperty')) or (colPickMode==1 and !data.containsKey('materialProperty'))">
a.materialProperty=#{data.materialProperty},
</if>
<if test="(colPickMode==0 and data.containsKey('electronicgs')) or (colPickMode==1 and !data.containsKey('electronicgs'))">
a.electronicgs=#{data.electronicgs},
</if>
<if test="(colPickMode==0 and data.containsKey('materialSource')) or (colPickMode==1 and !data.containsKey('materialSource'))">
a.materialSource=#{data.materialSource},
</if>
<if test="(colPickMode==0 and data.containsKey('paperNum')) or (colPickMode==1 and !data.containsKey('paperNum'))">
a.paperNum=#{data.paperNum},
</if>
<if test="(colPickMode==0 and data.containsKey('paperNumIncrement')) or (colPickMode==1 and !data.containsKey('paperNumIncrement'))">
a.paperNum=ifnull(a.paperNum,0) + #{data.paperNumIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('paperGg')) or (colPickMode==1 and !data.containsKey('paperGg'))">
a.paperGg=#{data.paperGg},
</if>
<if test="(colPickMode==0 and data.containsKey('jianmMs')) or (colPickMode==1 and !data.containsKey('jianmMs'))">
a.jianmMs=#{data.jianmMs},
</if>
<if test="(colPickMode==0 and data.containsKey('sealWay')) or (colPickMode==1 and !data.containsKey('sealWay'))">
a.sealWay=#{data.sealWay},
</if>
<if test="(colPickMode==0 and data.containsKey('isjianm')) or (colPickMode==1 and !data.containsKey('isjianm'))">
a.isjianm=#{data.isjianm},
</if>
<if test="(colPickMode==0 and data.containsKey('isLack')) or (colPickMode==1 and !data.containsKey('isLack'))">
a.isLack=#{data.isLack},
</if>
<if test="(colPickMode==0 and data.containsKey('ybUrl')) or (colPickMode==1 and !data.containsKey('ybUrl'))">
a.ybUrl=#{data.ybUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('materialSourceSm')) or (colPickMode==1 and !data.containsKey('materialSourceSm'))">
a.materialSourceSm=#{data.materialSourceSm},
</if>
<if test="(colPickMode==0 and data.containsKey('remarkSub')) or (colPickMode==1 and !data.containsKey('remarkSub'))">
a.remarkSub=#{data.remarkSub},
</if>
<if test="(colPickMode==0 and data.containsKey('clauseContent')) or (colPickMode==1 and !data.containsKey('clauseContent'))">
a.clauseContent=#{data.clauseContent},
</if>
<if test="(colPickMode==0 and data.containsKey('summary')) or (colPickMode==1 and !data.containsKey('summary'))">
a.summary=#{data.summary},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('source')) or (colPickMode==1 and !data.containsKey('source'))">
a.source=#{data.source},
</if>
<if test="(colPickMode==0 and data.containsKey('sourceIncrement')) or (colPickMode==1 and !data.containsKey('sourceIncrement'))">
a.source=ifnull(a.source,0) + #{data.sourceIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_sys_matter_datum as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="matterId=(case" suffix="ELSE matterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('matterId')) or (colPickMode==1 and !item.containsKey('matterId'))">
when a.id=#{item.id} then #{item.matterId}
</when>
<when test="(colPickMode==0 and item.containsKey('matterIdIncrement')) or (colPickMode==1 and !item.containsKey('matterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.matterId,0) + #{item.matterIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="materialName=(case" suffix="ELSE materialName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialName')) or (colPickMode==1 and !item.containsKey('materialName'))">
when a.id=#{item.id} then #{item.materialName}
</if>
</foreach>
</trim>
<trim prefix="isMust=(case" suffix="ELSE isMust end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('isMust')) or (colPickMode==1 and !item.containsKey('isMust'))">
when a.id=#{item.id} then #{item.isMust}
</if>
</foreach>
</trim>
<trim prefix="materialType=(case" suffix="ELSE materialType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialType')) or (colPickMode==1 and !item.containsKey('materialType'))">
when a.id=#{item.id} then #{item.materialType}
</if>
</foreach>
</trim>
<trim prefix="materialProperty=(case" suffix="ELSE materialProperty end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialProperty')) or (colPickMode==1 and !item.containsKey('materialProperty'))">
when a.id=#{item.id} then #{item.materialProperty}
</if>
</foreach>
</trim>
<trim prefix="electronicgs=(case" suffix="ELSE electronicgs end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('electronicgs')) or (colPickMode==1 and !item.containsKey('electronicgs'))">
when a.id=#{item.id} then #{item.electronicgs}
</if>
</foreach>
</trim>
<trim prefix="materialSource=(case" suffix="ELSE materialSource end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialSource')) or (colPickMode==1 and !item.containsKey('materialSource'))">
when a.id=#{item.id} then #{item.materialSource}
</if>
</foreach>
</trim>
<trim prefix="paperNum=(case" suffix="ELSE paperNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('paperNum')) or (colPickMode==1 and !item.containsKey('paperNum'))">
when a.id=#{item.id} then #{item.paperNum}
</when>
<when test="(colPickMode==0 and item.containsKey('paperNumIncrement')) or (colPickMode==1 and !item.containsKey('paperNumIncrement'))">
when a.id=#{item.id} then ifnull(a.paperNum,0) + #{item.paperNumIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="paperGg=(case" suffix="ELSE paperGg end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paperGg')) or (colPickMode==1 and !item.containsKey('paperGg'))">
when a.id=#{item.id} then #{item.paperGg}
</if>
</foreach>
</trim>
<trim prefix="jianmMs=(case" suffix="ELSE jianmMs end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('jianmMs')) or (colPickMode==1 and !item.containsKey('jianmMs'))">
when a.id=#{item.id} then #{item.jianmMs}
</if>
</foreach>
</trim>
<trim prefix="sealWay=(case" suffix="ELSE sealWay end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('sealWay')) or (colPickMode==1 and !item.containsKey('sealWay'))">
when a.id=#{item.id} then #{item.sealWay}
</if>
</foreach>
</trim>
<trim prefix="isjianm=(case" suffix="ELSE isjianm end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('isjianm')) or (colPickMode==1 and !item.containsKey('isjianm'))">
when a.id=#{item.id} then #{item.isjianm}
</if>
</foreach>
</trim>
<trim prefix="isLack=(case" suffix="ELSE isLack end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('isLack')) or (colPickMode==1 and !item.containsKey('isLack'))">
when a.id=#{item.id} then #{item.isLack}
</if>
</foreach>
</trim>
<trim prefix="ybUrl=(case" suffix="ELSE ybUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ybUrl')) or (colPickMode==1 and !item.containsKey('ybUrl'))">
when a.id=#{item.id} then #{item.ybUrl}
</if>
</foreach>
</trim>
<trim prefix="materialSourceSm=(case" suffix="ELSE materialSourceSm end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('materialSourceSm')) or (colPickMode==1 and !item.containsKey('materialSourceSm'))">
when a.id=#{item.id} then #{item.materialSourceSm}
</if>
</foreach>
</trim>
<trim prefix="remarkSub=(case" suffix="ELSE remarkSub end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remarkSub')) or (colPickMode==1 and !item.containsKey('remarkSub'))">
when a.id=#{item.id} then #{item.remarkSub}
</if>
</foreach>
</trim>
<trim prefix="clauseContent=(case" suffix="ELSE clauseContent end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('clauseContent')) or (colPickMode==1 and !item.containsKey('clauseContent'))">
when a.id=#{item.id} then #{item.clauseContent}
</if>
</foreach>
</trim>
<trim prefix="summary=(case" suffix="ELSE summary end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('summary')) or (colPickMode==1 and !item.containsKey('summary'))">
when a.id=#{item.id} then #{item.summary}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="source=(case" suffix="ELSE source end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('source')) or (colPickMode==1 and !item.containsKey('source'))">
when a.id=#{item.id} then #{item.source}
</when>
<when test="(colPickMode==0 and item.containsKey('sourceIncrement')) or (colPickMode==1 and !item.containsKey('sourceIncrement'))">
when a.id=#{item.id} then ifnull(a.source,0) + #{item.sourceIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MatterDatumEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_datum as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_sys_matter_datum as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_sys_matter_datum where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_sys_matter_datum where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_sys_matter_datum where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_sys_matter_datum as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MatterDatumEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_datum as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_sys_matter_datum as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('matterId')">
<if test="conditionParamRef.matterId != null ">
${_conditionType_} a.matterId = #{${_conditionParam_}.matterId}
</if>
<if test="conditionParamRef.matterId == null">
${_conditionType_} a.matterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('matterIdList')">
${_conditionType_} a.matterId in
<foreach collection="conditionParamRef.matterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdNotList')">
${_conditionType_} a.matterId not in
<foreach collection="conditionParamRef.matterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdStart') and conditionParamRef.matterIdStart != null">
${_conditionType_} a.matterId <![CDATA[ >= ]]> #{${_conditionParam_}.matterIdStart}
</if>
<if test="conditionParamRef.containsKey('matterIdEnd') and conditionParamRef.matterIdEnd != null">
${_conditionType_} a.matterId <![CDATA[ <= ]]> #{${_conditionParam_}.matterIdEnd}
</if>
<if test="conditionParamRef.containsKey('materialName')">
<if test="conditionParamRef.materialName != null and conditionParamRef.materialName != ''">
${_conditionType_} a.materialName like #{${_conditionParam_}.materialName}
</if>
<if test="conditionParamRef.materialName == null">
${_conditionType_} a.materialName is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialNameList')">
${_conditionType_} a.materialName in
<foreach collection="conditionParamRef.materialNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialNameNotList')">
${_conditionType_} a.materialName not in
<foreach collection="conditionParamRef.materialNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isMust')">
<if test="conditionParamRef.isMust != null and conditionParamRef.isMust != ''">
${_conditionType_} a.isMust like #{${_conditionParam_}.isMust}
</if>
<if test="conditionParamRef.isMust == null">
${_conditionType_} a.isMust is null
</if>
</if>
<if test="conditionParamRef.containsKey('isMustList')">
${_conditionType_} a.isMust in
<foreach collection="conditionParamRef.isMustList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isMustNotList')">
${_conditionType_} a.isMust not in
<foreach collection="conditionParamRef.isMustNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialType')">
<if test="conditionParamRef.materialType != null and conditionParamRef.materialType != ''">
${_conditionType_} a.materialType like #{${_conditionParam_}.materialType}
</if>
<if test="conditionParamRef.materialType == null">
${_conditionType_} a.materialType is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialTypeList')">
${_conditionType_} a.materialType in
<foreach collection="conditionParamRef.materialTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialTypeNotList')">
${_conditionType_} a.materialType not in
<foreach collection="conditionParamRef.materialTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialProperty')">
<if test="conditionParamRef.materialProperty != null and conditionParamRef.materialProperty != ''">
${_conditionType_} a.materialProperty like #{${_conditionParam_}.materialProperty}
</if>
<if test="conditionParamRef.materialProperty == null">
${_conditionType_} a.materialProperty is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialPropertyList')">
${_conditionType_} a.materialProperty in
<foreach collection="conditionParamRef.materialPropertyList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialPropertyNotList')">
${_conditionType_} a.materialProperty not in
<foreach collection="conditionParamRef.materialPropertyNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('electronicgs')">
<if test="conditionParamRef.electronicgs != null and conditionParamRef.electronicgs != ''">
${_conditionType_} a.electronicgs like #{${_conditionParam_}.electronicgs}
</if>
<if test="conditionParamRef.electronicgs == null">
${_conditionType_} a.electronicgs is null
</if>
</if>
<if test="conditionParamRef.containsKey('electronicgsList')">
${_conditionType_} a.electronicgs in
<foreach collection="conditionParamRef.electronicgsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('electronicgsNotList')">
${_conditionType_} a.electronicgs not in
<foreach collection="conditionParamRef.electronicgsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSource')">
<if test="conditionParamRef.materialSource != null and conditionParamRef.materialSource != ''">
${_conditionType_} a.materialSource like #{${_conditionParam_}.materialSource}
</if>
<if test="conditionParamRef.materialSource == null">
${_conditionType_} a.materialSource is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialSourceList')">
${_conditionType_} a.materialSource in
<foreach collection="conditionParamRef.materialSourceList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSourceNotList')">
${_conditionType_} a.materialSource not in
<foreach collection="conditionParamRef.materialSourceNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperNum')">
<if test="conditionParamRef.paperNum != null ">
${_conditionType_} a.paperNum = #{${_conditionParam_}.paperNum}
</if>
<if test="conditionParamRef.paperNum == null">
${_conditionType_} a.paperNum is null
</if>
</if>
<if test="conditionParamRef.containsKey('paperNumList')">
${_conditionType_} a.paperNum in
<foreach collection="conditionParamRef.paperNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperNumNotList')">
${_conditionType_} a.paperNum not in
<foreach collection="conditionParamRef.paperNumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperNumStart') and conditionParamRef.paperNumStart != null">
${_conditionType_} a.paperNum <![CDATA[ >= ]]> #{${_conditionParam_}.paperNumStart}
</if>
<if test="conditionParamRef.containsKey('paperNumEnd') and conditionParamRef.paperNumEnd != null">
${_conditionType_} a.paperNum <![CDATA[ <= ]]> #{${_conditionParam_}.paperNumEnd}
</if>
<if test="conditionParamRef.containsKey('paperGg')">
<if test="conditionParamRef.paperGg != null and conditionParamRef.paperGg != ''">
${_conditionType_} a.paperGg like #{${_conditionParam_}.paperGg}
</if>
<if test="conditionParamRef.paperGg == null">
${_conditionType_} a.paperGg is null
</if>
</if>
<if test="conditionParamRef.containsKey('paperGgList')">
${_conditionType_} a.paperGg in
<foreach collection="conditionParamRef.paperGgList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperGgNotList')">
${_conditionType_} a.paperGg not in
<foreach collection="conditionParamRef.paperGgNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('jianmMs')">
<if test="conditionParamRef.jianmMs != null and conditionParamRef.jianmMs != ''">
${_conditionType_} a.jianmMs like #{${_conditionParam_}.jianmMs}
</if>
<if test="conditionParamRef.jianmMs == null">
${_conditionType_} a.jianmMs is null
</if>
</if>
<if test="conditionParamRef.containsKey('jianmMsList')">
${_conditionType_} a.jianmMs in
<foreach collection="conditionParamRef.jianmMsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('jianmMsNotList')">
${_conditionType_} a.jianmMs not in
<foreach collection="conditionParamRef.jianmMsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sealWay')">
<if test="conditionParamRef.sealWay != null and conditionParamRef.sealWay != ''">
${_conditionType_} a.sealWay like #{${_conditionParam_}.sealWay}
</if>
<if test="conditionParamRef.sealWay == null">
${_conditionType_} a.sealWay is null
</if>
</if>
<if test="conditionParamRef.containsKey('sealWayList')">
${_conditionType_} a.sealWay in
<foreach collection="conditionParamRef.sealWayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sealWayNotList')">
${_conditionType_} a.sealWay not in
<foreach collection="conditionParamRef.sealWayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isjianm')">
<if test="conditionParamRef.isjianm != null and conditionParamRef.isjianm != ''">
${_conditionType_} a.isjianm like #{${_conditionParam_}.isjianm}
</if>
<if test="conditionParamRef.isjianm == null">
${_conditionType_} a.isjianm is null
</if>
</if>
<if test="conditionParamRef.containsKey('isjianmList')">
${_conditionType_} a.isjianm in
<foreach collection="conditionParamRef.isjianmList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isjianmNotList')">
${_conditionType_} a.isjianm not in
<foreach collection="conditionParamRef.isjianmNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isLack')">
<if test="conditionParamRef.isLack != null and conditionParamRef.isLack != ''">
${_conditionType_} a.isLack like #{${_conditionParam_}.isLack}
</if>
<if test="conditionParamRef.isLack == null">
${_conditionType_} a.isLack is null
</if>
</if>
<if test="conditionParamRef.containsKey('isLackList')">
${_conditionType_} a.isLack in
<foreach collection="conditionParamRef.isLackList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isLackNotList')">
${_conditionType_} a.isLack not in
<foreach collection="conditionParamRef.isLackNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ybUrl')">
<if test="conditionParamRef.ybUrl != null and conditionParamRef.ybUrl != ''">
${_conditionType_} a.ybUrl like #{${_conditionParam_}.ybUrl}
</if>
<if test="conditionParamRef.ybUrl == null">
${_conditionType_} a.ybUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('ybUrlList')">
${_conditionType_} a.ybUrl in
<foreach collection="conditionParamRef.ybUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ybUrlNotList')">
${_conditionType_} a.ybUrl not in
<foreach collection="conditionParamRef.ybUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSourceSm')">
<if test="conditionParamRef.materialSourceSm != null and conditionParamRef.materialSourceSm != ''">
${_conditionType_} a.materialSourceSm like #{${_conditionParam_}.materialSourceSm}
</if>
<if test="conditionParamRef.materialSourceSm == null">
${_conditionType_} a.materialSourceSm is null
</if>
</if>
<if test="conditionParamRef.containsKey('materialSourceSmList')">
${_conditionType_} a.materialSourceSm in
<foreach collection="conditionParamRef.materialSourceSmList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialSourceSmNotList')">
${_conditionType_} a.materialSourceSm not in
<foreach collection="conditionParamRef.materialSourceSmNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkSub')">
<if test="conditionParamRef.remarkSub != null and conditionParamRef.remarkSub != ''">
${_conditionType_} a.remarkSub like #{${_conditionParam_}.remarkSub}
</if>
<if test="conditionParamRef.remarkSub == null">
${_conditionType_} a.remarkSub is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkSubList')">
${_conditionType_} a.remarkSub in
<foreach collection="conditionParamRef.remarkSubList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkSubNotList')">
${_conditionType_} a.remarkSub not in
<foreach collection="conditionParamRef.remarkSubNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('clauseContent')">
<if test="conditionParamRef.clauseContent != null and conditionParamRef.clauseContent != ''">
${_conditionType_} a.clauseContent like #{${_conditionParam_}.clauseContent}
</if>
<if test="conditionParamRef.clauseContent == null">
${_conditionType_} a.clauseContent is null
</if>
</if>
<if test="conditionParamRef.containsKey('clauseContentList')">
${_conditionType_} a.clauseContent in
<foreach collection="conditionParamRef.clauseContentList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('clauseContentNotList')">
${_conditionType_} a.clauseContent not in
<foreach collection="conditionParamRef.clauseContentNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('summary')">
<if test="conditionParamRef.summary != null and conditionParamRef.summary != ''">
${_conditionType_} a.summary like #{${_conditionParam_}.summary}
</if>
<if test="conditionParamRef.summary == null">
${_conditionType_} a.summary is null
</if>
</if>
<if test="conditionParamRef.containsKey('summaryList')">
${_conditionType_} a.summary in
<foreach collection="conditionParamRef.summaryList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('summaryNotList')">
${_conditionType_} a.summary not in
<foreach collection="conditionParamRef.summaryNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList')">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('source')">
<if test="conditionParamRef.source != null ">
${_conditionType_} a.source = #{${_conditionParam_}.source}
</if>
<if test="conditionParamRef.source == null">
${_conditionType_} a.source is null
</if>
</if>
<if test="conditionParamRef.containsKey('sourceList')">
${_conditionType_} a.source in
<foreach collection="conditionParamRef.sourceList" open="(" close=")" index="index" item="item" separator=",">
#{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>
<if test="conditionParamRef.containsKey('sourceEnd') and conditionParamRef.sourceEnd != null">
${_conditionType_} a.source <![CDATA[ <= ]]> #{${_conditionParam_}.sourceEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('matterId')">
a.matterId
<if test='orderCol.matterId != null and "DESC".equalsIgnoreCase(orderCol.matterId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialName')">
a.materialName
<if test='orderCol.materialName != null and "DESC".equalsIgnoreCase(orderCol.materialName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isMust')">
a.isMust
<if test='orderCol.isMust != null and "DESC".equalsIgnoreCase(orderCol.isMust)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialType')">
a.materialType
<if test='orderCol.materialType != null and "DESC".equalsIgnoreCase(orderCol.materialType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialProperty')">
a.materialProperty
<if test='orderCol.materialProperty != null and "DESC".equalsIgnoreCase(orderCol.materialProperty)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('electronicgs')">
a.electronicgs
<if test='orderCol.electronicgs != null and "DESC".equalsIgnoreCase(orderCol.electronicgs)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialSource')">
a.materialSource
<if test='orderCol.materialSource != null and "DESC".equalsIgnoreCase(orderCol.materialSource)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paperNum')">
a.paperNum
<if test='orderCol.paperNum != null and "DESC".equalsIgnoreCase(orderCol.paperNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paperGg')">
a.paperGg
<if test='orderCol.paperGg != null and "DESC".equalsIgnoreCase(orderCol.paperGg)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('jianmMs')">
a.jianmMs
<if test='orderCol.jianmMs != null and "DESC".equalsIgnoreCase(orderCol.jianmMs)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('sealWay')">
a.sealWay
<if test='orderCol.sealWay != null and "DESC".equalsIgnoreCase(orderCol.sealWay)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isjianm')">
a.isjianm
<if test='orderCol.isjianm != null and "DESC".equalsIgnoreCase(orderCol.isjianm)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isLack')">
a.isLack
<if test='orderCol.isLack != null and "DESC".equalsIgnoreCase(orderCol.isLack)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ybUrl')">
a.ybUrl
<if test='orderCol.ybUrl != null and "DESC".equalsIgnoreCase(orderCol.ybUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('materialSourceSm')">
a.materialSourceSm
<if test='orderCol.materialSourceSm != null and "DESC".equalsIgnoreCase(orderCol.materialSourceSm)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remarkSub')">
a.remarkSub
<if test='orderCol.remarkSub != null and "DESC".equalsIgnoreCase(orderCol.remarkSub)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('clauseContent')">
a.clauseContent
<if test='orderCol.clauseContent != null and "DESC".equalsIgnoreCase(orderCol.clauseContent)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('summary')">
a.summary
<if test='orderCol.summary != null and "DESC".equalsIgnoreCase(orderCol.summary)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('source')">
a.source
<if test='orderCol.source != null and "DESC".equalsIgnoreCase(orderCol.source)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment