Skip to content

A
attendance-performance-platform
Commit 61ab114c authored by 赵啸非's avatar 赵啸非
Browse files
Options

规则添加编码字段

parent e9f02046
Hide whitespace changes
Inline Side-by-side
Showing with 1444 additions and 1339 deletions
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/PerformRulesEntity.java
View file @ 61ab114c
...@@ -8,58 +8,62 @@ import com.mortals.framework.model.BaseEntityLong; ...@@ -8,58 +8,62 @@ import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.perform.model.vo.PerformRulesVo; import com.mortals.xhx.module.perform.model.vo.PerformRulesVo;
import lombok.Data; import lombok.Data;
/** /**
* 绩效规则信息实体对象 * 绩效规则信息实体对象
* *
* @author zxfei * @author zxfei
* @date 2023-05-16 * @date 2023-07-10
*/ */
@Data @Data
public class PerformRulesEntity extends PerformRulesVo { public class PerformRulesEntity extends PerformRulesVo {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 分类id * 分类id
*/ */
private Long categoryId; private Long categoryId;
/** /**
* 分类名称 * 分类名称
*/ */
private String categoryName; private String categoryName;
/** /**
* 考核内容简称 * 考核内容简称
*/ */
private String name; private String name;
/** /**
* 评分标准 * 评分标准
*/ */
private String content; private String content;
/** /**
* 增减类型(1.增加,2.扣除) * 增减类型(1.增加,2.扣除)
*/ */
private Integer subAddType; private Integer subAddType;
/** /**
* 扣分或增加分值 * 扣分或增加分值
*/ */
private BigDecimal score; private BigDecimal score;
/** /**
* 是否关联负责人(0.否,1.是) * 是否关联负责人(0.否,1.是)
*/ */
private Integer assoOwner; private Integer assoOwner;
/** /**
* 负责人扣分或增加分值 * 负责人扣分或增加分值
*/ */
private BigDecimal ownerScore; private BigDecimal ownerScore;
/** /**
* 备注 * 备注
*/ */
private String remark; private String remark;
/** /**
* 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
*/ */
private Integer type; private Integer type;
/**
* 规则编码，唯一,默认规则类型内容简称拼音首字母。
*/
private String ruleCode;
@Override @Override
public int hashCode() { public int hashCode() {
return this.getId().hashCode(); return this.getId().hashCode();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
...@@ -67,7 +71,7 @@ public class PerformRulesEntity extends PerformRulesVo { ...@@ -67,7 +71,7 @@ public class PerformRulesEntity extends PerformRulesVo {
if (obj instanceof PerformRulesEntity) { if (obj instanceof PerformRulesEntity) {
PerformRulesEntity tmp = (PerformRulesEntity) obj; PerformRulesEntity tmp = (PerformRulesEntity) obj;
if (this.getId() == tmp.getId()) { if (this.getId() == tmp.getId()) {
return true; return true;
} }
} }
return false; return false;
...@@ -75,24 +79,26 @@ public class PerformRulesEntity extends PerformRulesVo { ...@@ -75,24 +79,26 @@ public class PerformRulesEntity extends PerformRulesVo {
public void initAttrValue(){ public void initAttrValue(){
this.categoryId = null; this.categoryId = -1L;
this.categoryName = "";
this.categoryName = ""; this.name = "";
this.name = ""; this.content = "";
this.content = ""; this.subAddType = 1;
this.subAddType = 1; this.score = BigDecimal.valueOf(0.00);
this.score = BigDecimal.valueOf(0.00); this.assoOwner = 0;
this.assoOwner = 0; this.ownerScore = BigDecimal.valueOf(0.00);
this.ownerScore = BigDecimal.valueOf(0.00); this.remark = "";
this.remark = ""; this.type = 1;
this.type = null; this.ruleCode = "";
} }
} }
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/PerformRulesQuery.java
View file @ 61ab114c
...@@ -4,11 +4,11 @@ import java.math.BigDecimal; ...@@ -4,11 +4,11 @@ import java.math.BigDecimal;
import java.util.List; import java.util.List;
import com.mortals.xhx.module.perform.model.PerformRulesEntity; import com.mortals.xhx.module.perform.model.PerformRulesEntity;
/** /**
* 绩效规则信息查询对象 * 绩效规则信息查询对象
* *
* @author zxfei * @author zxfei
* @date 2023-05-16 * @date 2023-07-10
*/ */
public class PerformRulesQuery extends PerformRulesEntity { public class PerformRulesQuery extends PerformRulesEntity {
/** 开始 序号，主键，自增长 */ /** 开始 序号，主键，自增长 */
private Long idStart; private Long idStart;
...@@ -177,6 +177,11 @@ public class PerformRulesQuery extends PerformRulesEntity { ...@@ -177,6 +177,11 @@ public class PerformRulesQuery extends PerformRulesEntity {
/** 结束 更新时间 */ /** 结束 更新时间 */
private String updateTimeEnd; private String updateTimeEnd;
/** 规则编码，唯一,默认规则类型内容简称拼音首字母。 */
private List<String> ruleCodeList;
/** 规则编码，唯一,默认规则类型内容简称拼音首字母。排除列表 */
private List <String> ruleCodeNotList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */ /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<PerformRulesQuery> orConditionList; private List<PerformRulesQuery> orConditionList;
...@@ -186,1518 +191,1569 @@ public class PerformRulesQuery extends PerformRulesEntity { ...@@ -186,1518 +191,1569 @@ public class PerformRulesQuery extends PerformRulesEntity {
public PerformRulesQuery(){} public PerformRulesQuery(){}
/** /**
* 获取 开始 序号，主键，自增长 * 获取 开始 序号，主键，自增长
* @return idStart * @return idStart
*/ */
public Long getIdStart(){ public Long getIdStart(){
return this.idStart; return this.idStart;
} }
/** /**
* 设置 开始 序号，主键，自增长 * 设置 开始 序号，主键，自增长
* @param idStart * @param idStart
*/ */
public void setIdStart(Long idStart){ public void setIdStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
} }
/** /**
* 获取 结束 序号，主键，自增长 * 获取 结束 序号，主键，自增长
* @return $idEnd * @return $idEnd
*/ */
public Long getIdEnd(){ public Long getIdEnd(){
return this.idEnd; return this.idEnd;
} }
/** /**
* 设置 结束 序号，主键，自增长 * 设置 结束 序号，主键，自增长
* @param idEnd * @param idEnd
*/ */
public void setIdEnd(Long idEnd){ public void setIdEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
} }
/** /**
* 获取 增加 序号，主键，自增长 * 获取 增加 序号，主键，自增长
* @return idIncrement * @return idIncrement
*/ */
public Long getIdIncrement(){ public Long getIdIncrement(){
return this.idIncrement; return this.idIncrement;
} }
/** /**
* 设置 增加 序号，主键，自增长 * 设置 增加 序号，主键，自增长
* @param idIncrement * @param idIncrement
*/ */
public void setIdIncrement(Long idIncrement){ public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
} }
/** /**
* 获取 序号，主键，自增长 * 获取 序号，主键，自增长
* @return idList * @return idList
*/ */
public List<Long> getIdList(){ public List<Long> getIdList(){
return this.idList; return this.idList;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idList * @param idList
*/ */
public void setIdList(List<Long> idList){ public void setIdList(List<Long> idList){
this.idList = idList; this.idList = idList;
} }
/** /**
* 获取 序号，主键，自增长 * 获取 序号，主键，自增长
* @return idNotList * @return idNotList
*/ */
public List<Long> getIdNotList(){ public List<Long> getIdNotList(){
return this.idNotList; return this.idNotList;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idNotList * @param idNotList
*/ */
public void setIdNotList(List<Long> idNotList){ public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList; this.idNotList = idNotList;
} }
/** /**
* 获取 开始 分类id * 获取 开始 分类id
* @return categoryIdStart * @return categoryIdStart
*/ */
public Long getCategoryIdStart(){ public Long getCategoryIdStart(){
return this.categoryIdStart; return this.categoryIdStart;
} }
/** /**
* 设置 开始 分类id * 设置 开始 分类id
* @param categoryIdStart * @param categoryIdStart
*/ */
public void setCategoryIdStart(Long categoryIdStart){ public void setCategoryIdStart(Long categoryIdStart){
this.categoryIdStart = categoryIdStart; this.categoryIdStart = categoryIdStart;
} }
/** /**
* 获取 结束 分类id * 获取 结束 分类id
* @return $categoryIdEnd * @return $categoryIdEnd
*/ */
public Long getCategoryIdEnd(){ public Long getCategoryIdEnd(){
return this.categoryIdEnd; return this.categoryIdEnd;
} }
/** /**
* 设置 结束 分类id * 设置 结束 分类id
* @param categoryIdEnd * @param categoryIdEnd
*/ */
public void setCategoryIdEnd(Long categoryIdEnd){ public void setCategoryIdEnd(Long categoryIdEnd){
this.categoryIdEnd = categoryIdEnd; this.categoryIdEnd = categoryIdEnd;
} }
/** /**
* 获取 增加 分类id * 获取 增加 分类id
* @return categoryIdIncrement * @return categoryIdIncrement
*/ */
public Long getCategoryIdIncrement(){ public Long getCategoryIdIncrement(){
return this.categoryIdIncrement; return this.categoryIdIncrement;
} }
/** /**
* 设置 增加 分类id * 设置 增加 分类id
* @param categoryIdIncrement * @param categoryIdIncrement
*/ */
public void setCategoryIdIncrement(Long categoryIdIncrement){ public void setCategoryIdIncrement(Long categoryIdIncrement){
this.categoryIdIncrement = categoryIdIncrement; this.categoryIdIncrement = categoryIdIncrement;
} }
/** /**
* 获取 分类id * 获取 分类id
* @return categoryIdList * @return categoryIdList
*/ */
public List<Long> getCategoryIdList(){ public List<Long> getCategoryIdList(){
return this.categoryIdList; return this.categoryIdList;
} }
/** /**
* 设置 分类id * 设置 分类id
* @param categoryIdList * @param categoryIdList
*/ */
public void setCategoryIdList(List<Long> categoryIdList){ public void setCategoryIdList(List<Long> categoryIdList){
this.categoryIdList = categoryIdList; this.categoryIdList = categoryIdList;
} }
/** /**
* 获取 分类id * 获取 分类id
* @return categoryIdNotList * @return categoryIdNotList
*/ */
public List<Long> getCategoryIdNotList(){ public List<Long> getCategoryIdNotList(){
return this.categoryIdNotList; return this.categoryIdNotList;
} }
/** /**
* 设置 分类id * 设置 分类id
* @param categoryIdNotList * @param categoryIdNotList
*/ */
public void setCategoryIdNotList(List<Long> categoryIdNotList){ public void setCategoryIdNotList(List<Long> categoryIdNotList){
this.categoryIdNotList = categoryIdNotList; this.categoryIdNotList = categoryIdNotList;
} }
/** /**
* 获取 分类名称 * 获取 分类名称
* @return categoryNameList * @return categoryNameList
*/ */
public List<String> getCategoryNameList(){ public List<String> getCategoryNameList(){
return this.categoryNameList; return this.categoryNameList;
} }
/** /**
* 设置 分类名称 * 设置 分类名称
* @param categoryNameList * @param categoryNameList
*/ */
public void setCategoryNameList(List<String> categoryNameList){ public void setCategoryNameList(List<String> categoryNameList){
this.categoryNameList = categoryNameList; this.categoryNameList = categoryNameList;
} }
/** /**
* 获取 分类名称 * 获取 分类名称
* @return categoryNameNotList * @return categoryNameNotList
*/ */
public List<String> getCategoryNameNotList(){ public List<String> getCategoryNameNotList(){
return this.categoryNameNotList; return this.categoryNameNotList;
} }
/** /**
* 设置 分类名称 * 设置 分类名称
* @param categoryNameNotList * @param categoryNameNotList
*/ */
public void setCategoryNameNotList(List<String> categoryNameNotList){ public void setCategoryNameNotList(List<String> categoryNameNotList){
this.categoryNameNotList = categoryNameNotList; this.categoryNameNotList = categoryNameNotList;
} }
/** /**
* 获取 考核内容简称 * 获取 考核内容简称
* @return nameList * @return nameList
*/ */
public List<String> getNameList(){ public List<String> getNameList(){
return this.nameList; return this.nameList;
} }
/** /**
* 设置 考核内容简称 * 设置 考核内容简称
* @param nameList * @param nameList
*/ */
public void setNameList(List<String> nameList){ public void setNameList(List<String> nameList){
this.nameList = nameList; this.nameList = nameList;
} }
/** /**
* 获取 考核内容简称 * 获取 考核内容简称
* @return nameNotList * @return nameNotList
*/ */
public List<String> getNameNotList(){ public List<String> getNameNotList(){
return this.nameNotList; return this.nameNotList;
} }
/** /**
* 设置 考核内容简称 * 设置 考核内容简称
* @param nameNotList * @param nameNotList
*/ */
public void setNameNotList(List<String> nameNotList){ public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList; this.nameNotList = nameNotList;
} }
/** /**
* 获取 评分标准 * 获取 评分标准
* @return contentList * @return contentList
*/ */
public List<String> getContentList(){ public List<String> getContentList(){
return this.contentList; return this.contentList;
} }
/** /**
* 设置 评分标准 * 设置 评分标准
* @param contentList * @param contentList
*/ */
public void setContentList(List<String> contentList){ public void setContentList(List<String> contentList){
this.contentList = contentList; this.contentList = contentList;
} }
/** /**
* 获取 评分标准 * 获取 评分标准
* @return contentNotList * @return contentNotList
*/ */
public List<String> getContentNotList(){ public List<String> getContentNotList(){
return this.contentNotList; return this.contentNotList;
} }
/** /**
* 设置 评分标准 * 设置 评分标准
* @param contentNotList * @param contentNotList
*/ */
public void setContentNotList(List<String> contentNotList){ public void setContentNotList(List<String> contentNotList){
this.contentNotList = contentNotList; this.contentNotList = contentNotList;
} }
/** /**
* 获取 开始 增减类型(1.增加,2.扣除) * 获取 开始 增减类型(1.增加,2.扣除)
* @return subAddTypeStart * @return subAddTypeStart
*/ */
public Integer getSubAddTypeStart(){ public Integer getSubAddTypeStart(){
return this.subAddTypeStart; return this.subAddTypeStart;
} }
/** /**
* 设置 开始 增减类型(1.增加,2.扣除) * 设置 开始 增减类型(1.增加,2.扣除)
* @param subAddTypeStart * @param subAddTypeStart
*/ */
public void setSubAddTypeStart(Integer subAddTypeStart){ public void setSubAddTypeStart(Integer subAddTypeStart){
this.subAddTypeStart = subAddTypeStart; this.subAddTypeStart = subAddTypeStart;
} }
/** /**
* 获取 结束 增减类型(1.增加,2.扣除) * 获取 结束 增减类型(1.增加,2.扣除)
* @return $subAddTypeEnd * @return $subAddTypeEnd
*/ */
public Integer getSubAddTypeEnd(){ public Integer getSubAddTypeEnd(){
return this.subAddTypeEnd; return this.subAddTypeEnd;
} }
/** /**
* 设置 结束 增减类型(1.增加,2.扣除) * 设置 结束 增减类型(1.增加,2.扣除)
* @param subAddTypeEnd * @param subAddTypeEnd
*/ */
public void setSubAddTypeEnd(Integer subAddTypeEnd){ public void setSubAddTypeEnd(Integer subAddTypeEnd){
this.subAddTypeEnd = subAddTypeEnd; this.subAddTypeEnd = subAddTypeEnd;
} }
/** /**
* 获取 增加 增减类型(1.增加,2.扣除) * 获取 增加 增减类型(1.增加,2.扣除)
* @return subAddTypeIncrement * @return subAddTypeIncrement
*/ */
public Integer getSubAddTypeIncrement(){ public Integer getSubAddTypeIncrement(){
return this.subAddTypeIncrement; return this.subAddTypeIncrement;
} }
/** /**
* 设置 增加 增减类型(1.增加,2.扣除) * 设置 增加 增减类型(1.增加,2.扣除)
* @param subAddTypeIncrement * @param subAddTypeIncrement
*/ */
public void setSubAddTypeIncrement(Integer subAddTypeIncrement){ public void setSubAddTypeIncrement(Integer subAddTypeIncrement){
this.subAddTypeIncrement = subAddTypeIncrement; this.subAddTypeIncrement = subAddTypeIncrement;
} }
/** /**
* 获取 增减类型(1.增加,2.扣除) * 获取 增减类型(1.增加,2.扣除)
* @return subAddTypeList * @return subAddTypeList
*/ */
public List<Integer> getSubAddTypeList(){ public List<Integer> getSubAddTypeList(){
return this.subAddTypeList; return this.subAddTypeList;
} }
/** /**
* 设置 增减类型(1.增加,2.扣除) * 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeList * @param subAddTypeList
*/ */
public void setSubAddTypeList(List<Integer> subAddTypeList){ public void setSubAddTypeList(List<Integer> subAddTypeList){
this.subAddTypeList = subAddTypeList; this.subAddTypeList = subAddTypeList;
} }
/** /**
* 获取 增减类型(1.增加,2.扣除) * 获取 增减类型(1.增加,2.扣除)
* @return subAddTypeNotList * @return subAddTypeNotList
*/ */
public List<Integer> getSubAddTypeNotList(){ public List<Integer> getSubAddTypeNotList(){
return this.subAddTypeNotList; return this.subAddTypeNotList;
} }
/** /**
* 设置 增减类型(1.增加,2.扣除) * 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeNotList * @param subAddTypeNotList
*/ */
public void setSubAddTypeNotList(List<Integer> subAddTypeNotList){ public void setSubAddTypeNotList(List<Integer> subAddTypeNotList){
this.subAddTypeNotList = subAddTypeNotList; this.subAddTypeNotList = subAddTypeNotList;
} }
/** /**
* 获取 开始 扣分或增加分值 * 获取 开始 扣分或增加分值
* @return scoreStart * @return scoreStart
*/ */
public BigDecimal getScoreStart(){ public BigDecimal getScoreStart(){
return this.scoreStart; return this.scoreStart;
} }
/** /**
* 设置 开始 扣分或增加分值 * 设置 开始 扣分或增加分值
* @param scoreStart * @param scoreStart
*/ */
public void setScoreStart(BigDecimal scoreStart){ public void setScoreStart(BigDecimal scoreStart){
this.scoreStart = scoreStart; this.scoreStart = scoreStart;
} }
/** /**
* 获取 结束 扣分或增加分值 * 获取 结束 扣分或增加分值
* @return $scoreEnd * @return $scoreEnd
*/ */
public BigDecimal getScoreEnd(){ public BigDecimal getScoreEnd(){
return this.scoreEnd; return this.scoreEnd;
} }
/** /**
* 设置 结束 扣分或增加分值 * 设置 结束 扣分或增加分值
* @param scoreEnd * @param scoreEnd
*/ */
public void setScoreEnd(BigDecimal scoreEnd){ public void setScoreEnd(BigDecimal scoreEnd){
this.scoreEnd = scoreEnd; this.scoreEnd = scoreEnd;
} }
/** /**
* 获取 增加 扣分或增加分值 * 获取 增加 扣分或增加分值
* @return scoreIncrement * @return scoreIncrement
*/ */
public BigDecimal getScoreIncrement(){ public BigDecimal getScoreIncrement(){
return this.scoreIncrement; return this.scoreIncrement;
} }
/** /**
* 设置 增加 扣分或增加分值 * 设置 增加 扣分或增加分值
* @param scoreIncrement * @param scoreIncrement
*/ */
public void setScoreIncrement(BigDecimal scoreIncrement){ public void setScoreIncrement(BigDecimal scoreIncrement){
this.scoreIncrement = scoreIncrement; this.scoreIncrement = scoreIncrement;
} }
/** /**
* 获取 扣分或增加分值 * 获取 扣分或增加分值
* @return scoreList * @return scoreList
*/ */
public List<BigDecimal> getScoreList(){ public List<BigDecimal> getScoreList(){
return this.scoreList; return this.scoreList;
} }
/** /**
* 设置 扣分或增加分值 * 设置 扣分或增加分值
* @param scoreList * @param scoreList
*/ */
public void setScoreList(List<BigDecimal> scoreList){ public void setScoreList(List<BigDecimal> scoreList){
this.scoreList = scoreList; this.scoreList = scoreList;
} }
/** /**
* 获取 扣分或增加分值 * 获取 扣分或增加分值
* @return scoreNotList * @return scoreNotList
*/ */
public List<BigDecimal> getScoreNotList(){ public List<BigDecimal> getScoreNotList(){
return this.scoreNotList; return this.scoreNotList;
} }
/** /**
* 设置 扣分或增加分值 * 设置 扣分或增加分值
* @param scoreNotList * @param scoreNotList
*/ */
public void setScoreNotList(List<BigDecimal> scoreNotList){ public void setScoreNotList(List<BigDecimal> scoreNotList){
this.scoreNotList = scoreNotList; this.scoreNotList = scoreNotList;
} }
/** /**
* 获取 开始 是否关联负责人(0.否,1.是) * 获取 开始 是否关联负责人(0.否,1.是)
* @return assoOwnerStart * @return assoOwnerStart
*/ */
public Integer getAssoOwnerStart(){ public Integer getAssoOwnerStart(){
return this.assoOwnerStart; return this.assoOwnerStart;
} }
/** /**
* 设置 开始 是否关联负责人(0.否,1.是) * 设置 开始 是否关联负责人(0.否,1.是)
* @param assoOwnerStart * @param assoOwnerStart
*/ */
public void setAssoOwnerStart(Integer assoOwnerStart){ public void setAssoOwnerStart(Integer assoOwnerStart){
this.assoOwnerStart = assoOwnerStart; this.assoOwnerStart = assoOwnerStart;
} }
/** /**
* 获取 结束 是否关联负责人(0.否,1.是) * 获取 结束 是否关联负责人(0.否,1.是)
* @return $assoOwnerEnd * @return $assoOwnerEnd
*/ */
public Integer getAssoOwnerEnd(){ public Integer getAssoOwnerEnd(){
return this.assoOwnerEnd; return this.assoOwnerEnd;
} }
/** /**
* 设置 结束 是否关联负责人(0.否,1.是) * 设置 结束 是否关联负责人(0.否,1.是)
* @param assoOwnerEnd * @param assoOwnerEnd
*/ */
public void setAssoOwnerEnd(Integer assoOwnerEnd){ public void setAssoOwnerEnd(Integer assoOwnerEnd){
this.assoOwnerEnd = assoOwnerEnd; this.assoOwnerEnd = assoOwnerEnd;
} }
/** /**
* 获取 增加 是否关联负责人(0.否,1.是) * 获取 增加 是否关联负责人(0.否,1.是)
* @return assoOwnerIncrement * @return assoOwnerIncrement
*/ */
public Integer getAssoOwnerIncrement(){ public Integer getAssoOwnerIncrement(){
return this.assoOwnerIncrement; return this.assoOwnerIncrement;
} }
/** /**
* 设置 增加 是否关联负责人(0.否,1.是) * 设置 增加 是否关联负责人(0.否,1.是)
* @param assoOwnerIncrement * @param assoOwnerIncrement
*/ */
public void setAssoOwnerIncrement(Integer assoOwnerIncrement){ public void setAssoOwnerIncrement(Integer assoOwnerIncrement){
this.assoOwnerIncrement = assoOwnerIncrement; this.assoOwnerIncrement = assoOwnerIncrement;
} }
/** /**
* 获取 是否关联负责人(0.否,1.是) * 获取 是否关联负责人(0.否,1.是)
* @return assoOwnerList * @return assoOwnerList
*/ */
public List<Integer> getAssoOwnerList(){ public List<Integer> getAssoOwnerList(){
return this.assoOwnerList; return this.assoOwnerList;
} }
/** /**
* 设置 是否关联负责人(0.否,1.是) * 设置 是否关联负责人(0.否,1.是)
* @param assoOwnerList * @param assoOwnerList
*/ */
public void setAssoOwnerList(List<Integer> assoOwnerList){ public void setAssoOwnerList(List<Integer> assoOwnerList){
this.assoOwnerList = assoOwnerList; this.assoOwnerList = assoOwnerList;
} }
/** /**
* 获取 是否关联负责人(0.否,1.是) * 获取 是否关联负责人(0.否,1.是)
* @return assoOwnerNotList * @return assoOwnerNotList
*/ */
public List<Integer> getAssoOwnerNotList(){ public List<Integer> getAssoOwnerNotList(){
return this.assoOwnerNotList; return this.assoOwnerNotList;
} }
/** /**
* 设置 是否关联负责人(0.否,1.是) * 设置 是否关联负责人(0.否,1.是)
* @param assoOwnerNotList * @param assoOwnerNotList
*/ */
public void setAssoOwnerNotList(List<Integer> assoOwnerNotList){ public void setAssoOwnerNotList(List<Integer> assoOwnerNotList){
this.assoOwnerNotList = assoOwnerNotList; this.assoOwnerNotList = assoOwnerNotList;
} }
/** /**
* 获取 开始 负责人扣分或增加分值 * 获取 开始 负责人扣分或增加分值
* @return ownerScoreStart * @return ownerScoreStart
*/ */
public BigDecimal getOwnerScoreStart(){ public BigDecimal getOwnerScoreStart(){
return this.ownerScoreStart; return this.ownerScoreStart;
} }
/** /**
* 设置 开始 负责人扣分或增加分值 * 设置 开始 负责人扣分或增加分值
* @param ownerScoreStart * @param ownerScoreStart
*/ */
public void setOwnerScoreStart(BigDecimal ownerScoreStart){ public void setOwnerScoreStart(BigDecimal ownerScoreStart){
this.ownerScoreStart = ownerScoreStart; this.ownerScoreStart = ownerScoreStart;
} }
/** /**
* 获取 结束 负责人扣分或增加分值 * 获取 结束 负责人扣分或增加分值
* @return $ownerScoreEnd * @return $ownerScoreEnd
*/ */
public BigDecimal getOwnerScoreEnd(){ public BigDecimal getOwnerScoreEnd(){
return this.ownerScoreEnd; return this.ownerScoreEnd;
} }
/** /**
* 设置 结束 负责人扣分或增加分值 * 设置 结束 负责人扣分或增加分值
* @param ownerScoreEnd * @param ownerScoreEnd
*/ */
public void setOwnerScoreEnd(BigDecimal ownerScoreEnd){ public void setOwnerScoreEnd(BigDecimal ownerScoreEnd){
this.ownerScoreEnd = ownerScoreEnd; this.ownerScoreEnd = ownerScoreEnd;
} }
/** /**
* 获取 增加 负责人扣分或增加分值 * 获取 增加 负责人扣分或增加分值
* @return ownerScoreIncrement * @return ownerScoreIncrement
*/ */
public BigDecimal getOwnerScoreIncrement(){ public BigDecimal getOwnerScoreIncrement(){
return this.ownerScoreIncrement; return this.ownerScoreIncrement;
} }
/** /**
* 设置 增加 负责人扣分或增加分值 * 设置 增加 负责人扣分或增加分值
* @param ownerScoreIncrement * @param ownerScoreIncrement
*/ */
public void setOwnerScoreIncrement(BigDecimal ownerScoreIncrement){ public void setOwnerScoreIncrement(BigDecimal ownerScoreIncrement){
this.ownerScoreIncrement = ownerScoreIncrement; this.ownerScoreIncrement = ownerScoreIncrement;
} }
/** /**
* 获取 负责人扣分或增加分值 * 获取 负责人扣分或增加分值
* @return ownerScoreList * @return ownerScoreList
*/ */
public List<BigDecimal> getOwnerScoreList(){ public List<BigDecimal> getOwnerScoreList(){
return this.ownerScoreList; return this.ownerScoreList;
} }
/** /**
* 设置 负责人扣分或增加分值 * 设置 负责人扣分或增加分值
* @param ownerScoreList * @param ownerScoreList
*/ */
public void setOwnerScoreList(List<BigDecimal> ownerScoreList){ public void setOwnerScoreList(List<BigDecimal> ownerScoreList){
this.ownerScoreList = ownerScoreList; this.ownerScoreList = ownerScoreList;
} }
/** /**
* 获取 负责人扣分或增加分值 * 获取 负责人扣分或增加分值
* @return ownerScoreNotList * @return ownerScoreNotList
*/ */
public List<BigDecimal> getOwnerScoreNotList(){ public List<BigDecimal> getOwnerScoreNotList(){
return this.ownerScoreNotList; return this.ownerScoreNotList;
} }
/** /**
* 设置 负责人扣分或增加分值 * 设置 负责人扣分或增加分值
* @param ownerScoreNotList * @param ownerScoreNotList
*/ */
public void setOwnerScoreNotList(List<BigDecimal> ownerScoreNotList){ public void setOwnerScoreNotList(List<BigDecimal> ownerScoreNotList){
this.ownerScoreNotList = ownerScoreNotList; this.ownerScoreNotList = ownerScoreNotList;
} }
/** /**
* 获取 备注 * 获取 备注
* @return remarkList * @return remarkList
*/ */
public List<String> getRemarkList(){ public List<String> getRemarkList(){
return this.remarkList; return this.remarkList;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkList * @param remarkList
*/ */
public void setRemarkList(List<String> remarkList){ public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList; this.remarkList = remarkList;
} }
/** /**
* 获取 备注 * 获取 备注
* @return remarkNotList * @return remarkNotList
*/ */
public List<String> getRemarkNotList(){ public List<String> getRemarkNotList(){
return this.remarkNotList; return this.remarkNotList;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkNotList * @param remarkNotList
*/ */
public void setRemarkNotList(List<String> remarkNotList){ public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList; this.remarkNotList = remarkNotList;
} }
/** /**
* 获取 开始 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 获取 开始 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @return typeStart * @return typeStart
*/ */
public Integer getTypeStart(){ public Integer getTypeStart(){
return this.typeStart; return this.typeStart;
} }
/** /**
* 设置 开始 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 开始 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeStart * @param typeStart
*/ */
public void setTypeStart(Integer typeStart){ public void setTypeStart(Integer typeStart){
this.typeStart = typeStart; this.typeStart = typeStart;
} }
/** /**
* 获取 结束 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 获取 结束 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @return $typeEnd * @return $typeEnd
*/ */
public Integer getTypeEnd(){ public Integer getTypeEnd(){
return this.typeEnd; return this.typeEnd;
} }
/** /**
* 设置 结束 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 结束 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeEnd * @param typeEnd
*/ */
public void setTypeEnd(Integer typeEnd){ public void setTypeEnd(Integer typeEnd){
this.typeEnd = typeEnd; this.typeEnd = typeEnd;
} }
/** /**
* 获取 增加 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 获取 增加 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @return typeIncrement * @return typeIncrement
*/ */
public Integer getTypeIncrement(){ public Integer getTypeIncrement(){
return this.typeIncrement; return this.typeIncrement;
} }
/** /**
* 设置 增加 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 增加 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeIncrement * @param typeIncrement
*/ */
public void setTypeIncrement(Integer typeIncrement){ public void setTypeIncrement(Integer typeIncrement){
this.typeIncrement = typeIncrement; this.typeIncrement = typeIncrement;
} }
/** /**
* 获取 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 获取 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @return typeList * @return typeList
*/ */
public List<Integer> getTypeList(){ public List<Integer> getTypeList(){
return this.typeList; return this.typeList;
} }
/** /**
* 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeList * @param typeList
*/ */
public void setTypeList(List<Integer> typeList){ public void setTypeList(List<Integer> typeList){
this.typeList = typeList; this.typeList = typeList;
} }
/** /**
* 获取 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 获取 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @return typeNotList * @return typeNotList
*/ */
public List<Integer> getTypeNotList(){ public List<Integer> getTypeNotList(){
return this.typeNotList; return this.typeNotList;
} }
/** /**
* 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeNotList * @param typeNotList
*/ */
public void setTypeNotList(List<Integer> typeNotList){ public void setTypeNotList(List<Integer> typeNotList){
this.typeNotList = typeNotList; this.typeNotList = typeNotList;
} }
/** /**
* 获取 开始 创建用户 * 获取 开始 创建用户
* @return createUserIdStart * @return createUserIdStart
*/ */
public Long getCreateUserIdStart(){ public Long getCreateUserIdStart(){
return this.createUserIdStart; return this.createUserIdStart;
} }
/** /**
* 设置 开始 创建用户 * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public void setCreateUserIdStart(Long createUserIdStart){ public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
} }
/** /**
* 获取 结束 创建用户 * 获取 结束 创建用户
* @return $createUserIdEnd * @return $createUserIdEnd
*/ */
public Long getCreateUserIdEnd(){ public Long getCreateUserIdEnd(){
return this.createUserIdEnd; return this.createUserIdEnd;
} }
/** /**
* 设置 结束 创建用户 * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public void setCreateUserIdEnd(Long createUserIdEnd){ public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
} }
/** /**
* 获取 增加 创建用户 * 获取 增加 创建用户
* @return createUserIdIncrement * @return createUserIdIncrement
*/ */
public Long getCreateUserIdIncrement(){ public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement; return this.createUserIdIncrement;
} }
/** /**
* 设置 增加 创建用户 * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public void setCreateUserIdIncrement(Long createUserIdIncrement){ public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
} }
/** /**
* 获取 创建用户 * 获取 创建用户
* @return createUserIdList * @return createUserIdList
*/ */
public List<Long> getCreateUserIdList(){ public List<Long> getCreateUserIdList(){
return this.createUserIdList; return this.createUserIdList;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public void setCreateUserIdList(List<Long> createUserIdList){ public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList; this.createUserIdList = createUserIdList;
} }
/** /**
* 获取 创建用户 * 获取 创建用户
* @return createUserIdNotList * @return createUserIdNotList
*/ */
public List<Long> getCreateUserIdNotList(){ public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList; return this.createUserIdNotList;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdNotList * @param createUserIdNotList
*/ */
public void setCreateUserIdNotList(List<Long> createUserIdNotList){ public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList; this.createUserIdNotList = createUserIdNotList;
} }
/** /**
* 获取 开始 创建时间 * 获取 开始 创建时间
* @return createTimeStart * @return createTimeStart
*/ */
public String getCreateTimeStart(){ public String getCreateTimeStart(){
return this.createTimeStart; return this.createTimeStart;
} }
/** /**
* 设置 开始 创建时间 * 设置 开始 创建时间
* @param createTimeStart * @param createTimeStart
*/ */
public void setCreateTimeStart(String createTimeStart){ public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart; this.createTimeStart = createTimeStart;
} }
/** /**
* 获取 结束 创建时间 * 获取 结束 创建时间
* @return createTimeEnd * @return createTimeEnd
*/ */
public String getCreateTimeEnd(){ public String getCreateTimeEnd(){
return this.createTimeEnd; return this.createTimeEnd;
} }
/** /**
* 设置 结束 创建时间 * 设置 结束 创建时间
* @param createTimeEnd * @param createTimeEnd
*/ */
public void setCreateTimeEnd(String createTimeEnd){ public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd; this.createTimeEnd = createTimeEnd;
} }
/** /**
* 获取 开始 更新用户 * 获取 开始 更新用户
* @return updateUserIdStart * @return updateUserIdStart
*/ */
public Long getUpdateUserIdStart(){ public Long getUpdateUserIdStart(){
return this.updateUserIdStart; return this.updateUserIdStart;
} }
/** /**
* 设置 开始 更新用户 * 设置 开始 更新用户
* @param updateUserIdStart * @param updateUserIdStart
*/ */
public void setUpdateUserIdStart(Long updateUserIdStart){ public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart; this.updateUserIdStart = updateUserIdStart;
} }
/** /**
* 获取 结束 更新用户 * 获取 结束 更新用户
* @return $updateUserIdEnd * @return $updateUserIdEnd
*/ */
public Long getUpdateUserIdEnd(){ public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd; return this.updateUserIdEnd;
} }
/** /**
* 设置 结束 更新用户 * 设置 结束 更新用户
* @param updateUserIdEnd * @param updateUserIdEnd
*/ */
public void setUpdateUserIdEnd(Long updateUserIdEnd){ public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd; this.updateUserIdEnd = updateUserIdEnd;
} }
/** /**
* 获取 增加 更新用户 * 获取 增加 更新用户
* @return updateUserIdIncrement * @return updateUserIdIncrement
*/ */
public Long getUpdateUserIdIncrement(){ public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement; return this.updateUserIdIncrement;
} }
/** /**
* 设置 增加 更新用户 * 设置 增加 更新用户
* @param updateUserIdIncrement * @param updateUserIdIncrement
*/ */
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){ public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement; this.updateUserIdIncrement = updateUserIdIncrement;
} }
/** /**
* 获取 更新用户 * 获取 更新用户
* @return updateUserIdList * @return updateUserIdList
*/ */
public List<Long> getUpdateUserIdList(){ public List<Long> getUpdateUserIdList(){
return this.updateUserIdList; return this.updateUserIdList;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdList * @param updateUserIdList
*/ */
public void setUpdateUserIdList(List<Long> updateUserIdList){ public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList; this.updateUserIdList = updateUserIdList;
} }
/** /**
* 获取 更新用户 * 获取 更新用户
* @return updateUserIdNotList * @return updateUserIdNotList
*/ */
public List<Long> getUpdateUserIdNotList(){ public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList; return this.updateUserIdNotList;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdNotList * @param updateUserIdNotList
*/ */
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){ public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList; this.updateUserIdNotList = updateUserIdNotList;
} }
/** /**
* 获取 开始 更新时间 * 获取 开始 更新时间
* @return updateTimeStart * @return updateTimeStart
*/ */
public String getUpdateTimeStart(){ public String getUpdateTimeStart(){
return this.updateTimeStart; return this.updateTimeStart;
} }
/** /**
* 设置 开始 更新时间 * 设置 开始 更新时间
* @param updateTimeStart * @param updateTimeStart
*/ */
public void setUpdateTimeStart(String updateTimeStart){ public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart; this.updateTimeStart = updateTimeStart;
} }
/** /**
* 获取 结束 更新时间 * 获取 结束 更新时间
* @return updateTimeEnd * @return updateTimeEnd
*/ */
public String getUpdateTimeEnd(){ public String getUpdateTimeEnd(){
return this.updateTimeEnd; return this.updateTimeEnd;
} }
/** /**
* 设置 结束 更新时间 * 设置 结束 更新时间
* @param updateTimeEnd * @param updateTimeEnd
*/ */
public void setUpdateTimeEnd(String updateTimeEnd){ public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd; this.updateTimeEnd = updateTimeEnd;
} }
/** /**
* 设置 序号，主键，自增长 * 获取 规则编码，唯一,默认规则类型内容简称拼音首字母。
* @param id * @return ruleCodeList
*/ */
public List<String> getRuleCodeList(){
return this.ruleCodeList;
}
/**
* 设置 规则编码，唯一,默认规则类型内容简称拼音首字母。
* @param ruleCodeList
*/
public void setRuleCodeList(List<String> ruleCodeList){
this.ruleCodeList = ruleCodeList;
}
/**
* 获取 规则编码，唯一,默认规则类型内容简称拼音首字母。
* @return ruleCodeNotList
*/
public List<String> getRuleCodeNotList(){
return this.ruleCodeNotList;
}
/**
* 设置 规则编码，唯一,默认规则类型内容简称拼音首字母。
* @param ruleCodeNotList
*/
public void setRuleCodeNotList(List<String> ruleCodeNotList){
this.ruleCodeNotList = ruleCodeNotList;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public PerformRulesQuery id(Long id){ public PerformRulesQuery id(Long id){
setId(id); setId(id);
return this; return this;
} }
/** /**
* 设置 开始 序号，主键，自增长 * 设置 开始 序号，主键，自增长
* @param idStart * @param idStart
*/ */
public PerformRulesQuery idStart(Long idStart){ public PerformRulesQuery idStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
return this; return this;
} }
/** /**
* 设置 结束 序号，主键，自增长 * 设置 结束 序号，主键，自增长
* @param idEnd * @param idEnd
*/ */
public PerformRulesQuery idEnd(Long idEnd){ public PerformRulesQuery idEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
return this; return this;
} }
/** /**
* 设置 增加 序号，主键，自增长 * 设置 增加 序号，主键，自增长
* @param idIncrement * @param idIncrement
*/ */
public PerformRulesQuery idIncrement(Long idIncrement){ public PerformRulesQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
return this; return this;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idList * @param idList
*/ */
public PerformRulesQuery idList(List<Long> idList){ public PerformRulesQuery idList(List<Long> idList){
this.idList = idList; this.idList = idList;
return this; return this;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idNotList * @param idNotList
*/ */
public PerformRulesQuery idNotList(List<Long> idNotList){ public PerformRulesQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList; this.idNotList = idNotList;
return this; return this;
} }
/** /**
* 设置 分类id * 设置 分类id
* @param categoryId * @param categoryId
*/ */
public PerformRulesQuery categoryId(Long categoryId){ public PerformRulesQuery categoryId(Long categoryId){
setCategoryId(categoryId); setCategoryId(categoryId);
return this; return this;
} }
/** /**
* 设置 开始 分类id * 设置 开始 分类id
* @param categoryIdStart * @param categoryIdStart
*/ */
public PerformRulesQuery categoryIdStart(Long categoryIdStart){ public PerformRulesQuery categoryIdStart(Long categoryIdStart){
this.categoryIdStart = categoryIdStart; this.categoryIdStart = categoryIdStart;
return this; return this;
} }
/** /**
* 设置 结束 分类id * 设置 结束 分类id
* @param categoryIdEnd * @param categoryIdEnd
*/ */
public PerformRulesQuery categoryIdEnd(Long categoryIdEnd){ public PerformRulesQuery categoryIdEnd(Long categoryIdEnd){
this.categoryIdEnd = categoryIdEnd; this.categoryIdEnd = categoryIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 分类id * 设置 增加 分类id
* @param categoryIdIncrement * @param categoryIdIncrement
*/ */
public PerformRulesQuery categoryIdIncrement(Long categoryIdIncrement){ public PerformRulesQuery categoryIdIncrement(Long categoryIdIncrement){
this.categoryIdIncrement = categoryIdIncrement; this.categoryIdIncrement = categoryIdIncrement;
return this; return this;
} }
/** /**
* 设置 分类id * 设置 分类id
* @param categoryIdList * @param categoryIdList
*/ */
public PerformRulesQuery categoryIdList(List<Long> categoryIdList){ public PerformRulesQuery categoryIdList(List<Long> categoryIdList){
this.categoryIdList = categoryIdList; this.categoryIdList = categoryIdList;
return this; return this;
} }
/** /**
* 设置 分类id * 设置 分类id
* @param categoryIdNotList * @param categoryIdNotList
*/ */
public PerformRulesQuery categoryIdNotList(List<Long> categoryIdNotList){ public PerformRulesQuery categoryIdNotList(List<Long> categoryIdNotList){
this.categoryIdNotList = categoryIdNotList; this.categoryIdNotList = categoryIdNotList;
return this; return this;
} }
/** /**
* 设置 分类名称 * 设置 分类名称
* @param categoryName * @param categoryName
*/ */
public PerformRulesQuery categoryName(String categoryName){ public PerformRulesQuery categoryName(String categoryName){
setCategoryName(categoryName); setCategoryName(categoryName);
return this; return this;
} }
/** /**
* 设置 分类名称 * 设置 分类名称
* @param categoryNameList * @param categoryNameList
*/ */
public PerformRulesQuery categoryNameList(List<String> categoryNameList){ public PerformRulesQuery categoryNameList(List<String> categoryNameList){
this.categoryNameList = categoryNameList; this.categoryNameList = categoryNameList;
return this; return this;
} }
/** /**
* 设置 考核内容简称 * 设置 考核内容简称
* @param name * @param name
*/ */
public PerformRulesQuery name(String name){ public PerformRulesQuery name(String name){
setName(name); setName(name);
return this; return this;
} }
/** /**
* 设置 考核内容简称 * 设置 考核内容简称
* @param nameList * @param nameList
*/ */
public PerformRulesQuery nameList(List<String> nameList){ public PerformRulesQuery nameList(List<String> nameList){
this.nameList = nameList; this.nameList = nameList;
return this; return this;
} }
/** /**
* 设置 评分标准 * 设置 评分标准
* @param content * @param content
*/ */
public PerformRulesQuery content(String content){ public PerformRulesQuery content(String content){
setContent(content); setContent(content);
return this; return this;
} }
/** /**
* 设置 评分标准 * 设置 评分标准
* @param contentList * @param contentList
*/ */
public PerformRulesQuery contentList(List<String> contentList){ public PerformRulesQuery contentList(List<String> contentList){
this.contentList = contentList; this.contentList = contentList;
return this; return this;
} }
/** /**
* 设置 增减类型(1.增加,2.扣除) * 设置 增减类型(1.增加,2.扣除)
* @param subAddType * @param subAddType
*/ */
public PerformRulesQuery subAddType(Integer subAddType){ public PerformRulesQuery subAddType(Integer subAddType){
setSubAddType(subAddType); setSubAddType(subAddType);
return this; return this;
} }
/** /**
* 设置 开始 增减类型(1.增加,2.扣除) * 设置 开始 增减类型(1.增加,2.扣除)
* @param subAddTypeStart * @param subAddTypeStart
*/ */
public PerformRulesQuery subAddTypeStart(Integer subAddTypeStart){ public PerformRulesQuery subAddTypeStart(Integer subAddTypeStart){
this.subAddTypeStart = subAddTypeStart; this.subAddTypeStart = subAddTypeStart;
return this; return this;
} }
/** /**
* 设置 结束 增减类型(1.增加,2.扣除) * 设置 结束 增减类型(1.增加,2.扣除)
* @param subAddTypeEnd * @param subAddTypeEnd
*/ */
public PerformRulesQuery subAddTypeEnd(Integer subAddTypeEnd){ public PerformRulesQuery subAddTypeEnd(Integer subAddTypeEnd){
this.subAddTypeEnd = subAddTypeEnd; this.subAddTypeEnd = subAddTypeEnd;
return this; return this;
} }
/** /**
* 设置 增加 增减类型(1.增加,2.扣除) * 设置 增加 增减类型(1.增加,2.扣除)
* @param subAddTypeIncrement * @param subAddTypeIncrement
*/ */
public PerformRulesQuery subAddTypeIncrement(Integer subAddTypeIncrement){ public PerformRulesQuery subAddTypeIncrement(Integer subAddTypeIncrement){
this.subAddTypeIncrement = subAddTypeIncrement; this.subAddTypeIncrement = subAddTypeIncrement;
return this; return this;
} }
/** /**
* 设置 增减类型(1.增加,2.扣除) * 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeList * @param subAddTypeList
*/ */
public PerformRulesQuery subAddTypeList(List<Integer> subAddTypeList){ public PerformRulesQuery subAddTypeList(List<Integer> subAddTypeList){
this.subAddTypeList = subAddTypeList; this.subAddTypeList = subAddTypeList;
return this; return this;
} }
/** /**
* 设置 增减类型(1.增加,2.扣除) * 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeNotList * @param subAddTypeNotList
*/ */
public PerformRulesQuery subAddTypeNotList(List<Integer> subAddTypeNotList){ public PerformRulesQuery subAddTypeNotList(List<Integer> subAddTypeNotList){
this.subAddTypeNotList = subAddTypeNotList; this.subAddTypeNotList = subAddTypeNotList;
return this; return this;
} }
/** /**
* 设置 扣分或增加分值 * 设置 扣分或增加分值
* @param score * @param score
*/ */
public PerformRulesQuery score(BigDecimal score){ public PerformRulesQuery score(BigDecimal score){
setScore(score); setScore(score);
return this; return this;
} }
/** /**
* 设置 开始 扣分或增加分值 * 设置 开始 扣分或增加分值
* @param scoreStart * @param scoreStart
*/ */
public PerformRulesQuery scoreStart(BigDecimal scoreStart){ public PerformRulesQuery scoreStart(BigDecimal scoreStart){
this.scoreStart = scoreStart; this.scoreStart = scoreStart;
return this; return this;
} }
/** /**
* 设置 结束 扣分或增加分值 * 设置 结束 扣分或增加分值
* @param scoreEnd * @param scoreEnd
*/ */
public PerformRulesQuery scoreEnd(BigDecimal scoreEnd){ public PerformRulesQuery scoreEnd(BigDecimal scoreEnd){
this.scoreEnd = scoreEnd; this.scoreEnd = scoreEnd;
return this; return this;
} }
/** /**
* 设置 增加 扣分或增加分值 * 设置 增加 扣分或增加分值
* @param scoreIncrement * @param scoreIncrement
*/ */
public PerformRulesQuery scoreIncrement(BigDecimal scoreIncrement){ public PerformRulesQuery scoreIncrement(BigDecimal scoreIncrement){
this.scoreIncrement = scoreIncrement; this.scoreIncrement = scoreIncrement;
return this; return this;
} }
/** /**
* 设置 扣分或增加分值 * 设置 扣分或增加分值
* @param scoreList * @param scoreList
*/ */
public PerformRulesQuery scoreList(List<BigDecimal> scoreList){ public PerformRulesQuery scoreList(List<BigDecimal> scoreList){
this.scoreList = scoreList; this.scoreList = scoreList;
return this; return this;
} }
/** /**
* 设置 扣分或增加分值 * 设置 扣分或增加分值
* @param scoreNotList * @param scoreNotList
*/ */
public PerformRulesQuery scoreNotList(List<BigDecimal> scoreNotList){ public PerformRulesQuery scoreNotList(List<BigDecimal> scoreNotList){
this.scoreNotList = scoreNotList; this.scoreNotList = scoreNotList;
return this; return this;
} }
/** /**
* 设置 是否关联负责人(0.否,1.是) * 设置 是否关联负责人(0.否,1.是)
* @param assoOwner * @param assoOwner
*/ */
public PerformRulesQuery assoOwner(Integer assoOwner){ public PerformRulesQuery assoOwner(Integer assoOwner){
setAssoOwner(assoOwner); setAssoOwner(assoOwner);
return this; return this;
} }
/** /**
* 设置 开始 是否关联负责人(0.否,1.是) * 设置 开始 是否关联负责人(0.否,1.是)
* @param assoOwnerStart * @param assoOwnerStart
*/ */
public PerformRulesQuery assoOwnerStart(Integer assoOwnerStart){ public PerformRulesQuery assoOwnerStart(Integer assoOwnerStart){
this.assoOwnerStart = assoOwnerStart; this.assoOwnerStart = assoOwnerStart;
return this; return this;
} }
/** /**
* 设置 结束 是否关联负责人(0.否,1.是) * 设置 结束 是否关联负责人(0.否,1.是)
* @param assoOwnerEnd * @param assoOwnerEnd
*/ */
public PerformRulesQuery assoOwnerEnd(Integer assoOwnerEnd){ public PerformRulesQuery assoOwnerEnd(Integer assoOwnerEnd){
this.assoOwnerEnd = assoOwnerEnd; this.assoOwnerEnd = assoOwnerEnd;
return this; return this;
} }
/** /**
* 设置 增加 是否关联负责人(0.否,1.是) * 设置 增加 是否关联负责人(0.否,1.是)
* @param assoOwnerIncrement * @param assoOwnerIncrement
*/ */
public PerformRulesQuery assoOwnerIncrement(Integer assoOwnerIncrement){ public PerformRulesQuery assoOwnerIncrement(Integer assoOwnerIncrement){
this.assoOwnerIncrement = assoOwnerIncrement; this.assoOwnerIncrement = assoOwnerIncrement;
return this; return this;
} }
/** /**
* 设置 是否关联负责人(0.否,1.是) * 设置 是否关联负责人(0.否,1.是)
* @param assoOwnerList * @param assoOwnerList
*/ */
public PerformRulesQuery assoOwnerList(List<Integer> assoOwnerList){ public PerformRulesQuery assoOwnerList(List<Integer> assoOwnerList){
this.assoOwnerList = assoOwnerList; this.assoOwnerList = assoOwnerList;
return this; return this;
} }
/** /**
* 设置 是否关联负责人(0.否,1.是) * 设置 是否关联负责人(0.否,1.是)
* @param assoOwnerNotList * @param assoOwnerNotList
*/ */
public PerformRulesQuery assoOwnerNotList(List<Integer> assoOwnerNotList){ public PerformRulesQuery assoOwnerNotList(List<Integer> assoOwnerNotList){
this.assoOwnerNotList = assoOwnerNotList; this.assoOwnerNotList = assoOwnerNotList;
return this; return this;
} }
/** /**
* 设置 负责人扣分或增加分值 * 设置 负责人扣分或增加分值
* @param ownerScore * @param ownerScore
*/ */
public PerformRulesQuery ownerScore(BigDecimal ownerScore){ public PerformRulesQuery ownerScore(BigDecimal ownerScore){
setOwnerScore(ownerScore); setOwnerScore(ownerScore);
return this; return this;
} }
/** /**
* 设置 开始 负责人扣分或增加分值 * 设置 开始 负责人扣分或增加分值
* @param ownerScoreStart * @param ownerScoreStart
*/ */
public PerformRulesQuery ownerScoreStart(BigDecimal ownerScoreStart){ public PerformRulesQuery ownerScoreStart(BigDecimal ownerScoreStart){
this.ownerScoreStart = ownerScoreStart; this.ownerScoreStart = ownerScoreStart;
return this; return this;
} }
/** /**
* 设置 结束 负责人扣分或增加分值 * 设置 结束 负责人扣分或增加分值
* @param ownerScoreEnd * @param ownerScoreEnd
*/ */
public PerformRulesQuery ownerScoreEnd(BigDecimal ownerScoreEnd){ public PerformRulesQuery ownerScoreEnd(BigDecimal ownerScoreEnd){
this.ownerScoreEnd = ownerScoreEnd; this.ownerScoreEnd = ownerScoreEnd;
return this; return this;
} }
/** /**
* 设置 增加 负责人扣分或增加分值 * 设置 增加 负责人扣分或增加分值
* @param ownerScoreIncrement * @param ownerScoreIncrement
*/ */
public PerformRulesQuery ownerScoreIncrement(BigDecimal ownerScoreIncrement){ public PerformRulesQuery ownerScoreIncrement(BigDecimal ownerScoreIncrement){
this.ownerScoreIncrement = ownerScoreIncrement; this.ownerScoreIncrement = ownerScoreIncrement;
return this; return this;
} }
/** /**
* 设置 负责人扣分或增加分值 * 设置 负责人扣分或增加分值
* @param ownerScoreList * @param ownerScoreList
*/ */
public PerformRulesQuery ownerScoreList(List<BigDecimal> ownerScoreList){ public PerformRulesQuery ownerScoreList(List<BigDecimal> ownerScoreList){
this.ownerScoreList = ownerScoreList; this.ownerScoreList = ownerScoreList;
return this; return this;
} }
/** /**
* 设置 负责人扣分或增加分值 * 设置 负责人扣分或增加分值
* @param ownerScoreNotList * @param ownerScoreNotList
*/ */
public PerformRulesQuery ownerScoreNotList(List<BigDecimal> ownerScoreNotList){ public PerformRulesQuery ownerScoreNotList(List<BigDecimal> ownerScoreNotList){
this.ownerScoreNotList = ownerScoreNotList; this.ownerScoreNotList = ownerScoreNotList;
return this; return this;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remark * @param remark
*/ */
public PerformRulesQuery remark(String remark){ public PerformRulesQuery remark(String remark){
setRemark(remark); setRemark(remark);
return this; return this;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkList * @param remarkList
*/ */
public PerformRulesQuery remarkList(List<String> remarkList){ public PerformRulesQuery remarkList(List<String> remarkList){
this.remarkList = remarkList; this.remarkList = remarkList;
return this; return this;
} }
/** /**
* 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param type * @param type
*/ */
public PerformRulesQuery type(Integer type){ public PerformRulesQuery type(Integer type){
setType(type); setType(type);
return this; return this;
} }
/** /**
* 设置 开始 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 开始 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeStart * @param typeStart
*/ */
public PerformRulesQuery typeStart(Integer typeStart){ public PerformRulesQuery typeStart(Integer typeStart){
this.typeStart = typeStart; this.typeStart = typeStart;
return this; return this;
} }
/** /**
* 设置 结束 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 结束 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeEnd * @param typeEnd
*/ */
public PerformRulesQuery typeEnd(Integer typeEnd){ public PerformRulesQuery typeEnd(Integer typeEnd){
this.typeEnd = typeEnd; this.typeEnd = typeEnd;
return this; return this;
} }
/** /**
* 设置 增加 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 增加 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeIncrement * @param typeIncrement
*/ */
public PerformRulesQuery typeIncrement(Integer typeIncrement){ public PerformRulesQuery typeIncrement(Integer typeIncrement){
this.typeIncrement = typeIncrement; this.typeIncrement = typeIncrement;
return this; return this;
} }
/** /**
* 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeList * @param typeList
*/ */
public PerformRulesQuery typeList(List<Integer> typeList){ public PerformRulesQuery typeList(List<Integer> typeList){
this.typeList = typeList; this.typeList = typeList;
return this; return this;
} }
/** /**
* 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标) * 设置 规则类型(1.考勤绩效,2.评价绩效指标,3.办件绩效指标,4.效能绩效指标,5.其它绩效指标)
* @param typeNotList * @param typeNotList
*/ */
public PerformRulesQuery typeNotList(List<Integer> typeNotList){ public PerformRulesQuery typeNotList(List<Integer> typeNotList){
this.typeNotList = typeNotList; this.typeNotList = typeNotList;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserId * @param createUserId
*/ */
public PerformRulesQuery createUserId(Long createUserId){ public PerformRulesQuery createUserId(Long createUserId){
setCreateUserId(createUserId); setCreateUserId(createUserId);
return this; return this;
} }
/** /**
* 设置 开始 创建用户 * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public PerformRulesQuery createUserIdStart(Long createUserIdStart){ public PerformRulesQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
return this; return this;
} }
/** /**
* 设置 结束 创建用户 * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public PerformRulesQuery createUserIdEnd(Long createUserIdEnd){ public PerformRulesQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 创建用户 * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public PerformRulesQuery createUserIdIncrement(Long createUserIdIncrement){ public PerformRulesQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public PerformRulesQuery createUserIdList(List<Long> createUserIdList){ public PerformRulesQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList; this.createUserIdList = createUserIdList;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdNotList * @param createUserIdNotList
*/ */
public PerformRulesQuery createUserIdNotList(List<Long> createUserIdNotList){ public PerformRulesQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList; this.createUserIdNotList = createUserIdNotList;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserId * @param updateUserId
*/ */
public PerformRulesQuery updateUserId(Long updateUserId){ public PerformRulesQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId); setUpdateUserId(updateUserId);
return this; return this;
} }
/** /**
* 设置 开始 更新用户 * 设置 开始 更新用户
* @param updateUserIdStart * @param updateUserIdStart
*/ */
public PerformRulesQuery updateUserIdStart(Long updateUserIdStart){ public PerformRulesQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart; this.updateUserIdStart = updateUserIdStart;
return this; return this;
} }
/** /**
* 设置 结束 更新用户 * 设置 结束 更新用户
* @param updateUserIdEnd * @param updateUserIdEnd
*/ */
public PerformRulesQuery updateUserIdEnd(Long updateUserIdEnd){ public PerformRulesQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd; this.updateUserIdEnd = updateUserIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 更新用户 * 设置 增加 更新用户
* @param updateUserIdIncrement * @param updateUserIdIncrement
*/ */
public PerformRulesQuery updateUserIdIncrement(Long updateUserIdIncrement){ public PerformRulesQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement; this.updateUserIdIncrement = updateUserIdIncrement;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdList * @param updateUserIdList
*/ */
public PerformRulesQuery updateUserIdList(List<Long> updateUserIdList){ public PerformRulesQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList; this.updateUserIdList = updateUserIdList;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdNotList * @param updateUserIdNotList
*/ */
public PerformRulesQuery updateUserIdNotList(List<Long> updateUserIdNotList){ public PerformRulesQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList; this.updateUserIdNotList = updateUserIdNotList;
return this; return this;
} }
/**
* 设置 规则编码，唯一,默认规则类型内容简称拼音首字母。
* @param ruleCode
*/
public PerformRulesQuery ruleCode(String ruleCode){
setRuleCode(ruleCode);
return this;
}
/**
* 设置 规则编码，唯一,默认规则类型内容简称拼音首字母。
* @param ruleCodeList
*/
public PerformRulesQuery ruleCodeList(List<String> ruleCodeList){
this.ruleCodeList = ruleCodeList;
return this;
}
/** /**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList * @return orConditionList
*/ */
public List<PerformRulesQuery> getOrConditionList(){ public List<PerformRulesQuery> getOrConditionList(){
return this.orConditionList; return this.orConditionList;
} }
/** /**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList * @param orConditionList
*/ */
public void setOrConditionList(List<PerformRulesQuery> orConditionList){ public void setOrConditionList(List<PerformRulesQuery> orConditionList){
this.orConditionList = orConditionList; this.orConditionList = orConditionList;
} }
/** /**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList * @return andConditionList
*/ */
public List<PerformRulesQuery> getAndConditionList(){ public List<PerformRulesQuery> getAndConditionList(){
return this.andConditionList; return this.andConditionList;
} }
/** /**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList * @param andConditionList
*/ */
public void setAndConditionList(List<PerformRulesQuery> andConditionList){ public void setAndConditionList(List<PerformRulesQuery> andConditionList){
this.andConditionList = andConditionList; this.andConditionList = andConditionList;
} }
......
attendance-performance-manager/src/main/resources/sqlmap/module/perform/PerformRulesMapper.xml
View file @ 61ab114c
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd"> "mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.perform.dao.ibatis.PerformRulesDaoImpl"> <mapper namespace="com.mortals.xhx.module.perform.dao.ibatis.PerformRulesDaoImpl">
<!-- 字段和属性映射 --> <!-- 字段和属性映射 -->
<resultMap type="PerformRulesEntity" id="PerformRulesEntity-Map"> <resultMap type="PerformRulesEntity" id="PerformRulesEntity-Map">
<id property="id" column="id" /> <id property="id" column="id" />
<result property="categoryId" column="categoryId" /> <result property="categoryId" column="categoryId" />
<result property="categoryName" column="categoryName" /> <result property="categoryName" column="categoryName" />
<result property="name" column="name" /> <result property="name" column="name" />
<result property="content" column="content" /> <result property="content" column="content" />
<result property="subAddType" column="subAddType" /> <result property="subAddType" column="subAddType" />
<result property="score" column="score" /> <result property="score" column="score" />
<result property="assoOwner" column="assoOwner" /> <result property="assoOwner" column="assoOwner" />
<result property="ownerScore" column="ownerScore" /> <result property="ownerScore" column="ownerScore" />
<result property="remark" column="remark" /> <result property="remark" column="remark" />
<result property="type" column="type" /> <result property="type" column="type" />
<result property="createUserId" column="createUserId" /> <result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" /> <result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" /> <result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" /> <result property="updateTime" column="updateTime" />
<result property="ruleCode" column="ruleCode" />
</resultMap> </resultMap>
<!-- 表所有列 --> <!-- 表所有列 -->
<sql id="_columns"> <sql id="_columns">
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id, a.id,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('categoryId') or colPickMode == 1 and data.containsKey('categoryId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('categoryId') or colPickMode == 1 and data.containsKey('categoryId')))">
a.categoryId, a.categoryId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('categoryName') or colPickMode == 1 and data.containsKey('categoryName')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('categoryName') or colPickMode == 1 and data.containsKey('categoryName')))">
a.categoryName, a.categoryName,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
a.name, a.name,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('content') or colPickMode == 1 and data.containsKey('content')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('content') or colPickMode == 1 and data.containsKey('content')))">
a.content, a.content,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('subAddType') or colPickMode == 1 and data.containsKey('subAddType')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('subAddType') or colPickMode == 1 and data.containsKey('subAddType')))">
a.subAddType, a.subAddType,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('score') or colPickMode == 1 and data.containsKey('score')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('score') or colPickMode == 1 and data.containsKey('score')))">
a.score, a.score,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('assoOwner') or colPickMode == 1 and data.containsKey('assoOwner')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('assoOwner') or colPickMode == 1 and data.containsKey('assoOwner')))">
a.assoOwner, a.assoOwner,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ownerScore') or colPickMode == 1 and data.containsKey('ownerScore')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ownerScore') or colPickMode == 1 and data.containsKey('ownerScore')))">
a.ownerScore, a.ownerScore,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark, a.remark,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('type') or colPickMode == 1 and data.containsKey('type')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('type') or colPickMode == 1 and data.containsKey('type')))">
a.type, a.type,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId, a.createUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime, a.createTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId, a.updateUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime, a.updateTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleCode') or colPickMode == 1 and data.containsKey('ruleCode')))">
a.ruleCode,
</if>
</trim> </trim>
</sql> </sql>
<!-- 新增 区分主键自增加还是业务插入 --> <!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="PerformRulesEntity" useGeneratedKeys="true" keyProperty="id"> <insert id="insert" parameterType="PerformRulesEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_perform_rules insert into mortals_xhx_perform_rules
(categoryId,categoryName,name,content,subAddType,score,assoOwner,ownerScore,remark,type,createUserId,createTime,updateUserId,updateTime) (categoryId,categoryName,name,content,subAddType,score,assoOwner,ownerScore,remark,type,createUserId,createTime,updateUserId,updateTime,ruleCode)
VALUES VALUES
(#{categoryId},#{categoryName},#{name},#{content},#{subAddType},#{score},#{assoOwner},#{ownerScore},#{remark},#{type},#{createUserId},#{createTime},#{updateUserId},#{updateTime}) (#{categoryId},#{categoryName},#{name},#{content},#{subAddType},#{score},#{assoOwner},#{ownerScore},#{remark},#{type},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{ruleCode})
</insert> </insert>
<!-- 批量新增 --> <!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto"> <insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_perform_rules insert into mortals_xhx_perform_rules
(categoryId,categoryName,name,content,subAddType,score,assoOwner,ownerScore,remark,type,createUserId,createTime,updateUserId,updateTime) (categoryId,categoryName,name,content,subAddType,score,assoOwner,ownerScore,remark,type,createUserId,createTime,updateUserId,updateTime,ruleCode)
VALUES VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," > <foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.categoryId},#{item.categoryName},#{item.name},#{item.content},#{item.subAddType},#{item.score},#{item.assoOwner},#{item.ownerScore},#{item.remark},#{item.type},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime}) (#{item.categoryId},#{item.categoryName},#{item.name},#{item.content},#{item.subAddType},#{item.score},#{item.assoOwner},#{item.ownerScore},#{item.remark},#{item.type},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.ruleCode})
</foreach> </foreach>
</insert> </insert>
...@@ -164,6 +168,9 @@ ...@@ -164,6 +168,9 @@
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))"> <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime}, a.updateTime=#{data.updateTime},
</if> </if>
<if test="(colPickMode==0 and data.containsKey('ruleCode')) or (colPickMode==1 and !data.containsKey('ruleCode'))">
a.ruleCode=#{data.ruleCode},
</if>
</trim> </trim>
<trim suffixOverrides="where" suffix=""> <trim suffixOverrides="where" suffix="">
where where
...@@ -176,144 +183,151 @@ ...@@ -176,144 +183,151 @@
<update id="updateBatch" parameterType="paramDto"> <update id="updateBatch" parameterType="paramDto">
update mortals_xhx_perform_rules as a update mortals_xhx_perform_rules as a
<trim prefix="set" suffixOverrides=","> <trim prefix="set" suffixOverrides=",">
<trim prefix="categoryId=(case" suffix="ELSE categoryId end),"> <trim prefix="categoryId=(case" suffix="ELSE categoryId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('categoryId')) or (colPickMode==1 and !item.containsKey('categoryId'))"> <when test="(colPickMode==0 and item.containsKey('categoryId')) or (colPickMode==1 and !item.containsKey('categoryId'))">
when a.id=#{item.id} then #{item.categoryId} when a.id=#{item.id} then #{item.categoryId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('categoryIdIncrement')) or (colPickMode==1 and !item.containsKey('categoryIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('categoryIdIncrement')) or (colPickMode==1 and !item.containsKey('categoryIdIncrement'))">
when a.id=#{item.id} then ifnull(a.categoryId,0) + #{item.categoryIdIncrement} when a.id=#{item.id} then ifnull(a.categoryId,0) + #{item.categoryIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="categoryName=(case" suffix="ELSE categoryName end),"> <trim prefix="categoryName=(case" suffix="ELSE categoryName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('categoryName')) or (colPickMode==1 and !item.containsKey('categoryName'))"> <if test="(colPickMode==0 and item.containsKey('categoryName')) or (colPickMode==1 and !item.containsKey('categoryName'))">
when a.id=#{item.id} then #{item.categoryName} when a.id=#{item.id} then #{item.categoryName}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="name=(case" suffix="ELSE name end),"> <trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))"> <if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name} when a.id=#{item.id} then #{item.name}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="content=(case" suffix="ELSE content end),"> <trim prefix="content=(case" suffix="ELSE content end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('content')) or (colPickMode==1 and !item.containsKey('content'))"> <if test="(colPickMode==0 and item.containsKey('content')) or (colPickMode==1 and !item.containsKey('content'))">
when a.id=#{item.id} then #{item.content} when a.id=#{item.id} then #{item.content}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="subAddType=(case" suffix="ELSE subAddType end),"> <trim prefix="subAddType=(case" suffix="ELSE subAddType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('subAddType')) or (colPickMode==1 and !item.containsKey('subAddType'))"> <when test="(colPickMode==0 and item.containsKey('subAddType')) or (colPickMode==1 and !item.containsKey('subAddType'))">
when a.id=#{item.id} then #{item.subAddType} when a.id=#{item.id} then #{item.subAddType}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('subAddTypeIncrement')) or (colPickMode==1 and !item.containsKey('subAddTypeIncrement'))"> <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 a.id=#{item.id} then ifnull(a.subAddType,0) + #{item.subAddTypeIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="score=(case" suffix="ELSE score end),"> <trim prefix="score=(case" suffix="ELSE score end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('score')) or (colPickMode==1 and !item.containsKey('score'))"> <when test="(colPickMode==0 and item.containsKey('score')) or (colPickMode==1 and !item.containsKey('score'))">
when a.id=#{item.id} then #{item.score} when a.id=#{item.id} then #{item.score}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('scoreIncrement')) or (colPickMode==1 and !item.containsKey('scoreIncrement'))"> <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 a.id=#{item.id} then ifnull(a.score,0) + #{item.scoreIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="assoOwner=(case" suffix="ELSE assoOwner end),"> <trim prefix="assoOwner=(case" suffix="ELSE assoOwner end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('assoOwner')) or (colPickMode==1 and !item.containsKey('assoOwner'))"> <when test="(colPickMode==0 and item.containsKey('assoOwner')) or (colPickMode==1 and !item.containsKey('assoOwner'))">
when a.id=#{item.id} then #{item.assoOwner} when a.id=#{item.id} then #{item.assoOwner}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('assoOwnerIncrement')) or (colPickMode==1 and !item.containsKey('assoOwnerIncrement'))"> <when test="(colPickMode==0 and item.containsKey('assoOwnerIncrement')) or (colPickMode==1 and !item.containsKey('assoOwnerIncrement'))">
when a.id=#{item.id} then ifnull(a.assoOwner,0) + #{item.assoOwnerIncrement} when a.id=#{item.id} then ifnull(a.assoOwner,0) + #{item.assoOwnerIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="ownerScore=(case" suffix="ELSE ownerScore end),"> <trim prefix="ownerScore=(case" suffix="ELSE ownerScore end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('ownerScore')) or (colPickMode==1 and !item.containsKey('ownerScore'))"> <when test="(colPickMode==0 and item.containsKey('ownerScore')) or (colPickMode==1 and !item.containsKey('ownerScore'))">
when a.id=#{item.id} then #{item.ownerScore} when a.id=#{item.id} then #{item.ownerScore}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('ownerScoreIncrement')) or (colPickMode==1 and !item.containsKey('ownerScoreIncrement'))"> <when test="(colPickMode==0 and item.containsKey('ownerScoreIncrement')) or (colPickMode==1 and !item.containsKey('ownerScoreIncrement'))">
when a.id=#{item.id} then ifnull(a.ownerScore,0) + #{item.ownerScoreIncrement} when a.id=#{item.id} then ifnull(a.ownerScore,0) + #{item.ownerScoreIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="remark=(case" suffix="ELSE remark end),"> <trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))"> <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark} when a.id=#{item.id} then #{item.remark}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="type=(case" suffix="ELSE type end),"> <trim prefix="type=(case" suffix="ELSE type end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('type')) or (colPickMode==1 and !item.containsKey('type'))"> <when test="(colPickMode==0 and item.containsKey('type')) or (colPickMode==1 and !item.containsKey('type'))">
when a.id=#{item.id} then #{item.type} when a.id=#{item.id} then #{item.type}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('typeIncrement')) or (colPickMode==1 and !item.containsKey('typeIncrement'))"> <when test="(colPickMode==0 and item.containsKey('typeIncrement')) or (colPickMode==1 and !item.containsKey('typeIncrement'))">
when a.id=#{item.id} then ifnull(a.type,0) + #{item.typeIncrement} when a.id=#{item.id} then ifnull(a.type,0) + #{item.typeIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),"> <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))"> <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId} when a.id=#{item.id} then #{item.createUserId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))"> <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 a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),"> <trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))"> <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime} when a.id=#{item.id} then #{item.createTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),"> <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))"> <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId} when a.id=#{item.id} then #{item.updateUserId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))"> <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 a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),"> <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))"> <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime} when a.id=#{item.id} then #{item.updateTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="ruleCode=(case" suffix="ELSE ruleCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ruleCode')) or (colPickMode==1 and !item.containsKey('ruleCode'))">
when a.id=#{item.id} then #{item.ruleCode}
</if>
</foreach>
</trim>
</trim> </trim>
where id in where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")"> <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
...@@ -430,451 +444,477 @@ ...@@ -430,451 +444,477 @@
${_conditionType_} a.id=#{${_conditionParam_}.id} ${_conditionType_} a.id=#{${_conditionParam_}.id}
</if> </if>
</if> </if>
<if test="conditionParamRef.containsKey('id')"> <if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null "> <if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id} ${_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>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null"> <if test="conditionParamRef.id == null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd} ${_conditionType_} a.id is null
</if> </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('categoryId')"> <if test="conditionParamRef.containsKey('categoryId')">
<if test="conditionParamRef.categoryId != null "> <if test="conditionParamRef.categoryId != null ">
${_conditionType_} a.categoryId = #{${_conditionParam_}.categoryId} ${_conditionType_} a.categoryId = #{${_conditionParam_}.categoryId}
</if>
<if test="conditionParamRef.categoryId == null">
${_conditionType_} a.categoryId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('categoryIdList') and conditionParamRef.categoryIdList.size() > 0"> <if test="conditionParamRef.categoryId == null">
${_conditionType_} a.categoryId in ${_conditionType_} a.categoryId is null
<foreach collection="conditionParamRef.categoryIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('categoryIdNotList') and conditionParamRef.categoryIdNotList.size() > 0">
${_conditionType_} a.categoryId not in
<foreach collection="conditionParamRef.categoryIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('categoryIdStart') and conditionParamRef.categoryIdStart != null">
${_conditionType_} a.categoryId <![CDATA[ >= ]]> #{${_conditionParam_}.categoryIdStart}
</if>
<if test="conditionParamRef.containsKey('categoryIdEnd') and conditionParamRef.categoryIdEnd != null">
${_conditionType_} a.categoryId <![CDATA[ <= ]]> #{${_conditionParam_}.categoryIdEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('categoryIdList') and conditionParamRef.categoryIdList.size() > 0">
${_conditionType_} a.categoryId in
<foreach collection="conditionParamRef.categoryIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('categoryIdNotList') and conditionParamRef.categoryIdNotList.size() > 0">
${_conditionType_} a.categoryId not in
<foreach collection="conditionParamRef.categoryIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('categoryIdStart') and conditionParamRef.categoryIdStart != null">
${_conditionType_} a.categoryId <![CDATA[ >= ]]> #{${_conditionParam_}.categoryIdStart}
</if>
<if test="conditionParamRef.containsKey('categoryIdEnd') and conditionParamRef.categoryIdEnd != null">
${_conditionType_} a.categoryId <![CDATA[ <= ]]> #{${_conditionParam_}.categoryIdEnd}
</if>
<if test="conditionParamRef.containsKey('categoryName')"> <if test="conditionParamRef.containsKey('categoryName')">
<if test="conditionParamRef.categoryName != null and conditionParamRef.categoryName != ''"> <if test="conditionParamRef.categoryName != null and conditionParamRef.categoryName != ''">
${_conditionType_} a.categoryName like #{${_conditionParam_}.categoryName} ${_conditionType_} a.categoryName like #{${_conditionParam_}.categoryName}
</if>
<if test="conditionParamRef.categoryName == null">
${_conditionType_} a.categoryName is null
</if>
</if>
<if test="conditionParamRef.containsKey('categoryNameList') and conditionParamRef.categoryNameList.size() > 0">
${_conditionType_} a.categoryName in
<foreach collection="conditionParamRef.categoryNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('categoryNameNotList') and conditionParamRef.categoryNameNotList.size() > 0"> <if test="conditionParamRef.categoryName == null">
${_conditionType_} a.categoryName not in ${_conditionType_} a.categoryName is null
<foreach collection="conditionParamRef.categoryNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
</if>
<if test="conditionParamRef.containsKey('categoryNameList') and conditionParamRef.categoryNameList.size() > 0">
${_conditionType_} a.categoryName in
<foreach collection="conditionParamRef.categoryNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('categoryNameNotList') and conditionParamRef.categoryNameNotList.size() > 0">
${_conditionType_} a.categoryName not in
<foreach collection="conditionParamRef.categoryNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('name')"> <if test="conditionParamRef.containsKey('name')">
<if test="conditionParamRef.name != null and conditionParamRef.name != ''"> <if test="conditionParamRef.name != null and conditionParamRef.name != ''">
${_conditionType_} a.name like #{${_conditionParam_}.name} ${_conditionType_} a.name like #{${_conditionParam_}.name}
</if>
<if test="conditionParamRef.name == null">
${_conditionType_} a.name is null
</if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0"> <if test="conditionParamRef.name == null">
${_conditionType_} a.name not in ${_conditionType_} a.name is null
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('content')"> <if test="conditionParamRef.containsKey('content')">
<if test="conditionParamRef.content != null and conditionParamRef.content != ''"> <if test="conditionParamRef.content != null and conditionParamRef.content != ''">
${_conditionType_} a.content like #{${_conditionParam_}.content} ${_conditionType_} a.content like #{${_conditionParam_}.content}
</if>
<if test="conditionParamRef.content == null">
${_conditionType_} a.content is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('contentList') and conditionParamRef.contentList.size() > 0"> <if test="conditionParamRef.content == null">
${_conditionType_} a.content in ${_conditionType_} a.content is null
<foreach collection="conditionParamRef.contentList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('contentNotList') and conditionParamRef.contentNotList.size() > 0"> </if>
${_conditionType_} a.content not in <if test="conditionParamRef.containsKey('contentList') and conditionParamRef.contentList.size() > 0">
<foreach collection="conditionParamRef.contentNotList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.content in
#{item} <foreach collection="conditionParamRef.contentList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('subAddType')"> </if>
<if test="conditionParamRef.subAddType != null "> <if test="conditionParamRef.containsKey('contentNotList') and conditionParamRef.contentNotList.size() > 0">
${_conditionType_} a.subAddType = #{${_conditionParam_}.subAddType} ${_conditionType_} a.content not in
</if> <foreach collection="conditionParamRef.contentNotList" open="(" close=")" index="index" item="item" separator=",">
<if test="conditionParamRef.subAddType == null"> #{item}
${_conditionType_} a.subAddType is null </foreach>
</if> </if>
</if> <if test="conditionParamRef.containsKey('subAddType')">
<if test="conditionParamRef.containsKey('subAddTypeList') and conditionParamRef.subAddTypeList.size() > 0"> <if test="conditionParamRef.subAddType != null ">
${_conditionType_} a.subAddType in ${_conditionType_} a.subAddType = #{${_conditionParam_}.subAddType}
<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>
<if test="conditionParamRef.containsKey('subAddTypeEnd') and conditionParamRef.subAddTypeEnd != null"> <if test="conditionParamRef.subAddType == null">
${_conditionType_} a.subAddType <![CDATA[ <= ]]> #{${_conditionParam_}.subAddTypeEnd} ${_conditionType_} a.subAddType is null
</if> </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.containsKey('score')">
<if test="conditionParamRef.score != null "> <if test="conditionParamRef.score != null ">
${_conditionType_} a.score = #{${_conditionParam_}.score} ${_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>
<if test="conditionParamRef.containsKey('scoreEnd') and conditionParamRef.scoreEnd != null"> <if test="conditionParamRef.score == null">
${_conditionType_} a.score <![CDATA[ <= ]]> #{${_conditionParam_}.scoreEnd} ${_conditionType_} a.score is null
</if> </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('assoOwner')"> <if test="conditionParamRef.containsKey('assoOwner')">
<if test="conditionParamRef.assoOwner != null "> <if test="conditionParamRef.assoOwner != null ">
${_conditionType_} a.assoOwner = #{${_conditionParam_}.assoOwner} ${_conditionType_} a.assoOwner = #{${_conditionParam_}.assoOwner}
</if>
<if test="conditionParamRef.assoOwner == null">
${_conditionType_} a.assoOwner is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('assoOwnerList') and conditionParamRef.assoOwnerList.size() > 0"> <if test="conditionParamRef.assoOwner == null">
${_conditionType_} a.assoOwner in ${_conditionType_} a.assoOwner is null
<foreach collection="conditionParamRef.assoOwnerList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('assoOwnerNotList') and conditionParamRef.assoOwnerNotList.size() > 0">
${_conditionType_} a.assoOwner not in
<foreach collection="conditionParamRef.assoOwnerNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('assoOwnerStart') and conditionParamRef.assoOwnerStart != null">
${_conditionType_} a.assoOwner <![CDATA[ >= ]]> #{${_conditionParam_}.assoOwnerStart}
</if>
<if test="conditionParamRef.containsKey('assoOwnerEnd') and conditionParamRef.assoOwnerEnd != null">
${_conditionType_} a.assoOwner <![CDATA[ <= ]]> #{${_conditionParam_}.assoOwnerEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('assoOwnerList') and conditionParamRef.assoOwnerList.size() > 0">
${_conditionType_} a.assoOwner in
<foreach collection="conditionParamRef.assoOwnerList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('assoOwnerNotList') and conditionParamRef.assoOwnerNotList.size() > 0">
${_conditionType_} a.assoOwner not in
<foreach collection="conditionParamRef.assoOwnerNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('assoOwnerStart') and conditionParamRef.assoOwnerStart != null">
${_conditionType_} a.assoOwner <![CDATA[ >= ]]> #{${_conditionParam_}.assoOwnerStart}
</if>
<if test="conditionParamRef.containsKey('assoOwnerEnd') and conditionParamRef.assoOwnerEnd != null">
${_conditionType_} a.assoOwner <![CDATA[ <= ]]> #{${_conditionParam_}.assoOwnerEnd}
</if>
<if test="conditionParamRef.containsKey('ownerScore')"> <if test="conditionParamRef.containsKey('ownerScore')">
<if test="conditionParamRef.ownerScore != null "> <if test="conditionParamRef.ownerScore != null ">
${_conditionType_} a.ownerScore = #{${_conditionParam_}.ownerScore} ${_conditionType_} a.ownerScore = #{${_conditionParam_}.ownerScore}
</if>
<if test="conditionParamRef.ownerScore == null">
${_conditionType_} a.ownerScore is null
</if>
</if>
<if test="conditionParamRef.containsKey('ownerScoreList') and conditionParamRef.ownerScoreList.size() > 0">
${_conditionType_} a.ownerScore in
<foreach collection="conditionParamRef.ownerScoreList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ownerScoreNotList') and conditionParamRef.ownerScoreNotList.size() > 0">
${_conditionType_} a.ownerScore not in
<foreach collection="conditionParamRef.ownerScoreNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('ownerScoreStart') and conditionParamRef.ownerScoreStart != null"> <if test="conditionParamRef.ownerScore == null">
${_conditionType_} a.ownerScore <![CDATA[ >= ]]> #{${_conditionParam_}.ownerScoreStart} ${_conditionType_} a.ownerScore is null
</if>
<if test="conditionParamRef.containsKey('ownerScoreEnd') and conditionParamRef.ownerScoreEnd != null">
${_conditionType_} a.ownerScore <![CDATA[ <= ]]> #{${_conditionParam_}.ownerScoreEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('ownerScoreList') and conditionParamRef.ownerScoreList.size() > 0">
${_conditionType_} a.ownerScore in
<foreach collection="conditionParamRef.ownerScoreList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ownerScoreNotList') and conditionParamRef.ownerScoreNotList.size() > 0">
${_conditionType_} a.ownerScore not in
<foreach collection="conditionParamRef.ownerScoreNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ownerScoreStart') and conditionParamRef.ownerScoreStart != null">
${_conditionType_} a.ownerScore <![CDATA[ >= ]]> #{${_conditionParam_}.ownerScoreStart}
</if>
<if test="conditionParamRef.containsKey('ownerScoreEnd') and conditionParamRef.ownerScoreEnd != null">
${_conditionType_} a.ownerScore <![CDATA[ <= ]]> #{${_conditionParam_}.ownerScoreEnd}
</if>
<if test="conditionParamRef.containsKey('remark')"> <if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''"> <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.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>
<if test="conditionParamRef.containsKey('type')"> <if test="conditionParamRef.remark == null">
<if test="conditionParamRef.type != null "> ${_conditionType_} a.remark is null
${_conditionType_} a.type = #{${_conditionParam_}.type}
</if>
<if test="conditionParamRef.type == null">
${_conditionType_} a.type is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('typeList') and conditionParamRef.typeList.size() > 0"> </if>
${_conditionType_} a.type in <if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
<foreach collection="conditionParamRef.typeList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.remark in
#{item} <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('typeNotList') and conditionParamRef.typeNotList.size() > 0"> </if>
${_conditionType_} a.type not in <if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
<foreach collection="conditionParamRef.typeNotList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.remark not in
#{item} <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('typeStart') and conditionParamRef.typeStart != null"> </if>
${_conditionType_} a.type <![CDATA[ >= ]]> #{${_conditionParam_}.typeStart} <if test="conditionParamRef.containsKey('type')">
<if test="conditionParamRef.type != null ">
${_conditionType_} a.type = #{${_conditionParam_}.type}
</if> </if>
<if test="conditionParamRef.containsKey('typeEnd') and conditionParamRef.typeEnd != null"> <if test="conditionParamRef.type == null">
${_conditionType_} a.type <![CDATA[ <= ]]> #{${_conditionParam_}.typeEnd} ${_conditionType_} a.type is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('typeList') and conditionParamRef.typeList.size() > 0">
${_conditionType_} a.type in
<foreach collection="conditionParamRef.typeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('typeNotList') and conditionParamRef.typeNotList.size() > 0">
${_conditionType_} a.type not in
<foreach collection="conditionParamRef.typeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('typeStart') and conditionParamRef.typeStart != null">
${_conditionType_} a.type <![CDATA[ >= ]]> #{${_conditionParam_}.typeStart}
</if>
<if test="conditionParamRef.containsKey('typeEnd') and conditionParamRef.typeEnd != null">
${_conditionType_} a.type <![CDATA[ <= ]]> #{${_conditionParam_}.typeEnd}
</if>
<if test="conditionParamRef.containsKey('createUserId')"> <if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null "> <if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId} ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0"> <if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId in ${_conditionType_} a.createUserId is null
<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>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')"> <if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null "> <if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime} ${_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>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''"> <if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.createTime is null
</if> </if>
<if test="conditionParamRef.containsKey('updateUserId')"> </if>
<if test="conditionParamRef.updateUserId != null "> <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId} ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.updateUserId == null"> <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.updateUserId is null ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
</if> <if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0"> <if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId in ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
<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>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null"> <if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd} ${_conditionType_} a.updateUserId is null
</if> </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.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null "> <if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime} ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''"> <if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.updateTime is null
</if> </if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''"> </if>
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('ruleCode')">
<if test="conditionParamRef.ruleCode != null and conditionParamRef.ruleCode != ''">
${_conditionType_} a.ruleCode like #{${_conditionParam_}.ruleCode}
</if> </if>
<if test="conditionParamRef.ruleCode == null">
${_conditionType_} a.ruleCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('ruleCodeList') and conditionParamRef.ruleCodeList.size() > 0">
${_conditionType_} a.ruleCode in
<foreach collection="conditionParamRef.ruleCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ruleCodeNotList') and conditionParamRef.ruleCodeNotList.size() > 0">
${_conditionType_} a.ruleCode not in
<foreach collection="conditionParamRef.ruleCodeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql> </sql>
<sql id="_orderCols_"> <sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()"> <if test="orderColList != null and !orderColList.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=","> <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind} ${item.colName} ${item.sortKind}
</foreach> </foreach>
</trim> </trim>
</if> </if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()"> <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')"> <if test="orderCol.containsKey('id')">
a.id a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if> <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('categoryId')"> <if test="orderCol.containsKey('categoryId')">
a.categoryId a.categoryId
<if test='orderCol.categoryId != null and "DESC".equalsIgnoreCase(orderCol.categoryId)'>DESC</if> <if test='orderCol.categoryId != null and "DESC".equalsIgnoreCase(orderCol.categoryId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('categoryName')"> <if test="orderCol.containsKey('categoryName')">
a.categoryName a.categoryName
<if test='orderCol.categoryName != null and "DESC".equalsIgnoreCase(orderCol.categoryName)'>DESC</if> <if test='orderCol.categoryName != null and "DESC".equalsIgnoreCase(orderCol.categoryName)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('name')"> <if test="orderCol.containsKey('name')">
a.name a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if> <if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('content')"> <if test="orderCol.containsKey('content')">
a.content a.content
<if test='orderCol.content != null and "DESC".equalsIgnoreCase(orderCol.content)'>DESC</if> <if test='orderCol.content != null and "DESC".equalsIgnoreCase(orderCol.content)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('subAddType')"> <if test="orderCol.containsKey('subAddType')">
a.subAddType a.subAddType
<if test='orderCol.subAddType != null and "DESC".equalsIgnoreCase(orderCol.subAddType)'>DESC</if> <if test='orderCol.subAddType != null and "DESC".equalsIgnoreCase(orderCol.subAddType)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('score')"> <if test="orderCol.containsKey('score')">
a.score a.score
<if test='orderCol.score != null and "DESC".equalsIgnoreCase(orderCol.score)'>DESC</if> <if test='orderCol.score != null and "DESC".equalsIgnoreCase(orderCol.score)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('assoOwner')"> <if test="orderCol.containsKey('assoOwner')">
a.assoOwner a.assoOwner
<if test='orderCol.assoOwner != null and "DESC".equalsIgnoreCase(orderCol.assoOwner)'>DESC</if> <if test='orderCol.assoOwner != null and "DESC".equalsIgnoreCase(orderCol.assoOwner)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('ownerScore')"> <if test="orderCol.containsKey('ownerScore')">
a.ownerScore a.ownerScore
<if test='orderCol.ownerScore != null and "DESC".equalsIgnoreCase(orderCol.ownerScore)'>DESC</if> <if test='orderCol.ownerScore != null and "DESC".equalsIgnoreCase(orderCol.ownerScore)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('remark')"> <if test="orderCol.containsKey('remark')">
a.remark a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if> <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('type')"> <if test="orderCol.containsKey('type')">
a.type a.type
<if test='orderCol.type != null and "DESC".equalsIgnoreCase(orderCol.type)'>DESC</if> <if test='orderCol.type != null and "DESC".equalsIgnoreCase(orderCol.type)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createUserId')"> <if test="orderCol.containsKey('createUserId')">
a.createUserId a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if> <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createTime')"> <if test="orderCol.containsKey('createTime')">
a.createTime a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if> <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateUserId')"> <if test="orderCol.containsKey('updateUserId')">
a.updateUserId a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if> <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateTime')"> <if test="orderCol.containsKey('updateTime')">
a.updateTime a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if> <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('ruleCode')">
a.ruleCode
<if test='orderCol.ruleCode != null and "DESC".equalsIgnoreCase(orderCol.ruleCode)'>DESC</if>
,
</if>
</trim> </trim>
</if> </if>
</sql> </sql>
......
db/add.sql
View file @ 61ab114c
...@@ -381,3 +381,6 @@ ALTER TABLE mortals_xhx_check_other_record ADD COLUMN `categoryId` bigint(20) ...@@ -381,3 +381,6 @@ ALTER TABLE mortals_xhx_check_other_record ADD COLUMN `categoryId` bigint(20)
ALTER TABLE mortals_xhx_check_other_record ADD COLUMN `categoryName` varchar(128) COMMENT '规则名称' AFTER categoryId; ALTER TABLE mortals_xhx_check_other_record ADD COLUMN `categoryName` varchar(128) COMMENT '规则名称' AFTER categoryId;
ALTER TABLE mortals_xhx_perform_rules ADD COLUMN `ruleCode` varchar(64) COMMENT '规则编码，唯一,默认规则类型内容简称拼音首字母。'AFTER id;
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