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