Skip to content

A
attendance-performance-platform
Commit 9bb74348 authored by 廖旭伟's avatar 廖旭伟
Browse files
Options

添加绩效异常信息表

parent 4f7225d0
Show whitespace changes
Inline Side-by-side
Showing with 4232 additions and 24 deletions
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/dao/PerformErrorMessageDao.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
import java.util.List;
/**
* 绩效异常信息Dao
* 绩效异常信息 DAO接口
*
* @author zxfei
* @date 2024-04-28
*/
public interface PerformErrorMessageDao extends ICRUDDao<PerformErrorMessageEntity,Long>{
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/dao/ibatis/PerformErrorMessageDaoImpl.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.module.perform.dao.PerformErrorMessageDao;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
import org.springframework.stereotype.Repository;
/**
* 绩效异常信息DaoImpl DAO接口
*
* @author zxfei
* @date 2024-04-28
*/
@Repository("performErrorMessageDao")
public class PerformErrorMessageDaoImpl extends BaseCRUDDaoMybatis<PerformErrorMessageEntity,Long> implements PerformErrorMessageDao {
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/PerformErrorMessageEntity.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.model;
import com.mortals.xhx.module.perform.model.vo.PerformErrorMessageVo;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
/**
* 绩效异常信息实体对象
*
* @author zxfei
* @date 2024-04-28
*/
@Data
public class PerformErrorMessageEntity extends PerformErrorMessageVo {
private static final long serialVersionUID = 1L;
/**
* 核查记录Id
*/
private Long checkRecordId;
/**
* 部门id号
*/
private Long deptId;
/**
* 部门名称
*/
private String deptName;
/**
* 所属大厅
*/
private Long salaId;
/**
* 所属大厅名称
*/
private String salaName;
/**
* 绩效责任人id
*/
private Long staffId;
/**
* 绩效负责人名称
*/
private String staffName;
/**
* 工号
*/
private String workNum;
/**
* 异常时间
*/
private Date errorTime;
/**
* 绩效规则id
*/
private Long ruleId;
/**
* 规则名称
*/
private String ruleName;
/**
* 增减类型(1.增加,2.扣除)
*/
private Integer subAddType;
/**
* 扣分或增加分值
*/
private BigDecimal score;
/**
* 阅读状态0未读1已读
*/
private Integer readStatus;
/**
* 核查处理状态1.未处理,2.已处理
*/
private Integer checkStatus;
/**
* 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
*/
private Integer appealStatus;
/**
* 备注
*/
private String remark;
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof PerformErrorMessageEntity) {
PerformErrorMessageEntity tmp = (PerformErrorMessageEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.checkRecordId = null;
this.deptId = null;
this.deptName = "";
this.salaId = null;
this.salaName = "";
this.staffId = null;
this.staffName = "";
this.workNum = "";
this.errorTime = new Date();
this.ruleId = null;
this.ruleName = "";
this.subAddType = 1;
this.score = BigDecimal.ZERO;
this.readStatus = 0;
this.checkStatus = 0;
this.appealStatus = -1;
this.remark = "";
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/PerformErrorMessageQuery.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.model;
import java.math.BigDecimal;
import java.util.List;
/**
* 绩效异常信息查询对象
*
* @author zxfei
* @date 2024-04-28
*/
public class PerformErrorMessageQuery extends PerformErrorMessageEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 序号，主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 核查记录Id */
private Long checkRecordIdStart;
/** 结束 核查记录Id */
private Long checkRecordIdEnd;
/** 增加 核查记录Id */
private Long checkRecordIdIncrement;
/** 核查记录Id列表 */
private List <Long> checkRecordIdList;
/** 核查记录Id排除列表 */
private List <Long> checkRecordIdNotList;
/** 开始 部门id号 */
private Long deptIdStart;
/** 结束 部门id号 */
private Long deptIdEnd;
/** 增加 部门id号 */
private Long deptIdIncrement;
/** 部门id号列表 */
private List <Long> deptIdList;
/** 部门id号排除列表 */
private List <Long> deptIdNotList;
/** 部门名称 */
private List<String> deptNameList;
/** 部门名称排除列表 */
private List <String> deptNameNotList;
/** 开始 所属大厅 */
private Long salaIdStart;
/** 结束 所属大厅 */
private Long salaIdEnd;
/** 增加 所属大厅 */
private Long salaIdIncrement;
/** 所属大厅列表 */
private List <Long> salaIdList;
/** 所属大厅排除列表 */
private List <Long> salaIdNotList;
/** 所属大厅名称 */
private List<String> salaNameList;
/** 所属大厅名称排除列表 */
private List <String> salaNameNotList;
/** 开始 绩效责任人id */
private Long staffIdStart;
/** 结束 绩效责任人id */
private Long staffIdEnd;
/** 增加 绩效责任人id */
private Long staffIdIncrement;
/** 绩效责任人id列表 */
private List <Long> staffIdList;
/** 绩效责任人id排除列表 */
private List <Long> staffIdNotList;
/** 绩效负责人名称 */
private List<String> staffNameList;
/** 绩效负责人名称排除列表 */
private List <String> staffNameNotList;
/** 工号 */
private List<String> workNumList;
/** 工号排除列表 */
private List <String> workNumNotList;
/** 开始 异常时间 */
private String errorTimeStart;
/** 结束 异常时间 */
private String errorTimeEnd;
/** 开始 绩效规则id */
private Long ruleIdStart;
/** 结束 绩效规则id */
private Long ruleIdEnd;
/** 增加 绩效规则id */
private Long ruleIdIncrement;
/** 绩效规则id列表 */
private List <Long> ruleIdList;
/** 绩效规则id排除列表 */
private List <Long> ruleIdNotList;
/** 规则名称 */
private List<String> ruleNameList;
/** 规则名称排除列表 */
private List <String> ruleNameNotList;
/** 开始 增减类型(1.增加,2.扣除) */
private Integer subAddTypeStart;
/** 结束 增减类型(1.增加,2.扣除) */
private Integer subAddTypeEnd;
/** 增加 增减类型(1.增加,2.扣除) */
private Integer subAddTypeIncrement;
/** 增减类型(1.增加,2.扣除)列表 */
private List <Integer> subAddTypeList;
/** 增减类型(1.增加,2.扣除)排除列表 */
private List <Integer> subAddTypeNotList;
/** 开始 扣分或增加分值 */
private BigDecimal scoreStart;
/** 结束 扣分或增加分值 */
private BigDecimal scoreEnd;
/** 增加 扣分或增加分值 */
private BigDecimal scoreIncrement;
/** 扣分或增加分值列表 */
private List <BigDecimal> scoreList;
/** 扣分或增加分值排除列表 */
private List <BigDecimal> scoreNotList;
/** 开始 阅读状态0未读1已读 */
private Integer readStatusStart;
/** 结束 阅读状态0未读1已读 */
private Integer readStatusEnd;
/** 增加 阅读状态0未读1已读 */
private Integer readStatusIncrement;
/** 阅读状态0未读1已读列表 */
private List <Integer> readStatusList;
/** 阅读状态0未读1已读排除列表 */
private List <Integer> readStatusNotList;
/** 开始 核查处理状态1.未处理,2.已处理 */
private Integer checkStatusStart;
/** 结束 核查处理状态1.未处理,2.已处理 */
private Integer checkStatusEnd;
/** 增加 核查处理状态1.未处理,2.已处理 */
private Integer checkStatusIncrement;
/** 核查处理状态1.未处理,2.已处理列表 */
private List <Integer> checkStatusList;
/** 核查处理状态1.未处理,2.已处理排除列表 */
private List <Integer> checkStatusNotList;
/** 开始 申述状态（-1未申诉，0，申述中1.通过,2.不通过） */
private Integer appealStatusStart;
/** 结束 申述状态（-1未申诉，0，申述中1.通过,2.不通过） */
private Integer appealStatusEnd;
/** 增加 申述状态（-1未申诉，0，申述中1.通过,2.不通过） */
private Integer appealStatusIncrement;
/** 申述状态（-1未申诉，0，申述中1.通过,2.不通过）列表 */
private List <Integer> appealStatusList;
/** 申述状态（-1未申诉，0，申述中1.通过,2.不通过）排除列表 */
private List <Integer> appealStatusNotList;
/** 备注 */
private List<String> remarkList;
/** 备注排除列表 */
private List <String> remarkNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 更新用户 */
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<PerformErrorMessageQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<PerformErrorMessageQuery> andConditionList;
public PerformErrorMessageQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @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 checkRecordIdStart
*/
public Long getCheckRecordIdStart(){
return this.checkRecordIdStart;
}
/**
* 设置 开始 核查记录Id
* @param checkRecordIdStart
*/
public void setCheckRecordIdStart(Long checkRecordIdStart){
this.checkRecordIdStart = checkRecordIdStart;
}
/**
* 获取 结束 核查记录Id
* @return $checkRecordIdEnd
*/
public Long getCheckRecordIdEnd(){
return this.checkRecordIdEnd;
}
/**
* 设置 结束 核查记录Id
* @param checkRecordIdEnd
*/
public void setCheckRecordIdEnd(Long checkRecordIdEnd){
this.checkRecordIdEnd = checkRecordIdEnd;
}
/**
* 获取 增加 核查记录Id
* @return checkRecordIdIncrement
*/
public Long getCheckRecordIdIncrement(){
return this.checkRecordIdIncrement;
}
/**
* 设置 增加 核查记录Id
* @param checkRecordIdIncrement
*/
public void setCheckRecordIdIncrement(Long checkRecordIdIncrement){
this.checkRecordIdIncrement = checkRecordIdIncrement;
}
/**
* 获取 核查记录Id
* @return checkRecordIdList
*/
public List<Long> getCheckRecordIdList(){
return this.checkRecordIdList;
}
/**
* 设置 核查记录Id
* @param checkRecordIdList
*/
public void setCheckRecordIdList(List<Long> checkRecordIdList){
this.checkRecordIdList = checkRecordIdList;
}
/**
* 获取 核查记录Id
* @return checkRecordIdNotList
*/
public List<Long> getCheckRecordIdNotList(){
return this.checkRecordIdNotList;
}
/**
* 设置 核查记录Id
* @param checkRecordIdNotList
*/
public void setCheckRecordIdNotList(List<Long> checkRecordIdNotList){
this.checkRecordIdNotList = checkRecordIdNotList;
}
/**
* 获取 开始 部门id号
* @return deptIdStart
*/
public Long getDeptIdStart(){
return this.deptIdStart;
}
/**
* 设置 开始 部门id号
* @param deptIdStart
*/
public void setDeptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
}
/**
* 获取 结束 部门id号
* @return $deptIdEnd
*/
public Long getDeptIdEnd(){
return this.deptIdEnd;
}
/**
* 设置 结束 部门id号
* @param deptIdEnd
*/
public void setDeptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
}
/**
* 获取 增加 部门id号
* @return deptIdIncrement
*/
public Long getDeptIdIncrement(){
return this.deptIdIncrement;
}
/**
* 设置 增加 部门id号
* @param deptIdIncrement
*/
public void setDeptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
}
/**
* 获取 部门id号
* @return deptIdList
*/
public List<Long> getDeptIdList(){
return this.deptIdList;
}
/**
* 设置 部门id号
* @param deptIdList
*/
public void setDeptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
}
/**
* 获取 部门id号
* @return deptIdNotList
*/
public List<Long> getDeptIdNotList(){
return this.deptIdNotList;
}
/**
* 设置 部门id号
* @param deptIdNotList
*/
public void setDeptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
}
/**
* 获取 部门名称
* @return deptNameList
*/
public List<String> getDeptNameList(){
return this.deptNameList;
}
/**
* 设置 部门名称
* @param deptNameList
*/
public void setDeptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
}
/**
* 获取 部门名称
* @return deptNameNotList
*/
public List<String> getDeptNameNotList(){
return this.deptNameNotList;
}
/**
* 设置 部门名称
* @param deptNameNotList
*/
public void setDeptNameNotList(List<String> deptNameNotList){
this.deptNameNotList = deptNameNotList;
}
/**
* 获取 开始 所属大厅
* @return salaIdStart
*/
public Long getSalaIdStart(){
return this.salaIdStart;
}
/**
* 设置 开始 所属大厅
* @param salaIdStart
*/
public void setSalaIdStart(Long salaIdStart){
this.salaIdStart = salaIdStart;
}
/**
* 获取 结束 所属大厅
* @return $salaIdEnd
*/
public Long getSalaIdEnd(){
return this.salaIdEnd;
}
/**
* 设置 结束 所属大厅
* @param salaIdEnd
*/
public void setSalaIdEnd(Long salaIdEnd){
this.salaIdEnd = salaIdEnd;
}
/**
* 获取 增加 所属大厅
* @return salaIdIncrement
*/
public Long getSalaIdIncrement(){
return this.salaIdIncrement;
}
/**
* 设置 增加 所属大厅
* @param salaIdIncrement
*/
public void setSalaIdIncrement(Long salaIdIncrement){
this.salaIdIncrement = salaIdIncrement;
}
/**
* 获取 所属大厅
* @return salaIdList
*/
public List<Long> getSalaIdList(){
return this.salaIdList;
}
/**
* 设置 所属大厅
* @param salaIdList
*/
public void setSalaIdList(List<Long> salaIdList){
this.salaIdList = salaIdList;
}
/**
* 获取 所属大厅
* @return salaIdNotList
*/
public List<Long> getSalaIdNotList(){
return this.salaIdNotList;
}
/**
* 设置 所属大厅
* @param salaIdNotList
*/
public void setSalaIdNotList(List<Long> salaIdNotList){
this.salaIdNotList = salaIdNotList;
}
/**
* 获取 所属大厅名称
* @return salaNameList
*/
public List<String> getSalaNameList(){
return this.salaNameList;
}
/**
* 设置 所属大厅名称
* @param salaNameList
*/
public void setSalaNameList(List<String> salaNameList){
this.salaNameList = salaNameList;
}
/**
* 获取 所属大厅名称
* @return salaNameNotList
*/
public List<String> getSalaNameNotList(){
return this.salaNameNotList;
}
/**
* 设置 所属大厅名称
* @param salaNameNotList
*/
public void setSalaNameNotList(List<String> salaNameNotList){
this.salaNameNotList = salaNameNotList;
}
/**
* 获取 开始 绩效责任人id
* @return staffIdStart
*/
public Long getStaffIdStart(){
return this.staffIdStart;
}
/**
* 设置 开始 绩效责任人id
* @param staffIdStart
*/
public void setStaffIdStart(Long staffIdStart){
this.staffIdStart = staffIdStart;
}
/**
* 获取 结束 绩效责任人id
* @return $staffIdEnd
*/
public Long getStaffIdEnd(){
return this.staffIdEnd;
}
/**
* 设置 结束 绩效责任人id
* @param staffIdEnd
*/
public void setStaffIdEnd(Long staffIdEnd){
this.staffIdEnd = staffIdEnd;
}
/**
* 获取 增加 绩效责任人id
* @return staffIdIncrement
*/
public Long getStaffIdIncrement(){
return this.staffIdIncrement;
}
/**
* 设置 增加 绩效责任人id
* @param staffIdIncrement
*/
public void setStaffIdIncrement(Long staffIdIncrement){
this.staffIdIncrement = staffIdIncrement;
}
/**
* 获取 绩效责任人id
* @return staffIdList
*/
public List<Long> getStaffIdList(){
return this.staffIdList;
}
/**
* 设置 绩效责任人id
* @param staffIdList
*/
public void setStaffIdList(List<Long> staffIdList){
this.staffIdList = staffIdList;
}
/**
* 获取 绩效责任人id
* @return staffIdNotList
*/
public List<Long> getStaffIdNotList(){
return this.staffIdNotList;
}
/**
* 设置 绩效责任人id
* @param staffIdNotList
*/
public void setStaffIdNotList(List<Long> staffIdNotList){
this.staffIdNotList = staffIdNotList;
}
/**
* 获取 绩效负责人名称
* @return staffNameList
*/
public List<String> getStaffNameList(){
return this.staffNameList;
}
/**
* 设置 绩效负责人名称
* @param staffNameList
*/
public void setStaffNameList(List<String> staffNameList){
this.staffNameList = staffNameList;
}
/**
* 获取 绩效负责人名称
* @return staffNameNotList
*/
public List<String> getStaffNameNotList(){
return this.staffNameNotList;
}
/**
* 设置 绩效负责人名称
* @param staffNameNotList
*/
public void setStaffNameNotList(List<String> staffNameNotList){
this.staffNameNotList = staffNameNotList;
}
/**
* 获取 工号
* @return workNumList
*/
public List<String> getWorkNumList(){
return this.workNumList;
}
/**
* 设置 工号
* @param workNumList
*/
public void setWorkNumList(List<String> workNumList){
this.workNumList = workNumList;
}
/**
* 获取 工号
* @return workNumNotList
*/
public List<String> getWorkNumNotList(){
return this.workNumNotList;
}
/**
* 设置 工号
* @param workNumNotList
*/
public void setWorkNumNotList(List<String> workNumNotList){
this.workNumNotList = workNumNotList;
}
/**
* 获取 开始 异常时间
* @return errorTimeStart
*/
public String getErrorTimeStart(){
return this.errorTimeStart;
}
/**
* 设置 开始 异常时间
* @param errorTimeStart
*/
public void setErrorTimeStart(String errorTimeStart){
this.errorTimeStart = errorTimeStart;
}
/**
* 获取 结束 异常时间
* @return errorTimeEnd
*/
public String getErrorTimeEnd(){
return this.errorTimeEnd;
}
/**
* 设置 结束 异常时间
* @param errorTimeEnd
*/
public void setErrorTimeEnd(String errorTimeEnd){
this.errorTimeEnd = errorTimeEnd;
}
/**
* 获取 开始 绩效规则id
* @return ruleIdStart
*/
public Long getRuleIdStart(){
return this.ruleIdStart;
}
/**
* 设置 开始 绩效规则id
* @param ruleIdStart
*/
public void setRuleIdStart(Long ruleIdStart){
this.ruleIdStart = ruleIdStart;
}
/**
* 获取 结束 绩效规则id
* @return $ruleIdEnd
*/
public Long getRuleIdEnd(){
return this.ruleIdEnd;
}
/**
* 设置 结束 绩效规则id
* @param ruleIdEnd
*/
public void setRuleIdEnd(Long ruleIdEnd){
this.ruleIdEnd = ruleIdEnd;
}
/**
* 获取 增加 绩效规则id
* @return ruleIdIncrement
*/
public Long getRuleIdIncrement(){
return this.ruleIdIncrement;
}
/**
* 设置 增加 绩效规则id
* @param ruleIdIncrement
*/
public void setRuleIdIncrement(Long ruleIdIncrement){
this.ruleIdIncrement = ruleIdIncrement;
}
/**
* 获取 绩效规则id
* @return ruleIdList
*/
public List<Long> getRuleIdList(){
return this.ruleIdList;
}
/**
* 设置 绩效规则id
* @param ruleIdList
*/
public void setRuleIdList(List<Long> ruleIdList){
this.ruleIdList = ruleIdList;
}
/**
* 获取 绩效规则id
* @return ruleIdNotList
*/
public List<Long> getRuleIdNotList(){
return this.ruleIdNotList;
}
/**
* 设置 绩效规则id
* @param ruleIdNotList
*/
public void setRuleIdNotList(List<Long> ruleIdNotList){
this.ruleIdNotList = ruleIdNotList;
}
/**
* 获取 规则名称
* @return ruleNameList
*/
public List<String> getRuleNameList(){
return this.ruleNameList;
}
/**
* 设置 规则名称
* @param ruleNameList
*/
public void setRuleNameList(List<String> ruleNameList){
this.ruleNameList = ruleNameList;
}
/**
* 获取 规则名称
* @return ruleNameNotList
*/
public List<String> getRuleNameNotList(){
return this.ruleNameNotList;
}
/**
* 设置 规则名称
* @param ruleNameNotList
*/
public void setRuleNameNotList(List<String> ruleNameNotList){
this.ruleNameNotList = ruleNameNotList;
}
/**
* 获取 开始 增减类型(1.增加,2.扣除)
* @return subAddTypeStart
*/
public Integer getSubAddTypeStart(){
return this.subAddTypeStart;
}
/**
* 设置 开始 增减类型(1.增加,2.扣除)
* @param subAddTypeStart
*/
public void setSubAddTypeStart(Integer subAddTypeStart){
this.subAddTypeStart = subAddTypeStart;
}
/**
* 获取 结束 增减类型(1.增加,2.扣除)
* @return $subAddTypeEnd
*/
public Integer getSubAddTypeEnd(){
return this.subAddTypeEnd;
}
/**
* 设置 结束 增减类型(1.增加,2.扣除)
* @param subAddTypeEnd
*/
public void setSubAddTypeEnd(Integer subAddTypeEnd){
this.subAddTypeEnd = subAddTypeEnd;
}
/**
* 获取 增加 增减类型(1.增加,2.扣除)
* @return subAddTypeIncrement
*/
public Integer getSubAddTypeIncrement(){
return this.subAddTypeIncrement;
}
/**
* 设置 增加 增减类型(1.增加,2.扣除)
* @param subAddTypeIncrement
*/
public void setSubAddTypeIncrement(Integer subAddTypeIncrement){
this.subAddTypeIncrement = subAddTypeIncrement;
}
/**
* 获取 增减类型(1.增加,2.扣除)
* @return subAddTypeList
*/
public List<Integer> getSubAddTypeList(){
return this.subAddTypeList;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeList
*/
public void setSubAddTypeList(List<Integer> subAddTypeList){
this.subAddTypeList = subAddTypeList;
}
/**
* 获取 增减类型(1.增加,2.扣除)
* @return subAddTypeNotList
*/
public List<Integer> getSubAddTypeNotList(){
return this.subAddTypeNotList;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeNotList
*/
public void setSubAddTypeNotList(List<Integer> subAddTypeNotList){
this.subAddTypeNotList = subAddTypeNotList;
}
/**
* 获取 开始 扣分或增加分值
* @return scoreStart
*/
public BigDecimal getScoreStart(){
return this.scoreStart;
}
/**
* 设置 开始 扣分或增加分值
* @param scoreStart
*/
public void setScoreStart(BigDecimal scoreStart){
this.scoreStart = scoreStart;
}
/**
* 获取 结束 扣分或增加分值
* @return $scoreEnd
*/
public BigDecimal getScoreEnd(){
return this.scoreEnd;
}
/**
* 设置 结束 扣分或增加分值
* @param scoreEnd
*/
public void setScoreEnd(BigDecimal scoreEnd){
this.scoreEnd = scoreEnd;
}
/**
* 获取 增加 扣分或增加分值
* @return scoreIncrement
*/
public BigDecimal getScoreIncrement(){
return this.scoreIncrement;
}
/**
* 设置 增加 扣分或增加分值
* @param scoreIncrement
*/
public void setScoreIncrement(BigDecimal scoreIncrement){
this.scoreIncrement = scoreIncrement;
}
/**
* 获取 扣分或增加分值
* @return scoreList
*/
public List<BigDecimal> getScoreList(){
return this.scoreList;
}
/**
* 设置 扣分或增加分值
* @param scoreList
*/
public void setScoreList(List<BigDecimal> scoreList){
this.scoreList = scoreList;
}
/**
* 获取 扣分或增加分值
* @return scoreNotList
*/
public List<BigDecimal> getScoreNotList(){
return this.scoreNotList;
}
/**
* 设置 扣分或增加分值
* @param scoreNotList
*/
public void setScoreNotList(List<BigDecimal> scoreNotList){
this.scoreNotList = scoreNotList;
}
/**
* 获取 开始 阅读状态0未读1已读
* @return readStatusStart
*/
public Integer getReadStatusStart(){
return this.readStatusStart;
}
/**
* 设置 开始 阅读状态0未读1已读
* @param readStatusStart
*/
public void setReadStatusStart(Integer readStatusStart){
this.readStatusStart = readStatusStart;
}
/**
* 获取 结束 阅读状态0未读1已读
* @return $readStatusEnd
*/
public Integer getReadStatusEnd(){
return this.readStatusEnd;
}
/**
* 设置 结束 阅读状态0未读1已读
* @param readStatusEnd
*/
public void setReadStatusEnd(Integer readStatusEnd){
this.readStatusEnd = readStatusEnd;
}
/**
* 获取 增加 阅读状态0未读1已读
* @return readStatusIncrement
*/
public Integer getReadStatusIncrement(){
return this.readStatusIncrement;
}
/**
* 设置 增加 阅读状态0未读1已读
* @param readStatusIncrement
*/
public void setReadStatusIncrement(Integer readStatusIncrement){
this.readStatusIncrement = readStatusIncrement;
}
/**
* 获取 阅读状态0未读1已读
* @return readStatusList
*/
public List<Integer> getReadStatusList(){
return this.readStatusList;
}
/**
* 设置 阅读状态0未读1已读
* @param readStatusList
*/
public void setReadStatusList(List<Integer> readStatusList){
this.readStatusList = readStatusList;
}
/**
* 获取 阅读状态0未读1已读
* @return readStatusNotList
*/
public List<Integer> getReadStatusNotList(){
return this.readStatusNotList;
}
/**
* 设置 阅读状态0未读1已读
* @param readStatusNotList
*/
public void setReadStatusNotList(List<Integer> readStatusNotList){
this.readStatusNotList = readStatusNotList;
}
/**
* 获取 开始 核查处理状态1.未处理,2.已处理
* @return checkStatusStart
*/
public Integer getCheckStatusStart(){
return this.checkStatusStart;
}
/**
* 设置 开始 核查处理状态1.未处理,2.已处理
* @param checkStatusStart
*/
public void setCheckStatusStart(Integer checkStatusStart){
this.checkStatusStart = checkStatusStart;
}
/**
* 获取 结束 核查处理状态1.未处理,2.已处理
* @return $checkStatusEnd
*/
public Integer getCheckStatusEnd(){
return this.checkStatusEnd;
}
/**
* 设置 结束 核查处理状态1.未处理,2.已处理
* @param checkStatusEnd
*/
public void setCheckStatusEnd(Integer checkStatusEnd){
this.checkStatusEnd = checkStatusEnd;
}
/**
* 获取 增加 核查处理状态1.未处理,2.已处理
* @return checkStatusIncrement
*/
public Integer getCheckStatusIncrement(){
return this.checkStatusIncrement;
}
/**
* 设置 增加 核查处理状态1.未处理,2.已处理
* @param checkStatusIncrement
*/
public void setCheckStatusIncrement(Integer checkStatusIncrement){
this.checkStatusIncrement = checkStatusIncrement;
}
/**
* 获取 核查处理状态1.未处理,2.已处理
* @return checkStatusList
*/
public List<Integer> getCheckStatusList(){
return this.checkStatusList;
}
/**
* 设置 核查处理状态1.未处理,2.已处理
* @param checkStatusList
*/
public void setCheckStatusList(List<Integer> checkStatusList){
this.checkStatusList = checkStatusList;
}
/**
* 获取 核查处理状态1.未处理,2.已处理
* @return checkStatusNotList
*/
public List<Integer> getCheckStatusNotList(){
return this.checkStatusNotList;
}
/**
* 设置 核查处理状态1.未处理,2.已处理
* @param checkStatusNotList
*/
public void setCheckStatusNotList(List<Integer> checkStatusNotList){
this.checkStatusNotList = checkStatusNotList;
}
/**
* 获取 开始 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @return appealStatusStart
*/
public Integer getAppealStatusStart(){
return this.appealStatusStart;
}
/**
* 设置 开始 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusStart
*/
public void setAppealStatusStart(Integer appealStatusStart){
this.appealStatusStart = appealStatusStart;
}
/**
* 获取 结束 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @return $appealStatusEnd
*/
public Integer getAppealStatusEnd(){
return this.appealStatusEnd;
}
/**
* 设置 结束 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusEnd
*/
public void setAppealStatusEnd(Integer appealStatusEnd){
this.appealStatusEnd = appealStatusEnd;
}
/**
* 获取 增加 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @return appealStatusIncrement
*/
public Integer getAppealStatusIncrement(){
return this.appealStatusIncrement;
}
/**
* 设置 增加 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusIncrement
*/
public void setAppealStatusIncrement(Integer appealStatusIncrement){
this.appealStatusIncrement = appealStatusIncrement;
}
/**
* 获取 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @return appealStatusList
*/
public List<Integer> getAppealStatusList(){
return this.appealStatusList;
}
/**
* 设置 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusList
*/
public void setAppealStatusList(List<Integer> appealStatusList){
this.appealStatusList = appealStatusList;
}
/**
* 获取 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @return appealStatusNotList
*/
public List<Integer> getAppealStatusNotList(){
return this.appealStatusNotList;
}
/**
* 设置 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusNotList
*/
public void setAppealStatusNotList(List<Integer> appealStatusNotList){
this.appealStatusNotList = appealStatusNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 开始 更新用户
* @return 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 PerformErrorMessageQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public PerformErrorMessageQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public PerformErrorMessageQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public PerformErrorMessageQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public PerformErrorMessageQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public PerformErrorMessageQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 核查记录Id
* @param checkRecordId
*/
public PerformErrorMessageQuery checkRecordId(Long checkRecordId){
setCheckRecordId(checkRecordId);
return this;
}
/**
* 设置 开始 核查记录Id
* @param checkRecordIdStart
*/
public PerformErrorMessageQuery checkRecordIdStart(Long checkRecordIdStart){
this.checkRecordIdStart = checkRecordIdStart;
return this;
}
/**
* 设置 结束 核查记录Id
* @param checkRecordIdEnd
*/
public PerformErrorMessageQuery checkRecordIdEnd(Long checkRecordIdEnd){
this.checkRecordIdEnd = checkRecordIdEnd;
return this;
}
/**
* 设置 增加 核查记录Id
* @param checkRecordIdIncrement
*/
public PerformErrorMessageQuery checkRecordIdIncrement(Long checkRecordIdIncrement){
this.checkRecordIdIncrement = checkRecordIdIncrement;
return this;
}
/**
* 设置 核查记录Id
* @param checkRecordIdList
*/
public PerformErrorMessageQuery checkRecordIdList(List<Long> checkRecordIdList){
this.checkRecordIdList = checkRecordIdList;
return this;
}
/**
* 设置 核查记录Id
* @param checkRecordIdNotList
*/
public PerformErrorMessageQuery checkRecordIdNotList(List<Long> checkRecordIdNotList){
this.checkRecordIdNotList = checkRecordIdNotList;
return this;
}
/**
* 设置 部门id号
* @param deptId
*/
public PerformErrorMessageQuery deptId(Long deptId){
setDeptId(deptId);
return this;
}
/**
* 设置 开始 部门id号
* @param deptIdStart
*/
public PerformErrorMessageQuery deptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
return this;
}
/**
* 设置 结束 部门id号
* @param deptIdEnd
*/
public PerformErrorMessageQuery deptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
return this;
}
/**
* 设置 增加 部门id号
* @param deptIdIncrement
*/
public PerformErrorMessageQuery deptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
return this;
}
/**
* 设置 部门id号
* @param deptIdList
*/
public PerformErrorMessageQuery deptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
return this;
}
/**
* 设置 部门id号
* @param deptIdNotList
*/
public PerformErrorMessageQuery deptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
return this;
}
/**
* 设置 部门名称
* @param deptName
*/
public PerformErrorMessageQuery deptName(String deptName){
setDeptName(deptName);
return this;
}
/**
* 设置 部门名称
* @param deptNameList
*/
public PerformErrorMessageQuery deptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
return this;
}
/**
* 设置 所属大厅
* @param salaId
*/
public PerformErrorMessageQuery salaId(Long salaId){
setSalaId(salaId);
return this;
}
/**
* 设置 开始 所属大厅
* @param salaIdStart
*/
public PerformErrorMessageQuery salaIdStart(Long salaIdStart){
this.salaIdStart = salaIdStart;
return this;
}
/**
* 设置 结束 所属大厅
* @param salaIdEnd
*/
public PerformErrorMessageQuery salaIdEnd(Long salaIdEnd){
this.salaIdEnd = salaIdEnd;
return this;
}
/**
* 设置 增加 所属大厅
* @param salaIdIncrement
*/
public PerformErrorMessageQuery salaIdIncrement(Long salaIdIncrement){
this.salaIdIncrement = salaIdIncrement;
return this;
}
/**
* 设置 所属大厅
* @param salaIdList
*/
public PerformErrorMessageQuery salaIdList(List<Long> salaIdList){
this.salaIdList = salaIdList;
return this;
}
/**
* 设置 所属大厅
* @param salaIdNotList
*/
public PerformErrorMessageQuery salaIdNotList(List<Long> salaIdNotList){
this.salaIdNotList = salaIdNotList;
return this;
}
/**
* 设置 所属大厅名称
* @param salaName
*/
public PerformErrorMessageQuery salaName(String salaName){
setSalaName(salaName);
return this;
}
/**
* 设置 所属大厅名称
* @param salaNameList
*/
public PerformErrorMessageQuery salaNameList(List<String> salaNameList){
this.salaNameList = salaNameList;
return this;
}
/**
* 设置 绩效责任人id
* @param staffId
*/
public PerformErrorMessageQuery staffId(Long staffId){
setStaffId(staffId);
return this;
}
/**
* 设置 开始 绩效责任人id
* @param staffIdStart
*/
public PerformErrorMessageQuery staffIdStart(Long staffIdStart){
this.staffIdStart = staffIdStart;
return this;
}
/**
* 设置 结束 绩效责任人id
* @param staffIdEnd
*/
public PerformErrorMessageQuery staffIdEnd(Long staffIdEnd){
this.staffIdEnd = staffIdEnd;
return this;
}
/**
* 设置 增加 绩效责任人id
* @param staffIdIncrement
*/
public PerformErrorMessageQuery staffIdIncrement(Long staffIdIncrement){
this.staffIdIncrement = staffIdIncrement;
return this;
}
/**
* 设置 绩效责任人id
* @param staffIdList
*/
public PerformErrorMessageQuery staffIdList(List<Long> staffIdList){
this.staffIdList = staffIdList;
return this;
}
/**
* 设置 绩效责任人id
* @param staffIdNotList
*/
public PerformErrorMessageQuery staffIdNotList(List<Long> staffIdNotList){
this.staffIdNotList = staffIdNotList;
return this;
}
/**
* 设置 绩效负责人名称
* @param staffName
*/
public PerformErrorMessageQuery staffName(String staffName){
setStaffName(staffName);
return this;
}
/**
* 设置 绩效负责人名称
* @param staffNameList
*/
public PerformErrorMessageQuery staffNameList(List<String> staffNameList){
this.staffNameList = staffNameList;
return this;
}
/**
* 设置 工号
* @param workNum
*/
public PerformErrorMessageQuery workNum(String workNum){
setWorkNum(workNum);
return this;
}
/**
* 设置 工号
* @param workNumList
*/
public PerformErrorMessageQuery workNumList(List<String> workNumList){
this.workNumList = workNumList;
return this;
}
/**
* 设置 绩效规则id
* @param ruleId
*/
public PerformErrorMessageQuery ruleId(Long ruleId){
setRuleId(ruleId);
return this;
}
/**
* 设置 开始 绩效规则id
* @param ruleIdStart
*/
public PerformErrorMessageQuery ruleIdStart(Long ruleIdStart){
this.ruleIdStart = ruleIdStart;
return this;
}
/**
* 设置 结束 绩效规则id
* @param ruleIdEnd
*/
public PerformErrorMessageQuery ruleIdEnd(Long ruleIdEnd){
this.ruleIdEnd = ruleIdEnd;
return this;
}
/**
* 设置 增加 绩效规则id
* @param ruleIdIncrement
*/
public PerformErrorMessageQuery ruleIdIncrement(Long ruleIdIncrement){
this.ruleIdIncrement = ruleIdIncrement;
return this;
}
/**
* 设置 绩效规则id
* @param ruleIdList
*/
public PerformErrorMessageQuery ruleIdList(List<Long> ruleIdList){
this.ruleIdList = ruleIdList;
return this;
}
/**
* 设置 绩效规则id
* @param ruleIdNotList
*/
public PerformErrorMessageQuery ruleIdNotList(List<Long> ruleIdNotList){
this.ruleIdNotList = ruleIdNotList;
return this;
}
/**
* 设置 规则名称
* @param ruleName
*/
public PerformErrorMessageQuery ruleName(String ruleName){
setRuleName(ruleName);
return this;
}
/**
* 设置 规则名称
* @param ruleNameList
*/
public PerformErrorMessageQuery ruleNameList(List<String> ruleNameList){
this.ruleNameList = ruleNameList;
return this;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddType
*/
public PerformErrorMessageQuery subAddType(Integer subAddType){
setSubAddType(subAddType);
return this;
}
/**
* 设置 开始 增减类型(1.增加,2.扣除)
* @param subAddTypeStart
*/
public PerformErrorMessageQuery subAddTypeStart(Integer subAddTypeStart){
this.subAddTypeStart = subAddTypeStart;
return this;
}
/**
* 设置 结束 增减类型(1.增加,2.扣除)
* @param subAddTypeEnd
*/
public PerformErrorMessageQuery subAddTypeEnd(Integer subAddTypeEnd){
this.subAddTypeEnd = subAddTypeEnd;
return this;
}
/**
* 设置 增加 增减类型(1.增加,2.扣除)
* @param subAddTypeIncrement
*/
public PerformErrorMessageQuery subAddTypeIncrement(Integer subAddTypeIncrement){
this.subAddTypeIncrement = subAddTypeIncrement;
return this;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeList
*/
public PerformErrorMessageQuery subAddTypeList(List<Integer> subAddTypeList){
this.subAddTypeList = subAddTypeList;
return this;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeNotList
*/
public PerformErrorMessageQuery subAddTypeNotList(List<Integer> subAddTypeNotList){
this.subAddTypeNotList = subAddTypeNotList;
return this;
}
/**
* 设置 扣分或增加分值
* @param score
*/
public PerformErrorMessageQuery score(BigDecimal score){
setScore(score);
return this;
}
/**
* 设置 开始 扣分或增加分值
* @param scoreStart
*/
public PerformErrorMessageQuery scoreStart(BigDecimal scoreStart){
this.scoreStart = scoreStart;
return this;
}
/**
* 设置 结束 扣分或增加分值
* @param scoreEnd
*/
public PerformErrorMessageQuery scoreEnd(BigDecimal scoreEnd){
this.scoreEnd = scoreEnd;
return this;
}
/**
* 设置 增加 扣分或增加分值
* @param scoreIncrement
*/
public PerformErrorMessageQuery scoreIncrement(BigDecimal scoreIncrement){
this.scoreIncrement = scoreIncrement;
return this;
}
/**
* 设置 扣分或增加分值
* @param scoreList
*/
public PerformErrorMessageQuery scoreList(List<BigDecimal> scoreList){
this.scoreList = scoreList;
return this;
}
/**
* 设置 扣分或增加分值
* @param scoreNotList
*/
public PerformErrorMessageQuery scoreNotList(List<BigDecimal> scoreNotList){
this.scoreNotList = scoreNotList;
return this;
}
/**
* 设置 阅读状态0未读1已读
* @param readStatus
*/
public PerformErrorMessageQuery readStatus(Integer readStatus){
setReadStatus(readStatus);
return this;
}
/**
* 设置 开始 阅读状态0未读1已读
* @param readStatusStart
*/
public PerformErrorMessageQuery readStatusStart(Integer readStatusStart){
this.readStatusStart = readStatusStart;
return this;
}
/**
* 设置 结束 阅读状态0未读1已读
* @param readStatusEnd
*/
public PerformErrorMessageQuery readStatusEnd(Integer readStatusEnd){
this.readStatusEnd = readStatusEnd;
return this;
}
/**
* 设置 增加 阅读状态0未读1已读
* @param readStatusIncrement
*/
public PerformErrorMessageQuery readStatusIncrement(Integer readStatusIncrement){
this.readStatusIncrement = readStatusIncrement;
return this;
}
/**
* 设置 阅读状态0未读1已读
* @param readStatusList
*/
public PerformErrorMessageQuery readStatusList(List<Integer> readStatusList){
this.readStatusList = readStatusList;
return this;
}
/**
* 设置 阅读状态0未读1已读
* @param readStatusNotList
*/
public PerformErrorMessageQuery readStatusNotList(List<Integer> readStatusNotList){
this.readStatusNotList = readStatusNotList;
return this;
}
/**
* 设置 核查处理状态1.未处理,2.已处理
* @param checkStatus
*/
public PerformErrorMessageQuery checkStatus(Integer checkStatus){
setCheckStatus(checkStatus);
return this;
}
/**
* 设置 开始 核查处理状态1.未处理,2.已处理
* @param checkStatusStart
*/
public PerformErrorMessageQuery checkStatusStart(Integer checkStatusStart){
this.checkStatusStart = checkStatusStart;
return this;
}
/**
* 设置 结束 核查处理状态1.未处理,2.已处理
* @param checkStatusEnd
*/
public PerformErrorMessageQuery checkStatusEnd(Integer checkStatusEnd){
this.checkStatusEnd = checkStatusEnd;
return this;
}
/**
* 设置 增加 核查处理状态1.未处理,2.已处理
* @param checkStatusIncrement
*/
public PerformErrorMessageQuery checkStatusIncrement(Integer checkStatusIncrement){
this.checkStatusIncrement = checkStatusIncrement;
return this;
}
/**
* 设置 核查处理状态1.未处理,2.已处理
* @param checkStatusList
*/
public PerformErrorMessageQuery checkStatusList(List<Integer> checkStatusList){
this.checkStatusList = checkStatusList;
return this;
}
/**
* 设置 核查处理状态1.未处理,2.已处理
* @param checkStatusNotList
*/
public PerformErrorMessageQuery checkStatusNotList(List<Integer> checkStatusNotList){
this.checkStatusNotList = checkStatusNotList;
return this;
}
/**
* 设置 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatus
*/
public PerformErrorMessageQuery appealStatus(Integer appealStatus){
setAppealStatus(appealStatus);
return this;
}
/**
* 设置 开始 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusStart
*/
public PerformErrorMessageQuery appealStatusStart(Integer appealStatusStart){
this.appealStatusStart = appealStatusStart;
return this;
}
/**
* 设置 结束 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusEnd
*/
public PerformErrorMessageQuery appealStatusEnd(Integer appealStatusEnd){
this.appealStatusEnd = appealStatusEnd;
return this;
}
/**
* 设置 增加 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusIncrement
*/
public PerformErrorMessageQuery appealStatusIncrement(Integer appealStatusIncrement){
this.appealStatusIncrement = appealStatusIncrement;
return this;
}
/**
* 设置 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusList
*/
public PerformErrorMessageQuery appealStatusList(List<Integer> appealStatusList){
this.appealStatusList = appealStatusList;
return this;
}
/**
* 设置 申述状态（-1未申诉，0，申述中1.通过,2.不通过）
* @param appealStatusNotList
*/
public PerformErrorMessageQuery appealStatusNotList(List<Integer> appealStatusNotList){
this.appealStatusNotList = appealStatusNotList;
return this;
}
/**
* 设置 备注
* @param remark
*/
public PerformErrorMessageQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public PerformErrorMessageQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public PerformErrorMessageQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public PerformErrorMessageQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public PerformErrorMessageQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public PerformErrorMessageQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public PerformErrorMessageQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public PerformErrorMessageQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public PerformErrorMessageQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public PerformErrorMessageQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public PerformErrorMessageQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public PerformErrorMessageQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public PerformErrorMessageQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public PerformErrorMessageQuery 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<PerformErrorMessageQuery> 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<PerformErrorMessageQuery> 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<PerformErrorMessageQuery> 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<PerformErrorMessageQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/vo/PerformErrorMessageVo.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
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 2024-04-28
*/
@Data
public class PerformErrorMessageVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/vo/StaffErrorMessageVo.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.model.vo;
import lombok.Data;
@Data
public class StaffErrorMessageVo {
/**
* 部门id号
*/
private Long deptId;
/**
* 部门名称
*/
private String deptName;
/**
* 所属大厅
*/
private Long salaId;
/**
* 所属大厅名称
*/
private String salaName;
/**
* 绩效责任人id
*/
private Long staffId;
/**
* 绩效负责人名称
*/
private String staffName;
/**
* 工号
*/
private String workNum;
/**
* 未读消息数量
*/
private Integer messageCount;
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/service/PerformErrorMessageService.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
import com.mortals.xhx.module.perform.dao.PerformErrorMessageDao;
/**
* PerformErrorMessageService
*
* 绩效异常信息 service接口
*
* @author zxfei
* @date 2024-04-28
*/
public interface PerformErrorMessageService extends ICRUDService<PerformErrorMessageEntity,Long>{
PerformErrorMessageDao getDao();
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/service/impl/PerformErrorMessageServiceImpl.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.service.impl;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.xhx.module.perform.dao.PerformErrorMessageDao;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
import com.mortals.xhx.module.perform.service.PerformErrorMessageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* PerformErrorMessageService
* 绩效异常信息 service实现
*
* @author zxfei
* @date 2024-04-28
*/
@Service("performErrorMessageService")
@Slf4j
public class PerformErrorMessageServiceImpl extends AbstractCRUDServiceImpl<PerformErrorMessageDao, PerformErrorMessageEntity, Long> implements PerformErrorMessageService {
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/web/PerformErrorMessageController.java 0 → 100644
View file @ 9bb74348
package com.mortals.xhx.module.perform.web;
import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.common.code.AppealStatusEnum;
import com.mortals.xhx.common.code.CheckStatusEnum;
import com.mortals.xhx.common.code.SubAddTypeEnum;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
import com.mortals.xhx.module.perform.service.PerformErrorMessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
*
* 绩效异常信息
*
* @author zxfei
* @date 2024-04-28
*/
@RestController
@RequestMapping("perform/error/message")
public class PerformErrorMessageController extends BaseCRUDJsonBodyMappingController<PerformErrorMessageService,PerformErrorMessageEntity,Long> {
@Autowired
private ParamService paramService;
public PerformErrorMessageController(){
super.setModuleDesc( "绩效异常信息");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "subAddType", SubAddTypeEnum.getEnumMap());
this.addDict(model, "checkStatus", CheckStatusEnum.getEnumMap());
this.addDict(model, "appealStatus", AppealStatusEnum.getEnumMap());
super.init(model, context);
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/window/service/WindowOwnerService.java
View file @ 9bb74348
...@@ -4,13 +4,13 @@ import com.mortals.framework.common.Rest; ...@@ -4,13 +4,13 @@ import com.mortals.framework.common.Rest;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService; import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.common.pdu.window.WindowPdu; import com.mortals.xhx.common.pdu.window.WindowPdu;
import com.mortals.xhx.module.perform.model.vo.StaffErrorMessageVo;
import com.mortals.xhx.module.staff.model.StaffEntity; import com.mortals.xhx.module.staff.model.StaffEntity;
import com.mortals.xhx.module.window.dao.WindowOwnerDao;
import com.mortals.xhx.module.window.model.WindowOwnerDetailEntity; import com.mortals.xhx.module.window.model.WindowOwnerDetailEntity;
import com.mortals.xhx.module.window.model.WindowOwnerEntity; import com.mortals.xhx.module.window.model.WindowOwnerEntity;
import com.mortals.xhx.module.window.dao.WindowOwnerDao;
import java.util.List; import java.util.List;
import java.util.Map;
/** /**
* WindowOwnerService * WindowOwnerService
...@@ -52,5 +52,5 @@ public interface WindowOwnerService extends ICRUDService<WindowOwnerEntity, Long ...@@ -52,5 +52,5 @@ public interface WindowOwnerService extends ICRUDService<WindowOwnerEntity, Long
* @param id * @param id
* @return * @return
*/ */
List<StaffEntity> getStaffList(Long id); List<StaffErrorMessageVo> getStaffList(Long id);
} }
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/window/service/impl/WindowOwnerServiceImpl.java
View file @ 9bb74348
...@@ -3,40 +3,43 @@ package com.mortals.xhx.module.window.service.impl; ...@@ -3,40 +3,43 @@ package com.mortals.xhx.module.window.service.impl;
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.common.Rest; import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.model.OrderCol; import com.mortals.framework.model.OrderCol;
import com.mortals.framework.model.PageInfo; import com.mortals.framework.model.PageInfo;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.xhx.base.system.user.service.UserService; import com.mortals.xhx.base.system.user.service.UserService;
import com.mortals.xhx.common.code.YesNoEnum; import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.common.pdu.RespData; import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.window.WindowPdu; import com.mortals.xhx.common.pdu.window.WindowPdu;
import com.mortals.xhx.common.pdu.workman.WorkmanPdu; import com.mortals.xhx.common.pdu.workman.WorkmanPdu;
import com.mortals.xhx.common.utils.BeanUtil;
import com.mortals.xhx.feign.window.IWindowFeign; import com.mortals.xhx.feign.window.IWindowFeign;
import com.mortals.xhx.feign.workman.IWorkmanFeign; import com.mortals.xhx.feign.workman.IWorkmanFeign;
import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
import com.mortals.xhx.module.perform.model.PerformErrorMessageQuery;
import com.mortals.xhx.module.perform.model.vo.StaffErrorMessageVo;
import com.mortals.xhx.module.perform.service.PerformErrorMessageService;
import com.mortals.xhx.module.staff.model.StaffEntity; import com.mortals.xhx.module.staff.model.StaffEntity;
import com.mortals.xhx.module.staff.model.StaffQuery; import com.mortals.xhx.module.staff.model.StaffQuery;
import com.mortals.xhx.module.staff.service.StaffService; import com.mortals.xhx.module.staff.service.StaffService;
import com.mortals.xhx.module.window.dao.WindowOwnerDao;
import com.mortals.xhx.module.window.model.*; import com.mortals.xhx.module.window.model.*;
import com.mortals.xhx.module.window.service.WindowOwnerDetailService;
import com.mortals.xhx.module.window.service.WindowOwnerService;
import com.mortals.xhx.module.window.service.WindowPerformService; import com.mortals.xhx.module.window.service.WindowPerformService;
import com.mortals.xhx.module.window.service.WindowWorkmanPerformService; import com.mortals.xhx.module.window.service.WindowWorkmanPerformService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service; import org.springframework.beans.BeanUtils;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.window.dao.WindowOwnerDao;
import com.mortals.xhx.module.window.service.WindowOwnerService;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import com.mortals.xhx.module.window.service.WindowOwnerDetailService; import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*; import java.util.*;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
/** /**
* WindowOwnerService * WindowOwnerService
* 窗口负责人 service实现 * 窗口负责人 service实现
...@@ -63,6 +66,8 @@ public class WindowOwnerServiceImpl extends AbstractCRUDServiceImpl<WindowOwnerD ...@@ -63,6 +66,8 @@ public class WindowOwnerServiceImpl extends AbstractCRUDServiceImpl<WindowOwnerD
private UserService userService; private UserService userService;
@Autowired @Autowired
private IWorkmanFeign workmanFeign; private IWorkmanFeign workmanFeign;
@Autowired
private PerformErrorMessageService performErrorMessageService;
@Override @Override
...@@ -319,18 +324,29 @@ public class WindowOwnerServiceImpl extends AbstractCRUDServiceImpl<WindowOwnerD ...@@ -319,18 +324,29 @@ public class WindowOwnerServiceImpl extends AbstractCRUDServiceImpl<WindowOwnerD
} }
@Override @Override
public List<StaffEntity> getStaffList(Long key) { public List<StaffErrorMessageVo> getStaffList(Long key) {
WindowOwnerEntity entity = this.dao.get(key); WindowOwnerEntity entity = this.dao.get(key);
List<StaffErrorMessageVo> result = new ArrayList<>();
if(entity!=null){ if(entity!=null){
if(StringUtils.isNotEmpty(entity.getStaffIds())){ if(StringUtils.isNotEmpty(entity.getStaffIds())){
List<Long> staffIdList = Arrays.asList(entity.getStaffIds().split(",")).stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList()); List<Long> staffIdList = Arrays.asList(entity.getStaffIds().split(",")).stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());
List<PerformErrorMessageEntity> errorMessageList = performErrorMessageService.find(new PerformErrorMessageQuery().staffIdList(staffIdList));
Map<Long,List<PerformErrorMessageEntity>> msgMap = errorMessageList.stream().collect(Collectors.groupingBy(PerformErrorMessageEntity::getStaffId));
List<StaffEntity> staffEntityList = staffService.find(new StaffQuery().idList(staffIdList)); List<StaffEntity> staffEntityList = staffService.find(new StaffQuery().idList(staffIdList));
return staffEntityList; for(StaffEntity staffEntity:staffEntityList){
StaffErrorMessageVo vo = new StaffErrorMessageVo();
BeanUtils.copyProperties(staffEntity, vo, BeanUtil.getNullPropertyNames(staffEntity));
vo.setStaffId(staffEntity.getId());
vo.setStaffName(staffEntity.getName());
if(msgMap.containsKey(staffEntity.getId())){
vo.setMessageCount(msgMap.get(staffEntity.getId()).size());
}else { }else {
return Collections.emptyList(); vo.setMessageCount(0);
}
result.add(vo);
}
} }
}else {
return Collections.emptyList();
} }
return result;
} }
} }
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/window/web/WindowOwnerController.java
View file @ 9bb74348
...@@ -20,6 +20,7 @@ import com.mortals.xhx.feign.site.ISiteHallFeign; ...@@ -20,6 +20,7 @@ import com.mortals.xhx.feign.site.ISiteHallFeign;
import com.mortals.xhx.feign.window.IWindowFeign; import com.mortals.xhx.feign.window.IWindowFeign;
import com.mortals.xhx.module.dept.model.DeptQuery; import com.mortals.xhx.module.dept.model.DeptQuery;
import com.mortals.xhx.module.dept.service.DeptService; import com.mortals.xhx.module.dept.service.DeptService;
import com.mortals.xhx.module.perform.model.vo.StaffErrorMessageVo;
import com.mortals.xhx.module.staff.model.StaffEntity; import com.mortals.xhx.module.staff.model.StaffEntity;
import com.mortals.xhx.module.window.model.WindowOwnerDetailEntity; import com.mortals.xhx.module.window.model.WindowOwnerDetailEntity;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
...@@ -207,14 +208,14 @@ public class WindowOwnerController extends BaseCRUDJsonBodyMappingController<Win ...@@ -207,14 +208,14 @@ public class WindowOwnerController extends BaseCRUDJsonBodyMappingController<Win
*/ */
@PostMapping(value = "staffList") @PostMapping(value = "staffList")
@UnAuth @UnAuth
public Rest<List<StaffEntity>> staffList(@RequestBody WindowOwnerEntity query){ public Rest<List<StaffErrorMessageVo>> staffList(@RequestBody WindowOwnerEntity query){
Rest<List<StaffEntity>> ret = new Rest(); Rest<List<StaffErrorMessageVo>> ret = new Rest();
String busiDesc = "查询当前负责人负责的人员列表" + this.getModuleDesc(); String busiDesc = "查询当前负责人负责的人员列表" + this.getModuleDesc();
Context context = this.getContext(); Context context = this.getContext();
Map<String, Object> model = new HashMap(); Map<String, Object> model = new HashMap();
int code = 1; int code = 1;
try { try {
List<StaffEntity> result = this.getService().getStaffList(query.getId()); List<StaffErrorMessageVo> result = this.getService().getStaffList(query.getId());
ret.setData(result); ret.setData(result);
model.put("message_info", busiDesc + "成功"); model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】"); this.recordSysLog(this.request, busiDesc + " 【成功】");
......
attendance-performance-manager/src/main/resources/sqlmap/module/perform/PerformErrorMessageMapper.xml 0 → 100644
View file @ 9bb74348
<?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.perform.dao.ibatis.PerformErrorMessageDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="PerformErrorMessageEntity" id="PerformErrorMessageEntity-Map">
<id property="id" column="id" />
<result property="checkRecordId" column="checkRecordId" />
<result property="deptId" column="deptId" />
<result property="deptName" column="deptName" />
<result property="salaId" column="salaId" />
<result property="salaName" column="salaName" />
<result property="staffId" column="staffId" />
<result property="staffName" column="staffName" />
<result property="workNum" column="workNum" />
<result property="errorTime" column="errorTime" />
<result property="ruleId" column="ruleId" />
<result property="ruleName" column="ruleName" />
<result property="subAddType" column="subAddType" />
<result property="score" column="score" />
<result property="readStatus" column="readStatus" />
<result property="checkStatus" column="checkStatus" />
<result property="appealStatus" column="appealStatus" />
<result property="remark" column="remark" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
</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('checkRecordId') or colPickMode == 1 and data.containsKey('checkRecordId')))">
a.checkRecordId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptId') or colPickMode == 1 and data.containsKey('deptId')))">
a.deptId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptName') or colPickMode == 1 and data.containsKey('deptName')))">
a.deptName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('salaId') or colPickMode == 1 and data.containsKey('salaId')))">
a.salaId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('salaName') or colPickMode == 1 and data.containsKey('salaName')))">
a.salaName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('staffId') or colPickMode == 1 and data.containsKey('staffId')))">
a.staffId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('staffName') or colPickMode == 1 and data.containsKey('staffName')))">
a.staffName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('workNum') or colPickMode == 1 and data.containsKey('workNum')))">
a.workNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('errorTime') or colPickMode == 1 and data.containsKey('errorTime')))">
a.errorTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleId') or colPickMode == 1 and data.containsKey('ruleId')))">
a.ruleId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleName') or colPickMode == 1 and data.containsKey('ruleName')))">
a.ruleName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('subAddType') or colPickMode == 1 and data.containsKey('subAddType')))">
a.subAddType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('score') or colPickMode == 1 and data.containsKey('score')))">
a.score,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('readStatus') or colPickMode == 1 and data.containsKey('readStatus')))">
a.readStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('checkStatus') or colPickMode == 1 and data.containsKey('checkStatus')))">
a.checkStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('appealStatus') or colPickMode == 1 and data.containsKey('appealStatus')))">
a.appealStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="PerformErrorMessageEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_perform_error_message
(checkRecordId,deptId,deptName,salaId,salaName,staffId,staffName,workNum,errorTime,ruleId,ruleName,subAddType,score,readStatus,checkStatus,appealStatus,remark,createTime,createUserId,updateUserId,updateTime)
VALUES
(#{checkRecordId},#{deptId},#{deptName},#{salaId},#{salaName},#{staffId},#{staffName},#{workNum},#{errorTime},#{ruleId},#{ruleName},#{subAddType},#{score},#{readStatus},#{checkStatus},#{appealStatus},#{remark},#{createTime},#{createUserId},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_perform_error_message
(checkRecordId,deptId,deptName,salaId,salaName,staffId,staffName,workNum,errorTime,ruleId,ruleName,subAddType,score,readStatus,checkStatus,appealStatus,remark,createTime,createUserId,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.checkRecordId},#{item.deptId},#{item.deptName},#{item.salaId},#{item.salaName},#{item.staffId},#{item.staffName},#{item.workNum},#{item.errorTime},#{item.ruleId},#{item.ruleName},#{item.subAddType},#{item.score},#{item.readStatus},#{item.checkStatus},#{item.appealStatus},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_perform_error_message as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('checkRecordId')) or (colPickMode==1 and !data.containsKey('checkRecordId'))">
a.checkRecordId=#{data.checkRecordId},
</if>
<if test="(colPickMode==0 and data.containsKey('checkRecordIdIncrement')) or (colPickMode==1 and !data.containsKey('checkRecordIdIncrement'))">
a.checkRecordId=ifnull(a.checkRecordId,0) + #{data.checkRecordIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('deptId')) or (colPickMode==1 and !data.containsKey('deptId'))">
a.deptId=#{data.deptId},
</if>
<if test="(colPickMode==0 and data.containsKey('deptIdIncrement')) or (colPickMode==1 and !data.containsKey('deptIdIncrement'))">
a.deptId=ifnull(a.deptId,0) + #{data.deptIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('deptName')) or (colPickMode==1 and !data.containsKey('deptName'))">
a.deptName=#{data.deptName},
</if>
<if test="(colPickMode==0 and data.containsKey('salaId')) or (colPickMode==1 and !data.containsKey('salaId'))">
a.salaId=#{data.salaId},
</if>
<if test="(colPickMode==0 and data.containsKey('salaIdIncrement')) or (colPickMode==1 and !data.containsKey('salaIdIncrement'))">
a.salaId=ifnull(a.salaId,0) + #{data.salaIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('salaName')) or (colPickMode==1 and !data.containsKey('salaName'))">
a.salaName=#{data.salaName},
</if>
<if test="(colPickMode==0 and data.containsKey('staffId')) or (colPickMode==1 and !data.containsKey('staffId'))">
a.staffId=#{data.staffId},
</if>
<if test="(colPickMode==0 and data.containsKey('staffIdIncrement')) or (colPickMode==1 and !data.containsKey('staffIdIncrement'))">
a.staffId=ifnull(a.staffId,0) + #{data.staffIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('staffName')) or (colPickMode==1 and !data.containsKey('staffName'))">
a.staffName=#{data.staffName},
</if>
<if test="(colPickMode==0 and data.containsKey('workNum')) or (colPickMode==1 and !data.containsKey('workNum'))">
a.workNum=#{data.workNum},
</if>
<if test="(colPickMode==0 and data.containsKey('errorTime')) or (colPickMode==1 and !data.containsKey('errorTime'))">
a.errorTime=#{data.errorTime},
</if>
<if test="(colPickMode==0 and data.containsKey('ruleId')) or (colPickMode==1 and !data.containsKey('ruleId'))">
a.ruleId=#{data.ruleId},
</if>
<if test="(colPickMode==0 and data.containsKey('ruleIdIncrement')) or (colPickMode==1 and !data.containsKey('ruleIdIncrement'))">
a.ruleId=ifnull(a.ruleId,0) + #{data.ruleIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('ruleName')) or (colPickMode==1 and !data.containsKey('ruleName'))">
a.ruleName=#{data.ruleName},
</if>
<if test="(colPickMode==0 and data.containsKey('subAddType')) or (colPickMode==1 and !data.containsKey('subAddType'))">
a.subAddType=#{data.subAddType},
</if>
<if test="(colPickMode==0 and data.containsKey('subAddTypeIncrement')) or (colPickMode==1 and !data.containsKey('subAddTypeIncrement'))">
a.subAddType=ifnull(a.subAddType,0) + #{data.subAddTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('score')) or (colPickMode==1 and !data.containsKey('score'))">
a.score=#{data.score},
</if>
<if test="(colPickMode==0 and data.containsKey('scoreIncrement')) or (colPickMode==1 and !data.containsKey('scoreIncrement'))">
a.score=ifnull(a.score,0) + #{data.scoreIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('readStatus')) or (colPickMode==1 and !data.containsKey('readStatus'))">
a.readStatus=#{data.readStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('readStatusIncrement')) or (colPickMode==1 and !data.containsKey('readStatusIncrement'))">
a.readStatus=ifnull(a.readStatus,0) + #{data.readStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('checkStatus')) or (colPickMode==1 and !data.containsKey('checkStatus'))">
a.checkStatus=#{data.checkStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('checkStatusIncrement')) or (colPickMode==1 and !data.containsKey('checkStatusIncrement'))">
a.checkStatus=ifnull(a.checkStatus,0) + #{data.checkStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('appealStatus')) or (colPickMode==1 and !data.containsKey('appealStatus'))">
a.appealStatus=#{data.appealStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('appealStatusIncrement')) or (colPickMode==1 and !data.containsKey('appealStatusIncrement'))">
a.appealStatus=ifnull(a.appealStatus,0) + #{data.appealStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('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_xhx_perform_error_message as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="checkRecordId=(case" suffix="ELSE checkRecordId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('checkRecordId')) or (colPickMode==1 and !item.containsKey('checkRecordId'))">
when a.id=#{item.id} then #{item.checkRecordId}
</when>
<when test="(colPickMode==0 and item.containsKey('checkRecordIdIncrement')) or (colPickMode==1 and !item.containsKey('checkRecordIdIncrement'))">
when a.id=#{item.id} then ifnull(a.checkRecordId,0) + #{item.checkRecordIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deptId=(case" suffix="ELSE deptId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deptId')) or (colPickMode==1 and !item.containsKey('deptId'))">
when a.id=#{item.id} then #{item.deptId}
</when>
<when test="(colPickMode==0 and item.containsKey('deptIdIncrement')) or (colPickMode==1 and !item.containsKey('deptIdIncrement'))">
when a.id=#{item.id} then ifnull(a.deptId,0) + #{item.deptIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deptName=(case" suffix="ELSE deptName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deptName')) or (colPickMode==1 and !item.containsKey('deptName'))">
when a.id=#{item.id} then #{item.deptName}
</if>
</foreach>
</trim>
<trim prefix="salaId=(case" suffix="ELSE salaId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('salaId')) or (colPickMode==1 and !item.containsKey('salaId'))">
when a.id=#{item.id} then #{item.salaId}
</when>
<when test="(colPickMode==0 and item.containsKey('salaIdIncrement')) or (colPickMode==1 and !item.containsKey('salaIdIncrement'))">
when a.id=#{item.id} then ifnull(a.salaId,0) + #{item.salaIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="salaName=(case" suffix="ELSE salaName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('salaName')) or (colPickMode==1 and !item.containsKey('salaName'))">
when a.id=#{item.id} then #{item.salaName}
</if>
</foreach>
</trim>
<trim prefix="staffId=(case" suffix="ELSE staffId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('staffId')) or (colPickMode==1 and !item.containsKey('staffId'))">
when a.id=#{item.id} then #{item.staffId}
</when>
<when test="(colPickMode==0 and item.containsKey('staffIdIncrement')) or (colPickMode==1 and !item.containsKey('staffIdIncrement'))">
when a.id=#{item.id} then ifnull(a.staffId,0) + #{item.staffIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="staffName=(case" suffix="ELSE staffName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('staffName')) or (colPickMode==1 and !item.containsKey('staffName'))">
when a.id=#{item.id} then #{item.staffName}
</if>
</foreach>
</trim>
<trim prefix="workNum=(case" suffix="ELSE workNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('workNum')) or (colPickMode==1 and !item.containsKey('workNum'))">
when a.id=#{item.id} then #{item.workNum}
</if>
</foreach>
</trim>
<trim prefix="errorTime=(case" suffix="ELSE errorTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('errorTime')) or (colPickMode==1 and !item.containsKey('errorTime'))">
when a.id=#{item.id} then #{item.errorTime}
</if>
</foreach>
</trim>
<trim prefix="ruleId=(case" suffix="ELSE ruleId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('ruleId')) or (colPickMode==1 and !item.containsKey('ruleId'))">
when a.id=#{item.id} then #{item.ruleId}
</when>
<when test="(colPickMode==0 and item.containsKey('ruleIdIncrement')) or (colPickMode==1 and !item.containsKey('ruleIdIncrement'))">
when a.id=#{item.id} then ifnull(a.ruleId,0) + #{item.ruleIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="ruleName=(case" suffix="ELSE ruleName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ruleName')) or (colPickMode==1 and !item.containsKey('ruleName'))">
when a.id=#{item.id} then #{item.ruleName}
</if>
</foreach>
</trim>
<trim prefix="subAddType=(case" suffix="ELSE subAddType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('subAddType')) or (colPickMode==1 and !item.containsKey('subAddType'))">
when a.id=#{item.id} then #{item.subAddType}
</when>
<when test="(colPickMode==0 and item.containsKey('subAddTypeIncrement')) or (colPickMode==1 and !item.containsKey('subAddTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.subAddType,0) + #{item.subAddTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="score=(case" suffix="ELSE score end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('score')) or (colPickMode==1 and !item.containsKey('score'))">
when a.id=#{item.id} then #{item.score}
</when>
<when test="(colPickMode==0 and item.containsKey('scoreIncrement')) or (colPickMode==1 and !item.containsKey('scoreIncrement'))">
when a.id=#{item.id} then ifnull(a.score,0) + #{item.scoreIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="readStatus=(case" suffix="ELSE readStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('readStatus')) or (colPickMode==1 and !item.containsKey('readStatus'))">
when a.id=#{item.id} then #{item.readStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('readStatusIncrement')) or (colPickMode==1 and !item.containsKey('readStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.readStatus,0) + #{item.readStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="checkStatus=(case" suffix="ELSE checkStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('checkStatus')) or (colPickMode==1 and !item.containsKey('checkStatus'))">
when a.id=#{item.id} then #{item.checkStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('checkStatusIncrement')) or (colPickMode==1 and !item.containsKey('checkStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.checkStatus,0) + #{item.checkStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="appealStatus=(case" suffix="ELSE appealStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('appealStatus')) or (colPickMode==1 and !item.containsKey('appealStatus'))">
when a.id=#{item.id} then #{item.appealStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('appealStatusIncrement')) or (colPickMode==1 and !item.containsKey('appealStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.appealStatus,0) + #{item.appealStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="PerformErrorMessageEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_perform_error_message as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_perform_error_message as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_perform_error_message where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_perform_error_message where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_perform_error_message 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_xhx_perform_error_message as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="PerformErrorMessageEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_perform_error_message 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_xhx_perform_error_message 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('checkRecordId')">
<if test="conditionParamRef.checkRecordId != null ">
${_conditionType_} a.checkRecordId = #{${_conditionParam_}.checkRecordId}
</if>
<if test="conditionParamRef.checkRecordId == null">
${_conditionType_} a.checkRecordId is null
</if>
</if>
<if test="conditionParamRef.containsKey('checkRecordIdList') and conditionParamRef.checkRecordIdList.size() > 0">
${_conditionType_} a.checkRecordId in
<foreach collection="conditionParamRef.checkRecordIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('checkRecordIdNotList') and conditionParamRef.checkRecordIdNotList.size() > 0">
${_conditionType_} a.checkRecordId not in
<foreach collection="conditionParamRef.checkRecordIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('checkRecordIdStart') and conditionParamRef.checkRecordIdStart != null">
${_conditionType_} a.checkRecordId <![CDATA[ >= ]]> #{${_conditionParam_}.checkRecordIdStart}
</if>
<if test="conditionParamRef.containsKey('checkRecordIdEnd') and conditionParamRef.checkRecordIdEnd != null">
${_conditionType_} a.checkRecordId <![CDATA[ <= ]]> #{${_conditionParam_}.checkRecordIdEnd}
</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('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('salaId')">
<if test="conditionParamRef.salaId != null ">
${_conditionType_} a.salaId = #{${_conditionParam_}.salaId}
</if>
<if test="conditionParamRef.salaId == null">
${_conditionType_} a.salaId is null
</if>
</if>
<if test="conditionParamRef.containsKey('salaIdList') and conditionParamRef.salaIdList.size() > 0">
${_conditionType_} a.salaId in
<foreach collection="conditionParamRef.salaIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('salaIdNotList') and conditionParamRef.salaIdNotList.size() > 0">
${_conditionType_} a.salaId not in
<foreach collection="conditionParamRef.salaIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('salaIdStart') and conditionParamRef.salaIdStart != null">
${_conditionType_} a.salaId <![CDATA[ >= ]]> #{${_conditionParam_}.salaIdStart}
</if>
<if test="conditionParamRef.containsKey('salaIdEnd') and conditionParamRef.salaIdEnd != null">
${_conditionType_} a.salaId <![CDATA[ <= ]]> #{${_conditionParam_}.salaIdEnd}
</if>
<if test="conditionParamRef.containsKey('salaName')">
<if test="conditionParamRef.salaName != null and conditionParamRef.salaName != ''">
${_conditionType_} a.salaName like #{${_conditionParam_}.salaName}
</if>
<if test="conditionParamRef.salaName == null">
${_conditionType_} a.salaName is null
</if>
</if>
<if test="conditionParamRef.containsKey('salaNameList') and conditionParamRef.salaNameList.size() > 0">
${_conditionType_} a.salaName in
<foreach collection="conditionParamRef.salaNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('salaNameNotList') and conditionParamRef.salaNameNotList.size() > 0">
${_conditionType_} a.salaName not in
<foreach collection="conditionParamRef.salaNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('staffId')">
<if test="conditionParamRef.staffId != null ">
${_conditionType_} a.staffId = #{${_conditionParam_}.staffId}
</if>
<if test="conditionParamRef.staffId == null">
${_conditionType_} a.staffId is null
</if>
</if>
<if test="conditionParamRef.containsKey('staffIdList') and conditionParamRef.staffIdList.size() > 0">
${_conditionType_} a.staffId in
<foreach collection="conditionParamRef.staffIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('staffIdNotList') and conditionParamRef.staffIdNotList.size() > 0">
${_conditionType_} a.staffId not in
<foreach collection="conditionParamRef.staffIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('staffIdStart') and conditionParamRef.staffIdStart != null">
${_conditionType_} a.staffId <![CDATA[ >= ]]> #{${_conditionParam_}.staffIdStart}
</if>
<if test="conditionParamRef.containsKey('staffIdEnd') and conditionParamRef.staffIdEnd != null">
${_conditionType_} a.staffId <![CDATA[ <= ]]> #{${_conditionParam_}.staffIdEnd}
</if>
<if test="conditionParamRef.containsKey('staffName')">
<if test="conditionParamRef.staffName != null and conditionParamRef.staffName != ''">
${_conditionType_} a.staffName like #{${_conditionParam_}.staffName}
</if>
<if test="conditionParamRef.staffName == null">
${_conditionType_} a.staffName is null
</if>
</if>
<if test="conditionParamRef.containsKey('staffNameList') and conditionParamRef.staffNameList.size() > 0">
${_conditionType_} a.staffName in
<foreach collection="conditionParamRef.staffNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('staffNameNotList') and conditionParamRef.staffNameNotList.size() > 0">
${_conditionType_} a.staffName not in
<foreach collection="conditionParamRef.staffNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('workNum')">
<if test="conditionParamRef.workNum != null and conditionParamRef.workNum != ''">
${_conditionType_} a.workNum like #{${_conditionParam_}.workNum}
</if>
<if test="conditionParamRef.workNum == null">
${_conditionType_} a.workNum is null
</if>
</if>
<if test="conditionParamRef.containsKey('workNumList') and conditionParamRef.workNumList.size() > 0">
${_conditionType_} a.workNum in
<foreach collection="conditionParamRef.workNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('workNumNotList') and conditionParamRef.workNumNotList.size() > 0">
${_conditionType_} a.workNum not in
<foreach collection="conditionParamRef.workNumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('errorTime')">
<if test="conditionParamRef.errorTime != null ">
${_conditionType_} a.errorTime = #{${_conditionParam_}.errorTime}
</if>
<if test="conditionParamRef.errorTime == null">
${_conditionType_} a.errorTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('errorTimeStart') and conditionParamRef.errorTimeStart != null and conditionParamRef.errorTimeStart!=''">
${_conditionType_} a.errorTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.errorTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('errorTimeEnd') and conditionParamRef.errorTimeEnd != null and conditionParamRef.errorTimeEnd!=''">
${_conditionType_} a.errorTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.errorTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('ruleId')">
<if test="conditionParamRef.ruleId != null ">
${_conditionType_} a.ruleId = #{${_conditionParam_}.ruleId}
</if>
<if test="conditionParamRef.ruleId == null">
${_conditionType_} a.ruleId is null
</if>
</if>
<if test="conditionParamRef.containsKey('ruleIdList') and conditionParamRef.ruleIdList.size() > 0">
${_conditionType_} a.ruleId in
<foreach collection="conditionParamRef.ruleIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ruleIdNotList') and conditionParamRef.ruleIdNotList.size() > 0">
${_conditionType_} a.ruleId not in
<foreach collection="conditionParamRef.ruleIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ruleIdStart') and conditionParamRef.ruleIdStart != null">
${_conditionType_} a.ruleId <![CDATA[ >= ]]> #{${_conditionParam_}.ruleIdStart}
</if>
<if test="conditionParamRef.containsKey('ruleIdEnd') and conditionParamRef.ruleIdEnd != null">
${_conditionType_} a.ruleId <![CDATA[ <= ]]> #{${_conditionParam_}.ruleIdEnd}
</if>
<if test="conditionParamRef.containsKey('ruleName')">
<if test="conditionParamRef.ruleName != null and conditionParamRef.ruleName != ''">
${_conditionType_} a.ruleName like #{${_conditionParam_}.ruleName}
</if>
<if test="conditionParamRef.ruleName == null">
${_conditionType_} a.ruleName is null
</if>
</if>
<if test="conditionParamRef.containsKey('ruleNameList') and conditionParamRef.ruleNameList.size() > 0">
${_conditionType_} a.ruleName in
<foreach collection="conditionParamRef.ruleNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ruleNameNotList') and conditionParamRef.ruleNameNotList.size() > 0">
${_conditionType_} a.ruleName not in
<foreach collection="conditionParamRef.ruleNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('subAddType')">
<if test="conditionParamRef.subAddType != null ">
${_conditionType_} a.subAddType = #{${_conditionParam_}.subAddType}
</if>
<if test="conditionParamRef.subAddType == null">
${_conditionType_} a.subAddType is null
</if>
</if>
<if test="conditionParamRef.containsKey('subAddTypeList') and conditionParamRef.subAddTypeList.size() > 0">
${_conditionType_} a.subAddType in
<foreach collection="conditionParamRef.subAddTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('subAddTypeNotList') and conditionParamRef.subAddTypeNotList.size() > 0">
${_conditionType_} a.subAddType not in
<foreach collection="conditionParamRef.subAddTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('subAddTypeStart') and conditionParamRef.subAddTypeStart != null">
${_conditionType_} a.subAddType <![CDATA[ >= ]]> #{${_conditionParam_}.subAddTypeStart}
</if>
<if test="conditionParamRef.containsKey('subAddTypeEnd') and conditionParamRef.subAddTypeEnd != null">
${_conditionType_} a.subAddType <![CDATA[ <= ]]> #{${_conditionParam_}.subAddTypeEnd}
</if>
<if test="conditionParamRef.containsKey('score')">
<if test="conditionParamRef.score != null ">
${_conditionType_} a.score = #{${_conditionParam_}.score}
</if>
<if test="conditionParamRef.score == null">
${_conditionType_} a.score is null
</if>
</if>
<if test="conditionParamRef.containsKey('scoreList') and conditionParamRef.scoreList.size() > 0">
${_conditionType_} a.score in
<foreach collection="conditionParamRef.scoreList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('scoreNotList') and conditionParamRef.scoreNotList.size() > 0">
${_conditionType_} a.score not in
<foreach collection="conditionParamRef.scoreNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('scoreStart') and conditionParamRef.scoreStart != null">
${_conditionType_} a.score <![CDATA[ >= ]]> #{${_conditionParam_}.scoreStart}
</if>
<if test="conditionParamRef.containsKey('scoreEnd') and conditionParamRef.scoreEnd != null">
${_conditionType_} a.score <![CDATA[ <= ]]> #{${_conditionParam_}.scoreEnd}
</if>
<if test="conditionParamRef.containsKey('readStatus')">
<if test="conditionParamRef.readStatus != null ">
${_conditionType_} a.readStatus = #{${_conditionParam_}.readStatus}
</if>
<if test="conditionParamRef.readStatus == null">
${_conditionType_} a.readStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('readStatusList') and conditionParamRef.readStatusList.size() > 0">
${_conditionType_} a.readStatus in
<foreach collection="conditionParamRef.readStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('readStatusNotList') and conditionParamRef.readStatusNotList.size() > 0">
${_conditionType_} a.readStatus not in
<foreach collection="conditionParamRef.readStatusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('readStatusStart') and conditionParamRef.readStatusStart != null">
${_conditionType_} a.readStatus <![CDATA[ >= ]]> #{${_conditionParam_}.readStatusStart}
</if>
<if test="conditionParamRef.containsKey('readStatusEnd') and conditionParamRef.readStatusEnd != null">
${_conditionType_} a.readStatus <![CDATA[ <= ]]> #{${_conditionParam_}.readStatusEnd}
</if>
<if test="conditionParamRef.containsKey('checkStatus')">
<if test="conditionParamRef.checkStatus != null ">
${_conditionType_} a.checkStatus = #{${_conditionParam_}.checkStatus}
</if>
<if test="conditionParamRef.checkStatus == null">
${_conditionType_} a.checkStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('checkStatusList') and conditionParamRef.checkStatusList.size() > 0">
${_conditionType_} a.checkStatus in
<foreach collection="conditionParamRef.checkStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('checkStatusNotList') and conditionParamRef.checkStatusNotList.size() > 0">
${_conditionType_} a.checkStatus not in
<foreach collection="conditionParamRef.checkStatusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('checkStatusStart') and conditionParamRef.checkStatusStart != null">
${_conditionType_} a.checkStatus <![CDATA[ >= ]]> #{${_conditionParam_}.checkStatusStart}
</if>
<if test="conditionParamRef.containsKey('checkStatusEnd') and conditionParamRef.checkStatusEnd != null">
${_conditionType_} a.checkStatus <![CDATA[ <= ]]> #{${_conditionParam_}.checkStatusEnd}
</if>
<if test="conditionParamRef.containsKey('appealStatus')">
<if test="conditionParamRef.appealStatus != null ">
${_conditionType_} a.appealStatus = #{${_conditionParam_}.appealStatus}
</if>
<if test="conditionParamRef.appealStatus == null">
${_conditionType_} a.appealStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('appealStatusList') and conditionParamRef.appealStatusList.size() > 0">
${_conditionType_} a.appealStatus in
<foreach collection="conditionParamRef.appealStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('appealStatusNotList') and conditionParamRef.appealStatusNotList.size() > 0">
${_conditionType_} a.appealStatus not in
<foreach collection="conditionParamRef.appealStatusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('appealStatusStart') and conditionParamRef.appealStatusStart != null">
${_conditionType_} a.appealStatus <![CDATA[ >= ]]> #{${_conditionParam_}.appealStatusStart}
</if>
<if test="conditionParamRef.containsKey('appealStatusEnd') and conditionParamRef.appealStatusEnd != null">
${_conditionType_} a.appealStatus <![CDATA[ <= ]]> #{${_conditionParam_}.appealStatusEnd}
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<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
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('checkRecordIdList') and conditionParamRef.checkRecordIdList.size() > 0">
field(a.checkRecordId,
<foreach collection="conditionParamRef.checkRecordIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('deptIdList') and conditionParamRef.deptIdList.size() > 0">
field(a.deptId,
<foreach collection="conditionParamRef.deptIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('salaIdList') and conditionParamRef.salaIdList.size() > 0">
field(a.salaId,
<foreach collection="conditionParamRef.salaIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('staffIdList') and conditionParamRef.staffIdList.size() > 0">
field(a.staffId,
<foreach collection="conditionParamRef.staffIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('ruleIdList') and conditionParamRef.ruleIdList.size() > 0">
field(a.ruleId,
<foreach collection="conditionParamRef.ruleIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('subAddTypeList') and conditionParamRef.subAddTypeList.size() > 0">
field(a.subAddType,
<foreach collection="conditionParamRef.subAddTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('scoreList') and conditionParamRef.scoreList.size() > 0">
field(a.score,
<foreach collection="conditionParamRef.scoreList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('readStatusList') and conditionParamRef.readStatusList.size() > 0">
field(a.readStatus,
<foreach collection="conditionParamRef.readStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('checkStatusList') and conditionParamRef.checkStatusList.size() > 0">
field(a.checkStatus,
<foreach collection="conditionParamRef.checkStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('appealStatusList') and conditionParamRef.appealStatusList.size() > 0">
field(a.appealStatus,
<foreach collection="conditionParamRef.appealStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('checkRecordIdList') and conditionParamRef.checkRecordIdList.size() > 0">
field(a.checkRecordId,
<foreach collection="conditionParamRef.checkRecordIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('deptIdList') and conditionParamRef.deptIdList.size() > 0">
field(a.deptId,
<foreach collection="conditionParamRef.deptIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('salaIdList') and conditionParamRef.salaIdList.size() > 0">
field(a.salaId,
<foreach collection="conditionParamRef.salaIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('staffIdList') and conditionParamRef.staffIdList.size() > 0">
field(a.staffId,
<foreach collection="conditionParamRef.staffIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('ruleIdList') and conditionParamRef.ruleIdList.size() > 0">
field(a.ruleId,
<foreach collection="conditionParamRef.ruleIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('subAddTypeList') and conditionParamRef.subAddTypeList.size() > 0">
field(a.subAddType,
<foreach collection="conditionParamRef.subAddTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('scoreList') and conditionParamRef.scoreList.size() > 0">
field(a.score,
<foreach collection="conditionParamRef.scoreList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('readStatusList') and conditionParamRef.readStatusList.size() > 0">
field(a.readStatus,
<foreach collection="conditionParamRef.readStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('checkStatusList') and conditionParamRef.checkStatusList.size() > 0">
field(a.checkStatus,
<foreach collection="conditionParamRef.checkStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('appealStatusList') and conditionParamRef.appealStatusList.size() > 0">
field(a.appealStatus,
<foreach collection="conditionParamRef.appealStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('checkRecordId')">
a.checkRecordId
<if test='orderCol.checkRecordId != null and "DESC".equalsIgnoreCase(orderCol.checkRecordId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deptId')">
a.deptId
<if test='orderCol.deptId != null and "DESC".equalsIgnoreCase(orderCol.deptId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deptName')">
a.deptName
<if test='orderCol.deptName != null and "DESC".equalsIgnoreCase(orderCol.deptName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('salaId')">
a.salaId
<if test='orderCol.salaId != null and "DESC".equalsIgnoreCase(orderCol.salaId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('salaName')">
a.salaName
<if test='orderCol.salaName != null and "DESC".equalsIgnoreCase(orderCol.salaName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('staffId')">
a.staffId
<if test='orderCol.staffId != null and "DESC".equalsIgnoreCase(orderCol.staffId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('staffName')">
a.staffName
<if test='orderCol.staffName != null and "DESC".equalsIgnoreCase(orderCol.staffName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('workNum')">
a.workNum
<if test='orderCol.workNum != null and "DESC".equalsIgnoreCase(orderCol.workNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('errorTime')">
a.errorTime
<if test='orderCol.errorTime != null and "DESC".equalsIgnoreCase(orderCol.errorTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ruleId')">
a.ruleId
<if test='orderCol.ruleId != null and "DESC".equalsIgnoreCase(orderCol.ruleId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ruleName')">
a.ruleName
<if test='orderCol.ruleName != null and "DESC".equalsIgnoreCase(orderCol.ruleName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('subAddType')">
a.subAddType
<if test='orderCol.subAddType != null and "DESC".equalsIgnoreCase(orderCol.subAddType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('score')">
a.score
<if test='orderCol.score != null and "DESC".equalsIgnoreCase(orderCol.score)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('readStatus')">
a.readStatus
<if test='orderCol.readStatus != null and "DESC".equalsIgnoreCase(orderCol.readStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('checkStatus')">
a.checkStatus
<if test='orderCol.checkStatus != null and "DESC".equalsIgnoreCase(orderCol.checkStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('appealStatus')">
a.appealStatus
<if test='orderCol.appealStatus != null and "DESC".equalsIgnoreCase(orderCol.appealStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</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
db/add.sql
View file @ 9bb74348
...@@ -1285,3 +1285,35 @@ PRIMARY KEY (`id`) ...@@ -1285,3 +1285,35 @@ PRIMARY KEY (`id`)
ALTER TABLE `mortals_xhx_window_owner` ADD COLUMN `roleType` tinyint(2) COMMENT '角色类型（首席代表，运维，审核，其他）' AFTER `remark`, ALTER TABLE `mortals_xhx_window_owner` ADD COLUMN `roleType` tinyint(2) COMMENT '角色类型（首席代表，运维，审核，其他）' AFTER `remark`,
ADD COLUMN `inspect` tinyint(2) DEFAULT '0' COMMENT '是否允许巡检' AFTER `roleType`, ADD COLUMN `inspect` tinyint(2) DEFAULT '0' COMMENT '是否允许巡检' AFTER `roleType`,
ADD COLUMN `staffIds` varchar(255) COMMENT '管辖人员' AFTER `inspect`; ADD COLUMN `staffIds` varchar(255) COMMENT '管辖人员' AFTER `inspect`;
-- ----------------------------
2024-04-28
-- ----------------------------
-- ----------------------------
-- 绩效异常信息表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_perform_error_message`;
CREATE TABLE mortals_xhx_perform_error_message(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号，主键，自增长',
`checkRecordId` bigint(20) COMMENT '核查记录Id',
`deptId` bigint(20) DEFAULT '0' COMMENT '部门id号',
`deptName` varchar(64) COMMENT '部门名称',
`salaId` bigint(20) COMMENT '所属大厅',
`salaName` varchar(128) COMMENT '所属大厅名称',
`staffId` bigint(20) COMMENT '绩效责任人id',
`staffName` varchar(64) COMMENT '绩效负责人名称',
`workNum` varchar(64) COMMENT '工号',
`errorTime` datetime COMMENT '异常时间',
`ruleId` bigint(20) COMMENT '绩效规则id',
`ruleName` varchar(128) COMMENT '规则名称',
`subAddType` tinyint(1) DEFAULT '1' COMMENT '增减类型(1.增加,2.扣除)',
`score` decimal(10,2) DEFAULT '0.00' COMMENT '扣分或增加分值',
`readStatus` tinyint(1) DEFAULT '0' COMMENT '阅读状态0未读1已读',
`checkStatus` tinyint(1) DEFAULT '0' COMMENT '核查处理状态1.未处理,2.已处理',
`appealStatus` tinyint(1) DEFAULT '0' COMMENT '申诉状态(0.未申诉,1.申诉中,2.申诉拒绝,3.申诉通过)',
`remark` varchar(255) COMMENT '备注',
`createTime` datetime COMMENT '创建时间',
`createUserId` bigint(20) COMMENT '创建用户',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '修改时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='绩效异常信息';
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