Skip to content

C
chuanshan_gov_platform
Commit 98512f44 authored by 廖旭伟's avatar 廖旭伟
Browse files
Options

事项申请，事项审批

parent 2e0ae969
Hide whitespace changes
Inline Side-by-side
Showing with 8664 additions and 3 deletions
knowledge-base/pom.xml
View file @ 98512f44
......@@ -20,9 +20,7 @@
<profiles>
<profile>
<id>develop</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<profiles.active>develop</profiles.active>
<profiles.server.path>/kb</profiles.server.path>
......@@ -54,6 +52,9 @@
<profile>
<id>product</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<profiles.active>product</profiles.active>
<profiles.server.path>/kb</profiles.server.path>
......
single-matter/db/add_table.sql 0 → 100644
View file @ 98512f44
-- ----------------------------
-- 单事项审批人员表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_approver`;
CREATE TABLE mortals_sys_approver(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号，主键，自增长',
`siteId` bigint(20) COMMENT '站点id',
`fullName` varchar(64) NOT NULL COMMENT '工作人员姓名',
`phoneNumber` varchar(128) NOT NULL COMMENT '联系电话',
`loginName` varchar(128) COMMENT '登录用户名',
`loginPwd` varchar(128) COMMENT '登录密码',
`deptId` bigint(20) COMMENT '所属部门',
`deptCode` varchar(128) COMMENT '所属部门编码',
`deptName` varchar(128) COMMENT '所属部门名称',
`remarks` varchar(255) COMMENT '备注',
`createUserId` bigint(20) COMMENT '创建用户',
`createTime` datetime COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='单事项审批人员';
-- ----------------------------
-- 单事项申报表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_matter_apply`;
CREATE TABLE mortals_sys_matter_apply(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号，主键，自增长',
`siteId` bigint(20) COMMENT '站点id',
`singleMatterId` bigint(20) COMMENT '单事项id',
`matterId` bigint(20) COMMENT '基础事项id',
`deptCode` varchar(128) COMMENT '部门编码',
`matterName` varchar(128) NOT NULL COMMENT '单事项名称',
`applyPerson` varchar(128) COMMENT '申请人姓名',
`sexual` tinyint(2) DEFAULT '1' COMMENT '申请人性别',
`phoneNum` varchar(128) COMMENT '申请人电话',
`idCard` varchar(128) COMMENT '申请人身份证号码',
`address` varchar(128) COMMENT '地点',
`applyType` tinyint(2) DEFAULT '1' COMMENT '申请方式1移动端2后台',
`applyTime` datetime COMMENT '申请时间',
`applyState` tinyint(2) DEFAULT '0' COMMENT '审批状态0审批中1通过2不通过',
`advisement` varchar(255) COMMENT '审批意见',
`remarks` varchar(255) COMMENT '备注',
`openId` varchar(128) COMMENT '微信openId',
`createUserId` bigint(20) COMMENT '创建用户',
`createTime` datetime COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='单事项申报';
-- ----------------------------
-- 事项申报材料表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_matter_apply_datum`;
CREATE TABLE mortals_sys_matter_apply_datum(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号，主键，自增长',
`siteId` bigint(20) COMMENT '站点id',
`applyId` bigint(20) COMMENT '用户申报id',
`singleMatterId` bigint(20) COMMENT '单事项id',
`matterId` bigint(20) COMMENT '基础事项id',
`datumId` bigint(20) COMMENT '材料id',
`materialName` varchar(1024) COMMENT '材料名称',
`fileName` varchar(128) COMMENT '附件文件名称',
`fileUrl` varchar(255) COMMENT '附件文件地址',
`createUserId` bigint(20) COMMENT '创建用户',
`createTime` datetime COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='事项申报材料';
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('申请方式', 'MatterApply', 'applyType', '1', '移动端', '1', '4', '0', 'applyType', NULL, NULL, NULL);
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('申请方式', 'MatterApply', 'applyType', '2', '后台', '1', '4', '0', 'applyType', NULL, NULL, NULL);
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('审批状态', 'MatterApply', 'applyState', '0', '审批中', '1', '4', '0', 'applyState', NULL, NULL, NULL);
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('审批状态', 'MatterApply', 'applyState', '1', '通过', '1', '4', '0', 'applyState', NULL, NULL, NULL);
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('审批状态', 'MatterApply', 'applyState', '2', '不通过', '1', '4', '0', 'applyState', NULL, NULL, NULL);
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('性别', 'MatterApply', 'sexual', '1', '男', '1', '4', '0', 'sexual', NULL, NULL, NULL);
INSERT INTO `mortals_xhx_param` (`name`, `firstOrganize`, `secondOrganize`, `paramKey`, `paramValue`, `validStatus`, `modStatus`, `displayType`, `remark`, `createTime`, `createUserId`, `createUserName`) VALUES ('性别', 'MatterApply', 'sexual', '2', '女', '1', '4', '0', 'sexual', NULL, NULL, NULL);
single-matter/pom.xml
View file @ 98512f44
......@@ -53,6 +53,7 @@
</profile>
<profile>
<id>product</id>
<properties>
<profiles.active>product</profiles.active>
<profiles.server.path>/sm</profiles.server.path>
......
single-matter/src/main/java/com/mortals/xhx/daemon/task/SyncUserTaskImpl.java
View file @ 98512f44
......@@ -11,6 +11,7 @@ import com.mortals.framework.service.ITaskExcuteService;
import com.mortals.framework.util.HttpUtil;
import com.mortals.xhx.base.system.user.service.UserService;
import com.mortals.xhx.common.pdu.user.UserPhpPdu;
import com.mortals.xhx.module.apply.service.ApproverService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
......@@ -29,6 +30,8 @@ public class SyncUserTaskImpl implements ITaskExcuteService {
@Autowired
private UserService userService;
@Autowired
private ApproverService approverService;
@Override
public void excuteTask(ITask task) throws AppException {
......@@ -43,6 +46,7 @@ public class SyncUserTaskImpl implements ITaskExcuteService {
Rest<List<JSONObject>> list = JSON.parseObject(resp,Rest.class);
List<UserPhpPdu> upp = JSONArray.parseArray(JSONObject.toJSONString(list.getData()),UserPhpPdu.class);
userService.updateUserList(upp);
approverService.updateUserList(upp);
} catch (Exception e) {
log.error("同步用户发生异常",e);
}
......
single-matter/src/main/java/com/mortals/xhx/module/apply/dao/ApproverDao.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.apply.model.ApproverEntity;
import java.util.List;
/**
* 单事项审批人员Dao
* 单事项审批人员 DAO接口
*
* @author zxfei
* @date 2023-05-23
*/
public interface ApproverDao extends ICRUDDao<ApproverEntity,Long>{
}
single-matter/src/main/java/com/mortals/xhx/module/apply/dao/MatterApplyDao.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.apply.model.MatterApplyEntity;
import java.util.List;
/**
* 单事项申报Dao
* 单事项申报 DAO接口
*
* @author zxfei
* @date 2023-05-23
*/
public interface MatterApplyDao extends ICRUDDao<MatterApplyEntity,Long>{
}
single-matter/src/main/java/com/mortals/xhx/module/apply/dao/MatterApplyDatumDao.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import java.util.List;
/**
* 事项申报材料Dao
* 事项申报材料 DAO接口
*
* @author zxfei
* @date 2023-05-23
*/
public interface MatterApplyDatumDao extends ICRUDDao<MatterApplyDatumEntity,Long>{
}
single-matter/src/main/java/com/mortals/xhx/module/apply/dao/ibatis/ApproverDaoImpl.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.apply.dao.ApproverDao;
import com.mortals.xhx.module.apply.model.ApproverEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 单事项审批人员DaoImpl DAO接口
*
* @author zxfei
* @date 2023-05-23
*/
@Repository("approverDao")
public class ApproverDaoImpl extends BaseCRUDDaoMybatis<ApproverEntity,Long> implements ApproverDao {
}
single-matter/src/main/java/com/mortals/xhx/module/apply/dao/ibatis/MatterApplyDaoImpl.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.apply.dao.MatterApplyDao;
import com.mortals.xhx.module.apply.model.MatterApplyEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 单事项申报DaoImpl DAO接口
*
* @author zxfei
* @date 2023-05-23
*/
@Repository("matterApplyDao")
public class MatterApplyDaoImpl extends BaseCRUDDaoMybatis<MatterApplyEntity,Long> implements MatterApplyDao {
}
single-matter/src/main/java/com/mortals/xhx/module/apply/dao/ibatis/MatterApplyDatumDaoImpl.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.apply.dao.MatterApplyDatumDao;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 事项申报材料DaoImpl DAO接口
*
* @author zxfei
* @date 2023-05-23
*/
@Repository("matterApplyDatumDao")
public class MatterApplyDatumDaoImpl extends BaseCRUDDaoMybatis<MatterApplyDatumEntity,Long> implements MatterApplyDatumDao {
}
single-matter/src/main/java/com/mortals/xhx/module/apply/model/ApproverEntity.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.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.apply.model.vo.ApproverVo;
import lombok.Data;
/**
* 单事项审批人员实体对象
*
* @author zxfei
* @date 2023-05-23
*/
@Data
public class ApproverEntity extends ApproverVo {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 工作人员姓名
*/
private String fullName;
/**
* 联系电话
*/
private String phoneNumber;
/**
* 登录用户名
*/
private String loginName;
/**
* 登录密码
*/
private String loginPwd;
/**
* 所属部门
*/
private Long deptId;
/**
* 所属部门编码
*/
private String deptCode;
/**
* 所属部门名称
*/
private String deptName;
/**
* 备注
*/
private String remarks;
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof ApproverEntity) {
ApproverEntity tmp = (ApproverEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.siteId = -1L;
this.fullName = "";
this.phoneNumber = "";
this.loginName = "";
this.loginPwd = "";
this.deptId = -1L;
this.deptCode = "";
this.deptName = "";
this.remarks = "";
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/ApproverQuery.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model;
import java.util.List;
import com.mortals.xhx.module.apply.model.ApproverEntity;
/**
* 单事项审批人员查询对象
*
* @author zxfei
* @date 2023-05-23
*/
public class ApproverQuery extends ApproverEntity {
/** 开始 序号，主键，自增长 */
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> fullNameList;
/** 工作人员姓名排除列表 */
private List <String> fullNameNotList;
/** 联系电话 */
private List<String> phoneNumberList;
/** 联系电话排除列表 */
private List <String> phoneNumberNotList;
/** 登录用户名 */
private List<String> loginNameList;
/** 登录用户名排除列表 */
private List <String> loginNameNotList;
/** 登录密码 */
private List<String> loginPwdList;
/** 登录密码排除列表 */
private List <String> loginPwdNotList;
/** 开始 所属部门 */
private Long deptIdStart;
/** 结束 所属部门 */
private Long deptIdEnd;
/** 增加 所属部门 */
private Long deptIdIncrement;
/** 所属部门列表 */
private List <Long> deptIdList;
/** 所属部门排除列表 */
private List <Long> deptIdNotList;
/** 所属部门编码 */
private List<String> deptCodeList;
/** 所属部门编码排除列表 */
private List <String> deptCodeNotList;
/** 所属部门名称 */
private List<String> deptNameList;
/** 所属部门名称排除列表 */
private List <String> deptNameNotList;
/** 备注 */
private List<String> remarksList;
/** 备注排除列表 */
private List <String> remarksNotList;
/** 开始 创建用户 */
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;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<ApproverQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<ApproverQuery> andConditionList;
public ApproverQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @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 fullNameList
*/
public List<String> getFullNameList(){
return this.fullNameList;
}
/**
* 设置 工作人员姓名
* @param fullNameList
*/
public void setFullNameList(List<String> fullNameList){
this.fullNameList = fullNameList;
}
/**
* 获取 工作人员姓名
* @return fullNameNotList
*/
public List<String> getFullNameNotList(){
return this.fullNameNotList;
}
/**
* 设置 工作人员姓名
* @param fullNameNotList
*/
public void setFullNameNotList(List<String> fullNameNotList){
this.fullNameNotList = fullNameNotList;
}
/**
* 获取 联系电话
* @return phoneNumberList
*/
public List<String> getPhoneNumberList(){
return this.phoneNumberList;
}
/**
* 设置 联系电话
* @param phoneNumberList
*/
public void setPhoneNumberList(List<String> phoneNumberList){
this.phoneNumberList = phoneNumberList;
}
/**
* 获取 联系电话
* @return phoneNumberNotList
*/
public List<String> getPhoneNumberNotList(){
return this.phoneNumberNotList;
}
/**
* 设置 联系电话
* @param phoneNumberNotList
*/
public void setPhoneNumberNotList(List<String> phoneNumberNotList){
this.phoneNumberNotList = phoneNumberNotList;
}
/**
* 获取 登录用户名
* @return loginNameList
*/
public List<String> getLoginNameList(){
return this.loginNameList;
}
/**
* 设置 登录用户名
* @param loginNameList
*/
public void setLoginNameList(List<String> loginNameList){
this.loginNameList = loginNameList;
}
/**
* 获取 登录用户名
* @return loginNameNotList
*/
public List<String> getLoginNameNotList(){
return this.loginNameNotList;
}
/**
* 设置 登录用户名
* @param loginNameNotList
*/
public void setLoginNameNotList(List<String> loginNameNotList){
this.loginNameNotList = loginNameNotList;
}
/**
* 获取 登录密码
* @return loginPwdList
*/
public List<String> getLoginPwdList(){
return this.loginPwdList;
}
/**
* 设置 登录密码
* @param loginPwdList
*/
public void setLoginPwdList(List<String> loginPwdList){
this.loginPwdList = loginPwdList;
}
/**
* 获取 登录密码
* @return loginPwdNotList
*/
public List<String> getLoginPwdNotList(){
return this.loginPwdNotList;
}
/**
* 设置 登录密码
* @param loginPwdNotList
*/
public void setLoginPwdNotList(List<String> loginPwdNotList){
this.loginPwdNotList = loginPwdNotList;
}
/**
* 获取 开始 所属部门
* @return deptIdStart
*/
public Long getDeptIdStart(){
return this.deptIdStart;
}
/**
* 设置 开始 所属部门
* @param deptIdStart
*/
public void setDeptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
}
/**
* 获取 结束 所属部门
* @return $deptIdEnd
*/
public Long getDeptIdEnd(){
return this.deptIdEnd;
}
/**
* 设置 结束 所属部门
* @param deptIdEnd
*/
public void setDeptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
}
/**
* 获取 增加 所属部门
* @return deptIdIncrement
*/
public Long getDeptIdIncrement(){
return this.deptIdIncrement;
}
/**
* 设置 增加 所属部门
* @param deptIdIncrement
*/
public void setDeptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
}
/**
* 获取 所属部门
* @return deptIdList
*/
public List<Long> getDeptIdList(){
return this.deptIdList;
}
/**
* 设置 所属部门
* @param deptIdList
*/
public void setDeptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
}
/**
* 获取 所属部门
* @return deptIdNotList
*/
public List<Long> getDeptIdNotList(){
return this.deptIdNotList;
}
/**
* 设置 所属部门
* @param deptIdNotList
*/
public void setDeptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
}
/**
* 获取 所属部门编码
* @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 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 remarksList
*/
public List<String> getRemarksList(){
return this.remarksList;
}
/**
* 设置 备注
* @param remarksList
*/
public void setRemarksList(List<String> remarksList){
this.remarksList = remarksList;
}
/**
* 获取 备注
* @return remarksNotList
*/
public List<String> getRemarksNotList(){
return this.remarksNotList;
}
/**
* 设置 备注
* @param remarksNotList
*/
public void setRemarksNotList(List<String> remarksNotList){
this.remarksNotList = remarksNotList;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public ApproverQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public ApproverQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public ApproverQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public ApproverQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public ApproverQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public ApproverQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 站点id
* @param siteId
*/
public ApproverQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public ApproverQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public ApproverQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public ApproverQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点id
* @param siteIdList
*/
public ApproverQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点id
* @param siteIdNotList
*/
public ApproverQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
/**
* 设置 工作人员姓名
* @param fullName
*/
public ApproverQuery fullName(String fullName){
setFullName(fullName);
return this;
}
/**
* 设置 工作人员姓名
* @param fullNameList
*/
public ApproverQuery fullNameList(List<String> fullNameList){
this.fullNameList = fullNameList;
return this;
}
/**
* 设置 联系电话
* @param phoneNumber
*/
public ApproverQuery phoneNumber(String phoneNumber){
setPhoneNumber(phoneNumber);
return this;
}
/**
* 设置 联系电话
* @param phoneNumberList
*/
public ApproverQuery phoneNumberList(List<String> phoneNumberList){
this.phoneNumberList = phoneNumberList;
return this;
}
/**
* 设置 登录用户名
* @param loginName
*/
public ApproverQuery loginName(String loginName){
setLoginName(loginName);
return this;
}
/**
* 设置 登录用户名
* @param loginNameList
*/
public ApproverQuery loginNameList(List<String> loginNameList){
this.loginNameList = loginNameList;
return this;
}
/**
* 设置 登录密码
* @param loginPwd
*/
public ApproverQuery loginPwd(String loginPwd){
setLoginPwd(loginPwd);
return this;
}
/**
* 设置 登录密码
* @param loginPwdList
*/
public ApproverQuery loginPwdList(List<String> loginPwdList){
this.loginPwdList = loginPwdList;
return this;
}
/**
* 设置 所属部门
* @param deptId
*/
public ApproverQuery deptId(Long deptId){
setDeptId(deptId);
return this;
}
/**
* 设置 开始 所属部门
* @param deptIdStart
*/
public ApproverQuery deptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
return this;
}
/**
* 设置 结束 所属部门
* @param deptIdEnd
*/
public ApproverQuery deptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
return this;
}
/**
* 设置 增加 所属部门
* @param deptIdIncrement
*/
public ApproverQuery deptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
return this;
}
/**
* 设置 所属部门
* @param deptIdList
*/
public ApproverQuery deptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
return this;
}
/**
* 设置 所属部门
* @param deptIdNotList
*/
public ApproverQuery deptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
return this;
}
/**
* 设置 所属部门编码
* @param deptCode
*/
public ApproverQuery deptCode(String deptCode){
setDeptCode(deptCode);
return this;
}
/**
* 设置 所属部门编码
* @param deptCodeList
*/
public ApproverQuery deptCodeList(List<String> deptCodeList){
this.deptCodeList = deptCodeList;
return this;
}
/**
* 设置 所属部门名称
* @param deptName
*/
public ApproverQuery deptName(String deptName){
setDeptName(deptName);
return this;
}
/**
* 设置 所属部门名称
* @param deptNameList
*/
public ApproverQuery deptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
return this;
}
/**
* 设置 备注
* @param remarks
*/
public ApproverQuery remarks(String remarks){
setRemarks(remarks);
return this;
}
/**
* 设置 备注
* @param remarksList
*/
public ApproverQuery remarksList(List<String> remarksList){
this.remarksList = remarksList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public ApproverQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public ApproverQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public ApproverQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public ApproverQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public ApproverQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public ApproverQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public ApproverQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public ApproverQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public ApproverQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public ApproverQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public ApproverQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public ApproverQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<ApproverQuery> 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<ApproverQuery> 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<ApproverQuery> 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<ApproverQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/MatterApplyDatumEntity.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.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.apply.model.vo.MatterApplyDatumVo;
import lombok.Data;
/**
* 事项申报材料实体对象
*
* @author zxfei
* @date 2023-05-23
*/
@Data
public class MatterApplyDatumEntity extends MatterApplyDatumVo {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 用户申报id
*/
private Long applyId;
/**
* 单事项id
*/
private Long singleMatterId;
/**
* 基础事项id
*/
private Long matterId;
/**
* 材料id
*/
private Long datumId;
/**
* 材料名称
*/
private String materialName;
/**
* 附件文件名称
*/
private String fileName;
/**
* 附件文件地址
*/
private String fileUrl;
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MatterApplyDatumEntity) {
MatterApplyDatumEntity tmp = (MatterApplyDatumEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.siteId = -1L;
this.applyId = -1L;
this.singleMatterId = -1L;
this.matterId = -1L;
this.datumId = -1L;
this.materialName = "";
this.fileName = "";
this.fileUrl = "";
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/MatterApplyDatumQuery.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model;
import java.util.List;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
/**
* 事项申报材料查询对象
*
* @author zxfei
* @date 2023-05-23
*/
public class MatterApplyDatumQuery extends MatterApplyDatumEntity {
/** 开始 序号，主键，自增长 */
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;
/** 开始 用户申报id */
private Long applyIdStart;
/** 结束 用户申报id */
private Long applyIdEnd;
/** 增加 用户申报id */
private Long applyIdIncrement;
/** 用户申报id列表 */
private List <Long> applyIdList;
/** 用户申报id排除列表 */
private List <Long> applyIdNotList;
/** 开始 单事项id */
private Long singleMatterIdStart;
/** 结束 单事项id */
private Long singleMatterIdEnd;
/** 增加 单事项id */
private Long singleMatterIdIncrement;
/** 单事项id列表 */
private List <Long> singleMatterIdList;
/** 单事项id排除列表 */
private List <Long> singleMatterIdNotList;
/** 开始 基础事项id */
private Long matterIdStart;
/** 结束 基础事项id */
private Long matterIdEnd;
/** 增加 基础事项id */
private Long matterIdIncrement;
/** 基础事项id列表 */
private List <Long> matterIdList;
/** 基础事项id排除列表 */
private List <Long> matterIdNotList;
/** 开始 材料id */
private Long datumIdStart;
/** 结束 材料id */
private Long datumIdEnd;
/** 增加 材料id */
private Long datumIdIncrement;
/** 材料id列表 */
private List <Long> datumIdList;
/** 材料id排除列表 */
private List <Long> datumIdNotList;
/** 材料名称 */
private List<String> materialNameList;
/** 材料名称排除列表 */
private List <String> materialNameNotList;
/** 附件文件名称 */
private List<String> fileNameList;
/** 附件文件名称排除列表 */
private List <String> fileNameNotList;
/** 附件文件地址 */
private List<String> fileUrlList;
/** 附件文件地址排除列表 */
private List <String> fileUrlNotList;
/** 开始 创建用户 */
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;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MatterApplyDatumQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MatterApplyDatumQuery> andConditionList;
public MatterApplyDatumQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @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;
}
/**
* 获取 开始 用户申报id
* @return applyIdStart
*/
public Long getApplyIdStart(){
return this.applyIdStart;
}
/**
* 设置 开始 用户申报id
* @param applyIdStart
*/
public void setApplyIdStart(Long applyIdStart){
this.applyIdStart = applyIdStart;
}
/**
* 获取 结束 用户申报id
* @return $applyIdEnd
*/
public Long getApplyIdEnd(){
return this.applyIdEnd;
}
/**
* 设置 结束 用户申报id
* @param applyIdEnd
*/
public void setApplyIdEnd(Long applyIdEnd){
this.applyIdEnd = applyIdEnd;
}
/**
* 获取 增加 用户申报id
* @return applyIdIncrement
*/
public Long getApplyIdIncrement(){
return this.applyIdIncrement;
}
/**
* 设置 增加 用户申报id
* @param applyIdIncrement
*/
public void setApplyIdIncrement(Long applyIdIncrement){
this.applyIdIncrement = applyIdIncrement;
}
/**
* 获取 用户申报id
* @return applyIdList
*/
public List<Long> getApplyIdList(){
return this.applyIdList;
}
/**
* 设置 用户申报id
* @param applyIdList
*/
public void setApplyIdList(List<Long> applyIdList){
this.applyIdList = applyIdList;
}
/**
* 获取 用户申报id
* @return applyIdNotList
*/
public List<Long> getApplyIdNotList(){
return this.applyIdNotList;
}
/**
* 设置 用户申报id
* @param applyIdNotList
*/
public void setApplyIdNotList(List<Long> applyIdNotList){
this.applyIdNotList = applyIdNotList;
}
/**
* 获取 开始 单事项id
* @return singleMatterIdStart
*/
public Long getSingleMatterIdStart(){
return this.singleMatterIdStart;
}
/**
* 设置 开始 单事项id
* @param singleMatterIdStart
*/
public void setSingleMatterIdStart(Long singleMatterIdStart){
this.singleMatterIdStart = singleMatterIdStart;
}
/**
* 获取 结束 单事项id
* @return $singleMatterIdEnd
*/
public Long getSingleMatterIdEnd(){
return this.singleMatterIdEnd;
}
/**
* 设置 结束 单事项id
* @param singleMatterIdEnd
*/
public void setSingleMatterIdEnd(Long singleMatterIdEnd){
this.singleMatterIdEnd = singleMatterIdEnd;
}
/**
* 获取 增加 单事项id
* @return singleMatterIdIncrement
*/
public Long getSingleMatterIdIncrement(){
return this.singleMatterIdIncrement;
}
/**
* 设置 增加 单事项id
* @param singleMatterIdIncrement
*/
public void setSingleMatterIdIncrement(Long singleMatterIdIncrement){
this.singleMatterIdIncrement = singleMatterIdIncrement;
}
/**
* 获取 单事项id
* @return singleMatterIdList
*/
public List<Long> getSingleMatterIdList(){
return this.singleMatterIdList;
}
/**
* 设置 单事项id
* @param singleMatterIdList
*/
public void setSingleMatterIdList(List<Long> singleMatterIdList){
this.singleMatterIdList = singleMatterIdList;
}
/**
* 获取 单事项id
* @return singleMatterIdNotList
*/
public List<Long> getSingleMatterIdNotList(){
return this.singleMatterIdNotList;
}
/**
* 设置 单事项id
* @param singleMatterIdNotList
*/
public void setSingleMatterIdNotList(List<Long> singleMatterIdNotList){
this.singleMatterIdNotList = singleMatterIdNotList;
}
/**
* 获取 开始 基础事项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;
}
/**
* 获取 开始 材料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;
}
/**
* 获取 材料名称
* @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;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public MatterApplyDatumQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public MatterApplyDatumQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public MatterApplyDatumQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public MatterApplyDatumQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public MatterApplyDatumQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public MatterApplyDatumQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 站点id
* @param siteId
*/
public MatterApplyDatumQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public MatterApplyDatumQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public MatterApplyDatumQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public MatterApplyDatumQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点id
* @param siteIdList
*/
public MatterApplyDatumQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点id
* @param siteIdNotList
*/
public MatterApplyDatumQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
/**
* 设置 用户申报id
* @param applyId
*/
public MatterApplyDatumQuery applyId(Long applyId){
setApplyId(applyId);
return this;
}
/**
* 设置 开始 用户申报id
* @param applyIdStart
*/
public MatterApplyDatumQuery applyIdStart(Long applyIdStart){
this.applyIdStart = applyIdStart;
return this;
}
/**
* 设置 结束 用户申报id
* @param applyIdEnd
*/
public MatterApplyDatumQuery applyIdEnd(Long applyIdEnd){
this.applyIdEnd = applyIdEnd;
return this;
}
/**
* 设置 增加 用户申报id
* @param applyIdIncrement
*/
public MatterApplyDatumQuery applyIdIncrement(Long applyIdIncrement){
this.applyIdIncrement = applyIdIncrement;
return this;
}
/**
* 设置 用户申报id
* @param applyIdList
*/
public MatterApplyDatumQuery applyIdList(List<Long> applyIdList){
this.applyIdList = applyIdList;
return this;
}
/**
* 设置 用户申报id
* @param applyIdNotList
*/
public MatterApplyDatumQuery applyIdNotList(List<Long> applyIdNotList){
this.applyIdNotList = applyIdNotList;
return this;
}
/**
* 设置 单事项id
* @param singleMatterId
*/
public MatterApplyDatumQuery singleMatterId(Long singleMatterId){
setSingleMatterId(singleMatterId);
return this;
}
/**
* 设置 开始 单事项id
* @param singleMatterIdStart
*/
public MatterApplyDatumQuery singleMatterIdStart(Long singleMatterIdStart){
this.singleMatterIdStart = singleMatterIdStart;
return this;
}
/**
* 设置 结束 单事项id
* @param singleMatterIdEnd
*/
public MatterApplyDatumQuery singleMatterIdEnd(Long singleMatterIdEnd){
this.singleMatterIdEnd = singleMatterIdEnd;
return this;
}
/**
* 设置 增加 单事项id
* @param singleMatterIdIncrement
*/
public MatterApplyDatumQuery singleMatterIdIncrement(Long singleMatterIdIncrement){
this.singleMatterIdIncrement = singleMatterIdIncrement;
return this;
}
/**
* 设置 单事项id
* @param singleMatterIdList
*/
public MatterApplyDatumQuery singleMatterIdList(List<Long> singleMatterIdList){
this.singleMatterIdList = singleMatterIdList;
return this;
}
/**
* 设置 单事项id
* @param singleMatterIdNotList
*/
public MatterApplyDatumQuery singleMatterIdNotList(List<Long> singleMatterIdNotList){
this.singleMatterIdNotList = singleMatterIdNotList;
return this;
}
/**
* 设置 基础事项id
* @param matterId
*/
public MatterApplyDatumQuery matterId(Long matterId){
setMatterId(matterId);
return this;
}
/**
* 设置 开始 基础事项id
* @param matterIdStart
*/
public MatterApplyDatumQuery matterIdStart(Long matterIdStart){
this.matterIdStart = matterIdStart;
return this;
}
/**
* 设置 结束 基础事项id
* @param matterIdEnd
*/
public MatterApplyDatumQuery matterIdEnd(Long matterIdEnd){
this.matterIdEnd = matterIdEnd;
return this;
}
/**
* 设置 增加 基础事项id
* @param matterIdIncrement
*/
public MatterApplyDatumQuery matterIdIncrement(Long matterIdIncrement){
this.matterIdIncrement = matterIdIncrement;
return this;
}
/**
* 设置 基础事项id
* @param matterIdList
*/
public MatterApplyDatumQuery matterIdList(List<Long> matterIdList){
this.matterIdList = matterIdList;
return this;
}
/**
* 设置 基础事项id
* @param matterIdNotList
*/
public MatterApplyDatumQuery matterIdNotList(List<Long> matterIdNotList){
this.matterIdNotList = matterIdNotList;
return this;
}
/**
* 设置 材料id
* @param datumId
*/
public MatterApplyDatumQuery datumId(Long datumId){
setDatumId(datumId);
return this;
}
/**
* 设置 开始 材料id
* @param datumIdStart
*/
public MatterApplyDatumQuery datumIdStart(Long datumIdStart){
this.datumIdStart = datumIdStart;
return this;
}
/**
* 设置 结束 材料id
* @param datumIdEnd
*/
public MatterApplyDatumQuery datumIdEnd(Long datumIdEnd){
this.datumIdEnd = datumIdEnd;
return this;
}
/**
* 设置 增加 材料id
* @param datumIdIncrement
*/
public MatterApplyDatumQuery datumIdIncrement(Long datumIdIncrement){
this.datumIdIncrement = datumIdIncrement;
return this;
}
/**
* 设置 材料id
* @param datumIdList
*/
public MatterApplyDatumQuery datumIdList(List<Long> datumIdList){
this.datumIdList = datumIdList;
return this;
}
/**
* 设置 材料id
* @param datumIdNotList
*/
public MatterApplyDatumQuery datumIdNotList(List<Long> datumIdNotList){
this.datumIdNotList = datumIdNotList;
return this;
}
/**
* 设置 材料名称
* @param materialName
*/
public MatterApplyDatumQuery materialName(String materialName){
setMaterialName(materialName);
return this;
}
/**
* 设置 材料名称
* @param materialNameList
*/
public MatterApplyDatumQuery materialNameList(List<String> materialNameList){
this.materialNameList = materialNameList;
return this;
}
/**
* 设置 附件文件名称
* @param fileName
*/
public MatterApplyDatumQuery fileName(String fileName){
setFileName(fileName);
return this;
}
/**
* 设置 附件文件名称
* @param fileNameList
*/
public MatterApplyDatumQuery fileNameList(List<String> fileNameList){
this.fileNameList = fileNameList;
return this;
}
/**
* 设置 附件文件地址
* @param fileUrl
*/
public MatterApplyDatumQuery fileUrl(String fileUrl){
setFileUrl(fileUrl);
return this;
}
/**
* 设置 附件文件地址
* @param fileUrlList
*/
public MatterApplyDatumQuery fileUrlList(List<String> fileUrlList){
this.fileUrlList = fileUrlList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MatterApplyDatumQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MatterApplyDatumQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MatterApplyDatumQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MatterApplyDatumQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MatterApplyDatumQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MatterApplyDatumQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public MatterApplyDatumQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public MatterApplyDatumQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public MatterApplyDatumQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public MatterApplyDatumQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public MatterApplyDatumQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public MatterApplyDatumQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MatterApplyDatumQuery> 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<MatterApplyDatumQuery> 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<MatterApplyDatumQuery> 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<MatterApplyDatumQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/MatterApplyEntity.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model;
import java.util.Date;
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.apply.model.vo.MatterApplyVo;
import lombok.Data;
/**
* 单事项申报实体对象
*
* @author zxfei
* @date 2023-05-27
*/
@Data
public class MatterApplyEntity extends MatterApplyVo {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 单事项id
*/
private Long singleMatterId;
/**
* 基础事项id
*/
private Long matterId;
/**
* 部门编码
*/
private String deptCode;
/**
* 单事项名称
*/
private String matterName;
/**
* 申请人姓名
*/
private String applyPerson;
/**
* 申请人性别
*/
private Integer sexual;
/**
* 申请人电话
*/
private String phoneNum;
/**
* 申请人身份证号码
*/
private String idCard;
/**
* 地点
*/
private String address;
/**
* 申请方式1移动端2后台
*/
private Integer applyType;
/**
* 申请时间
*/
private Date applyTime;
/**
* 审批状态0审批中1通过2不通过
*/
private Integer applyState;
/**
* 审批意见
*/
private String advisement;
/**
* 备注
*/
private String remarks;
/**
* 微信openId
*/
private String openId;
@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 void initAttrValue(){
this.siteId = -1L;
this.singleMatterId = -1L;
this.matterId = -1L;
this.deptCode = "";
this.matterName = "";
this.applyPerson = "";
this.sexual = 1;
this.phoneNum = "";
this.idCard = "";
this.address = "";
this.applyType = 1;
this.applyTime = null;
this.applyState = 0;
this.advisement = "";
this.remarks = "";
this.openId = "";
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/MatterApplyQuery.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model;
import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.apply.model.MatterApplyEntity;
/**
* 单事项申报查询对象
*
* @author zxfei
* @date 2023-05-27
*/
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;
/** 开始 单事项id */
private Long singleMatterIdStart;
/** 结束 单事项id */
private Long singleMatterIdEnd;
/** 增加 单事项id */
private Long singleMatterIdIncrement;
/** 单事项id列表 */
private List <Long> singleMatterIdList;
/** 单事项id排除列表 */
private List <Long> singleMatterIdNotList;
/** 开始 基础事项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> deptCodeList;
/** 部门编码排除列表 */
private List <String> deptCodeNotList;
/** 单事项名称 */
private List<String> matterNameList;
/** 单事项名称排除列表 */
private List <String> matterNameNotList;
/** 申请人姓名 */
private List<String> applyPersonList;
/** 申请人姓名排除列表 */
private List <String> applyPersonNotList;
/** 开始 申请人性别 */
private Integer sexualStart;
/** 结束 申请人性别 */
private Integer sexualEnd;
/** 增加 申请人性别 */
private Integer sexualIncrement;
/** 申请人性别列表 */
private List <Integer> sexualList;
/** 申请人性别排除列表 */
private List <Integer> sexualNotList;
/** 申请人电话 */
private List<String> phoneNumList;
/** 申请人电话排除列表 */
private List <String> phoneNumNotList;
/** 申请人身份证号码 */
private List<String> idCardList;
/** 申请人身份证号码排除列表 */
private List <String> idCardNotList;
/** 地点 */
private List<String> addressList;
/** 地点排除列表 */
private List <String> addressNotList;
/** 开始 申请方式1移动端2后台 */
private Integer applyTypeStart;
/** 结束 申请方式1移动端2后台 */
private Integer applyTypeEnd;
/** 增加 申请方式1移动端2后台 */
private Integer applyTypeIncrement;
/** 申请方式1移动端2后台列表 */
private List <Integer> applyTypeList;
/** 申请方式1移动端2后台排除列表 */
private List <Integer> applyTypeNotList;
/** 开始 申请时间 */
private String applyTimeStart;
/** 结束 申请时间 */
private String applyTimeEnd;
/** 开始 审批状态0审批中1通过2不通过 */
private Integer applyStateStart;
/** 结束 审批状态0审批中1通过2不通过 */
private Integer applyStateEnd;
/** 增加 审批状态0审批中1通过2不通过 */
private Integer applyStateIncrement;
/** 审批状态0审批中1通过2不通过列表 */
private List <Integer> applyStateList;
/** 审批状态0审批中1通过2不通过排除列表 */
private List <Integer> applyStateNotList;
/** 审批意见 */
private List<String> advisementList;
/** 审批意见排除列表 */
private List <String> advisementNotList;
/** 备注 */
private List<String> remarksList;
/** 备注排除列表 */
private List <String> remarksNotList;
/** 微信openId */
private List<String> openIdList;
/** 微信openId排除列表 */
private List <String> openIdNotList;
/** 开始 创建用户 */
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;
/** 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;
}
/**
* 获取 开始 单事项id
* @return singleMatterIdStart
*/
public Long getSingleMatterIdStart(){
return this.singleMatterIdStart;
}
/**
* 设置 开始 单事项id
* @param singleMatterIdStart
*/
public void setSingleMatterIdStart(Long singleMatterIdStart){
this.singleMatterIdStart = singleMatterIdStart;
}
/**
* 获取 结束 单事项id
* @return $singleMatterIdEnd
*/
public Long getSingleMatterIdEnd(){
return this.singleMatterIdEnd;
}
/**
* 设置 结束 单事项id
* @param singleMatterIdEnd
*/
public void setSingleMatterIdEnd(Long singleMatterIdEnd){
this.singleMatterIdEnd = singleMatterIdEnd;
}
/**
* 获取 增加 单事项id
* @return singleMatterIdIncrement
*/
public Long getSingleMatterIdIncrement(){
return this.singleMatterIdIncrement;
}
/**
* 设置 增加 单事项id
* @param singleMatterIdIncrement
*/
public void setSingleMatterIdIncrement(Long singleMatterIdIncrement){
this.singleMatterIdIncrement = singleMatterIdIncrement;
}
/**
* 获取 单事项id
* @return singleMatterIdList
*/
public List<Long> getSingleMatterIdList(){
return this.singleMatterIdList;
}
/**
* 设置 单事项id
* @param singleMatterIdList
*/
public void setSingleMatterIdList(List<Long> singleMatterIdList){
this.singleMatterIdList = singleMatterIdList;
}
/**
* 获取 单事项id
* @return singleMatterIdNotList
*/
public List<Long> getSingleMatterIdNotList(){
return this.singleMatterIdNotList;
}
/**
* 设置 单事项id
* @param singleMatterIdNotList
*/
public void setSingleMatterIdNotList(List<Long> singleMatterIdNotList){
this.singleMatterIdNotList = singleMatterIdNotList;
}
/**
* 获取 开始 基础事项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 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 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 applyPersonList
*/
public List<String> getApplyPersonList(){
return this.applyPersonList;
}
/**
* 设置 申请人姓名
* @param applyPersonList
*/
public void setApplyPersonList(List<String> applyPersonList){
this.applyPersonList = applyPersonList;
}
/**
* 获取 申请人姓名
* @return applyPersonNotList
*/
public List<String> getApplyPersonNotList(){
return this.applyPersonNotList;
}
/**
* 设置 申请人姓名
* @param applyPersonNotList
*/
public void setApplyPersonNotList(List<String> applyPersonNotList){
this.applyPersonNotList = applyPersonNotList;
}
/**
* 获取 开始 申请人性别
* @return sexualStart
*/
public Integer getSexualStart(){
return this.sexualStart;
}
/**
* 设置 开始 申请人性别
* @param sexualStart
*/
public void setSexualStart(Integer sexualStart){
this.sexualStart = sexualStart;
}
/**
* 获取 结束 申请人性别
* @return $sexualEnd
*/
public Integer getSexualEnd(){
return this.sexualEnd;
}
/**
* 设置 结束 申请人性别
* @param sexualEnd
*/
public void setSexualEnd(Integer sexualEnd){
this.sexualEnd = sexualEnd;
}
/**
* 获取 增加 申请人性别
* @return sexualIncrement
*/
public Integer getSexualIncrement(){
return this.sexualIncrement;
}
/**
* 设置 增加 申请人性别
* @param sexualIncrement
*/
public void setSexualIncrement(Integer sexualIncrement){
this.sexualIncrement = sexualIncrement;
}
/**
* 获取 申请人性别
* @return sexualList
*/
public List<Integer> getSexualList(){
return this.sexualList;
}
/**
* 设置 申请人性别
* @param sexualList
*/
public void setSexualList(List<Integer> sexualList){
this.sexualList = sexualList;
}
/**
* 获取 申请人性别
* @return sexualNotList
*/
public List<Integer> getSexualNotList(){
return this.sexualNotList;
}
/**
* 设置 申请人性别
* @param sexualNotList
*/
public void setSexualNotList(List<Integer> sexualNotList){
this.sexualNotList = sexualNotList;
}
/**
* 获取 申请人电话
* @return phoneNumList
*/
public List<String> getPhoneNumList(){
return this.phoneNumList;
}
/**
* 设置 申请人电话
* @param phoneNumList
*/
public void setPhoneNumList(List<String> phoneNumList){
this.phoneNumList = phoneNumList;
}
/**
* 获取 申请人电话
* @return phoneNumNotList
*/
public List<String> getPhoneNumNotList(){
return this.phoneNumNotList;
}
/**
* 设置 申请人电话
* @param phoneNumNotList
*/
public void setPhoneNumNotList(List<String> phoneNumNotList){
this.phoneNumNotList = phoneNumNotList;
}
/**
* 获取 申请人身份证号码
* @return idCardList
*/
public List<String> getIdCardList(){
return this.idCardList;
}
/**
* 设置 申请人身份证号码
* @param idCardList
*/
public void setIdCardList(List<String> idCardList){
this.idCardList = idCardList;
}
/**
* 获取 申请人身份证号码
* @return idCardNotList
*/
public List<String> getIdCardNotList(){
return this.idCardNotList;
}
/**
* 设置 申请人身份证号码
* @param idCardNotList
*/
public void setIdCardNotList(List<String> idCardNotList){
this.idCardNotList = idCardNotList;
}
/**
* 获取 地点
* @return addressList
*/
public List<String> getAddressList(){
return this.addressList;
}
/**
* 设置 地点
* @param addressList
*/
public void setAddressList(List<String> addressList){
this.addressList = addressList;
}
/**
* 获取 地点
* @return addressNotList
*/
public List<String> getAddressNotList(){
return this.addressNotList;
}
/**
* 设置 地点
* @param addressNotList
*/
public void setAddressNotList(List<String> addressNotList){
this.addressNotList = addressNotList;
}
/**
* 获取 开始 申请方式1移动端2后台
* @return applyTypeStart
*/
public Integer getApplyTypeStart(){
return this.applyTypeStart;
}
/**
* 设置 开始 申请方式1移动端2后台
* @param applyTypeStart
*/
public void setApplyTypeStart(Integer applyTypeStart){
this.applyTypeStart = applyTypeStart;
}
/**
* 获取 结束 申请方式1移动端2后台
* @return $applyTypeEnd
*/
public Integer getApplyTypeEnd(){
return this.applyTypeEnd;
}
/**
* 设置 结束 申请方式1移动端2后台
* @param applyTypeEnd
*/
public void setApplyTypeEnd(Integer applyTypeEnd){
this.applyTypeEnd = applyTypeEnd;
}
/**
* 获取 增加 申请方式1移动端2后台
* @return applyTypeIncrement
*/
public Integer getApplyTypeIncrement(){
return this.applyTypeIncrement;
}
/**
* 设置 增加 申请方式1移动端2后台
* @param applyTypeIncrement
*/
public void setApplyTypeIncrement(Integer applyTypeIncrement){
this.applyTypeIncrement = applyTypeIncrement;
}
/**
* 获取 申请方式1移动端2后台
* @return applyTypeList
*/
public List<Integer> getApplyTypeList(){
return this.applyTypeList;
}
/**
* 设置 申请方式1移动端2后台
* @param applyTypeList
*/
public void setApplyTypeList(List<Integer> applyTypeList){
this.applyTypeList = applyTypeList;
}
/**
* 获取 申请方式1移动端2后台
* @return applyTypeNotList
*/
public List<Integer> getApplyTypeNotList(){
return this.applyTypeNotList;
}
/**
* 设置 申请方式1移动端2后台
* @param applyTypeNotList
*/
public void setApplyTypeNotList(List<Integer> applyTypeNotList){
this.applyTypeNotList = applyTypeNotList;
}
/**
* 获取 开始 申请时间
* @return applyTimeStart
*/
public String getApplyTimeStart(){
return this.applyTimeStart;
}
/**
* 设置 开始 申请时间
* @param applyTimeStart
*/
public void setApplyTimeStart(String applyTimeStart){
this.applyTimeStart = applyTimeStart;
}
/**
* 获取 结束 申请时间
* @return applyTimeEnd
*/
public String getApplyTimeEnd(){
return this.applyTimeEnd;
}
/**
* 设置 结束 申请时间
* @param applyTimeEnd
*/
public void setApplyTimeEnd(String applyTimeEnd){
this.applyTimeEnd = applyTimeEnd;
}
/**
* 获取 开始 审批状态0审批中1通过2不通过
* @return applyStateStart
*/
public Integer getApplyStateStart(){
return this.applyStateStart;
}
/**
* 设置 开始 审批状态0审批中1通过2不通过
* @param applyStateStart
*/
public void setApplyStateStart(Integer applyStateStart){
this.applyStateStart = applyStateStart;
}
/**
* 获取 结束 审批状态0审批中1通过2不通过
* @return $applyStateEnd
*/
public Integer getApplyStateEnd(){
return this.applyStateEnd;
}
/**
* 设置 结束 审批状态0审批中1通过2不通过
* @param applyStateEnd
*/
public void setApplyStateEnd(Integer applyStateEnd){
this.applyStateEnd = applyStateEnd;
}
/**
* 获取 增加 审批状态0审批中1通过2不通过
* @return applyStateIncrement
*/
public Integer getApplyStateIncrement(){
return this.applyStateIncrement;
}
/**
* 设置 增加 审批状态0审批中1通过2不通过
* @param applyStateIncrement
*/
public void setApplyStateIncrement(Integer applyStateIncrement){
this.applyStateIncrement = applyStateIncrement;
}
/**
* 获取 审批状态0审批中1通过2不通过
* @return applyStateList
*/
public List<Integer> getApplyStateList(){
return this.applyStateList;
}
/**
* 设置 审批状态0审批中1通过2不通过
* @param applyStateList
*/
public void setApplyStateList(List<Integer> applyStateList){
this.applyStateList = applyStateList;
}
/**
* 获取 审批状态0审批中1通过2不通过
* @return applyStateNotList
*/
public List<Integer> getApplyStateNotList(){
return this.applyStateNotList;
}
/**
* 设置 审批状态0审批中1通过2不通过
* @param applyStateNotList
*/
public void setApplyStateNotList(List<Integer> applyStateNotList){
this.applyStateNotList = applyStateNotList;
}
/**
* 获取 审批意见
* @return advisementList
*/
public List<String> getAdvisementList(){
return this.advisementList;
}
/**
* 设置 审批意见
* @param advisementList
*/
public void setAdvisementList(List<String> advisementList){
this.advisementList = advisementList;
}
/**
* 获取 审批意见
* @return advisementNotList
*/
public List<String> getAdvisementNotList(){
return this.advisementNotList;
}
/**
* 设置 审批意见
* @param advisementNotList
*/
public void setAdvisementNotList(List<String> advisementNotList){
this.advisementNotList = advisementNotList;
}
/**
* 获取 备注
* @return remarksList
*/
public List<String> getRemarksList(){
return this.remarksList;
}
/**
* 设置 备注
* @param remarksList
*/
public void setRemarksList(List<String> remarksList){
this.remarksList = remarksList;
}
/**
* 获取 备注
* @return remarksNotList
*/
public List<String> getRemarksNotList(){
return this.remarksNotList;
}
/**
* 设置 备注
* @param remarksNotList
*/
public void setRemarksNotList(List<String> remarksNotList){
this.remarksNotList = remarksNotList;
}
/**
* 获取 微信openId
* @return openIdList
*/
public List<String> getOpenIdList(){
return this.openIdList;
}
/**
* 设置 微信openId
* @param openIdList
*/
public void setOpenIdList(List<String> openIdList){
this.openIdList = openIdList;
}
/**
* 获取 微信openId
* @return openIdNotList
*/
public List<String> getOpenIdNotList(){
return this.openIdNotList;
}
/**
* 设置 微信openId
* @param openIdNotList
*/
public void setOpenIdNotList(List<String> openIdNotList){
this.openIdNotList = openIdNotList;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 设置 序号，主键，自增长
* @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;
}
/**
* 设置 单事项id
* @param singleMatterId
*/
public MatterApplyQuery singleMatterId(Long singleMatterId){
setSingleMatterId(singleMatterId);
return this;
}
/**
* 设置 开始 单事项id
* @param singleMatterIdStart
*/
public MatterApplyQuery singleMatterIdStart(Long singleMatterIdStart){
this.singleMatterIdStart = singleMatterIdStart;
return this;
}
/**
* 设置 结束 单事项id
* @param singleMatterIdEnd
*/
public MatterApplyQuery singleMatterIdEnd(Long singleMatterIdEnd){
this.singleMatterIdEnd = singleMatterIdEnd;
return this;
}
/**
* 设置 增加 单事项id
* @param singleMatterIdIncrement
*/
public MatterApplyQuery singleMatterIdIncrement(Long singleMatterIdIncrement){
this.singleMatterIdIncrement = singleMatterIdIncrement;
return this;
}
/**
* 设置 单事项id
* @param singleMatterIdList
*/
public MatterApplyQuery singleMatterIdList(List<Long> singleMatterIdList){
this.singleMatterIdList = singleMatterIdList;
return this;
}
/**
* 设置 单事项id
* @param singleMatterIdNotList
*/
public MatterApplyQuery singleMatterIdNotList(List<Long> singleMatterIdNotList){
this.singleMatterIdNotList = singleMatterIdNotList;
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 deptCode
*/
public MatterApplyQuery deptCode(String deptCode){
setDeptCode(deptCode);
return this;
}
/**
* 设置 部门编码
* @param deptCodeList
*/
public MatterApplyQuery deptCodeList(List<String> deptCodeList){
this.deptCodeList = deptCodeList;
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 applyPerson
*/
public MatterApplyQuery applyPerson(String applyPerson){
setApplyPerson(applyPerson);
return this;
}
/**
* 设置 申请人姓名
* @param applyPersonList
*/
public MatterApplyQuery applyPersonList(List<String> applyPersonList){
this.applyPersonList = applyPersonList;
return this;
}
/**
* 设置 申请人性别
* @param sexual
*/
public MatterApplyQuery sexual(Integer sexual){
setSexual(sexual);
return this;
}
/**
* 设置 开始 申请人性别
* @param sexualStart
*/
public MatterApplyQuery sexualStart(Integer sexualStart){
this.sexualStart = sexualStart;
return this;
}
/**
* 设置 结束 申请人性别
* @param sexualEnd
*/
public MatterApplyQuery sexualEnd(Integer sexualEnd){
this.sexualEnd = sexualEnd;
return this;
}
/**
* 设置 增加 申请人性别
* @param sexualIncrement
*/
public MatterApplyQuery sexualIncrement(Integer sexualIncrement){
this.sexualIncrement = sexualIncrement;
return this;
}
/**
* 设置 申请人性别
* @param sexualList
*/
public MatterApplyQuery sexualList(List<Integer> sexualList){
this.sexualList = sexualList;
return this;
}
/**
* 设置 申请人性别
* @param sexualNotList
*/
public MatterApplyQuery sexualNotList(List<Integer> sexualNotList){
this.sexualNotList = sexualNotList;
return this;
}
/**
* 设置 申请人电话
* @param phoneNum
*/
public MatterApplyQuery phoneNum(String phoneNum){
setPhoneNum(phoneNum);
return this;
}
/**
* 设置 申请人电话
* @param phoneNumList
*/
public MatterApplyQuery phoneNumList(List<String> phoneNumList){
this.phoneNumList = phoneNumList;
return this;
}
/**
* 设置 申请人身份证号码
* @param idCard
*/
public MatterApplyQuery idCard(String idCard){
setIdCard(idCard);
return this;
}
/**
* 设置 申请人身份证号码
* @param idCardList
*/
public MatterApplyQuery idCardList(List<String> idCardList){
this.idCardList = idCardList;
return this;
}
/**
* 设置 地点
* @param address
*/
public MatterApplyQuery address(String address){
setAddress(address);
return this;
}
/**
* 设置 地点
* @param addressList
*/
public MatterApplyQuery addressList(List<String> addressList){
this.addressList = addressList;
return this;
}
/**
* 设置 申请方式1移动端2后台
* @param applyType
*/
public MatterApplyQuery applyType(Integer applyType){
setApplyType(applyType);
return this;
}
/**
* 设置 开始 申请方式1移动端2后台
* @param applyTypeStart
*/
public MatterApplyQuery applyTypeStart(Integer applyTypeStart){
this.applyTypeStart = applyTypeStart;
return this;
}
/**
* 设置 结束 申请方式1移动端2后台
* @param applyTypeEnd
*/
public MatterApplyQuery applyTypeEnd(Integer applyTypeEnd){
this.applyTypeEnd = applyTypeEnd;
return this;
}
/**
* 设置 增加 申请方式1移动端2后台
* @param applyTypeIncrement
*/
public MatterApplyQuery applyTypeIncrement(Integer applyTypeIncrement){
this.applyTypeIncrement = applyTypeIncrement;
return this;
}
/**
* 设置 申请方式1移动端2后台
* @param applyTypeList
*/
public MatterApplyQuery applyTypeList(List<Integer> applyTypeList){
this.applyTypeList = applyTypeList;
return this;
}
/**
* 设置 申请方式1移动端2后台
* @param applyTypeNotList
*/
public MatterApplyQuery applyTypeNotList(List<Integer> applyTypeNotList){
this.applyTypeNotList = applyTypeNotList;
return this;
}
/**
* 设置 审批状态0审批中1通过2不通过
* @param applyState
*/
public MatterApplyQuery applyState(Integer applyState){
setApplyState(applyState);
return this;
}
/**
* 设置 开始 审批状态0审批中1通过2不通过
* @param applyStateStart
*/
public MatterApplyQuery applyStateStart(Integer applyStateStart){
this.applyStateStart = applyStateStart;
return this;
}
/**
* 设置 结束 审批状态0审批中1通过2不通过
* @param applyStateEnd
*/
public MatterApplyQuery applyStateEnd(Integer applyStateEnd){
this.applyStateEnd = applyStateEnd;
return this;
}
/**
* 设置 增加 审批状态0审批中1通过2不通过
* @param applyStateIncrement
*/
public MatterApplyQuery applyStateIncrement(Integer applyStateIncrement){
this.applyStateIncrement = applyStateIncrement;
return this;
}
/**
* 设置 审批状态0审批中1通过2不通过
* @param applyStateList
*/
public MatterApplyQuery applyStateList(List<Integer> applyStateList){
this.applyStateList = applyStateList;
return this;
}
/**
* 设置 审批状态0审批中1通过2不通过
* @param applyStateNotList
*/
public MatterApplyQuery applyStateNotList(List<Integer> applyStateNotList){
this.applyStateNotList = applyStateNotList;
return this;
}
/**
* 设置 审批意见
* @param advisement
*/
public MatterApplyQuery advisement(String advisement){
setAdvisement(advisement);
return this;
}
/**
* 设置 审批意见
* @param advisementList
*/
public MatterApplyQuery advisementList(List<String> advisementList){
this.advisementList = advisementList;
return this;
}
/**
* 设置 备注
* @param remarks
*/
public MatterApplyQuery remarks(String remarks){
setRemarks(remarks);
return this;
}
/**
* 设置 备注
* @param remarksList
*/
public MatterApplyQuery remarksList(List<String> remarksList){
this.remarksList = remarksList;
return this;
}
/**
* 设置 微信openId
* @param openId
*/
public MatterApplyQuery openId(String openId){
setOpenId(openId);
return this;
}
/**
* 设置 微信openId
* @param openIdList
*/
public MatterApplyQuery openIdList(List<String> openIdList){
this.openIdList = openIdList;
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;
}
/**
* 获取 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
single-matter/src/main/java/com/mortals/xhx/module/apply/model/vo/ApproverVo.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.apply.model.ApproverEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 单事项审批人员视图对象
*
* @author zxfei
* @date 2023-05-23
*/
@Data
public class ApproverVo extends BaseEntityLong {
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/vo/MatterApplyDatumVo.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 事项申报材料视图对象
*
* @author zxfei
* @date 2023-05-23
*/
@Data
public class MatterApplyDatumVo extends BaseEntityLong {
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/model/vo/MatterApplyVo.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import com.mortals.xhx.module.apply.model.MatterApplyEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 单事项申报视图对象
*
* @author zxfei
* @date 2023-05-23
*/
@Data
public class MatterApplyVo extends BaseEntityLong {
/** 申请材料 */
private List<MatterApplyDatumEntity> applyDatumList;
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/service/ApproverService.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.common.pdu.user.UserPhpPdu;
import com.mortals.xhx.module.apply.model.ApproverEntity;
import com.mortals.xhx.module.apply.dao.ApproverDao;
import java.util.List;
/**
* ApproverService
*
* 单事项审批人员 service接口
*
* @author zxfei
* @date 2023-05-23
*/
public interface ApproverService extends ICRUDService<ApproverEntity,Long>{
ApproverDao getDao();
void updateUserList(List<UserPhpPdu> list);
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/service/MatterApplyDatumService.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import com.mortals.xhx.module.apply.dao.MatterApplyDatumDao;
/**
* MatterApplyDatumService
*
* 事项申报材料 service接口
*
* @author zxfei
* @date 2023-05-23
*/
public interface MatterApplyDatumService extends ICRUDService<MatterApplyDatumEntity,Long>{
MatterApplyDatumDao getDao();
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/service/MatterApplyService.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.service;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.apply.model.MatterApplyEntity;
import com.mortals.xhx.module.apply.dao.MatterApplyDao;
/**
* MatterApplyService
*
* 单事项申报 service接口
*
* @author zxfei
* @date 2023-05-23
*/
public interface MatterApplyService extends ICRUDService<MatterApplyEntity,Long>{
MatterApplyDao getDao();
/**
* 申请审批
* @param entity
* @throws AppException
*/
void applyExamine(MatterApplyEntity entity, Context context) throws AppException;
/**
* 重新申请
* @param entity
* @param context
* @throws AppException
*/
void reApply(MatterApplyEntity entity, Context context) throws AppException;
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/service/impl/ApproverServiceImpl.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.service.impl;
import com.mortals.framework.util.DataUtil;
import com.mortals.framework.util.SecurityUtil;
import com.mortals.xhx.base.system.user.model.UserEntity;
import com.mortals.xhx.base.system.user.model.UserQuery;
import com.mortals.xhx.common.pdu.user.UserPhpPdu;
import com.mortals.xhx.module.apply.model.ApproverQuery;
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.apply.dao.ApproverDao;
import com.mortals.xhx.module.apply.model.ApproverEntity;
import com.mortals.xhx.module.apply.service.ApproverService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import java.util.List;
/**
* ApproverService
* 单事项审批人员 service实现
*
* @author zxfei
* @date 2023-05-23
*/
@Service("approverService")
@Slf4j
public class ApproverServiceImpl extends AbstractCRUDServiceImpl<ApproverDao, ApproverEntity, Long> implements ApproverService {
@Override
public void updateUserList(List<UserPhpPdu> list) {
if(!CollectionUtils.isEmpty(list)){
for(UserPhpPdu phpPdu:list){
if(!phpPdu.getType().equals("2")){
continue;
}
ApproverEntity tempUser = this.selectOne(new ApproverQuery().loginName(phpPdu.getAccount()));
if (ObjectUtils.isEmpty(tempUser)) {
//新增
ApproverEntity approverEntity = new ApproverEntity();
approverEntity.initAttrValue();
approverEntity.setFullName(phpPdu.getUser_name());
approverEntity.setLoginName(phpPdu.getAccount());
try {
approverEntity.setLoginPwd(SecurityUtil.md5DoubleEncoding(phpPdu.getPassword()));
} catch (Exception e) {
throw new AppException("密码转换异常！", e);
}
approverEntity.setPhoneNumber(phpPdu.getMobile());
approverEntity.setSiteId(1l);
dao.insert(approverEntity);
} else {
//更新
ApproverEntity approverEntity = new ApproverEntity();
approverEntity.setId(tempUser.getId());
approverEntity.initAttrValue();
approverEntity.setFullName(phpPdu.getUser_name());
approverEntity.setLoginName(phpPdu.getAccount());
try {
approverEntity.setLoginPwd(SecurityUtil.md5DoubleEncoding(phpPdu.getPassword()));
} catch (Exception e) {
throw new AppException("密码转换异常！", e);
}
approverEntity.setPhoneNumber(phpPdu.getMobile());
dao.update(approverEntity);
}
}
}
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/service/impl/MatterApplyDatumServiceImpl.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.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.apply.dao.MatterApplyDatumDao;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import com.mortals.xhx.module.apply.service.MatterApplyDatumService;
import lombok.extern.slf4j.Slf4j;
/**
* MatterApplyDatumService
* 事项申报材料 service实现
*
* @author zxfei
* @date 2023-05-23
*/
@Service("matterApplyDatumService")
@Slf4j
public class MatterApplyDatumServiceImpl extends AbstractCRUDServiceImpl<MatterApplyDatumDao, MatterApplyDatumEntity, Long> implements MatterApplyDatumService {
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/service/impl/MatterApplyServiceImpl.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.service.impl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.model.PageInfo;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.xhx.module.apply.dao.MatterApplyDao;
import com.mortals.xhx.module.apply.model.MatterApplyDatumEntity;
import com.mortals.xhx.module.apply.model.MatterApplyDatumQuery;
import com.mortals.xhx.module.apply.model.MatterApplyEntity;
import com.mortals.xhx.module.apply.service.MatterApplyDatumService;
import com.mortals.xhx.module.apply.service.MatterApplyService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
* MatterApplyService
* 单事项申报 service实现
*
* @author zxfei
* @date 2023-05-23
*/
@Service("matterApplyService")
@Slf4j
public class MatterApplyServiceImpl extends AbstractCRUDServiceImpl<MatterApplyDao, MatterApplyEntity, Long> implements MatterApplyService {
@Autowired
private MatterApplyDatumService matterApplyDatumService;
@Override
protected void saveBefore(MatterApplyEntity entity, Context context) throws AppException {
entity.setSiteId(1l);
entity.setApplyTime(entity.getCreateTime());
entity.setApplyState(0);
}
@Override
protected void saveAfter(MatterApplyEntity entity, Context context) throws AppException {
if(CollectionUtils.isNotEmpty(entity.getApplyDatumList())){
for (MatterApplyDatumEntity item:entity.getApplyDatumList()){
item.setSiteId(entity.getSiteId());
item.setSingleMatterId(entity.getSingleMatterId());
item.setMatterId(entity.getMatterId());
item.setApplyId(entity.getId());
item.setCreateTime(entity.getCreateTime());
item.setCreateUserId(entity.getCreateUserId());
}
matterApplyDatumService.save(entity.getApplyDatumList(),context);
}
}
@Override
protected void updateBefore(MatterApplyEntity entity, Context context) throws AppException {
entity.setApplyTime(new Date());
entity.setAdvisement("");
entity.setApplyState(0);
}
@Override
protected void updateAfter(MatterApplyEntity entity, Context context) throws AppException {
if(CollectionUtils.isNotEmpty(entity.getApplyDatumList())){
matterApplyDatumService.update(entity.getApplyDatumList());
}
}
@Override
protected void findAfter(MatterApplyEntity params, Context context, List<MatterApplyEntity> list) throws AppException {
if(CollectionUtils.isNotEmpty(list)){
for (MatterApplyEntity entity:list){
List<MatterApplyDatumEntity> datumEntities = matterApplyDatumService.find(new MatterApplyDatumQuery().applyId(entity.getId()));
entity.setApplyDatumList(datumEntities);
}
}
}
@Override
protected void findAfter(MatterApplyEntity params, PageInfo pageInfo, Context context, List<MatterApplyEntity> list) throws AppException {
if(CollectionUtils.isNotEmpty(list)){
for (MatterApplyEntity entity:list){
List<MatterApplyDatumEntity> datumEntities = matterApplyDatumService.find(new MatterApplyDatumQuery().applyId(entity.getId()));
entity.setApplyDatumList(datumEntities);
}
}
}
@Override
public void applyExamine(MatterApplyEntity entity, Context context) throws AppException {
if(entity.getId()==null){
throw new AppException("申报id不能为空");
}
if(entity.getApplyState()==null){
throw new AppException("审批状态不能为空");
}
MatterApplyEntity update = new MatterApplyEntity();
update.setId(entity.getId());
update.setApplyState(entity.getApplyState());
update.setAdvisement(entity.getAdvisement());
if(context!=null && context.getUser()!=null){
update.setUpdateUserId(context.getUser().getId());
}
update.setUpdateTime(new Date());
dao.update(update);
}
@Override
public void reApply(MatterApplyEntity entity, Context context) throws AppException {
if(entity.getId()==null){
throw new AppException("申报id不能为空");
}
entity.setApplyState(0);
entity.setAdvisement("");
this.update(entity,context);
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/web/ApproverController.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.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.apply.model.ApproverEntity;
import com.mortals.xhx.module.apply.service.ApproverService;
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-05-23
*/
@RestController
@RequestMapping("approver")
public class ApproverController extends BaseCRUDJsonBodyMappingController<ApproverService,ApproverEntity,Long> {
@Autowired
private ParamService paramService;
public ApproverController(){
super.setModuleDesc( "单事项审批人员");
}
@Override
protected void init(Map<String, Object> model, Context context) {
super.init(model, context);
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/web/MatterApplyController.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.web;
import com.mortals.framework.annotation.RepeatSubmit;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.model.BaseEntity;
import com.mortals.framework.service.IUser;
import com.mortals.framework.utils.BeanUtil;
import com.mortals.framework.utils.ReflectUtils;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.BeanUtils;
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.apply.model.MatterApplyEntity;
import com.mortals.xhx.module.apply.service.MatterApplyService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.*;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 单事项申报
*
* @author zxfei
* @date 2023-05-23
*/
@RestController
@RequestMapping("matter/apply")
public class MatterApplyController extends BaseCRUDJsonBodyMappingController<MatterApplyService,MatterApplyEntity,Long> {
@Autowired
private ParamService paramService;
public MatterApplyController(){
super.setModuleDesc( "单事项申报");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "applyType", paramService.getParamBySecondOrganize("MatterApply","applyType"));
this.addDict(model, "applyState", paramService.getParamBySecondOrganize("MatterApply","applyState"));
this.addDict(model, "sexual", paramService.getParamBySecondOrganize("MatterApply","sexual"));
super.init(model, context);
}
@PostMapping({"save"})
@RepeatSubmit
@UnAuth
public String save(@RequestBody MatterApplyEntity entity) {
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "保存" + this.getModuleDesc();
int code;
try {
this.saveBefore(entity, model, context);
if (entity.newEntity()) {
Class<MatterApplyEntity> tClass = ReflectUtils.getClassGenricType(this.getClass(), 1);
MatterApplyEntity initEntity = (MatterApplyEntity)tClass.newInstance();
initEntity.initAttrValue();
BeanUtils.copyProperties(entity, initEntity, BeanUtil.getNullPropertyNames(entity));
entity = initEntity;
busiDesc = "新增" + this.getModuleDesc();
initEntity.setCreateTime(new Date());
initEntity.setUpdateTime(initEntity.getCreateTime());
IUser user = this.getCurUser();
if (user != null) {
initEntity.setCreateUserId(user.getId());
initEntity.setCreateUser(user.getLoginName());
initEntity.setCreateUserName(user.getRealName());
initEntity.setCreateUserDeptId(user.getDeptId());
initEntity.setCreateUserDeptName(user.getDeptName());
initEntity.setUpdateUserId(user.getId());
initEntity.setUpdateUser(user.getLoginName());
initEntity.setUpdateUserName(user.getRealName());
initEntity.setUpdateUserDeptId(user.getDeptId());
initEntity.setUpdateUserDeptName(user.getDeptName());
}
this.service.save(initEntity, context);
} else {
busiDesc = "修改" + this.getModuleDesc();
entity.setUpdateTime(new Date());
IUser user = this.getCurUser();
if (user != null) {
entity.setUpdateUserId(user.getId());
entity.setUpdateUser(user.getLoginName());
entity.setUpdateUserName(user.getRealName());
entity.setUpdateUserDeptId(user.getDeptId());
entity.setUpdateUserDeptName(user.getDeptName());
}
this.service.update(entity, context);
}
model.put("id", entity.getId());
code = this.saveAfter(entity, model, context);
model.put("entity", entity);
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】 [id:" + entity.getId() + "]");
} catch (Exception var9) {
this.doException(this.request, busiDesc, model, var9);
model.put("entity", entity);
this.init(model, context);
code = this.saveException(entity, model, context, var9);
}
this.init(model, context);
JSONObject ret = new JSONObject();
ret.put("code", code);
ret.put("msg", model.remove("message_info"));
ret.put("data", model);
return ret.toJSONString();
}
/**
* 审批
* @param entity
* @return
*/
@PostMapping({"examine"})
public String applyExamine(@RequestBody MatterApplyEntity entity) {
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "审批" + this.getModuleDesc();
int code;
try {
this.service.applyExamine(entity,context);
model.put("id", entity.getId());
code = this.saveAfter(entity, model, context);
model.put("entity", entity);
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】 [id:" + entity.getId() + "]");
} catch (Exception var9) {
this.doException(this.request, busiDesc, model, var9);
model.put("entity", entity);
this.init(model, context);
code = this.saveException(entity, model, context, var9);
}
this.init(model, context);
JSONObject ret = new JSONObject();
ret.put("code", code);
ret.put("msg", model.remove("message_info"));
ret.put("data", model);
return ret.toJSONString();
}
/**
* 重新申请
* @param entity
* @return
*/
@PostMapping({"reApply"})
@RepeatSubmit
@UnAuth
public String reApply(@RequestBody MatterApplyEntity entity) {
Map<String, Object> model = new HashMap();
Context context = this.getContext();
String busiDesc = "重新申请" + this.getModuleDesc();
int code;
try {
this.service.reApply(entity,context);
model.put("id", entity.getId());
code = this.saveAfter(entity, model, context);
model.put("entity", entity);
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】 [id:" + entity.getId() + "]");
} catch (Exception var9) {
this.doException(this.request, busiDesc, model, var9);
model.put("entity", entity);
this.init(model, context);
code = this.saveException(entity, model, context, var9);
}
this.init(model, context);
JSONObject ret = new JSONObject();
ret.put("code", code);
ret.put("msg", model.remove("message_info"));
ret.put("data", model);
return ret.toJSONString();
}
}
\ No newline at end of file
single-matter/src/main/java/com/mortals/xhx/module/apply/web/MatterApplyDatumController.java 0 → 100644
View file @ 98512f44
package com.mortals.xhx.module.apply.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.apply.model.MatterApplyDatumEntity;
import com.mortals.xhx.module.apply.service.MatterApplyDatumService;
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-05-23
*/
@RestController
@RequestMapping("matter/apply/datum")
public class MatterApplyDatumController extends BaseCRUDJsonBodyMappingController<MatterApplyDatumService,MatterApplyDatumEntity,Long> {
@Autowired
private ParamService paramService;
public MatterApplyDatumController(){
super.setModuleDesc( "事项申报材料");
}
@Override
protected void init(Map<String, Object> model, Context context) {
super.init(model, context);
}
}
\ No newline at end of file
single-matter/src/main/resources/sqlmap/module/apply/ApproverMapper.xml 0 → 100644
View file @ 98512f44
<?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.apply.dao.ibatis.ApproverDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="ApproverEntity" id="ApproverEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="fullName" column="fullName" />
<result property="phoneNumber" column="phoneNumber" />
<result property="loginName" column="loginName" />
<result property="loginPwd" column="loginPwd" />
<result property="deptId" column="deptId" />
<result property="deptCode" column="deptCode" />
<result property="deptName" column="deptName" />
<result property="remarks" column="remarks" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<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('fullName') or colPickMode == 1 and data.containsKey('fullName')))">
a.fullName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('phoneNumber') or colPickMode == 1 and data.containsKey('phoneNumber')))">
a.phoneNumber,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginName') or colPickMode == 1 and data.containsKey('loginName')))">
a.loginName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginPwd') or colPickMode == 1 and data.containsKey('loginPwd')))">
a.loginPwd,
</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('deptCode') or colPickMode == 1 and data.containsKey('deptCode')))">
a.deptCode,
</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('remarks') or colPickMode == 1 and data.containsKey('remarks')))">
a.remarks,
</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>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="ApproverEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_approver
(siteId,fullName,phoneNumber,loginName,loginPwd,deptId,deptCode,deptName,remarks,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{siteId},#{fullName},#{phoneNumber},#{loginName},#{loginPwd},#{deptId},#{deptCode},#{deptName},#{remarks},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_approver
(siteId,fullName,phoneNumber,loginName,loginPwd,deptId,deptCode,deptName,remarks,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.fullName},#{item.phoneNumber},#{item.loginName},#{item.loginPwd},#{item.deptId},#{item.deptCode},#{item.deptName},#{item.remarks},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_sys_approver 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('fullName')) or (colPickMode==1 and !data.containsKey('fullName'))">
a.fullName=#{data.fullName},
</if>
<if test="(colPickMode==0 and data.containsKey('phoneNumber')) or (colPickMode==1 and !data.containsKey('phoneNumber'))">
a.phoneNumber=#{data.phoneNumber},
</if>
<if test="(colPickMode==0 and data.containsKey('loginName')) or (colPickMode==1 and !data.containsKey('loginName'))">
a.loginName=#{data.loginName},
</if>
<if test="(colPickMode==0 and data.containsKey('loginPwd')) or (colPickMode==1 and !data.containsKey('loginPwd'))">
a.loginPwd=#{data.loginPwd},
</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('deptCode')) or (colPickMode==1 and !data.containsKey('deptCode'))">
a.deptCode=#{data.deptCode},
</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('remarks')) or (colPickMode==1 and !data.containsKey('remarks'))">
a.remarks=#{data.remarks},
</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>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_sys_approver 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="fullName=(case" suffix="ELSE fullName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('fullName')) or (colPickMode==1 and !item.containsKey('fullName'))">
when a.id=#{item.id} then #{item.fullName}
</if>
</foreach>
</trim>
<trim prefix="phoneNumber=(case" suffix="ELSE phoneNumber end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('phoneNumber')) or (colPickMode==1 and !item.containsKey('phoneNumber'))">
when a.id=#{item.id} then #{item.phoneNumber}
</if>
</foreach>
</trim>
<trim prefix="loginName=(case" suffix="ELSE loginName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('loginName')) or (colPickMode==1 and !item.containsKey('loginName'))">
when a.id=#{item.id} then #{item.loginName}
</if>
</foreach>
</trim>
<trim prefix="loginPwd=(case" suffix="ELSE loginPwd end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('loginPwd')) or (colPickMode==1 and !item.containsKey('loginPwd'))">
when a.id=#{item.id} then #{item.loginPwd}
</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="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="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="remarks=(case" suffix="ELSE remarks end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remarks')) or (colPickMode==1 and !item.containsKey('remarks'))">
when a.id=#{item.id} then #{item.remarks}
</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="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>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="ApproverEntity-Map">
select <include refid="_columns"/>
from mortals_sys_approver as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_sys_approver as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_sys_approver where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_sys_approver where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_sys_approver 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_approver as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="ApproverEntity-Map">
select <include refid="_columns"/>
from mortals_sys_approver 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_approver 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') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
${_conditionType_} a.siteId not in
<foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
</if>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('fullName')">
<if test="conditionParamRef.fullName != null and conditionParamRef.fullName != ''">
${_conditionType_} a.fullName like #{${_conditionParam_}.fullName}
</if>
<if test="conditionParamRef.fullName == null">
${_conditionType_} a.fullName is null
</if>
</if>
<if test="conditionParamRef.containsKey('fullNameList') and conditionParamRef.fullNameList.size() > 0">
${_conditionType_} a.fullName in
<foreach collection="conditionParamRef.fullNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fullNameNotList') and conditionParamRef.fullNameNotList.size() > 0">
${_conditionType_} a.fullName not in
<foreach collection="conditionParamRef.fullNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('phoneNumber')">
<if test="conditionParamRef.phoneNumber != null and conditionParamRef.phoneNumber != ''">
${_conditionType_} a.phoneNumber like #{${_conditionParam_}.phoneNumber}
</if>
<if test="conditionParamRef.phoneNumber == null">
${_conditionType_} a.phoneNumber is null
</if>
</if>
<if test="conditionParamRef.containsKey('phoneNumberList') and conditionParamRef.phoneNumberList.size() > 0">
${_conditionType_} a.phoneNumber in
<foreach collection="conditionParamRef.phoneNumberList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('phoneNumberNotList') and conditionParamRef.phoneNumberNotList.size() > 0">
${_conditionType_} a.phoneNumber not in
<foreach collection="conditionParamRef.phoneNumberNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('loginName')">
<if test="conditionParamRef.loginName != null and conditionParamRef.loginName != ''">
${_conditionType_} a.loginName like #{${_conditionParam_}.loginName}
</if>
<if test="conditionParamRef.loginName == null">
${_conditionType_} a.loginName is null
</if>
</if>
<if test="conditionParamRef.containsKey('loginNameList') and conditionParamRef.loginNameList.size() > 0">
${_conditionType_} a.loginName in
<foreach collection="conditionParamRef.loginNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('loginNameNotList') and conditionParamRef.loginNameNotList.size() > 0">
${_conditionType_} a.loginName not in
<foreach collection="conditionParamRef.loginNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('loginPwd')">
<if test="conditionParamRef.loginPwd != null and conditionParamRef.loginPwd != ''">
${_conditionType_} a.loginPwd like #{${_conditionParam_}.loginPwd}
</if>
<if test="conditionParamRef.loginPwd == null">
${_conditionType_} a.loginPwd is null
</if>
</if>
<if test="conditionParamRef.containsKey('loginPwdList') and conditionParamRef.loginPwdList.size() > 0">
${_conditionType_} a.loginPwd in
<foreach collection="conditionParamRef.loginPwdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('loginPwdNotList') and conditionParamRef.loginPwdNotList.size() > 0">
${_conditionType_} a.loginPwd not in
<foreach collection="conditionParamRef.loginPwdNotList" 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') and conditionParamRef.deptIdList.size() > 0">
${_conditionType_} a.deptId in
<foreach collection="conditionParamRef.deptIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptIdNotList') and conditionParamRef.deptIdNotList.size() > 0">
${_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('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') and conditionParamRef.deptCodeList.size() > 0">
${_conditionType_} a.deptCode in
<foreach collection="conditionParamRef.deptCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptCodeNotList') and conditionParamRef.deptCodeNotList.size() > 0">
${_conditionType_} a.deptCode not in
<foreach collection="conditionParamRef.deptCodeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptName')">
<if test="conditionParamRef.deptName != null and conditionParamRef.deptName != ''">
${_conditionType_} a.deptName like #{${_conditionParam_}.deptName}
</if>
<if test="conditionParamRef.deptName == null">
${_conditionType_} a.deptName is null
</if>
</if>
<if test="conditionParamRef.containsKey('deptNameList') and conditionParamRef.deptNameList.size() > 0">
${_conditionType_} a.deptName in
<foreach collection="conditionParamRef.deptNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptNameNotList') and conditionParamRef.deptNameNotList.size() > 0">
${_conditionType_} a.deptName not in
<foreach collection="conditionParamRef.deptNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarks')">
<if test="conditionParamRef.remarks != null and conditionParamRef.remarks != ''">
${_conditionType_} a.remarks like #{${_conditionParam_}.remarks}
</if>
<if test="conditionParamRef.remarks == null">
${_conditionType_} a.remarks is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarksList') and conditionParamRef.remarksList.size() > 0">
${_conditionType_} a.remarks in
<foreach collection="conditionParamRef.remarksList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarksNotList') and conditionParamRef.remarksNotList.size() > 0">
${_conditionType_} a.remarks not in
<foreach collection="conditionParamRef.remarksNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</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('fullName')">
a.fullName
<if test='orderCol.fullName != null and "DESC".equalsIgnoreCase(orderCol.fullName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('phoneNumber')">
a.phoneNumber
<if test='orderCol.phoneNumber != null and "DESC".equalsIgnoreCase(orderCol.phoneNumber)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('loginName')">
a.loginName
<if test='orderCol.loginName != null and "DESC".equalsIgnoreCase(orderCol.loginName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('loginPwd')">
a.loginPwd
<if test='orderCol.loginPwd != null and "DESC".equalsIgnoreCase(orderCol.loginPwd)'>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('deptCode')">
a.deptCode
<if test='orderCol.deptCode != null and "DESC".equalsIgnoreCase(orderCol.deptCode)'>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('remarks')">
a.remarks
<if test='orderCol.remarks != null and "DESC".equalsIgnoreCase(orderCol.remarks)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</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
single-matter/src/main/resources/sqlmap/module/apply/MatterApplyDatumMapper.xml 0 → 100644
View file @ 98512f44
<?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.apply.dao.ibatis.MatterApplyDatumDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MatterApplyDatumEntity" id="MatterApplyDatumEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="applyId" column="applyId" />
<result property="singleMatterId" column="singleMatterId" />
<result property="matterId" column="matterId" />
<result property="datumId" column="datumId" />
<result property="materialName" column="materialName" />
<result property="fileName" column="fileName" />
<result property="fileUrl" column="fileUrl" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<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('applyId') or colPickMode == 1 and data.containsKey('applyId')))">
a.applyId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('singleMatterId') or colPickMode == 1 and data.containsKey('singleMatterId')))">
a.singleMatterId,
</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('datumId') or colPickMode == 1 and data.containsKey('datumId')))">
a.datumId,
</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('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>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MatterApplyDatumEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_matter_apply_datum
(siteId,applyId,singleMatterId,matterId,datumId,materialName,fileName,fileUrl,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{siteId},#{applyId},#{singleMatterId},#{matterId},#{datumId},#{materialName},#{fileName},#{fileUrl},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_matter_apply_datum
(siteId,applyId,singleMatterId,matterId,datumId,materialName,fileName,fileUrl,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.applyId},#{item.singleMatterId},#{item.matterId},#{item.datumId},#{item.materialName},#{item.fileName},#{item.fileUrl},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_sys_matter_apply_datum 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('applyId')) or (colPickMode==1 and !data.containsKey('applyId'))">
a.applyId=#{data.applyId},
</if>
<if test="(colPickMode==0 and data.containsKey('applyIdIncrement')) or (colPickMode==1 and !data.containsKey('applyIdIncrement'))">
a.applyId=ifnull(a.applyId,0) + #{data.applyIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('singleMatterId')) or (colPickMode==1 and !data.containsKey('singleMatterId'))">
a.singleMatterId=#{data.singleMatterId},
</if>
<if test="(colPickMode==0 and data.containsKey('singleMatterIdIncrement')) or (colPickMode==1 and !data.containsKey('singleMatterIdIncrement'))">
a.singleMatterId=ifnull(a.singleMatterId,0) + #{data.singleMatterIdIncrement},
</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('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('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('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>
</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_datum 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="applyId=(case" suffix="ELSE applyId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('applyId')) or (colPickMode==1 and !item.containsKey('applyId'))">
when a.id=#{item.id} then #{item.applyId}
</when>
<when test="(colPickMode==0 and item.containsKey('applyIdIncrement')) or (colPickMode==1 and !item.containsKey('applyIdIncrement'))">
when a.id=#{item.id} then ifnull(a.applyId,0) + #{item.applyIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="singleMatterId=(case" suffix="ELSE singleMatterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('singleMatterId')) or (colPickMode==1 and !item.containsKey('singleMatterId'))">
when a.id=#{item.id} then #{item.singleMatterId}
</when>
<when test="(colPickMode==0 and item.containsKey('singleMatterIdIncrement')) or (colPickMode==1 and !item.containsKey('singleMatterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.singleMatterId,0) + #{item.singleMatterIdIncrement}
</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="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="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="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>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MatterApplyDatumEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_apply_datum as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_sys_matter_apply_datum as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_sys_matter_apply_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_apply_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_apply_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_apply_datum as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MatterApplyDatumEntity-Map">
select <include refid="_columns"/>
from mortals_sys_matter_apply_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_apply_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') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
${_conditionType_} a.siteId not in
<foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
</if>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('applyId')">
<if test="conditionParamRef.applyId != null ">
${_conditionType_} a.applyId = #{${_conditionParam_}.applyId}
</if>
<if test="conditionParamRef.applyId == null">
${_conditionType_} a.applyId is null
</if>
</if>
<if test="conditionParamRef.containsKey('applyIdList') and conditionParamRef.applyIdList.size() > 0">
${_conditionType_} a.applyId in
<foreach collection="conditionParamRef.applyIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyIdNotList') and conditionParamRef.applyIdNotList.size() > 0">
${_conditionType_} a.applyId not in
<foreach collection="conditionParamRef.applyIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyIdStart') and conditionParamRef.applyIdStart != null">
${_conditionType_} a.applyId <![CDATA[ >= ]]> #{${_conditionParam_}.applyIdStart}
</if>
<if test="conditionParamRef.containsKey('applyIdEnd') and conditionParamRef.applyIdEnd != null">
${_conditionType_} a.applyId <![CDATA[ <= ]]> #{${_conditionParam_}.applyIdEnd}
</if>
<if test="conditionParamRef.containsKey('singleMatterId')">
<if test="conditionParamRef.singleMatterId != null ">
${_conditionType_} a.singleMatterId = #{${_conditionParam_}.singleMatterId}
</if>
<if test="conditionParamRef.singleMatterId == null">
${_conditionType_} a.singleMatterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('singleMatterIdList') and conditionParamRef.singleMatterIdList.size() > 0">
${_conditionType_} a.singleMatterId in
<foreach collection="conditionParamRef.singleMatterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('singleMatterIdNotList') and conditionParamRef.singleMatterIdNotList.size() > 0">
${_conditionType_} a.singleMatterId not in
<foreach collection="conditionParamRef.singleMatterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('singleMatterIdStart') and conditionParamRef.singleMatterIdStart != null">
${_conditionType_} a.singleMatterId <![CDATA[ >= ]]> #{${_conditionParam_}.singleMatterIdStart}
</if>
<if test="conditionParamRef.containsKey('singleMatterIdEnd') and conditionParamRef.singleMatterIdEnd != null">
${_conditionType_} a.singleMatterId <![CDATA[ <= ]]> #{${_conditionParam_}.singleMatterIdEnd}
</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') and conditionParamRef.matterIdList.size() > 0">
${_conditionType_} a.matterId in
<foreach collection="conditionParamRef.matterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdNotList') and conditionParamRef.matterIdNotList.size() > 0">
${_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('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') and conditionParamRef.datumIdList.size() > 0">
${_conditionType_} a.datumId in
<foreach collection="conditionParamRef.datumIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('datumIdNotList') and conditionParamRef.datumIdNotList.size() > 0">
${_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('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') and conditionParamRef.materialNameList.size() > 0">
${_conditionType_} a.materialName in
<foreach collection="conditionParamRef.materialNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('materialNameNotList') and conditionParamRef.materialNameNotList.size() > 0">
${_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') and conditionParamRef.fileNameList.size() > 0">
${_conditionType_} a.fileName in
<foreach collection="conditionParamRef.fileNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileNameNotList') and conditionParamRef.fileNameNotList.size() > 0">
${_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') and conditionParamRef.fileUrlList.size() > 0">
${_conditionType_} a.fileUrl in
<foreach collection="conditionParamRef.fileUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileUrlNotList') and conditionParamRef.fileUrlNotList.size() > 0">
${_conditionType_} a.fileUrl not in
<foreach collection="conditionParamRef.fileUrlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</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('applyId')">
a.applyId
<if test='orderCol.applyId != null and "DESC".equalsIgnoreCase(orderCol.applyId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('singleMatterId')">
a.singleMatterId
<if test='orderCol.singleMatterId != null and "DESC".equalsIgnoreCase(orderCol.singleMatterId)'>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('datumId')">
a.datumId
<if test='orderCol.datumId != null and "DESC".equalsIgnoreCase(orderCol.datumId)'>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('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</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
single-matter/src/main/resources/sqlmap/module/apply/MatterApplyMapper.xml 0 → 100644
View file @ 98512f44
<?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.apply.dao.ibatis.MatterApplyDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MatterApplyEntity" id="MatterApplyEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="singleMatterId" column="singleMatterId" />
<result property="matterId" column="matterId" />
<result property="deptCode" column="deptCode" />
<result property="matterName" column="matterName" />
<result property="applyPerson" column="applyPerson" />
<result property="sexual" column="sexual" />
<result property="phoneNum" column="phoneNum" />
<result property="idCard" column="idCard" />
<result property="address" column="address" />
<result property="applyType" column="applyType" />
<result property="applyTime" column="applyTime" />
<result property="applyState" column="applyState" />
<result property="advisement" column="advisement" />
<result property="remarks" column="remarks" />
<result property="openId" column="openId" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<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('singleMatterId') or colPickMode == 1 and data.containsKey('singleMatterId')))">
a.singleMatterId,
</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('deptCode') or colPickMode == 1 and data.containsKey('deptCode')))">
a.deptCode,
</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('applyPerson') or colPickMode == 1 and data.containsKey('applyPerson')))">
a.applyPerson,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sexual') or colPickMode == 1 and data.containsKey('sexual')))">
a.sexual,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('phoneNum') or colPickMode == 1 and data.containsKey('phoneNum')))">
a.phoneNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('idCard') or colPickMode == 1 and data.containsKey('idCard')))">
a.idCard,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('address') or colPickMode == 1 and data.containsKey('address')))">
a.address,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('applyType') or colPickMode == 1 and data.containsKey('applyType')))">
a.applyType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('applyTime') or colPickMode == 1 and data.containsKey('applyTime')))">
a.applyTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('applyState') or colPickMode == 1 and data.containsKey('applyState')))">
a.applyState,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('advisement') or colPickMode == 1 and data.containsKey('advisement')))">
a.advisement,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remarks') or colPickMode == 1 and data.containsKey('remarks')))">
a.remarks,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('openId') or colPickMode == 1 and data.containsKey('openId')))">
a.openId,
</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>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MatterApplyEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_sys_matter_apply
(siteId,singleMatterId,matterId,deptCode,matterName,applyPerson,sexual,phoneNum,idCard,address,applyType,applyTime,applyState,advisement,remarks,openId,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{siteId},#{singleMatterId},#{matterId},#{deptCode},#{matterName},#{applyPerson},#{sexual},#{phoneNum},#{idCard},#{address},#{applyType},#{applyTime},#{applyState},#{advisement},#{remarks},#{openId},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_sys_matter_apply
(siteId,singleMatterId,matterId,deptCode,matterName,applyPerson,sexual,phoneNum,idCard,address,applyType,applyTime,applyState,advisement,remarks,openId,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.singleMatterId},#{item.matterId},#{item.deptCode},#{item.matterName},#{item.applyPerson},#{item.sexual},#{item.phoneNum},#{item.idCard},#{item.address},#{item.applyType},#{item.applyTime},#{item.applyState},#{item.advisement},#{item.remarks},#{item.openId},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</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('singleMatterId')) or (colPickMode==1 and !data.containsKey('singleMatterId'))">
a.singleMatterId=#{data.singleMatterId},
</if>
<if test="(colPickMode==0 and data.containsKey('singleMatterIdIncrement')) or (colPickMode==1 and !data.containsKey('singleMatterIdIncrement'))">
a.singleMatterId=ifnull(a.singleMatterId,0) + #{data.singleMatterIdIncrement},
</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('deptCode')) or (colPickMode==1 and !data.containsKey('deptCode'))">
a.deptCode=#{data.deptCode},
</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('applyPerson')) or (colPickMode==1 and !data.containsKey('applyPerson'))">
a.applyPerson=#{data.applyPerson},
</if>
<if test="(colPickMode==0 and data.containsKey('sexual')) or (colPickMode==1 and !data.containsKey('sexual'))">
a.sexual=#{data.sexual},
</if>
<if test="(colPickMode==0 and data.containsKey('sexualIncrement')) or (colPickMode==1 and !data.containsKey('sexualIncrement'))">
a.sexual=ifnull(a.sexual,0) + #{data.sexualIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('phoneNum')) or (colPickMode==1 and !data.containsKey('phoneNum'))">
a.phoneNum=#{data.phoneNum},
</if>
<if test="(colPickMode==0 and data.containsKey('idCard')) or (colPickMode==1 and !data.containsKey('idCard'))">
a.idCard=#{data.idCard},
</if>
<if test="(colPickMode==0 and data.containsKey('address')) or (colPickMode==1 and !data.containsKey('address'))">
a.address=#{data.address},
</if>
<if test="(colPickMode==0 and data.containsKey('applyType')) or (colPickMode==1 and !data.containsKey('applyType'))">
a.applyType=#{data.applyType},
</if>
<if test="(colPickMode==0 and data.containsKey('applyTypeIncrement')) or (colPickMode==1 and !data.containsKey('applyTypeIncrement'))">
a.applyType=ifnull(a.applyType,0) + #{data.applyTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('applyTime')) or (colPickMode==1 and !data.containsKey('applyTime'))">
a.applyTime=#{data.applyTime},
</if>
<if test="(colPickMode==0 and data.containsKey('applyState')) or (colPickMode==1 and !data.containsKey('applyState'))">
a.applyState=#{data.applyState},
</if>
<if test="(colPickMode==0 and data.containsKey('applyStateIncrement')) or (colPickMode==1 and !data.containsKey('applyStateIncrement'))">
a.applyState=ifnull(a.applyState,0) + #{data.applyStateIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('advisement')) or (colPickMode==1 and !data.containsKey('advisement'))">
a.advisement=#{data.advisement},
</if>
<if test="(colPickMode==0 and data.containsKey('remarks')) or (colPickMode==1 and !data.containsKey('remarks'))">
a.remarks=#{data.remarks},
</if>
<if test="(colPickMode==0 and data.containsKey('openId')) or (colPickMode==1 and !data.containsKey('openId'))">
a.openId=#{data.openId},
</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>
</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="singleMatterId=(case" suffix="ELSE singleMatterId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('singleMatterId')) or (colPickMode==1 and !item.containsKey('singleMatterId'))">
when a.id=#{item.id} then #{item.singleMatterId}
</when>
<when test="(colPickMode==0 and item.containsKey('singleMatterIdIncrement')) or (colPickMode==1 and !item.containsKey('singleMatterIdIncrement'))">
when a.id=#{item.id} then ifnull(a.singleMatterId,0) + #{item.singleMatterIdIncrement}
</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="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="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="applyPerson=(case" suffix="ELSE applyPerson end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('applyPerson')) or (colPickMode==1 and !item.containsKey('applyPerson'))">
when a.id=#{item.id} then #{item.applyPerson}
</if>
</foreach>
</trim>
<trim prefix="sexual=(case" suffix="ELSE sexual end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('sexual')) or (colPickMode==1 and !item.containsKey('sexual'))">
when a.id=#{item.id} then #{item.sexual}
</when>
<when test="(colPickMode==0 and item.containsKey('sexualIncrement')) or (colPickMode==1 and !item.containsKey('sexualIncrement'))">
when a.id=#{item.id} then ifnull(a.sexual,0) + #{item.sexualIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="phoneNum=(case" suffix="ELSE phoneNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('phoneNum')) or (colPickMode==1 and !item.containsKey('phoneNum'))">
when a.id=#{item.id} then #{item.phoneNum}
</if>
</foreach>
</trim>
<trim prefix="idCard=(case" suffix="ELSE idCard end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('idCard')) or (colPickMode==1 and !item.containsKey('idCard'))">
when a.id=#{item.id} then #{item.idCard}
</if>
</foreach>
</trim>
<trim prefix="address=(case" suffix="ELSE address end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('address')) or (colPickMode==1 and !item.containsKey('address'))">
when a.id=#{item.id} then #{item.address}
</if>
</foreach>
</trim>
<trim prefix="applyType=(case" suffix="ELSE applyType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('applyType')) or (colPickMode==1 and !item.containsKey('applyType'))">
when a.id=#{item.id} then #{item.applyType}
</when>
<when test="(colPickMode==0 and item.containsKey('applyTypeIncrement')) or (colPickMode==1 and !item.containsKey('applyTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.applyType,0) + #{item.applyTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="applyTime=(case" suffix="ELSE applyTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('applyTime')) or (colPickMode==1 and !item.containsKey('applyTime'))">
when a.id=#{item.id} then #{item.applyTime}
</if>
</foreach>
</trim>
<trim prefix="applyState=(case" suffix="ELSE applyState end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('applyState')) or (colPickMode==1 and !item.containsKey('applyState'))">
when a.id=#{item.id} then #{item.applyState}
</when>
<when test="(colPickMode==0 and item.containsKey('applyStateIncrement')) or (colPickMode==1 and !item.containsKey('applyStateIncrement'))">
when a.id=#{item.id} then ifnull(a.applyState,0) + #{item.applyStateIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="advisement=(case" suffix="ELSE advisement end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('advisement')) or (colPickMode==1 and !item.containsKey('advisement'))">
when a.id=#{item.id} then #{item.advisement}
</if>
</foreach>
</trim>
<trim prefix="remarks=(case" suffix="ELSE remarks end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remarks')) or (colPickMode==1 and !item.containsKey('remarks'))">
when a.id=#{item.id} then #{item.remarks}
</if>
</foreach>
</trim>
<trim prefix="openId=(case" suffix="ELSE openId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('openId')) or (colPickMode==1 and !item.containsKey('openId'))">
when a.id=#{item.id} then #{item.openId}
</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="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>
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') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
${_conditionType_} a.siteId not in
<foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
</if>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('singleMatterId')">
<if test="conditionParamRef.singleMatterId != null ">
${_conditionType_} a.singleMatterId = #{${_conditionParam_}.singleMatterId}
</if>
<if test="conditionParamRef.singleMatterId == null">
${_conditionType_} a.singleMatterId is null
</if>
</if>
<if test="conditionParamRef.containsKey('singleMatterIdList') and conditionParamRef.singleMatterIdList.size() > 0">
${_conditionType_} a.singleMatterId in
<foreach collection="conditionParamRef.singleMatterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('singleMatterIdNotList') and conditionParamRef.singleMatterIdNotList.size() > 0">
${_conditionType_} a.singleMatterId not in
<foreach collection="conditionParamRef.singleMatterIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('singleMatterIdStart') and conditionParamRef.singleMatterIdStart != null">
${_conditionType_} a.singleMatterId <![CDATA[ >= ]]> #{${_conditionParam_}.singleMatterIdStart}
</if>
<if test="conditionParamRef.containsKey('singleMatterIdEnd') and conditionParamRef.singleMatterIdEnd != null">
${_conditionType_} a.singleMatterId <![CDATA[ <= ]]> #{${_conditionParam_}.singleMatterIdEnd}
</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') and conditionParamRef.matterIdList.size() > 0">
${_conditionType_} a.matterId in
<foreach collection="conditionParamRef.matterIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterIdNotList') and conditionParamRef.matterIdNotList.size() > 0">
${_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('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') and conditionParamRef.deptCodeList.size() > 0">
${_conditionType_} a.deptCode in
<foreach collection="conditionParamRef.deptCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deptCodeNotList') and conditionParamRef.deptCodeNotList.size() > 0">
${_conditionType_} a.deptCode not in
<foreach collection="conditionParamRef.deptCodeNotList" 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') and conditionParamRef.matterNameList.size() > 0">
${_conditionType_} a.matterName in
<foreach collection="conditionParamRef.matterNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('matterNameNotList') and conditionParamRef.matterNameNotList.size() > 0">
${_conditionType_} a.matterName not in
<foreach collection="conditionParamRef.matterNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyPerson')">
<if test="conditionParamRef.applyPerson != null and conditionParamRef.applyPerson != ''">
${_conditionType_} a.applyPerson like #{${_conditionParam_}.applyPerson}
</if>
<if test="conditionParamRef.applyPerson == null">
${_conditionType_} a.applyPerson is null
</if>
</if>
<if test="conditionParamRef.containsKey('applyPersonList') and conditionParamRef.applyPersonList.size() > 0">
${_conditionType_} a.applyPerson in
<foreach collection="conditionParamRef.applyPersonList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyPersonNotList') and conditionParamRef.applyPersonNotList.size() > 0">
${_conditionType_} a.applyPerson not in
<foreach collection="conditionParamRef.applyPersonNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sexual')">
<if test="conditionParamRef.sexual != null ">
${_conditionType_} a.sexual = #{${_conditionParam_}.sexual}
</if>
<if test="conditionParamRef.sexual == null">
${_conditionType_} a.sexual is null
</if>
</if>
<if test="conditionParamRef.containsKey('sexualList') and conditionParamRef.sexualList.size() > 0">
${_conditionType_} a.sexual in
<foreach collection="conditionParamRef.sexualList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sexualNotList') and conditionParamRef.sexualNotList.size() > 0">
${_conditionType_} a.sexual not in
<foreach collection="conditionParamRef.sexualNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sexualStart') and conditionParamRef.sexualStart != null">
${_conditionType_} a.sexual <![CDATA[ >= ]]> #{${_conditionParam_}.sexualStart}
</if>
<if test="conditionParamRef.containsKey('sexualEnd') and conditionParamRef.sexualEnd != null">
${_conditionType_} a.sexual <![CDATA[ <= ]]> #{${_conditionParam_}.sexualEnd}
</if>
<if test="conditionParamRef.containsKey('phoneNum')">
<if test="conditionParamRef.phoneNum != null and conditionParamRef.phoneNum != ''">
${_conditionType_} a.phoneNum like #{${_conditionParam_}.phoneNum}
</if>
<if test="conditionParamRef.phoneNum == null">
${_conditionType_} a.phoneNum is null
</if>
</if>
<if test="conditionParamRef.containsKey('phoneNumList') and conditionParamRef.phoneNumList.size() > 0">
${_conditionType_} a.phoneNum in
<foreach collection="conditionParamRef.phoneNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('phoneNumNotList') and conditionParamRef.phoneNumNotList.size() > 0">
${_conditionType_} a.phoneNum not in
<foreach collection="conditionParamRef.phoneNumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idCard')">
<if test="conditionParamRef.idCard != null and conditionParamRef.idCard != ''">
${_conditionType_} a.idCard like #{${_conditionParam_}.idCard}
</if>
<if test="conditionParamRef.idCard == null">
${_conditionType_} a.idCard is null
</if>
</if>
<if test="conditionParamRef.containsKey('idCardList') and conditionParamRef.idCardList.size() > 0">
${_conditionType_} a.idCard in
<foreach collection="conditionParamRef.idCardList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idCardNotList') and conditionParamRef.idCardNotList.size() > 0">
${_conditionType_} a.idCard not in
<foreach collection="conditionParamRef.idCardNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('address')">
<if test="conditionParamRef.address != null and conditionParamRef.address != ''">
${_conditionType_} a.address like #{${_conditionParam_}.address}
</if>
<if test="conditionParamRef.address == null">
${_conditionType_} a.address is null
</if>
</if>
<if test="conditionParamRef.containsKey('addressList') and conditionParamRef.addressList.size() > 0">
${_conditionType_} a.address in
<foreach collection="conditionParamRef.addressList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addressNotList') and conditionParamRef.addressNotList.size() > 0">
${_conditionType_} a.address not in
<foreach collection="conditionParamRef.addressNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyType')">
<if test="conditionParamRef.applyType != null ">
${_conditionType_} a.applyType = #{${_conditionParam_}.applyType}
</if>
<if test="conditionParamRef.applyType == null">
${_conditionType_} a.applyType is null
</if>
</if>
<if test="conditionParamRef.containsKey('applyTypeList') and conditionParamRef.applyTypeList.size() > 0">
${_conditionType_} a.applyType in
<foreach collection="conditionParamRef.applyTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyTypeNotList') and conditionParamRef.applyTypeNotList.size() > 0">
${_conditionType_} a.applyType not in
<foreach collection="conditionParamRef.applyTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyTypeStart') and conditionParamRef.applyTypeStart != null">
${_conditionType_} a.applyType <![CDATA[ >= ]]> #{${_conditionParam_}.applyTypeStart}
</if>
<if test="conditionParamRef.containsKey('applyTypeEnd') and conditionParamRef.applyTypeEnd != null">
${_conditionType_} a.applyType <![CDATA[ <= ]]> #{${_conditionParam_}.applyTypeEnd}
</if>
<if test="conditionParamRef.containsKey('applyTime')">
<if test="conditionParamRef.applyTime != null ">
${_conditionType_} a.applyTime = #{${_conditionParam_}.applyTime}
</if>
<if test="conditionParamRef.applyTime == null">
${_conditionType_} a.applyTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('applyTimeStart') and conditionParamRef.applyTimeStart != null and conditionParamRef.applyTimeStart!=''">
${_conditionType_} a.applyTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.applyTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('applyTimeEnd') and conditionParamRef.applyTimeEnd != null and conditionParamRef.applyTimeEnd!=''">
${_conditionType_} a.applyTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.applyTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('applyState')">
<if test="conditionParamRef.applyState != null ">
${_conditionType_} a.applyState = #{${_conditionParam_}.applyState}
</if>
<if test="conditionParamRef.applyState == null">
${_conditionType_} a.applyState is null
</if>
</if>
<if test="conditionParamRef.containsKey('applyStateList') and conditionParamRef.applyStateList.size() > 0">
${_conditionType_} a.applyState in
<foreach collection="conditionParamRef.applyStateList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyStateNotList') and conditionParamRef.applyStateNotList.size() > 0">
${_conditionType_} a.applyState not in
<foreach collection="conditionParamRef.applyStateNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('applyStateStart') and conditionParamRef.applyStateStart != null">
${_conditionType_} a.applyState <![CDATA[ >= ]]> #{${_conditionParam_}.applyStateStart}
</if>
<if test="conditionParamRef.containsKey('applyStateEnd') and conditionParamRef.applyStateEnd != null">
${_conditionType_} a.applyState <![CDATA[ <= ]]> #{${_conditionParam_}.applyStateEnd}
</if>
<if test="conditionParamRef.containsKey('advisement')">
<if test="conditionParamRef.advisement != null and conditionParamRef.advisement != ''">
${_conditionType_} a.advisement like #{${_conditionParam_}.advisement}
</if>
<if test="conditionParamRef.advisement == null">
${_conditionType_} a.advisement is null
</if>
</if>
<if test="conditionParamRef.containsKey('advisementList') and conditionParamRef.advisementList.size() > 0">
${_conditionType_} a.advisement in
<foreach collection="conditionParamRef.advisementList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('advisementNotList') and conditionParamRef.advisementNotList.size() > 0">
${_conditionType_} a.advisement not in
<foreach collection="conditionParamRef.advisementNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarks')">
<if test="conditionParamRef.remarks != null and conditionParamRef.remarks != ''">
${_conditionType_} a.remarks like #{${_conditionParam_}.remarks}
</if>
<if test="conditionParamRef.remarks == null">
${_conditionType_} a.remarks is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarksList') and conditionParamRef.remarksList.size() > 0">
${_conditionType_} a.remarks in
<foreach collection="conditionParamRef.remarksList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarksNotList') and conditionParamRef.remarksNotList.size() > 0">
${_conditionType_} a.remarks not in
<foreach collection="conditionParamRef.remarksNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('openId')">
<if test="conditionParamRef.openId != null and conditionParamRef.openId != ''">
${_conditionType_} a.openId like #{${_conditionParam_}.openId}
</if>
<if test="conditionParamRef.openId == null">
${_conditionType_} a.openId is null
</if>
</if>
<if test="conditionParamRef.containsKey('openIdList') and conditionParamRef.openIdList.size() > 0">
${_conditionType_} a.openId in
<foreach collection="conditionParamRef.openIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('openIdNotList') and conditionParamRef.openIdNotList.size() > 0">
${_conditionType_} a.openId not in
<foreach collection="conditionParamRef.openIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</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('singleMatterId')">
a.singleMatterId
<if test='orderCol.singleMatterId != null and "DESC".equalsIgnoreCase(orderCol.singleMatterId)'>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('deptCode')">
a.deptCode
<if test='orderCol.deptCode != null and "DESC".equalsIgnoreCase(orderCol.deptCode)'>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('applyPerson')">
a.applyPerson
<if test='orderCol.applyPerson != null and "DESC".equalsIgnoreCase(orderCol.applyPerson)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('sexual')">
a.sexual
<if test='orderCol.sexual != null and "DESC".equalsIgnoreCase(orderCol.sexual)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('phoneNum')">
a.phoneNum
<if test='orderCol.phoneNum != null and "DESC".equalsIgnoreCase(orderCol.phoneNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('idCard')">
a.idCard
<if test='orderCol.idCard != null and "DESC".equalsIgnoreCase(orderCol.idCard)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('address')">
a.address
<if test='orderCol.address != null and "DESC".equalsIgnoreCase(orderCol.address)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('applyType')">
a.applyType
<if test='orderCol.applyType != null and "DESC".equalsIgnoreCase(orderCol.applyType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('applyTime')">
a.applyTime
<if test='orderCol.applyTime != null and "DESC".equalsIgnoreCase(orderCol.applyTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('applyState')">
a.applyState
<if test='orderCol.applyState != null and "DESC".equalsIgnoreCase(orderCol.applyState)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('advisement')">
a.advisement
<if test='orderCol.advisement != null and "DESC".equalsIgnoreCase(orderCol.advisement)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remarks')">
a.remarks
<if test='orderCol.remarks != null and "DESC".equalsIgnoreCase(orderCol.remarks)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('openId')">
a.openId
<if test='orderCol.openId != null and "DESC".equalsIgnoreCase(orderCol.openId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</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