Skip to content

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

修改特殊配置字段实体类

parent 970816ee
Hide whitespace changes
Inline Side-by-side
Showing with 4535 additions and 4522 deletions
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/model/AttendanceGroupFixedworkSpecialEntity.java
View file @ 9173472b
...@@ -8,180 +8,180 @@ import com.mortals.framework.annotation.Excel; ...@@ -8,180 +8,180 @@ import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.attendance.model.vo.AttendanceGroupFixedworkSpecialVo; import com.mortals.xhx.module.attendance.model.vo.AttendanceGroupFixedworkSpecialVo;
/** /**
* 考勤组考勤固定班制特殊日期配置实体对象 * 考勤组考勤固定班制特殊日期配置实体对象
* *
* @author zxfei * @author zxfei
* @date 2023-04-08 * @date 2023-04-10
*/ */
public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedworkSpecialVo { public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedworkSpecialVo {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 固定班制考勤配置id * 固定班制考勤配置id
*/ */
private Long fixedWorkId; private Long fixedWorkId;
/** /**
* 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
*/ */
private Integer must; private Integer must;
/** /**
* 班次ID * 班次ID
*/ */
private Long classId; private Long classId;
/** /**
* 班次名称 * 班次名称
*/ */
private String className; private String className;
/** /**
* 无需打卡的日期类型(0.单个日期,1.时间段) * 无需打卡的日期类型(0.单个日期,1.时间段)
*/ */
private Integer addWay; private Integer addWay;
/** /**
* 特殊时间 * 特殊时间
*/ */
private Date specialTime; private Date specialTime;
/** /**
* 时间段时候开始时间 * 备注
*/ */
private Date specialTimeStart; private String remark;
/** /**
* 时间段结束时间 * 时间段时候开始时间
*/ */
private Date specialTimeEnd; private Date specialStartTime;
/** /**
* 备注 * 时间段结束时间
*/ */
private String remark; private Date specialEndTime;
public AttendanceGroupFixedworkSpecialEntity(){} public AttendanceGroupFixedworkSpecialEntity(){}
/** /**
* 获取 固定班制考勤配置id * 获取 固定班制考勤配置id
* @return Long * @return Long
*/ */
public Long getFixedWorkId(){ public Long getFixedWorkId(){
return fixedWorkId; return fixedWorkId;
} }
/** /**
* 设置 固定班制考勤配置id * 设置 固定班制考勤配置id
* @param fixedWorkId * @param fixedWorkId
*/ */
public void setFixedWorkId(Long fixedWorkId){ public void setFixedWorkId(Long fixedWorkId){
this.fixedWorkId = fixedWorkId; this.fixedWorkId = fixedWorkId;
} }
/** /**
* 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return Integer * @return Integer
*/ */
public Integer getMust(){ public Integer getMust(){
return must; return must;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param must * @param must
*/ */
public void setMust(Integer must){ public void setMust(Integer must){
this.must = must; this.must = must;
} }
/** /**
* 获取 班次ID * 获取 班次ID
* @return Long * @return Long
*/ */
public Long getClassId(){ public Long getClassId(){
return classId; return classId;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classId * @param classId
*/ */
public void setClassId(Long classId){ public void setClassId(Long classId){
this.classId = classId; this.classId = classId;
} }
/** /**
* 获取 班次名称 * 获取 班次名称
* @return String * @return String
*/ */
public String getClassName(){ public String getClassName(){
return className; return className;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param className * @param className
*/ */
public void setClassName(String className){ public void setClassName(String className){
this.className = className; this.className = className;
} }
/** /**
* 获取 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 无需打卡的日期类型(0.单个日期,1.时间段)
* @return Integer * @return Integer
*/ */
public Integer getAddWay(){ public Integer getAddWay(){
return addWay; return addWay;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWay * @param addWay
*/ */
public void setAddWay(Integer addWay){ public void setAddWay(Integer addWay){
this.addWay = addWay; this.addWay = addWay;
} }
/** /**
* 获取 特殊时间 * 获取 特殊时间
* @return Date * @return Date
*/ */
public Date getSpecialTime(){ public Date getSpecialTime(){
return specialTime; return specialTime;
} }
/** /**
* 设置 特殊时间 * 设置 特殊时间
* @param specialTime * @param specialTime
*/ */
public void setSpecialTime(Date specialTime){ public void setSpecialTime(Date specialTime){
this.specialTime = specialTime; this.specialTime = specialTime;
} }
/** /**
* 获取 时间段时候开始时间 * 获取 备注
* @return Date * @return String
*/ */
public Date getSpecialTimeStart(){ public String getRemark(){
return specialTimeStart; return remark;
} }
/** /**
* 设置 时间段时候开始时间 * 设置 备注
* @param specialTimeStart * @param remark
*/ */
public void setSpecialTimeStart(Date specialTimeStart){ public void setRemark(String remark){
this.specialTimeStart = specialTimeStart; this.remark = remark;
} }
/** /**
* 获取 时间段结束时间 * 获取 时间段时候开始时间
* @return Date * @return Date
*/ */
public Date getSpecialTimeEnd(){ public Date getSpecialStartTime(){
return specialTimeEnd; return specialStartTime;
} }
/** /**
* 设置 时间段结束时间 * 设置 时间段时候开始时间
* @param specialTimeEnd * @param specialStartTime
*/ */
public void setSpecialTimeEnd(Date specialTimeEnd){ public void setSpecialStartTime(Date specialStartTime){
this.specialTimeEnd = specialTimeEnd; this.specialStartTime = specialStartTime;
} }
/** /**
* 获取 备注 * 获取 时间段结束时间
* @return String * @return Date
*/ */
public String getRemark(){ public Date getSpecialEndTime(){
return remark; return specialEndTime;
} }
/** /**
* 设置 备注 * 设置 时间段结束时间
* @param remark * @param specialEndTime
*/ */
public void setRemark(String remark){ public void setSpecialEndTime(Date specialEndTime){
this.remark = remark; this.specialEndTime = specialEndTime;
} }
...@@ -189,7 +189,7 @@ public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedw ...@@ -189,7 +189,7 @@ public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedw
@Override @Override
public int hashCode() { public int hashCode() {
return this.getId().hashCode(); return this.getId().hashCode();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
...@@ -197,7 +197,7 @@ public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedw ...@@ -197,7 +197,7 @@ public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedw
if (obj instanceof AttendanceGroupFixedworkSpecialEntity) { if (obj instanceof AttendanceGroupFixedworkSpecialEntity) {
AttendanceGroupFixedworkSpecialEntity tmp = (AttendanceGroupFixedworkSpecialEntity) obj; AttendanceGroupFixedworkSpecialEntity tmp = (AttendanceGroupFixedworkSpecialEntity) obj;
if (this.getId() == tmp.getId()) { if (this.getId() == tmp.getId()) {
return true; return true;
} }
} }
return false; return false;
...@@ -211,30 +211,30 @@ public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedw ...@@ -211,30 +211,30 @@ public class AttendanceGroupFixedworkSpecialEntity extends AttendanceGroupFixedw
sb.append(",className:").append(getClassName()); sb.append(",className:").append(getClassName());
sb.append(",addWay:").append(getAddWay()); sb.append(",addWay:").append(getAddWay());
sb.append(",specialTime:").append(getSpecialTime()); sb.append(",specialTime:").append(getSpecialTime());
sb.append(",specialTimeStart:").append(getSpecialTimeStart());
sb.append(",specialTimeEnd:").append(getSpecialTimeEnd());
sb.append(",remark:").append(getRemark()); sb.append(",remark:").append(getRemark());
sb.append(",specialStartTime:").append(getSpecialStartTime());
sb.append(",specialEndTime:").append(getSpecialEndTime());
return sb.toString(); return sb.toString();
} }
public void initAttrValue(){ public void initAttrValue(){
this.fixedWorkId = null; this.fixedWorkId = null;
this.must = 0; this.must = 0;
this.classId = null; this.classId = null;
this.className = ""; this.className = "";
this.addWay = 0; this.addWay = 0;
this.specialTime = null; this.specialTime = null;
this.specialTimeStart = null; this.remark = "";
this.specialTimeEnd = null; this.specialStartTime = null;
this.remark = ""; this.specialEndTime = null;
} }
} }
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/model/AttendanceGroupFixedworkSpecialQuery.java
View file @ 9173472b
...@@ -4,11 +4,11 @@ import java.util.Date; ...@@ -4,11 +4,11 @@ import java.util.Date;
import java.util.List; import java.util.List;
import com.mortals.xhx.module.attendance.model.AttendanceGroupFixedworkSpecialEntity; import com.mortals.xhx.module.attendance.model.AttendanceGroupFixedworkSpecialEntity;
/** /**
* 考勤组考勤固定班制特殊日期配置查询对象 * 考勤组考勤固定班制特殊日期配置查询对象
* *
* @author zxfei * @author zxfei
* @date 2023-04-08 * @date 2023-04-10
*/ */
public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedworkSpecialEntity { public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedworkSpecialEntity {
/** 开始 序号，主键，自增长 */ /** 开始 序号，主键，自增长 */
private Long idStart; private Long idStart;
...@@ -96,18 +96,6 @@ public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedwo ...@@ -96,18 +96,6 @@ public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedwo
/** 结束 特殊时间 */ /** 结束 特殊时间 */
private String specialTimeEnd; private String specialTimeEnd;
/** 开始 时间段时候开始时间 */
private String specialTimeStartStart;
/** 结束 时间段时候开始时间 */
private String specialTimeStartEnd;
/** 开始 时间段结束时间 */
private String specialTimeEndStart;
/** 结束 时间段结束时间 */
private String specialTimeEndEnd;
/** 备注 */ /** 备注 */
private List<String> remarkList; private List<String> remarkList;
...@@ -155,6 +143,18 @@ public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedwo ...@@ -155,6 +143,18 @@ public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedwo
/** 结束 更新时间 */ /** 结束 更新时间 */
private String updateTimeEnd; private String updateTimeEnd;
/** 开始 时间段时候开始时间 */
private String specialStartTimeStart;
/** 结束 时间段时候开始时间 */
private String specialStartTimeEnd;
/** 开始 时间段结束时间 */
private String specialEndTimeStart;
/** 结束 时间段结束时间 */
private String specialEndTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */ /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<AttendanceGroupFixedworkSpecialQuery> orConditionList; private List<AttendanceGroupFixedworkSpecialQuery> orConditionList;
...@@ -164,1245 +164,1245 @@ public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedwo ...@@ -164,1245 +164,1245 @@ public class AttendanceGroupFixedworkSpecialQuery extends AttendanceGroupFixedwo
public AttendanceGroupFixedworkSpecialQuery(){} public AttendanceGroupFixedworkSpecialQuery(){}
/** /**
* 获取 开始 序号，主键，自增长 * 获取 开始 序号，主键，自增长
* @return idStart * @return idStart
*/ */
public Long getIdStart(){ public Long getIdStart(){
return this.idStart; return this.idStart;
} }
/** /**
* 设置 开始 序号，主键，自增长 * 设置 开始 序号，主键，自增长
* @param idStart * @param idStart
*/ */
public void setIdStart(Long idStart){ public void setIdStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
} }
/** /**
* 获取 结束 序号，主键，自增长 * 获取 结束 序号，主键，自增长
* @return $idEnd * @return $idEnd
*/ */
public Long getIdEnd(){ public Long getIdEnd(){
return this.idEnd; return this.idEnd;
} }
/** /**
* 设置 结束 序号，主键，自增长 * 设置 结束 序号，主键，自增长
* @param idEnd * @param idEnd
*/ */
public void setIdEnd(Long idEnd){ public void setIdEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
} }
/** /**
* 获取 增加 序号，主键，自增长 * 获取 增加 序号，主键，自增长
* @return idIncrement * @return idIncrement
*/ */
public Long getIdIncrement(){ public Long getIdIncrement(){
return this.idIncrement; return this.idIncrement;
} }
/** /**
* 设置 增加 序号，主键，自增长 * 设置 增加 序号，主键，自增长
* @param idIncrement * @param idIncrement
*/ */
public void setIdIncrement(Long idIncrement){ public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
} }
/** /**
* 获取 序号，主键，自增长 * 获取 序号，主键，自增长
* @return idList * @return idList
*/ */
public List<Long> getIdList(){ public List<Long> getIdList(){
return this.idList; return this.idList;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idList * @param idList
*/ */
public void setIdList(List<Long> idList){ public void setIdList(List<Long> idList){
this.idList = idList; this.idList = idList;
} }
/** /**
* 获取 序号，主键，自增长 * 获取 序号，主键，自增长
* @return idNotList * @return idNotList
*/ */
public List<Long> getIdNotList(){ public List<Long> getIdNotList(){
return this.idNotList; return this.idNotList;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idNotList * @param idNotList
*/ */
public void setIdNotList(List<Long> idNotList){ public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList; this.idNotList = idNotList;
} }
/** /**
* 获取 开始 固定班制考勤配置id * 获取 开始 固定班制考勤配置id
* @return fixedWorkIdStart * @return fixedWorkIdStart
*/ */
public Long getFixedWorkIdStart(){ public Long getFixedWorkIdStart(){
return this.fixedWorkIdStart; return this.fixedWorkIdStart;
} }
/** /**
* 设置 开始 固定班制考勤配置id * 设置 开始 固定班制考勤配置id
* @param fixedWorkIdStart * @param fixedWorkIdStart
*/ */
public void setFixedWorkIdStart(Long fixedWorkIdStart){ public void setFixedWorkIdStart(Long fixedWorkIdStart){
this.fixedWorkIdStart = fixedWorkIdStart; this.fixedWorkIdStart = fixedWorkIdStart;
} }
/** /**
* 获取 结束 固定班制考勤配置id * 获取 结束 固定班制考勤配置id
* @return $fixedWorkIdEnd * @return $fixedWorkIdEnd
*/ */
public Long getFixedWorkIdEnd(){ public Long getFixedWorkIdEnd(){
return this.fixedWorkIdEnd; return this.fixedWorkIdEnd;
} }
/** /**
* 设置 结束 固定班制考勤配置id * 设置 结束 固定班制考勤配置id
* @param fixedWorkIdEnd * @param fixedWorkIdEnd
*/ */
public void setFixedWorkIdEnd(Long fixedWorkIdEnd){ public void setFixedWorkIdEnd(Long fixedWorkIdEnd){
this.fixedWorkIdEnd = fixedWorkIdEnd; this.fixedWorkIdEnd = fixedWorkIdEnd;
} }
/** /**
* 获取 增加 固定班制考勤配置id * 获取 增加 固定班制考勤配置id
* @return fixedWorkIdIncrement * @return fixedWorkIdIncrement
*/ */
public Long getFixedWorkIdIncrement(){ public Long getFixedWorkIdIncrement(){
return this.fixedWorkIdIncrement; return this.fixedWorkIdIncrement;
} }
/** /**
* 设置 增加 固定班制考勤配置id * 设置 增加 固定班制考勤配置id
* @param fixedWorkIdIncrement * @param fixedWorkIdIncrement
*/ */
public void setFixedWorkIdIncrement(Long fixedWorkIdIncrement){ public void setFixedWorkIdIncrement(Long fixedWorkIdIncrement){
this.fixedWorkIdIncrement = fixedWorkIdIncrement; this.fixedWorkIdIncrement = fixedWorkIdIncrement;
} }
/** /**
* 获取 固定班制考勤配置id * 获取 固定班制考勤配置id
* @return fixedWorkIdList * @return fixedWorkIdList
*/ */
public List<Long> getFixedWorkIdList(){ public List<Long> getFixedWorkIdList(){
return this.fixedWorkIdList; return this.fixedWorkIdList;
} }
/** /**
* 设置 固定班制考勤配置id * 设置 固定班制考勤配置id
* @param fixedWorkIdList * @param fixedWorkIdList
*/ */
public void setFixedWorkIdList(List<Long> fixedWorkIdList){ public void setFixedWorkIdList(List<Long> fixedWorkIdList){
this.fixedWorkIdList = fixedWorkIdList; this.fixedWorkIdList = fixedWorkIdList;
} }
/** /**
* 获取 固定班制考勤配置id * 获取 固定班制考勤配置id
* @return fixedWorkIdNotList * @return fixedWorkIdNotList
*/ */
public List<Long> getFixedWorkIdNotList(){ public List<Long> getFixedWorkIdNotList(){
return this.fixedWorkIdNotList; return this.fixedWorkIdNotList;
} }
/** /**
* 设置 固定班制考勤配置id * 设置 固定班制考勤配置id
* @param fixedWorkIdNotList * @param fixedWorkIdNotList
*/ */
public void setFixedWorkIdNotList(List<Long> fixedWorkIdNotList){ public void setFixedWorkIdNotList(List<Long> fixedWorkIdNotList){
this.fixedWorkIdNotList = fixedWorkIdNotList; this.fixedWorkIdNotList = fixedWorkIdNotList;
} }
/** /**
* 获取 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustStart * @return mustStart
*/ */
public Integer getMustStart(){ public Integer getMustStart(){
return this.mustStart; return this.mustStart;
} }
/** /**
* 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustStart * @param mustStart
*/ */
public void setMustStart(Integer mustStart){ public void setMustStart(Integer mustStart){
this.mustStart = mustStart; this.mustStart = mustStart;
} }
/** /**
* 获取 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return $mustEnd * @return $mustEnd
*/ */
public Integer getMustEnd(){ public Integer getMustEnd(){
return this.mustEnd; return this.mustEnd;
} }
/** /**
* 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustEnd * @param mustEnd
*/ */
public void setMustEnd(Integer mustEnd){ public void setMustEnd(Integer mustEnd){
this.mustEnd = mustEnd; this.mustEnd = mustEnd;
} }
/** /**
* 获取 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustIncrement * @return mustIncrement
*/ */
public Integer getMustIncrement(){ public Integer getMustIncrement(){
return this.mustIncrement; return this.mustIncrement;
} }
/** /**
* 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustIncrement * @param mustIncrement
*/ */
public void setMustIncrement(Integer mustIncrement){ public void setMustIncrement(Integer mustIncrement){
this.mustIncrement = mustIncrement; this.mustIncrement = mustIncrement;
} }
/** /**
* 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustList * @return mustList
*/ */
public List<Integer> getMustList(){ public List<Integer> getMustList(){
return this.mustList; return this.mustList;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustList * @param mustList
*/ */
public void setMustList(List<Integer> mustList){ public void setMustList(List<Integer> mustList){
this.mustList = mustList; this.mustList = mustList;
} }
/** /**
* 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustNotList * @return mustNotList
*/ */
public List<Integer> getMustNotList(){ public List<Integer> getMustNotList(){
return this.mustNotList; return this.mustNotList;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustNotList * @param mustNotList
*/ */
public void setMustNotList(List<Integer> mustNotList){ public void setMustNotList(List<Integer> mustNotList){
this.mustNotList = mustNotList; this.mustNotList = mustNotList;
} }
/** /**
* 获取 开始 班次ID * 获取 开始 班次ID
* @return classIdStart * @return classIdStart
*/ */
public Long getClassIdStart(){ public Long getClassIdStart(){
return this.classIdStart; return this.classIdStart;
} }
/** /**
* 设置 开始 班次ID * 设置 开始 班次ID
* @param classIdStart * @param classIdStart
*/ */
public void setClassIdStart(Long classIdStart){ public void setClassIdStart(Long classIdStart){
this.classIdStart = classIdStart; this.classIdStart = classIdStart;
} }
/** /**
* 获取 结束 班次ID * 获取 结束 班次ID
* @return $classIdEnd * @return $classIdEnd
*/ */
public Long getClassIdEnd(){ public Long getClassIdEnd(){
return this.classIdEnd; return this.classIdEnd;
} }
/** /**
* 设置 结束 班次ID * 设置 结束 班次ID
* @param classIdEnd * @param classIdEnd
*/ */
public void setClassIdEnd(Long classIdEnd){ public void setClassIdEnd(Long classIdEnd){
this.classIdEnd = classIdEnd; this.classIdEnd = classIdEnd;
} }
/** /**
* 获取 增加 班次ID * 获取 增加 班次ID
* @return classIdIncrement * @return classIdIncrement
*/ */
public Long getClassIdIncrement(){ public Long getClassIdIncrement(){
return this.classIdIncrement; return this.classIdIncrement;
} }
/** /**
* 设置 增加 班次ID * 设置 增加 班次ID
* @param classIdIncrement * @param classIdIncrement
*/ */
public void setClassIdIncrement(Long classIdIncrement){ public void setClassIdIncrement(Long classIdIncrement){
this.classIdIncrement = classIdIncrement; this.classIdIncrement = classIdIncrement;
} }
/** /**
* 获取 班次ID * 获取 班次ID
* @return classIdList * @return classIdList
*/ */
public List<Long> getClassIdList(){ public List<Long> getClassIdList(){
return this.classIdList; return this.classIdList;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdList * @param classIdList
*/ */
public void setClassIdList(List<Long> classIdList){ public void setClassIdList(List<Long> classIdList){
this.classIdList = classIdList; this.classIdList = classIdList;
} }
/** /**
* 获取 班次ID * 获取 班次ID
* @return classIdNotList * @return classIdNotList
*/ */
public List<Long> getClassIdNotList(){ public List<Long> getClassIdNotList(){
return this.classIdNotList; return this.classIdNotList;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdNotList * @param classIdNotList
*/ */
public void setClassIdNotList(List<Long> classIdNotList){ public void setClassIdNotList(List<Long> classIdNotList){
this.classIdNotList = classIdNotList; this.classIdNotList = classIdNotList;
} }
/** /**
* 获取 班次名称 * 获取 班次名称
* @return classNameList * @return classNameList
*/ */
public List<String> getClassNameList(){ public List<String> getClassNameList(){
return this.classNameList; return this.classNameList;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param classNameList * @param classNameList
*/ */
public void setClassNameList(List<String> classNameList){ public void setClassNameList(List<String> classNameList){
this.classNameList = classNameList; this.classNameList = classNameList;
} }
/** /**
* 获取 班次名称 * 获取 班次名称
* @return classNameNotList * @return classNameNotList
*/ */
public List<String> getClassNameNotList(){ public List<String> getClassNameNotList(){
return this.classNameNotList; return this.classNameNotList;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param classNameNotList * @param classNameNotList
*/ */
public void setClassNameNotList(List<String> classNameNotList){ public void setClassNameNotList(List<String> classNameNotList){
this.classNameNotList = classNameNotList; this.classNameNotList = classNameNotList;
} }
/** /**
* 获取 开始 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 开始 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayStart * @return addWayStart
*/ */
public Integer getAddWayStart(){ public Integer getAddWayStart(){
return this.addWayStart; return this.addWayStart;
} }
/** /**
* 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayStart * @param addWayStart
*/ */
public void setAddWayStart(Integer addWayStart){ public void setAddWayStart(Integer addWayStart){
this.addWayStart = addWayStart; this.addWayStart = addWayStart;
} }
/** /**
* 获取 结束 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 结束 无需打卡的日期类型(0.单个日期,1.时间段)
* @return $addWayEnd * @return $addWayEnd
*/ */
public Integer getAddWayEnd(){ public Integer getAddWayEnd(){
return this.addWayEnd; return this.addWayEnd;
} }
/** /**
* 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayEnd * @param addWayEnd
*/ */
public void setAddWayEnd(Integer addWayEnd){ public void setAddWayEnd(Integer addWayEnd){
this.addWayEnd = addWayEnd; this.addWayEnd = addWayEnd;
} }
/** /**
* 获取 增加 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 增加 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayIncrement * @return addWayIncrement
*/ */
public Integer getAddWayIncrement(){ public Integer getAddWayIncrement(){
return this.addWayIncrement; return this.addWayIncrement;
} }
/** /**
* 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayIncrement * @param addWayIncrement
*/ */
public void setAddWayIncrement(Integer addWayIncrement){ public void setAddWayIncrement(Integer addWayIncrement){
this.addWayIncrement = addWayIncrement; this.addWayIncrement = addWayIncrement;
} }
/** /**
* 获取 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayList * @return addWayList
*/ */
public List<Integer> getAddWayList(){ public List<Integer> getAddWayList(){
return this.addWayList; return this.addWayList;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayList * @param addWayList
*/ */
public void setAddWayList(List<Integer> addWayList){ public void setAddWayList(List<Integer> addWayList){
this.addWayList = addWayList; this.addWayList = addWayList;
} }
/** /**
* 获取 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayNotList * @return addWayNotList
*/ */
public List<Integer> getAddWayNotList(){ public List<Integer> getAddWayNotList(){
return this.addWayNotList; return this.addWayNotList;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayNotList * @param addWayNotList
*/ */
public void setAddWayNotList(List<Integer> addWayNotList){ public void setAddWayNotList(List<Integer> addWayNotList){
this.addWayNotList = addWayNotList; this.addWayNotList = addWayNotList;
} }
/** /**
* 获取 开始 特殊时间 * 获取 开始 特殊时间
* @return specialTimeStart * @return specialTimeStart
*/ */
public String getSpecialTimeStart(){ public String getSpecialTimeStart(){
return this.specialTimeStart; return this.specialTimeStart;
} }
/** /**
* 设置 开始 特殊时间 * 设置 开始 特殊时间
* @param specialTimeStart * @param specialTimeStart
*/ */
public void setSpecialTimeStart(String specialTimeStart){ public void setSpecialTimeStart(String specialTimeStart){
this.specialTimeStart = specialTimeStart; this.specialTimeStart = specialTimeStart;
} }
/** /**
* 获取 结束 特殊时间 * 获取 结束 特殊时间
* @return specialTimeEnd * @return specialTimeEnd
*/ */
public String getSpecialTimeEnd(){ public String getSpecialTimeEnd(){
return this.specialTimeEnd; return this.specialTimeEnd;
} }
/** /**
* 设置 结束 特殊时间 * 设置 结束 特殊时间
* @param specialTimeEnd * @param specialTimeEnd
*/ */
public void setSpecialTimeEnd(String specialTimeEnd){ public void setSpecialTimeEnd(String specialTimeEnd){
this.specialTimeEnd = specialTimeEnd; this.specialTimeEnd = specialTimeEnd;
} }
/** /**
* 获取 开始 时间段时候开始时间 * 获取 备注
* @return specialTimeStartStart * @return remarkList
*/ */
public String getSpecialTimeStartStart(){
return this.specialTimeStartStart;
}
/**
* 设置 开始 时间段时候开始时间
* @param specialTimeStartStart
*/
public void setSpecialTimeStartStart(String specialTimeStartStart){
this.specialTimeStartStart = specialTimeStartStart;
}
/**
* 获取 结束 时间段时候开始时间
* @return specialTimeStartEnd
*/
public String getSpecialTimeStartEnd(){
return this.specialTimeStartEnd;
}
/**
* 设置 结束 时间段时候开始时间
* @param specialTimeStartEnd
*/
public void setSpecialTimeStartEnd(String specialTimeStartEnd){
this.specialTimeStartEnd = specialTimeStartEnd;
}
/**
* 获取 开始 时间段结束时间
* @return specialTimeEndStart
*/
public String getSpecialTimeEndStart(){
return this.specialTimeEndStart;
}
/**
* 设置 开始 时间段结束时间
* @param specialTimeEndStart
*/
public void setSpecialTimeEndStart(String specialTimeEndStart){
this.specialTimeEndStart = specialTimeEndStart;
}
/**
* 获取 结束 时间段结束时间
* @return specialTimeEndEnd
*/
public String getSpecialTimeEndEnd(){
return this.specialTimeEndEnd;
}
/**
* 设置 结束 时间段结束时间
* @param specialTimeEndEnd
*/
public void setSpecialTimeEndEnd(String specialTimeEndEnd){
this.specialTimeEndEnd = specialTimeEndEnd;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){ public List<String> getRemarkList(){
return this.remarkList; return this.remarkList;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkList * @param remarkList
*/ */
public void setRemarkList(List<String> remarkList){ public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList; this.remarkList = remarkList;
} }
/** /**
* 获取 备注 * 获取 备注
* @return remarkNotList * @return remarkNotList
*/ */
public List<String> getRemarkNotList(){ public List<String> getRemarkNotList(){
return this.remarkNotList; return this.remarkNotList;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkNotList * @param remarkNotList
*/ */
public void setRemarkNotList(List<String> remarkNotList){ public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList; this.remarkNotList = remarkNotList;
} }
/** /**
* 获取 开始 创建用户 * 获取 开始 创建用户
* @return createUserIdStart * @return createUserIdStart
*/ */
public Long getCreateUserIdStart(){ public Long getCreateUserIdStart(){
return this.createUserIdStart; return this.createUserIdStart;
} }
/** /**
* 设置 开始 创建用户 * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public void setCreateUserIdStart(Long createUserIdStart){ public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
} }
/** /**
* 获取 结束 创建用户 * 获取 结束 创建用户
* @return $createUserIdEnd * @return $createUserIdEnd
*/ */
public Long getCreateUserIdEnd(){ public Long getCreateUserIdEnd(){
return this.createUserIdEnd; return this.createUserIdEnd;
} }
/** /**
* 设置 结束 创建用户 * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public void setCreateUserIdEnd(Long createUserIdEnd){ public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
} }
/** /**
* 获取 增加 创建用户 * 获取 增加 创建用户
* @return createUserIdIncrement * @return createUserIdIncrement
*/ */
public Long getCreateUserIdIncrement(){ public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement; return this.createUserIdIncrement;
} }
/** /**
* 设置 增加 创建用户 * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public void setCreateUserIdIncrement(Long createUserIdIncrement){ public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
} }
/** /**
* 获取 创建用户 * 获取 创建用户
* @return createUserIdList * @return createUserIdList
*/ */
public List<Long> getCreateUserIdList(){ public List<Long> getCreateUserIdList(){
return this.createUserIdList; return this.createUserIdList;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public void setCreateUserIdList(List<Long> createUserIdList){ public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList; this.createUserIdList = createUserIdList;
} }
/** /**
* 获取 创建用户 * 获取 创建用户
* @return createUserIdNotList * @return createUserIdNotList
*/ */
public List<Long> getCreateUserIdNotList(){ public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList; return this.createUserIdNotList;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdNotList * @param createUserIdNotList
*/ */
public void setCreateUserIdNotList(List<Long> createUserIdNotList){ public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList; this.createUserIdNotList = createUserIdNotList;
} }
/** /**
* 获取 开始 创建时间 * 获取 开始 创建时间
* @return createTimeStart * @return createTimeStart
*/ */
public String getCreateTimeStart(){ public String getCreateTimeStart(){
return this.createTimeStart; return this.createTimeStart;
} }
/** /**
* 设置 开始 创建时间 * 设置 开始 创建时间
* @param createTimeStart * @param createTimeStart
*/ */
public void setCreateTimeStart(String createTimeStart){ public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart; this.createTimeStart = createTimeStart;
} }
/** /**
* 获取 结束 创建时间 * 获取 结束 创建时间
* @return createTimeEnd * @return createTimeEnd
*/ */
public String getCreateTimeEnd(){ public String getCreateTimeEnd(){
return this.createTimeEnd; return this.createTimeEnd;
} }
/** /**
* 设置 结束 创建时间 * 设置 结束 创建时间
* @param createTimeEnd * @param createTimeEnd
*/ */
public void setCreateTimeEnd(String createTimeEnd){ public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd; this.createTimeEnd = createTimeEnd;
} }
/** /**
* 获取 开始 更新用户 * 获取 开始 更新用户
* @return updateUserIdStart * @return updateUserIdStart
*/ */
public Long getUpdateUserIdStart(){ public Long getUpdateUserIdStart(){
return this.updateUserIdStart; return this.updateUserIdStart;
} }
/** /**
* 设置 开始 更新用户 * 设置 开始 更新用户
* @param updateUserIdStart * @param updateUserIdStart
*/ */
public void setUpdateUserIdStart(Long updateUserIdStart){ public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart; this.updateUserIdStart = updateUserIdStart;
} }
/** /**
* 获取 结束 更新用户 * 获取 结束 更新用户
* @return $updateUserIdEnd * @return $updateUserIdEnd
*/ */
public Long getUpdateUserIdEnd(){ public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd; return this.updateUserIdEnd;
} }
/** /**
* 设置 结束 更新用户 * 设置 结束 更新用户
* @param updateUserIdEnd * @param updateUserIdEnd
*/ */
public void setUpdateUserIdEnd(Long updateUserIdEnd){ public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd; this.updateUserIdEnd = updateUserIdEnd;
} }
/** /**
* 获取 增加 更新用户 * 获取 增加 更新用户
* @return updateUserIdIncrement * @return updateUserIdIncrement
*/ */
public Long getUpdateUserIdIncrement(){ public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement; return this.updateUserIdIncrement;
} }
/** /**
* 设置 增加 更新用户 * 设置 增加 更新用户
* @param updateUserIdIncrement * @param updateUserIdIncrement
*/ */
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){ public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement; this.updateUserIdIncrement = updateUserIdIncrement;
} }
/** /**
* 获取 更新用户 * 获取 更新用户
* @return updateUserIdList * @return updateUserIdList
*/ */
public List<Long> getUpdateUserIdList(){ public List<Long> getUpdateUserIdList(){
return this.updateUserIdList; return this.updateUserIdList;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdList * @param updateUserIdList
*/ */
public void setUpdateUserIdList(List<Long> updateUserIdList){ public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList; this.updateUserIdList = updateUserIdList;
} }
/** /**
* 获取 更新用户 * 获取 更新用户
* @return updateUserIdNotList * @return updateUserIdNotList
*/ */
public List<Long> getUpdateUserIdNotList(){ public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList; return this.updateUserIdNotList;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdNotList * @param updateUserIdNotList
*/ */
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){ public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList; this.updateUserIdNotList = updateUserIdNotList;
} }
/** /**
* 获取 开始 更新时间 * 获取 开始 更新时间
* @return updateTimeStart * @return updateTimeStart
*/ */
public String getUpdateTimeStart(){ public String getUpdateTimeStart(){
return this.updateTimeStart; return this.updateTimeStart;
} }
/** /**
* 设置 开始 更新时间 * 设置 开始 更新时间
* @param updateTimeStart * @param updateTimeStart
*/ */
public void setUpdateTimeStart(String updateTimeStart){ public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart; this.updateTimeStart = updateTimeStart;
} }
/** /**
* 获取 结束 更新时间 * 获取 结束 更新时间
* @return updateTimeEnd * @return updateTimeEnd
*/ */
public String getUpdateTimeEnd(){ public String getUpdateTimeEnd(){
return this.updateTimeEnd; return this.updateTimeEnd;
} }
/** /**
* 设置 结束 更新时间 * 设置 结束 更新时间
* @param updateTimeEnd * @param updateTimeEnd
*/ */
public void setUpdateTimeEnd(String updateTimeEnd){ public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd; this.updateTimeEnd = updateTimeEnd;
} }
/** /**
* 设置 序号，主键，自增长 * 获取 开始 时间段时候开始时间
* @param id * @return specialStartTimeStart
*/ */
public String getSpecialStartTimeStart(){
return this.specialStartTimeStart;
}
/**
* 设置 开始 时间段时候开始时间
* @param specialStartTimeStart
*/
public void setSpecialStartTimeStart(String specialStartTimeStart){
this.specialStartTimeStart = specialStartTimeStart;
}
/**
* 获取 结束 时间段时候开始时间
* @return specialStartTimeEnd
*/
public String getSpecialStartTimeEnd(){
return this.specialStartTimeEnd;
}
/**
* 设置 结束 时间段时候开始时间
* @param specialStartTimeEnd
*/
public void setSpecialStartTimeEnd(String specialStartTimeEnd){
this.specialStartTimeEnd = specialStartTimeEnd;
}
/**
* 获取 开始 时间段结束时间
* @return specialEndTimeStart
*/
public String getSpecialEndTimeStart(){
return this.specialEndTimeStart;
}
/**
* 设置 开始 时间段结束时间
* @param specialEndTimeStart
*/
public void setSpecialEndTimeStart(String specialEndTimeStart){
this.specialEndTimeStart = specialEndTimeStart;
}
/**
* 获取 结束 时间段结束时间
* @return specialEndTimeEnd
*/
public String getSpecialEndTimeEnd(){
return this.specialEndTimeEnd;
}
/**
* 设置 结束 时间段结束时间
* @param specialEndTimeEnd
*/
public void setSpecialEndTimeEnd(String specialEndTimeEnd){
this.specialEndTimeEnd = specialEndTimeEnd;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public AttendanceGroupFixedworkSpecialQuery id(Long id){ public AttendanceGroupFixedworkSpecialQuery id(Long id){
setId(id); setId(id);
return this; return this;
} }
/** /**
* 设置 开始 序号，主键，自增长 * 设置 开始 序号，主键，自增长
* @param idStart * @param idStart
*/ */
public AttendanceGroupFixedworkSpecialQuery idStart(Long idStart){ public AttendanceGroupFixedworkSpecialQuery idStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
return this; return this;
} }
/** /**
* 设置 结束 序号，主键，自增长 * 设置 结束 序号，主键，自增长
* @param idEnd * @param idEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery idEnd(Long idEnd){ public AttendanceGroupFixedworkSpecialQuery idEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
return this; return this;
} }
/** /**
* 设置 增加 序号，主键，自增长 * 设置 增加 序号，主键，自增长
* @param idIncrement * @param idIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery idIncrement(Long idIncrement){ public AttendanceGroupFixedworkSpecialQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
return this; return this;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idList * @param idList
*/ */
public AttendanceGroupFixedworkSpecialQuery idList(List<Long> idList){ public AttendanceGroupFixedworkSpecialQuery idList(List<Long> idList){
this.idList = idList; this.idList = idList;
return this; return this;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idNotList * @param idNotList
*/ */
public AttendanceGroupFixedworkSpecialQuery idNotList(List<Long> idNotList){ public AttendanceGroupFixedworkSpecialQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList; this.idNotList = idNotList;
return this; return this;
} }
/** /**
* 设置 固定班制考勤配置id * 设置 固定班制考勤配置id
* @param fixedWorkId * @param fixedWorkId
*/ */
public AttendanceGroupFixedworkSpecialQuery fixedWorkId(Long fixedWorkId){ public AttendanceGroupFixedworkSpecialQuery fixedWorkId(Long fixedWorkId){
setFixedWorkId(fixedWorkId); setFixedWorkId(fixedWorkId);
return this; return this;
} }
/** /**
* 设置 开始 固定班制考勤配置id * 设置 开始 固定班制考勤配置id
* @param fixedWorkIdStart * @param fixedWorkIdStart
*/ */
public AttendanceGroupFixedworkSpecialQuery fixedWorkIdStart(Long fixedWorkIdStart){ public AttendanceGroupFixedworkSpecialQuery fixedWorkIdStart(Long fixedWorkIdStart){
this.fixedWorkIdStart = fixedWorkIdStart; this.fixedWorkIdStart = fixedWorkIdStart;
return this; return this;
} }
/** /**
* 设置 结束 固定班制考勤配置id * 设置 结束 固定班制考勤配置id
* @param fixedWorkIdEnd * @param fixedWorkIdEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery fixedWorkIdEnd(Long fixedWorkIdEnd){ public AttendanceGroupFixedworkSpecialQuery fixedWorkIdEnd(Long fixedWorkIdEnd){
this.fixedWorkIdEnd = fixedWorkIdEnd; this.fixedWorkIdEnd = fixedWorkIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 固定班制考勤配置id * 设置 增加 固定班制考勤配置id
* @param fixedWorkIdIncrement * @param fixedWorkIdIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery fixedWorkIdIncrement(Long fixedWorkIdIncrement){ public AttendanceGroupFixedworkSpecialQuery fixedWorkIdIncrement(Long fixedWorkIdIncrement){
this.fixedWorkIdIncrement = fixedWorkIdIncrement; this.fixedWorkIdIncrement = fixedWorkIdIncrement;
return this; return this;
} }
/** /**
* 设置 固定班制考勤配置id * 设置 固定班制考勤配置id
* @param fixedWorkIdList * @param fixedWorkIdList
*/ */
public AttendanceGroupFixedworkSpecialQuery fixedWorkIdList(List<Long> fixedWorkIdList){ public AttendanceGroupFixedworkSpecialQuery fixedWorkIdList(List<Long> fixedWorkIdList){
this.fixedWorkIdList = fixedWorkIdList; this.fixedWorkIdList = fixedWorkIdList;
return this; return this;
} }
/** /**
* 设置 固定班制考勤配置id * 设置 固定班制考勤配置id
* @param fixedWorkIdNotList * @param fixedWorkIdNotList
*/ */
public AttendanceGroupFixedworkSpecialQuery fixedWorkIdNotList(List<Long> fixedWorkIdNotList){ public AttendanceGroupFixedworkSpecialQuery fixedWorkIdNotList(List<Long> fixedWorkIdNotList){
this.fixedWorkIdNotList = fixedWorkIdNotList; this.fixedWorkIdNotList = fixedWorkIdNotList;
return this; return this;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param must * @param must
*/ */
public AttendanceGroupFixedworkSpecialQuery must(Integer must){ public AttendanceGroupFixedworkSpecialQuery must(Integer must){
setMust(must); setMust(must);
return this; return this;
} }
/** /**
* 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustStart * @param mustStart
*/ */
public AttendanceGroupFixedworkSpecialQuery mustStart(Integer mustStart){ public AttendanceGroupFixedworkSpecialQuery mustStart(Integer mustStart){
this.mustStart = mustStart; this.mustStart = mustStart;
return this; return this;
} }
/** /**
* 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustEnd * @param mustEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery mustEnd(Integer mustEnd){ public AttendanceGroupFixedworkSpecialQuery mustEnd(Integer mustEnd){
this.mustEnd = mustEnd; this.mustEnd = mustEnd;
return this; return this;
} }
/** /**
* 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustIncrement * @param mustIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery mustIncrement(Integer mustIncrement){ public AttendanceGroupFixedworkSpecialQuery mustIncrement(Integer mustIncrement){
this.mustIncrement = mustIncrement; this.mustIncrement = mustIncrement;
return this; return this;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustList * @param mustList
*/ */
public AttendanceGroupFixedworkSpecialQuery mustList(List<Integer> mustList){ public AttendanceGroupFixedworkSpecialQuery mustList(List<Integer> mustList){
this.mustList = mustList; this.mustList = mustList;
return this; return this;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustNotList * @param mustNotList
*/ */
public AttendanceGroupFixedworkSpecialQuery mustNotList(List<Integer> mustNotList){ public AttendanceGroupFixedworkSpecialQuery mustNotList(List<Integer> mustNotList){
this.mustNotList = mustNotList; this.mustNotList = mustNotList;
return this; return this;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classId * @param classId
*/ */
public AttendanceGroupFixedworkSpecialQuery classId(Long classId){ public AttendanceGroupFixedworkSpecialQuery classId(Long classId){
setClassId(classId); setClassId(classId);
return this; return this;
} }
/** /**
* 设置 开始 班次ID * 设置 开始 班次ID
* @param classIdStart * @param classIdStart
*/ */
public AttendanceGroupFixedworkSpecialQuery classIdStart(Long classIdStart){ public AttendanceGroupFixedworkSpecialQuery classIdStart(Long classIdStart){
this.classIdStart = classIdStart; this.classIdStart = classIdStart;
return this; return this;
} }
/** /**
* 设置 结束 班次ID * 设置 结束 班次ID
* @param classIdEnd * @param classIdEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery classIdEnd(Long classIdEnd){ public AttendanceGroupFixedworkSpecialQuery classIdEnd(Long classIdEnd){
this.classIdEnd = classIdEnd; this.classIdEnd = classIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 班次ID * 设置 增加 班次ID
* @param classIdIncrement * @param classIdIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery classIdIncrement(Long classIdIncrement){ public AttendanceGroupFixedworkSpecialQuery classIdIncrement(Long classIdIncrement){
this.classIdIncrement = classIdIncrement; this.classIdIncrement = classIdIncrement;
return this; return this;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdList * @param classIdList
*/ */
public AttendanceGroupFixedworkSpecialQuery classIdList(List<Long> classIdList){ public AttendanceGroupFixedworkSpecialQuery classIdList(List<Long> classIdList){
this.classIdList = classIdList; this.classIdList = classIdList;
return this; return this;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdNotList * @param classIdNotList
*/ */
public AttendanceGroupFixedworkSpecialQuery classIdNotList(List<Long> classIdNotList){ public AttendanceGroupFixedworkSpecialQuery classIdNotList(List<Long> classIdNotList){
this.classIdNotList = classIdNotList; this.classIdNotList = classIdNotList;
return this; return this;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param className * @param className
*/ */
public AttendanceGroupFixedworkSpecialQuery className(String className){ public AttendanceGroupFixedworkSpecialQuery className(String className){
setClassName(className); setClassName(className);
return this; return this;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param classNameList * @param classNameList
*/ */
public AttendanceGroupFixedworkSpecialQuery classNameList(List<String> classNameList){ public AttendanceGroupFixedworkSpecialQuery classNameList(List<String> classNameList){
this.classNameList = classNameList; this.classNameList = classNameList;
return this; return this;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWay * @param addWay
*/ */
public AttendanceGroupFixedworkSpecialQuery addWay(Integer addWay){ public AttendanceGroupFixedworkSpecialQuery addWay(Integer addWay){
setAddWay(addWay); setAddWay(addWay);
return this; return this;
} }
/** /**
* 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayStart * @param addWayStart
*/ */
public AttendanceGroupFixedworkSpecialQuery addWayStart(Integer addWayStart){ public AttendanceGroupFixedworkSpecialQuery addWayStart(Integer addWayStart){
this.addWayStart = addWayStart; this.addWayStart = addWayStart;
return this; return this;
} }
/** /**
* 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayEnd * @param addWayEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery addWayEnd(Integer addWayEnd){ public AttendanceGroupFixedworkSpecialQuery addWayEnd(Integer addWayEnd){
this.addWayEnd = addWayEnd; this.addWayEnd = addWayEnd;
return this; return this;
} }
/** /**
* 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayIncrement * @param addWayIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery addWayIncrement(Integer addWayIncrement){ public AttendanceGroupFixedworkSpecialQuery addWayIncrement(Integer addWayIncrement){
this.addWayIncrement = addWayIncrement; this.addWayIncrement = addWayIncrement;
return this; return this;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayList * @param addWayList
*/ */
public AttendanceGroupFixedworkSpecialQuery addWayList(List<Integer> addWayList){ public AttendanceGroupFixedworkSpecialQuery addWayList(List<Integer> addWayList){
this.addWayList = addWayList; this.addWayList = addWayList;
return this;
}
/**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayNotList
*/
public AttendanceGroupFixedworkSpecialQuery addWayNotList(List<Integer> addWayNotList){
this.addWayNotList = addWayNotList;
return this; return this;
} }
/**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayNotList
*/
public AttendanceGroupFixedworkSpecialQuery addWayNotList(List<Integer> addWayNotList){
this.addWayNotList = addWayNotList;
return this;
}
/** /**
* 设置 备注 * 设置 备注
* @param remark * @param remark
*/ */
public AttendanceGroupFixedworkSpecialQuery remark(String remark){ public AttendanceGroupFixedworkSpecialQuery remark(String remark){
setRemark(remark); setRemark(remark);
return this; return this;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkList * @param remarkList
*/ */
public AttendanceGroupFixedworkSpecialQuery remarkList(List<String> remarkList){ public AttendanceGroupFixedworkSpecialQuery remarkList(List<String> remarkList){
this.remarkList = remarkList; this.remarkList = remarkList;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserId * @param createUserId
*/ */
public AttendanceGroupFixedworkSpecialQuery createUserId(Long createUserId){ public AttendanceGroupFixedworkSpecialQuery createUserId(Long createUserId){
setCreateUserId(createUserId); setCreateUserId(createUserId);
return this; return this;
} }
/** /**
* 设置 开始 创建用户 * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public AttendanceGroupFixedworkSpecialQuery createUserIdStart(Long createUserIdStart){ public AttendanceGroupFixedworkSpecialQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
return this; return this;
} }
/** /**
* 设置 结束 创建用户 * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery createUserIdEnd(Long createUserIdEnd){ public AttendanceGroupFixedworkSpecialQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 创建用户 * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery createUserIdIncrement(Long createUserIdIncrement){ public AttendanceGroupFixedworkSpecialQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public AttendanceGroupFixedworkSpecialQuery createUserIdList(List<Long> createUserIdList){ public AttendanceGroupFixedworkSpecialQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList; this.createUserIdList = createUserIdList;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdNotList * @param createUserIdNotList
*/ */
public AttendanceGroupFixedworkSpecialQuery createUserIdNotList(List<Long> createUserIdNotList){ public AttendanceGroupFixedworkSpecialQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList; this.createUserIdNotList = createUserIdNotList;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserId * @param updateUserId
*/ */
public AttendanceGroupFixedworkSpecialQuery updateUserId(Long updateUserId){ public AttendanceGroupFixedworkSpecialQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId); setUpdateUserId(updateUserId);
return this; return this;
} }
/** /**
* 设置 开始 更新用户 * 设置 开始 更新用户
* @param updateUserIdStart * @param updateUserIdStart
*/ */
public AttendanceGroupFixedworkSpecialQuery updateUserIdStart(Long updateUserIdStart){ public AttendanceGroupFixedworkSpecialQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart; this.updateUserIdStart = updateUserIdStart;
return this; return this;
} }
/** /**
* 设置 结束 更新用户 * 设置 结束 更新用户
* @param updateUserIdEnd * @param updateUserIdEnd
*/ */
public AttendanceGroupFixedworkSpecialQuery updateUserIdEnd(Long updateUserIdEnd){ public AttendanceGroupFixedworkSpecialQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd; this.updateUserIdEnd = updateUserIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 更新用户 * 设置 增加 更新用户
* @param updateUserIdIncrement * @param updateUserIdIncrement
*/ */
public AttendanceGroupFixedworkSpecialQuery updateUserIdIncrement(Long updateUserIdIncrement){ public AttendanceGroupFixedworkSpecialQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement; this.updateUserIdIncrement = updateUserIdIncrement;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdList * @param updateUserIdList
*/ */
public AttendanceGroupFixedworkSpecialQuery updateUserIdList(List<Long> updateUserIdList){ public AttendanceGroupFixedworkSpecialQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList; this.updateUserIdList = updateUserIdList;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdNotList * @param updateUserIdNotList
*/ */
public AttendanceGroupFixedworkSpecialQuery updateUserIdNotList(List<Long> updateUserIdNotList){ public AttendanceGroupFixedworkSpecialQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList; this.updateUserIdNotList = updateUserIdNotList;
return this; return this;
} }
/** /**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList * @return orConditionList
*/ */
public List<AttendanceGroupFixedworkSpecialQuery> getOrConditionList(){ public List<AttendanceGroupFixedworkSpecialQuery> getOrConditionList(){
return this.orConditionList; return this.orConditionList;
} }
/** /**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList * @param orConditionList
*/ */
public void setOrConditionList(List<AttendanceGroupFixedworkSpecialQuery> orConditionList){ public void setOrConditionList(List<AttendanceGroupFixedworkSpecialQuery> orConditionList){
this.orConditionList = orConditionList; this.orConditionList = orConditionList;
} }
/** /**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList * @return andConditionList
*/ */
public List<AttendanceGroupFixedworkSpecialQuery> getAndConditionList(){ public List<AttendanceGroupFixedworkSpecialQuery> getAndConditionList(){
return this.andConditionList; return this.andConditionList;
} }
/** /**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList * @param andConditionList
*/ */
public void setAndConditionList(List<AttendanceGroupFixedworkSpecialQuery> andConditionList){ public void setAndConditionList(List<AttendanceGroupFixedworkSpecialQuery> andConditionList){
this.andConditionList = andConditionList; this.andConditionList = andConditionList;
} }
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/model/AttendanceGroupFreeworkSpecialEntity.java
View file @ 9173472b
...@@ -8,180 +8,180 @@ import com.mortals.framework.annotation.Excel; ...@@ -8,180 +8,180 @@ import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.attendance.model.vo.AttendanceGroupFreeworkSpecialVo; import com.mortals.xhx.module.attendance.model.vo.AttendanceGroupFreeworkSpecialVo;
/** /**
* 考勤组考勤自由工时特殊日期配置实体对象 * 考勤组考勤自由工时特殊日期配置实体对象
* *
* @author zxfei * @author zxfei
* @date 2023-04-08 * @date 2023-04-10
*/ */
public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreeworkSpecialVo { public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreeworkSpecialVo {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 自由工时考勤配置id * 自由工时考勤配置id
*/ */
private Long freeWorkId; private Long freeWorkId;
/** /**
* 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
*/ */
private Integer must; private Integer must;
/** /**
* 班次ID * 班次ID
*/ */
private Long classId; private Long classId;
/** /**
* 班次名称 * 班次名称
*/ */
private String className; private String className;
/** /**
* 无需打卡的日期类型(0.单个日期,1.时间段) * 无需打卡的日期类型(0.单个日期,1.时间段)
*/ */
private Integer addWay; private Integer addWay;
/** /**
* 特殊时间 * 特殊时间
*/ */
private Date specialTime; private Date specialTime;
/** /**
* 时间段时候开始时间 * 备注
*/ */
private Date specialTimeStart; private String remark;
/** /**
* 时间段结束时间 * 时间段时候开始时间
*/ */
private Date specialTimeEnd; private Date specialStartTime;
/** /**
* 备注 * 时间段结束时间
*/ */
private String remark; private Date specialEndTime;
public AttendanceGroupFreeworkSpecialEntity(){} public AttendanceGroupFreeworkSpecialEntity(){}
/** /**
* 获取 自由工时考勤配置id * 获取 自由工时考勤配置id
* @return Long * @return Long
*/ */
public Long getFreeWorkId(){ public Long getFreeWorkId(){
return freeWorkId; return freeWorkId;
} }
/** /**
* 设置 自由工时考勤配置id * 设置 自由工时考勤配置id
* @param freeWorkId * @param freeWorkId
*/ */
public void setFreeWorkId(Long freeWorkId){ public void setFreeWorkId(Long freeWorkId){
this.freeWorkId = freeWorkId; this.freeWorkId = freeWorkId;
} }
/** /**
* 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return Integer * @return Integer
*/ */
public Integer getMust(){ public Integer getMust(){
return must; return must;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param must * @param must
*/ */
public void setMust(Integer must){ public void setMust(Integer must){
this.must = must; this.must = must;
} }
/** /**
* 获取 班次ID * 获取 班次ID
* @return Long * @return Long
*/ */
public Long getClassId(){ public Long getClassId(){
return classId; return classId;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classId * @param classId
*/ */
public void setClassId(Long classId){ public void setClassId(Long classId){
this.classId = classId; this.classId = classId;
} }
/** /**
* 获取 班次名称 * 获取 班次名称
* @return String * @return String
*/ */
public String getClassName(){ public String getClassName(){
return className; return className;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param className * @param className
*/ */
public void setClassName(String className){ public void setClassName(String className){
this.className = className; this.className = className;
} }
/** /**
* 获取 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 无需打卡的日期类型(0.单个日期,1.时间段)
* @return Integer * @return Integer
*/ */
public Integer getAddWay(){ public Integer getAddWay(){
return addWay; return addWay;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWay * @param addWay
*/ */
public void setAddWay(Integer addWay){ public void setAddWay(Integer addWay){
this.addWay = addWay; this.addWay = addWay;
} }
/** /**
* 获取 特殊时间 * 获取 特殊时间
* @return Date * @return Date
*/ */
public Date getSpecialTime(){ public Date getSpecialTime(){
return specialTime; return specialTime;
} }
/** /**
* 设置 特殊时间 * 设置 特殊时间
* @param specialTime * @param specialTime
*/ */
public void setSpecialTime(Date specialTime){ public void setSpecialTime(Date specialTime){
this.specialTime = specialTime; this.specialTime = specialTime;
} }
/** /**
* 获取 时间段时候开始时间 * 获取 备注
* @return Date * @return String
*/ */
public Date getSpecialTimeStart(){ public String getRemark(){
return specialTimeStart; return remark;
} }
/** /**
* 设置 时间段时候开始时间 * 设置 备注
* @param specialTimeStart * @param remark
*/ */
public void setSpecialTimeStart(Date specialTimeStart){ public void setRemark(String remark){
this.specialTimeStart = specialTimeStart; this.remark = remark;
} }
/** /**
* 获取 时间段结束时间 * 获取 时间段时候开始时间
* @return Date * @return Date
*/ */
public Date getSpecialTimeEnd(){ public Date getSpecialStartTime(){
return specialTimeEnd; return specialStartTime;
} }
/** /**
* 设置 时间段结束时间 * 设置 时间段时候开始时间
* @param specialTimeEnd * @param specialStartTime
*/ */
public void setSpecialTimeEnd(Date specialTimeEnd){ public void setSpecialStartTime(Date specialStartTime){
this.specialTimeEnd = specialTimeEnd; this.specialStartTime = specialStartTime;
} }
/** /**
* 获取 备注 * 获取 时间段结束时间
* @return String * @return Date
*/ */
public String getRemark(){ public Date getSpecialEndTime(){
return remark; return specialEndTime;
} }
/** /**
* 设置 备注 * 设置 时间段结束时间
* @param remark * @param specialEndTime
*/ */
public void setRemark(String remark){ public void setSpecialEndTime(Date specialEndTime){
this.remark = remark; this.specialEndTime = specialEndTime;
} }
...@@ -189,7 +189,7 @@ public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreewor ...@@ -189,7 +189,7 @@ public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreewor
@Override @Override
public int hashCode() { public int hashCode() {
return this.getId().hashCode(); return this.getId().hashCode();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
...@@ -197,7 +197,7 @@ public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreewor ...@@ -197,7 +197,7 @@ public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreewor
if (obj instanceof AttendanceGroupFreeworkSpecialEntity) { if (obj instanceof AttendanceGroupFreeworkSpecialEntity) {
AttendanceGroupFreeworkSpecialEntity tmp = (AttendanceGroupFreeworkSpecialEntity) obj; AttendanceGroupFreeworkSpecialEntity tmp = (AttendanceGroupFreeworkSpecialEntity) obj;
if (this.getId() == tmp.getId()) { if (this.getId() == tmp.getId()) {
return true; return true;
} }
} }
return false; return false;
...@@ -211,30 +211,30 @@ public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreewor ...@@ -211,30 +211,30 @@ public class AttendanceGroupFreeworkSpecialEntity extends AttendanceGroupFreewor
sb.append(",className:").append(getClassName()); sb.append(",className:").append(getClassName());
sb.append(",addWay:").append(getAddWay()); sb.append(",addWay:").append(getAddWay());
sb.append(",specialTime:").append(getSpecialTime()); sb.append(",specialTime:").append(getSpecialTime());
sb.append(",specialTimeStart:").append(getSpecialTimeStart());
sb.append(",specialTimeEnd:").append(getSpecialTimeEnd());
sb.append(",remark:").append(getRemark()); sb.append(",remark:").append(getRemark());
sb.append(",specialStartTime:").append(getSpecialStartTime());
sb.append(",specialEndTime:").append(getSpecialEndTime());
return sb.toString(); return sb.toString();
} }
public void initAttrValue(){ public void initAttrValue(){
this.freeWorkId = null; this.freeWorkId = null;
this.must = 0; this.must = 0;
this.classId = null; this.classId = null;
this.className = ""; this.className = "";
this.addWay = 0; this.addWay = 0;
this.specialTime = null; this.specialTime = null;
this.specialTimeStart = null; this.remark = "";
this.specialTimeEnd = null; this.specialStartTime = null;
this.remark = ""; this.specialEndTime = null;
} }
} }
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/model/AttendanceGroupFreeworkSpecialQuery.java
View file @ 9173472b
...@@ -4,11 +4,11 @@ import java.util.Date; ...@@ -4,11 +4,11 @@ import java.util.Date;
import java.util.List; import java.util.List;
import com.mortals.xhx.module.attendance.model.AttendanceGroupFreeworkSpecialEntity; import com.mortals.xhx.module.attendance.model.AttendanceGroupFreeworkSpecialEntity;
/** /**
* 考勤组考勤自由工时特殊日期配置查询对象 * 考勤组考勤自由工时特殊日期配置查询对象
* *
* @author zxfei * @author zxfei
* @date 2023-04-08 * @date 2023-04-10
*/ */
public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreeworkSpecialEntity { public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreeworkSpecialEntity {
/** 开始 序号，主键，自增长 */ /** 开始 序号，主键，自增长 */
private Long idStart; private Long idStart;
...@@ -96,18 +96,6 @@ public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreework ...@@ -96,18 +96,6 @@ public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreework
/** 结束 特殊时间 */ /** 结束 特殊时间 */
private String specialTimeEnd; private String specialTimeEnd;
/** 开始 时间段时候开始时间 */
private String specialTimeStartStart;
/** 结束 时间段时候开始时间 */
private String specialTimeStartEnd;
/** 开始 时间段结束时间 */
private String specialTimeEndStart;
/** 结束 时间段结束时间 */
private String specialTimeEndEnd;
/** 备注 */ /** 备注 */
private List<String> remarkList; private List<String> remarkList;
...@@ -155,6 +143,18 @@ public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreework ...@@ -155,6 +143,18 @@ public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreework
/** 结束 更新时间 */ /** 结束 更新时间 */
private String updateTimeEnd; private String updateTimeEnd;
/** 开始 时间段时候开始时间 */
private String specialStartTimeStart;
/** 结束 时间段时候开始时间 */
private String specialStartTimeEnd;
/** 开始 时间段结束时间 */
private String specialEndTimeStart;
/** 结束 时间段结束时间 */
private String specialEndTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */ /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<AttendanceGroupFreeworkSpecialQuery> orConditionList; private List<AttendanceGroupFreeworkSpecialQuery> orConditionList;
...@@ -164,1245 +164,1245 @@ public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreework ...@@ -164,1245 +164,1245 @@ public class AttendanceGroupFreeworkSpecialQuery extends AttendanceGroupFreework
public AttendanceGroupFreeworkSpecialQuery(){} public AttendanceGroupFreeworkSpecialQuery(){}
/** /**
* 获取 开始 序号，主键，自增长 * 获取 开始 序号，主键，自增长
* @return idStart * @return idStart
*/ */
public Long getIdStart(){ public Long getIdStart(){
return this.idStart; return this.idStart;
} }
/** /**
* 设置 开始 序号，主键，自增长 * 设置 开始 序号，主键，自增长
* @param idStart * @param idStart
*/ */
public void setIdStart(Long idStart){ public void setIdStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
} }
/** /**
* 获取 结束 序号，主键，自增长 * 获取 结束 序号，主键，自增长
* @return $idEnd * @return $idEnd
*/ */
public Long getIdEnd(){ public Long getIdEnd(){
return this.idEnd; return this.idEnd;
} }
/** /**
* 设置 结束 序号，主键，自增长 * 设置 结束 序号，主键，自增长
* @param idEnd * @param idEnd
*/ */
public void setIdEnd(Long idEnd){ public void setIdEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
} }
/** /**
* 获取 增加 序号，主键，自增长 * 获取 增加 序号，主键，自增长
* @return idIncrement * @return idIncrement
*/ */
public Long getIdIncrement(){ public Long getIdIncrement(){
return this.idIncrement; return this.idIncrement;
} }
/** /**
* 设置 增加 序号，主键，自增长 * 设置 增加 序号，主键，自增长
* @param idIncrement * @param idIncrement
*/ */
public void setIdIncrement(Long idIncrement){ public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
} }
/** /**
* 获取 序号，主键，自增长 * 获取 序号，主键，自增长
* @return idList * @return idList
*/ */
public List<Long> getIdList(){ public List<Long> getIdList(){
return this.idList; return this.idList;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idList * @param idList
*/ */
public void setIdList(List<Long> idList){ public void setIdList(List<Long> idList){
this.idList = idList; this.idList = idList;
} }
/** /**
* 获取 序号，主键，自增长 * 获取 序号，主键，自增长
* @return idNotList * @return idNotList
*/ */
public List<Long> getIdNotList(){ public List<Long> getIdNotList(){
return this.idNotList; return this.idNotList;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idNotList * @param idNotList
*/ */
public void setIdNotList(List<Long> idNotList){ public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList; this.idNotList = idNotList;
} }
/** /**
* 获取 开始 自由工时考勤配置id * 获取 开始 自由工时考勤配置id
* @return freeWorkIdStart * @return freeWorkIdStart
*/ */
public Long getFreeWorkIdStart(){ public Long getFreeWorkIdStart(){
return this.freeWorkIdStart; return this.freeWorkIdStart;
} }
/** /**
* 设置 开始 自由工时考勤配置id * 设置 开始 自由工时考勤配置id
* @param freeWorkIdStart * @param freeWorkIdStart
*/ */
public void setFreeWorkIdStart(Long freeWorkIdStart){ public void setFreeWorkIdStart(Long freeWorkIdStart){
this.freeWorkIdStart = freeWorkIdStart; this.freeWorkIdStart = freeWorkIdStart;
} }
/** /**
* 获取 结束 自由工时考勤配置id * 获取 结束 自由工时考勤配置id
* @return $freeWorkIdEnd * @return $freeWorkIdEnd
*/ */
public Long getFreeWorkIdEnd(){ public Long getFreeWorkIdEnd(){
return this.freeWorkIdEnd; return this.freeWorkIdEnd;
} }
/** /**
* 设置 结束 自由工时考勤配置id * 设置 结束 自由工时考勤配置id
* @param freeWorkIdEnd * @param freeWorkIdEnd
*/ */
public void setFreeWorkIdEnd(Long freeWorkIdEnd){ public void setFreeWorkIdEnd(Long freeWorkIdEnd){
this.freeWorkIdEnd = freeWorkIdEnd; this.freeWorkIdEnd = freeWorkIdEnd;
} }
/** /**
* 获取 增加 自由工时考勤配置id * 获取 增加 自由工时考勤配置id
* @return freeWorkIdIncrement * @return freeWorkIdIncrement
*/ */
public Long getFreeWorkIdIncrement(){ public Long getFreeWorkIdIncrement(){
return this.freeWorkIdIncrement; return this.freeWorkIdIncrement;
} }
/** /**
* 设置 增加 自由工时考勤配置id * 设置 增加 自由工时考勤配置id
* @param freeWorkIdIncrement * @param freeWorkIdIncrement
*/ */
public void setFreeWorkIdIncrement(Long freeWorkIdIncrement){ public void setFreeWorkIdIncrement(Long freeWorkIdIncrement){
this.freeWorkIdIncrement = freeWorkIdIncrement; this.freeWorkIdIncrement = freeWorkIdIncrement;
} }
/** /**
* 获取 自由工时考勤配置id * 获取 自由工时考勤配置id
* @return freeWorkIdList * @return freeWorkIdList
*/ */
public List<Long> getFreeWorkIdList(){ public List<Long> getFreeWorkIdList(){
return this.freeWorkIdList; return this.freeWorkIdList;
} }
/** /**
* 设置 自由工时考勤配置id * 设置 自由工时考勤配置id
* @param freeWorkIdList * @param freeWorkIdList
*/ */
public void setFreeWorkIdList(List<Long> freeWorkIdList){ public void setFreeWorkIdList(List<Long> freeWorkIdList){
this.freeWorkIdList = freeWorkIdList; this.freeWorkIdList = freeWorkIdList;
} }
/** /**
* 获取 自由工时考勤配置id * 获取 自由工时考勤配置id
* @return freeWorkIdNotList * @return freeWorkIdNotList
*/ */
public List<Long> getFreeWorkIdNotList(){ public List<Long> getFreeWorkIdNotList(){
return this.freeWorkIdNotList; return this.freeWorkIdNotList;
} }
/** /**
* 设置 自由工时考勤配置id * 设置 自由工时考勤配置id
* @param freeWorkIdNotList * @param freeWorkIdNotList
*/ */
public void setFreeWorkIdNotList(List<Long> freeWorkIdNotList){ public void setFreeWorkIdNotList(List<Long> freeWorkIdNotList){
this.freeWorkIdNotList = freeWorkIdNotList; this.freeWorkIdNotList = freeWorkIdNotList;
} }
/** /**
* 获取 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustStart * @return mustStart
*/ */
public Integer getMustStart(){ public Integer getMustStart(){
return this.mustStart; return this.mustStart;
} }
/** /**
* 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustStart * @param mustStart
*/ */
public void setMustStart(Integer mustStart){ public void setMustStart(Integer mustStart){
this.mustStart = mustStart; this.mustStart = mustStart;
} }
/** /**
* 获取 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return $mustEnd * @return $mustEnd
*/ */
public Integer getMustEnd(){ public Integer getMustEnd(){
return this.mustEnd; return this.mustEnd;
} }
/** /**
* 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustEnd * @param mustEnd
*/ */
public void setMustEnd(Integer mustEnd){ public void setMustEnd(Integer mustEnd){
this.mustEnd = mustEnd; this.mustEnd = mustEnd;
} }
/** /**
* 获取 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustIncrement * @return mustIncrement
*/ */
public Integer getMustIncrement(){ public Integer getMustIncrement(){
return this.mustIncrement; return this.mustIncrement;
} }
/** /**
* 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustIncrement * @param mustIncrement
*/ */
public void setMustIncrement(Integer mustIncrement){ public void setMustIncrement(Integer mustIncrement){
this.mustIncrement = mustIncrement; this.mustIncrement = mustIncrement;
} }
/** /**
* 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustList * @return mustList
*/ */
public List<Integer> getMustList(){ public List<Integer> getMustList(){
return this.mustList; return this.mustList;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustList * @param mustList
*/ */
public void setMustList(List<Integer> mustList){ public void setMustList(List<Integer> mustList){
this.mustList = mustList; this.mustList = mustList;
} }
/** /**
* 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 获取 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @return mustNotList * @return mustNotList
*/ */
public List<Integer> getMustNotList(){ public List<Integer> getMustNotList(){
return this.mustNotList; return this.mustNotList;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustNotList * @param mustNotList
*/ */
public void setMustNotList(List<Integer> mustNotList){ public void setMustNotList(List<Integer> mustNotList){
this.mustNotList = mustNotList; this.mustNotList = mustNotList;
} }
/** /**
* 获取 开始 班次ID * 获取 开始 班次ID
* @return classIdStart * @return classIdStart
*/ */
public Long getClassIdStart(){ public Long getClassIdStart(){
return this.classIdStart; return this.classIdStart;
} }
/** /**
* 设置 开始 班次ID * 设置 开始 班次ID
* @param classIdStart * @param classIdStart
*/ */
public void setClassIdStart(Long classIdStart){ public void setClassIdStart(Long classIdStart){
this.classIdStart = classIdStart; this.classIdStart = classIdStart;
} }
/** /**
* 获取 结束 班次ID * 获取 结束 班次ID
* @return $classIdEnd * @return $classIdEnd
*/ */
public Long getClassIdEnd(){ public Long getClassIdEnd(){
return this.classIdEnd; return this.classIdEnd;
} }
/** /**
* 设置 结束 班次ID * 设置 结束 班次ID
* @param classIdEnd * @param classIdEnd
*/ */
public void setClassIdEnd(Long classIdEnd){ public void setClassIdEnd(Long classIdEnd){
this.classIdEnd = classIdEnd; this.classIdEnd = classIdEnd;
} }
/** /**
* 获取 增加 班次ID * 获取 增加 班次ID
* @return classIdIncrement * @return classIdIncrement
*/ */
public Long getClassIdIncrement(){ public Long getClassIdIncrement(){
return this.classIdIncrement; return this.classIdIncrement;
} }
/** /**
* 设置 增加 班次ID * 设置 增加 班次ID
* @param classIdIncrement * @param classIdIncrement
*/ */
public void setClassIdIncrement(Long classIdIncrement){ public void setClassIdIncrement(Long classIdIncrement){
this.classIdIncrement = classIdIncrement; this.classIdIncrement = classIdIncrement;
} }
/** /**
* 获取 班次ID * 获取 班次ID
* @return classIdList * @return classIdList
*/ */
public List<Long> getClassIdList(){ public List<Long> getClassIdList(){
return this.classIdList; return this.classIdList;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdList * @param classIdList
*/ */
public void setClassIdList(List<Long> classIdList){ public void setClassIdList(List<Long> classIdList){
this.classIdList = classIdList; this.classIdList = classIdList;
} }
/** /**
* 获取 班次ID * 获取 班次ID
* @return classIdNotList * @return classIdNotList
*/ */
public List<Long> getClassIdNotList(){ public List<Long> getClassIdNotList(){
return this.classIdNotList; return this.classIdNotList;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdNotList * @param classIdNotList
*/ */
public void setClassIdNotList(List<Long> classIdNotList){ public void setClassIdNotList(List<Long> classIdNotList){
this.classIdNotList = classIdNotList; this.classIdNotList = classIdNotList;
} }
/** /**
* 获取 班次名称 * 获取 班次名称
* @return classNameList * @return classNameList
*/ */
public List<String> getClassNameList(){ public List<String> getClassNameList(){
return this.classNameList; return this.classNameList;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param classNameList * @param classNameList
*/ */
public void setClassNameList(List<String> classNameList){ public void setClassNameList(List<String> classNameList){
this.classNameList = classNameList; this.classNameList = classNameList;
} }
/** /**
* 获取 班次名称 * 获取 班次名称
* @return classNameNotList * @return classNameNotList
*/ */
public List<String> getClassNameNotList(){ public List<String> getClassNameNotList(){
return this.classNameNotList; return this.classNameNotList;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param classNameNotList * @param classNameNotList
*/ */
public void setClassNameNotList(List<String> classNameNotList){ public void setClassNameNotList(List<String> classNameNotList){
this.classNameNotList = classNameNotList; this.classNameNotList = classNameNotList;
} }
/** /**
* 获取 开始 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 开始 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayStart * @return addWayStart
*/ */
public Integer getAddWayStart(){ public Integer getAddWayStart(){
return this.addWayStart; return this.addWayStart;
} }
/** /**
* 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayStart * @param addWayStart
*/ */
public void setAddWayStart(Integer addWayStart){ public void setAddWayStart(Integer addWayStart){
this.addWayStart = addWayStart; this.addWayStart = addWayStart;
} }
/** /**
* 获取 结束 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 结束 无需打卡的日期类型(0.单个日期,1.时间段)
* @return $addWayEnd * @return $addWayEnd
*/ */
public Integer getAddWayEnd(){ public Integer getAddWayEnd(){
return this.addWayEnd; return this.addWayEnd;
} }
/** /**
* 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayEnd * @param addWayEnd
*/ */
public void setAddWayEnd(Integer addWayEnd){ public void setAddWayEnd(Integer addWayEnd){
this.addWayEnd = addWayEnd; this.addWayEnd = addWayEnd;
} }
/** /**
* 获取 增加 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 增加 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayIncrement * @return addWayIncrement
*/ */
public Integer getAddWayIncrement(){ public Integer getAddWayIncrement(){
return this.addWayIncrement; return this.addWayIncrement;
} }
/** /**
* 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayIncrement * @param addWayIncrement
*/ */
public void setAddWayIncrement(Integer addWayIncrement){ public void setAddWayIncrement(Integer addWayIncrement){
this.addWayIncrement = addWayIncrement; this.addWayIncrement = addWayIncrement;
} }
/** /**
* 获取 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayList * @return addWayList
*/ */
public List<Integer> getAddWayList(){ public List<Integer> getAddWayList(){
return this.addWayList; return this.addWayList;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayList * @param addWayList
*/ */
public void setAddWayList(List<Integer> addWayList){ public void setAddWayList(List<Integer> addWayList){
this.addWayList = addWayList; this.addWayList = addWayList;
} }
/** /**
* 获取 无需打卡的日期类型(0.单个日期,1.时间段) * 获取 无需打卡的日期类型(0.单个日期,1.时间段)
* @return addWayNotList * @return addWayNotList
*/ */
public List<Integer> getAddWayNotList(){ public List<Integer> getAddWayNotList(){
return this.addWayNotList; return this.addWayNotList;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayNotList * @param addWayNotList
*/ */
public void setAddWayNotList(List<Integer> addWayNotList){ public void setAddWayNotList(List<Integer> addWayNotList){
this.addWayNotList = addWayNotList; this.addWayNotList = addWayNotList;
} }
/** /**
* 获取 开始 特殊时间 * 获取 开始 特殊时间
* @return specialTimeStart * @return specialTimeStart
*/ */
public String getSpecialTimeStart(){ public String getSpecialTimeStart(){
return this.specialTimeStart; return this.specialTimeStart;
} }
/** /**
* 设置 开始 特殊时间 * 设置 开始 特殊时间
* @param specialTimeStart * @param specialTimeStart
*/ */
public void setSpecialTimeStart(String specialTimeStart){ public void setSpecialTimeStart(String specialTimeStart){
this.specialTimeStart = specialTimeStart; this.specialTimeStart = specialTimeStart;
} }
/** /**
* 获取 结束 特殊时间 * 获取 结束 特殊时间
* @return specialTimeEnd * @return specialTimeEnd
*/ */
public String getSpecialTimeEnd(){ public String getSpecialTimeEnd(){
return this.specialTimeEnd; return this.specialTimeEnd;
} }
/** /**
* 设置 结束 特殊时间 * 设置 结束 特殊时间
* @param specialTimeEnd * @param specialTimeEnd
*/ */
public void setSpecialTimeEnd(String specialTimeEnd){ public void setSpecialTimeEnd(String specialTimeEnd){
this.specialTimeEnd = specialTimeEnd; this.specialTimeEnd = specialTimeEnd;
} }
/** /**
* 获取 开始 时间段时候开始时间 * 获取 备注
* @return specialTimeStartStart * @return remarkList
*/ */
public String getSpecialTimeStartStart(){
return this.specialTimeStartStart;
}
/**
* 设置 开始 时间段时候开始时间
* @param specialTimeStartStart
*/
public void setSpecialTimeStartStart(String specialTimeStartStart){
this.specialTimeStartStart = specialTimeStartStart;
}
/**
* 获取 结束 时间段时候开始时间
* @return specialTimeStartEnd
*/
public String getSpecialTimeStartEnd(){
return this.specialTimeStartEnd;
}
/**
* 设置 结束 时间段时候开始时间
* @param specialTimeStartEnd
*/
public void setSpecialTimeStartEnd(String specialTimeStartEnd){
this.specialTimeStartEnd = specialTimeStartEnd;
}
/**
* 获取 开始 时间段结束时间
* @return specialTimeEndStart
*/
public String getSpecialTimeEndStart(){
return this.specialTimeEndStart;
}
/**
* 设置 开始 时间段结束时间
* @param specialTimeEndStart
*/
public void setSpecialTimeEndStart(String specialTimeEndStart){
this.specialTimeEndStart = specialTimeEndStart;
}
/**
* 获取 结束 时间段结束时间
* @return specialTimeEndEnd
*/
public String getSpecialTimeEndEnd(){
return this.specialTimeEndEnd;
}
/**
* 设置 结束 时间段结束时间
* @param specialTimeEndEnd
*/
public void setSpecialTimeEndEnd(String specialTimeEndEnd){
this.specialTimeEndEnd = specialTimeEndEnd;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){ public List<String> getRemarkList(){
return this.remarkList; return this.remarkList;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkList * @param remarkList
*/ */
public void setRemarkList(List<String> remarkList){ public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList; this.remarkList = remarkList;
} }
/** /**
* 获取 备注 * 获取 备注
* @return remarkNotList * @return remarkNotList
*/ */
public List<String> getRemarkNotList(){ public List<String> getRemarkNotList(){
return this.remarkNotList; return this.remarkNotList;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkNotList * @param remarkNotList
*/ */
public void setRemarkNotList(List<String> remarkNotList){ public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList; this.remarkNotList = remarkNotList;
} }
/** /**
* 获取 开始 创建用户 * 获取 开始 创建用户
* @return createUserIdStart * @return createUserIdStart
*/ */
public Long getCreateUserIdStart(){ public Long getCreateUserIdStart(){
return this.createUserIdStart; return this.createUserIdStart;
} }
/** /**
* 设置 开始 创建用户 * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public void setCreateUserIdStart(Long createUserIdStart){ public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
} }
/** /**
* 获取 结束 创建用户 * 获取 结束 创建用户
* @return $createUserIdEnd * @return $createUserIdEnd
*/ */
public Long getCreateUserIdEnd(){ public Long getCreateUserIdEnd(){
return this.createUserIdEnd; return this.createUserIdEnd;
} }
/** /**
* 设置 结束 创建用户 * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public void setCreateUserIdEnd(Long createUserIdEnd){ public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
} }
/** /**
* 获取 增加 创建用户 * 获取 增加 创建用户
* @return createUserIdIncrement * @return createUserIdIncrement
*/ */
public Long getCreateUserIdIncrement(){ public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement; return this.createUserIdIncrement;
} }
/** /**
* 设置 增加 创建用户 * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public void setCreateUserIdIncrement(Long createUserIdIncrement){ public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
} }
/** /**
* 获取 创建用户 * 获取 创建用户
* @return createUserIdList * @return createUserIdList
*/ */
public List<Long> getCreateUserIdList(){ public List<Long> getCreateUserIdList(){
return this.createUserIdList; return this.createUserIdList;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public void setCreateUserIdList(List<Long> createUserIdList){ public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList; this.createUserIdList = createUserIdList;
} }
/** /**
* 获取 创建用户 * 获取 创建用户
* @return createUserIdNotList * @return createUserIdNotList
*/ */
public List<Long> getCreateUserIdNotList(){ public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList; return this.createUserIdNotList;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdNotList * @param createUserIdNotList
*/ */
public void setCreateUserIdNotList(List<Long> createUserIdNotList){ public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList; this.createUserIdNotList = createUserIdNotList;
} }
/** /**
* 获取 开始 创建时间 * 获取 开始 创建时间
* @return createTimeStart * @return createTimeStart
*/ */
public String getCreateTimeStart(){ public String getCreateTimeStart(){
return this.createTimeStart; return this.createTimeStart;
} }
/** /**
* 设置 开始 创建时间 * 设置 开始 创建时间
* @param createTimeStart * @param createTimeStart
*/ */
public void setCreateTimeStart(String createTimeStart){ public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart; this.createTimeStart = createTimeStart;
} }
/** /**
* 获取 结束 创建时间 * 获取 结束 创建时间
* @return createTimeEnd * @return createTimeEnd
*/ */
public String getCreateTimeEnd(){ public String getCreateTimeEnd(){
return this.createTimeEnd; return this.createTimeEnd;
} }
/** /**
* 设置 结束 创建时间 * 设置 结束 创建时间
* @param createTimeEnd * @param createTimeEnd
*/ */
public void setCreateTimeEnd(String createTimeEnd){ public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd; this.createTimeEnd = createTimeEnd;
} }
/** /**
* 获取 开始 更新用户 * 获取 开始 更新用户
* @return updateUserIdStart * @return updateUserIdStart
*/ */
public Long getUpdateUserIdStart(){ public Long getUpdateUserIdStart(){
return this.updateUserIdStart; return this.updateUserIdStart;
} }
/** /**
* 设置 开始 更新用户 * 设置 开始 更新用户
* @param updateUserIdStart * @param updateUserIdStart
*/ */
public void setUpdateUserIdStart(Long updateUserIdStart){ public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart; this.updateUserIdStart = updateUserIdStart;
} }
/** /**
* 获取 结束 更新用户 * 获取 结束 更新用户
* @return $updateUserIdEnd * @return $updateUserIdEnd
*/ */
public Long getUpdateUserIdEnd(){ public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd; return this.updateUserIdEnd;
} }
/** /**
* 设置 结束 更新用户 * 设置 结束 更新用户
* @param updateUserIdEnd * @param updateUserIdEnd
*/ */
public void setUpdateUserIdEnd(Long updateUserIdEnd){ public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd; this.updateUserIdEnd = updateUserIdEnd;
} }
/** /**
* 获取 增加 更新用户 * 获取 增加 更新用户
* @return updateUserIdIncrement * @return updateUserIdIncrement
*/ */
public Long getUpdateUserIdIncrement(){ public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement; return this.updateUserIdIncrement;
} }
/** /**
* 设置 增加 更新用户 * 设置 增加 更新用户
* @param updateUserIdIncrement * @param updateUserIdIncrement
*/ */
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){ public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement; this.updateUserIdIncrement = updateUserIdIncrement;
} }
/** /**
* 获取 更新用户 * 获取 更新用户
* @return updateUserIdList * @return updateUserIdList
*/ */
public List<Long> getUpdateUserIdList(){ public List<Long> getUpdateUserIdList(){
return this.updateUserIdList; return this.updateUserIdList;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdList * @param updateUserIdList
*/ */
public void setUpdateUserIdList(List<Long> updateUserIdList){ public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList; this.updateUserIdList = updateUserIdList;
} }
/** /**
* 获取 更新用户 * 获取 更新用户
* @return updateUserIdNotList * @return updateUserIdNotList
*/ */
public List<Long> getUpdateUserIdNotList(){ public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList; return this.updateUserIdNotList;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdNotList * @param updateUserIdNotList
*/ */
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){ public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList; this.updateUserIdNotList = updateUserIdNotList;
} }
/** /**
* 获取 开始 更新时间 * 获取 开始 更新时间
* @return updateTimeStart * @return updateTimeStart
*/ */
public String getUpdateTimeStart(){ public String getUpdateTimeStart(){
return this.updateTimeStart; return this.updateTimeStart;
} }
/** /**
* 设置 开始 更新时间 * 设置 开始 更新时间
* @param updateTimeStart * @param updateTimeStart
*/ */
public void setUpdateTimeStart(String updateTimeStart){ public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart; this.updateTimeStart = updateTimeStart;
} }
/** /**
* 获取 结束 更新时间 * 获取 结束 更新时间
* @return updateTimeEnd * @return updateTimeEnd
*/ */
public String getUpdateTimeEnd(){ public String getUpdateTimeEnd(){
return this.updateTimeEnd; return this.updateTimeEnd;
} }
/** /**
* 设置 结束 更新时间 * 设置 结束 更新时间
* @param updateTimeEnd * @param updateTimeEnd
*/ */
public void setUpdateTimeEnd(String updateTimeEnd){ public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd; this.updateTimeEnd = updateTimeEnd;
} }
/** /**
* 设置 序号，主键，自增长 * 获取 开始 时间段时候开始时间
* @param id * @return specialStartTimeStart
*/ */
public String getSpecialStartTimeStart(){
return this.specialStartTimeStart;
}
/**
* 设置 开始 时间段时候开始时间
* @param specialStartTimeStart
*/
public void setSpecialStartTimeStart(String specialStartTimeStart){
this.specialStartTimeStart = specialStartTimeStart;
}
/**
* 获取 结束 时间段时候开始时间
* @return specialStartTimeEnd
*/
public String getSpecialStartTimeEnd(){
return this.specialStartTimeEnd;
}
/**
* 设置 结束 时间段时候开始时间
* @param specialStartTimeEnd
*/
public void setSpecialStartTimeEnd(String specialStartTimeEnd){
this.specialStartTimeEnd = specialStartTimeEnd;
}
/**
* 获取 开始 时间段结束时间
* @return specialEndTimeStart
*/
public String getSpecialEndTimeStart(){
return this.specialEndTimeStart;
}
/**
* 设置 开始 时间段结束时间
* @param specialEndTimeStart
*/
public void setSpecialEndTimeStart(String specialEndTimeStart){
this.specialEndTimeStart = specialEndTimeStart;
}
/**
* 获取 结束 时间段结束时间
* @return specialEndTimeEnd
*/
public String getSpecialEndTimeEnd(){
return this.specialEndTimeEnd;
}
/**
* 设置 结束 时间段结束时间
* @param specialEndTimeEnd
*/
public void setSpecialEndTimeEnd(String specialEndTimeEnd){
this.specialEndTimeEnd = specialEndTimeEnd;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public AttendanceGroupFreeworkSpecialQuery id(Long id){ public AttendanceGroupFreeworkSpecialQuery id(Long id){
setId(id); setId(id);
return this; return this;
} }
/** /**
* 设置 开始 序号，主键，自增长 * 设置 开始 序号，主键，自增长
* @param idStart * @param idStart
*/ */
public AttendanceGroupFreeworkSpecialQuery idStart(Long idStart){ public AttendanceGroupFreeworkSpecialQuery idStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
return this; return this;
} }
/** /**
* 设置 结束 序号，主键，自增长 * 设置 结束 序号，主键，自增长
* @param idEnd * @param idEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery idEnd(Long idEnd){ public AttendanceGroupFreeworkSpecialQuery idEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
return this; return this;
} }
/** /**
* 设置 增加 序号，主键，自增长 * 设置 增加 序号，主键，自增长
* @param idIncrement * @param idIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery idIncrement(Long idIncrement){ public AttendanceGroupFreeworkSpecialQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
return this; return this;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idList * @param idList
*/ */
public AttendanceGroupFreeworkSpecialQuery idList(List<Long> idList){ public AttendanceGroupFreeworkSpecialQuery idList(List<Long> idList){
this.idList = idList; this.idList = idList;
return this; return this;
} }
/** /**
* 设置 序号，主键，自增长 * 设置 序号，主键，自增长
* @param idNotList * @param idNotList
*/ */
public AttendanceGroupFreeworkSpecialQuery idNotList(List<Long> idNotList){ public AttendanceGroupFreeworkSpecialQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList; this.idNotList = idNotList;
return this; return this;
} }
/** /**
* 设置 自由工时考勤配置id * 设置 自由工时考勤配置id
* @param freeWorkId * @param freeWorkId
*/ */
public AttendanceGroupFreeworkSpecialQuery freeWorkId(Long freeWorkId){ public AttendanceGroupFreeworkSpecialQuery freeWorkId(Long freeWorkId){
setFreeWorkId(freeWorkId); setFreeWorkId(freeWorkId);
return this; return this;
} }
/** /**
* 设置 开始 自由工时考勤配置id * 设置 开始 自由工时考勤配置id
* @param freeWorkIdStart * @param freeWorkIdStart
*/ */
public AttendanceGroupFreeworkSpecialQuery freeWorkIdStart(Long freeWorkIdStart){ public AttendanceGroupFreeworkSpecialQuery freeWorkIdStart(Long freeWorkIdStart){
this.freeWorkIdStart = freeWorkIdStart; this.freeWorkIdStart = freeWorkIdStart;
return this; return this;
} }
/** /**
* 设置 结束 自由工时考勤配置id * 设置 结束 自由工时考勤配置id
* @param freeWorkIdEnd * @param freeWorkIdEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery freeWorkIdEnd(Long freeWorkIdEnd){ public AttendanceGroupFreeworkSpecialQuery freeWorkIdEnd(Long freeWorkIdEnd){
this.freeWorkIdEnd = freeWorkIdEnd; this.freeWorkIdEnd = freeWorkIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 自由工时考勤配置id * 设置 增加 自由工时考勤配置id
* @param freeWorkIdIncrement * @param freeWorkIdIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery freeWorkIdIncrement(Long freeWorkIdIncrement){ public AttendanceGroupFreeworkSpecialQuery freeWorkIdIncrement(Long freeWorkIdIncrement){
this.freeWorkIdIncrement = freeWorkIdIncrement; this.freeWorkIdIncrement = freeWorkIdIncrement;
return this; return this;
} }
/** /**
* 设置 自由工时考勤配置id * 设置 自由工时考勤配置id
* @param freeWorkIdList * @param freeWorkIdList
*/ */
public AttendanceGroupFreeworkSpecialQuery freeWorkIdList(List<Long> freeWorkIdList){ public AttendanceGroupFreeworkSpecialQuery freeWorkIdList(List<Long> freeWorkIdList){
this.freeWorkIdList = freeWorkIdList; this.freeWorkIdList = freeWorkIdList;
return this; return this;
} }
/** /**
* 设置 自由工时考勤配置id * 设置 自由工时考勤配置id
* @param freeWorkIdNotList * @param freeWorkIdNotList
*/ */
public AttendanceGroupFreeworkSpecialQuery freeWorkIdNotList(List<Long> freeWorkIdNotList){ public AttendanceGroupFreeworkSpecialQuery freeWorkIdNotList(List<Long> freeWorkIdNotList){
this.freeWorkIdNotList = freeWorkIdNotList; this.freeWorkIdNotList = freeWorkIdNotList;
return this; return this;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param must * @param must
*/ */
public AttendanceGroupFreeworkSpecialQuery must(Integer must){ public AttendanceGroupFreeworkSpecialQuery must(Integer must){
setMust(must); setMust(must);
return this; return this;
} }
/** /**
* 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 开始 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustStart * @param mustStart
*/ */
public AttendanceGroupFreeworkSpecialQuery mustStart(Integer mustStart){ public AttendanceGroupFreeworkSpecialQuery mustStart(Integer mustStart){
this.mustStart = mustStart; this.mustStart = mustStart;
return this; return this;
} }
/** /**
* 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 结束 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustEnd * @param mustEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery mustEnd(Integer mustEnd){ public AttendanceGroupFreeworkSpecialQuery mustEnd(Integer mustEnd){
this.mustEnd = mustEnd; this.mustEnd = mustEnd;
return this; return this;
} }
/** /**
* 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 增加 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustIncrement * @param mustIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery mustIncrement(Integer mustIncrement){ public AttendanceGroupFreeworkSpecialQuery mustIncrement(Integer mustIncrement){
this.mustIncrement = mustIncrement; this.mustIncrement = mustIncrement;
return this; return this;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustList * @param mustList
*/ */
public AttendanceGroupFreeworkSpecialQuery mustList(List<Integer> mustList){ public AttendanceGroupFreeworkSpecialQuery mustList(List<Integer> mustList){
this.mustList = mustList; this.mustList = mustList;
return this; return this;
} }
/** /**
* 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是) * 设置 是否必须打卡的日期，当为1时有班次相关信息，否则有无需打卡时间段信息(0.否,1.是)
* @param mustNotList * @param mustNotList
*/ */
public AttendanceGroupFreeworkSpecialQuery mustNotList(List<Integer> mustNotList){ public AttendanceGroupFreeworkSpecialQuery mustNotList(List<Integer> mustNotList){
this.mustNotList = mustNotList; this.mustNotList = mustNotList;
return this; return this;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classId * @param classId
*/ */
public AttendanceGroupFreeworkSpecialQuery classId(Long classId){ public AttendanceGroupFreeworkSpecialQuery classId(Long classId){
setClassId(classId); setClassId(classId);
return this; return this;
} }
/** /**
* 设置 开始 班次ID * 设置 开始 班次ID
* @param classIdStart * @param classIdStart
*/ */
public AttendanceGroupFreeworkSpecialQuery classIdStart(Long classIdStart){ public AttendanceGroupFreeworkSpecialQuery classIdStart(Long classIdStart){
this.classIdStart = classIdStart; this.classIdStart = classIdStart;
return this; return this;
} }
/** /**
* 设置 结束 班次ID * 设置 结束 班次ID
* @param classIdEnd * @param classIdEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery classIdEnd(Long classIdEnd){ public AttendanceGroupFreeworkSpecialQuery classIdEnd(Long classIdEnd){
this.classIdEnd = classIdEnd; this.classIdEnd = classIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 班次ID * 设置 增加 班次ID
* @param classIdIncrement * @param classIdIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery classIdIncrement(Long classIdIncrement){ public AttendanceGroupFreeworkSpecialQuery classIdIncrement(Long classIdIncrement){
this.classIdIncrement = classIdIncrement; this.classIdIncrement = classIdIncrement;
return this; return this;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdList * @param classIdList
*/ */
public AttendanceGroupFreeworkSpecialQuery classIdList(List<Long> classIdList){ public AttendanceGroupFreeworkSpecialQuery classIdList(List<Long> classIdList){
this.classIdList = classIdList; this.classIdList = classIdList;
return this; return this;
} }
/** /**
* 设置 班次ID * 设置 班次ID
* @param classIdNotList * @param classIdNotList
*/ */
public AttendanceGroupFreeworkSpecialQuery classIdNotList(List<Long> classIdNotList){ public AttendanceGroupFreeworkSpecialQuery classIdNotList(List<Long> classIdNotList){
this.classIdNotList = classIdNotList; this.classIdNotList = classIdNotList;
return this; return this;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param className * @param className
*/ */
public AttendanceGroupFreeworkSpecialQuery className(String className){ public AttendanceGroupFreeworkSpecialQuery className(String className){
setClassName(className); setClassName(className);
return this; return this;
} }
/** /**
* 设置 班次名称 * 设置 班次名称
* @param classNameList * @param classNameList
*/ */
public AttendanceGroupFreeworkSpecialQuery classNameList(List<String> classNameList){ public AttendanceGroupFreeworkSpecialQuery classNameList(List<String> classNameList){
this.classNameList = classNameList; this.classNameList = classNameList;
return this; return this;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWay * @param addWay
*/ */
public AttendanceGroupFreeworkSpecialQuery addWay(Integer addWay){ public AttendanceGroupFreeworkSpecialQuery addWay(Integer addWay){
setAddWay(addWay); setAddWay(addWay);
return this; return this;
} }
/** /**
* 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 开始 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayStart * @param addWayStart
*/ */
public AttendanceGroupFreeworkSpecialQuery addWayStart(Integer addWayStart){ public AttendanceGroupFreeworkSpecialQuery addWayStart(Integer addWayStart){
this.addWayStart = addWayStart; this.addWayStart = addWayStart;
return this; return this;
} }
/** /**
* 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 结束 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayEnd * @param addWayEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery addWayEnd(Integer addWayEnd){ public AttendanceGroupFreeworkSpecialQuery addWayEnd(Integer addWayEnd){
this.addWayEnd = addWayEnd; this.addWayEnd = addWayEnd;
return this; return this;
} }
/** /**
* 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 增加 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayIncrement * @param addWayIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery addWayIncrement(Integer addWayIncrement){ public AttendanceGroupFreeworkSpecialQuery addWayIncrement(Integer addWayIncrement){
this.addWayIncrement = addWayIncrement; this.addWayIncrement = addWayIncrement;
return this; return this;
} }
/** /**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段) * 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayList * @param addWayList
*/ */
public AttendanceGroupFreeworkSpecialQuery addWayList(List<Integer> addWayList){ public AttendanceGroupFreeworkSpecialQuery addWayList(List<Integer> addWayList){
this.addWayList = addWayList; this.addWayList = addWayList;
return this;
}
/**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayNotList
*/
public AttendanceGroupFreeworkSpecialQuery addWayNotList(List<Integer> addWayNotList){
this.addWayNotList = addWayNotList;
return this; return this;
} }
/**
* 设置 无需打卡的日期类型(0.单个日期,1.时间段)
* @param addWayNotList
*/
public AttendanceGroupFreeworkSpecialQuery addWayNotList(List<Integer> addWayNotList){
this.addWayNotList = addWayNotList;
return this;
}
/** /**
* 设置 备注 * 设置 备注
* @param remark * @param remark
*/ */
public AttendanceGroupFreeworkSpecialQuery remark(String remark){ public AttendanceGroupFreeworkSpecialQuery remark(String remark){
setRemark(remark); setRemark(remark);
return this; return this;
} }
/** /**
* 设置 备注 * 设置 备注
* @param remarkList * @param remarkList
*/ */
public AttendanceGroupFreeworkSpecialQuery remarkList(List<String> remarkList){ public AttendanceGroupFreeworkSpecialQuery remarkList(List<String> remarkList){
this.remarkList = remarkList; this.remarkList = remarkList;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserId * @param createUserId
*/ */
public AttendanceGroupFreeworkSpecialQuery createUserId(Long createUserId){ public AttendanceGroupFreeworkSpecialQuery createUserId(Long createUserId){
setCreateUserId(createUserId); setCreateUserId(createUserId);
return this; return this;
} }
/** /**
* 设置 开始 创建用户 * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public AttendanceGroupFreeworkSpecialQuery createUserIdStart(Long createUserIdStart){ public AttendanceGroupFreeworkSpecialQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
return this; return this;
} }
/** /**
* 设置 结束 创建用户 * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery createUserIdEnd(Long createUserIdEnd){ public AttendanceGroupFreeworkSpecialQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 创建用户 * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery createUserIdIncrement(Long createUserIdIncrement){ public AttendanceGroupFreeworkSpecialQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public AttendanceGroupFreeworkSpecialQuery createUserIdList(List<Long> createUserIdList){ public AttendanceGroupFreeworkSpecialQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList; this.createUserIdList = createUserIdList;
return this; return this;
} }
/** /**
* 设置 创建用户 * 设置 创建用户
* @param createUserIdNotList * @param createUserIdNotList
*/ */
public AttendanceGroupFreeworkSpecialQuery createUserIdNotList(List<Long> createUserIdNotList){ public AttendanceGroupFreeworkSpecialQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList; this.createUserIdNotList = createUserIdNotList;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserId * @param updateUserId
*/ */
public AttendanceGroupFreeworkSpecialQuery updateUserId(Long updateUserId){ public AttendanceGroupFreeworkSpecialQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId); setUpdateUserId(updateUserId);
return this; return this;
} }
/** /**
* 设置 开始 更新用户 * 设置 开始 更新用户
* @param updateUserIdStart * @param updateUserIdStart
*/ */
public AttendanceGroupFreeworkSpecialQuery updateUserIdStart(Long updateUserIdStart){ public AttendanceGroupFreeworkSpecialQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart; this.updateUserIdStart = updateUserIdStart;
return this; return this;
} }
/** /**
* 设置 结束 更新用户 * 设置 结束 更新用户
* @param updateUserIdEnd * @param updateUserIdEnd
*/ */
public AttendanceGroupFreeworkSpecialQuery updateUserIdEnd(Long updateUserIdEnd){ public AttendanceGroupFreeworkSpecialQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd; this.updateUserIdEnd = updateUserIdEnd;
return this; return this;
} }
/** /**
* 设置 增加 更新用户 * 设置 增加 更新用户
* @param updateUserIdIncrement * @param updateUserIdIncrement
*/ */
public AttendanceGroupFreeworkSpecialQuery updateUserIdIncrement(Long updateUserIdIncrement){ public AttendanceGroupFreeworkSpecialQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement; this.updateUserIdIncrement = updateUserIdIncrement;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdList * @param updateUserIdList
*/ */
public AttendanceGroupFreeworkSpecialQuery updateUserIdList(List<Long> updateUserIdList){ public AttendanceGroupFreeworkSpecialQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList; this.updateUserIdList = updateUserIdList;
return this; return this;
} }
/** /**
* 设置 更新用户 * 设置 更新用户
* @param updateUserIdNotList * @param updateUserIdNotList
*/ */
public AttendanceGroupFreeworkSpecialQuery updateUserIdNotList(List<Long> updateUserIdNotList){ public AttendanceGroupFreeworkSpecialQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList; this.updateUserIdNotList = updateUserIdNotList;
return this; return this;
} }
/** /**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList * @return orConditionList
*/ */
public List<AttendanceGroupFreeworkSpecialQuery> getOrConditionList(){ public List<AttendanceGroupFreeworkSpecialQuery> getOrConditionList(){
return this.orConditionList; return this.orConditionList;
} }
/** /**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList * @param orConditionList
*/ */
public void setOrConditionList(List<AttendanceGroupFreeworkSpecialQuery> orConditionList){ public void setOrConditionList(List<AttendanceGroupFreeworkSpecialQuery> orConditionList){
this.orConditionList = orConditionList; this.orConditionList = orConditionList;
} }
/** /**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList * @return andConditionList
*/ */
public List<AttendanceGroupFreeworkSpecialQuery> getAndConditionList(){ public List<AttendanceGroupFreeworkSpecialQuery> getAndConditionList(){
return this.andConditionList; return this.andConditionList;
} }
/** /**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList * @param andConditionList
*/ */
public void setAndConditionList(List<AttendanceGroupFreeworkSpecialQuery> andConditionList){ public void setAndConditionList(List<AttendanceGroupFreeworkSpecialQuery> andConditionList){
this.andConditionList = andConditionList; this.andConditionList = andConditionList;
} }
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/impl/AttendanceClassServiceImpl.java
View file @ 9173472b
...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceClassDetailService; ...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceClassDetailService;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import java.util.Date; import java.util.Date;
import java.util.Arrays; import java.util.Arrays;
import java.util.List;
/** /**
* AttendanceClassService * AttendanceClassService
* 考勤班次信息 service实现 * 考勤班次信息 service实现
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/impl/AttendanceGroupFixedworkServiceImpl.java
View file @ 9173472b
...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceGroupFixedworkSpecial ...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceGroupFixedworkSpecial
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import java.util.Date; import java.util.Date;
import java.util.Arrays; import java.util.Arrays;
import java.util.List;
/** /**
* AttendanceGroupFixedworkService * AttendanceGroupFixedworkService
* 考勤组考勤固定工时 service实现 * 考勤组考勤固定工时 service实现
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/impl/AttendanceGroupFreeworkServiceImpl.java
View file @ 9173472b
...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceGroupFreeworkSpecialS ...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceGroupFreeworkSpecialS
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import java.util.Date; import java.util.Date;
import java.util.Arrays; import java.util.Arrays;
import java.util.List;
/** /**
* AttendanceGroupFreeworkService * AttendanceGroupFreeworkService
* 考勤组考勤自由工时配置 service实现 * 考勤组考勤自由工时配置 service实现
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/impl/AttendanceGroupServiceImpl.java
View file @ 9173472b
...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceGroupStaffService; ...@@ -13,6 +13,8 @@ import com.mortals.xhx.module.attendance.service.AttendanceGroupStaffService;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import java.util.Date; import java.util.Date;
import java.util.Arrays; import java.util.Arrays;
import java.util.List;
/** /**
* AttendanceGroupService * AttendanceGroupService
* 考勤组信息 service实现 * 考勤组信息 service实现
......
attendance-performance-manager/src/main/resources/sqlmap/module/attendance/AttendanceGroupFixedworkSpecialMapper.xml
View file @ 9173472b
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd"> "mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.attendance.dao.ibatis.AttendanceGroupFixedworkSpecialDaoImpl"> <mapper namespace="com.mortals.xhx.module.attendance.dao.ibatis.AttendanceGroupFixedworkSpecialDaoImpl">
<!-- 字段和属性映射 --> <!-- 字段和属性映射 -->
<resultMap type="AttendanceGroupFixedworkSpecialEntity" id="AttendanceGroupFixedworkSpecialEntity-Map"> <resultMap type="AttendanceGroupFixedworkSpecialEntity" id="AttendanceGroupFixedworkSpecialEntity-Map">
<id property="id" column="id" /> <id property="id" column="id" />
<result property="fixedWorkId" column="fixedWorkId" /> <result property="fixedWorkId" column="fixedWorkId" />
<result property="must" column="must" /> <result property="must" column="must" />
<result property="classId" column="classId" /> <result property="classId" column="classId" />
<result property="className" column="className" /> <result property="className" column="className" />
<result property="addWay" column="addWay" /> <result property="addWay" column="addWay" />
<result property="specialTime" column="specialTime" /> <result property="specialTime" column="specialTime" />
<result property="specialTimeStart" column="specialTimeStart" /> <result property="remark" column="remark" />
<result property="specialTimeEnd" column="specialTimeEnd" /> <result property="createUserId" column="createUserId" />
<result property="remark" column="remark" /> <result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" /> <result property="updateUserId" column="updateUserId" />
<result property="createTime" column="createTime" /> <result property="updateTime" column="updateTime" />
<result property="updateUserId" column="updateUserId" /> <result property="specialStartTime" column="specialStartTime" />
<result property="updateTime" column="updateTime" /> <result property="specialEndTime" column="specialEndTime" />
</resultMap> </resultMap>
<!-- 表所有列 --> <!-- 表所有列 -->
<sql id="_columns"> <sql id="_columns">
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id, a.id,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fixedWorkId') or colPickMode == 1 and data.containsKey('fixedWorkId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fixedWorkId') or colPickMode == 1 and data.containsKey('fixedWorkId')))">
a.fixedWorkId, a.fixedWorkId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('must') or colPickMode == 1 and data.containsKey('must')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('must') or colPickMode == 1 and data.containsKey('must')))">
a.must, a.must,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('classId') or colPickMode == 1 and data.containsKey('classId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('classId') or colPickMode == 1 and data.containsKey('classId')))">
a.classId, a.classId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('className') or colPickMode == 1 and data.containsKey('className')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('className') or colPickMode == 1 and data.containsKey('className')))">
a.className, a.className,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('addWay') or colPickMode == 1 and data.containsKey('addWay')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('addWay') or colPickMode == 1 and data.containsKey('addWay')))">
a.addWay, a.addWay,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTime') or colPickMode == 1 and data.containsKey('specialTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTime') or colPickMode == 1 and data.containsKey('specialTime')))">
a.specialTime, a.specialTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTimeStart') or colPickMode == 1 and data.containsKey('specialTimeStart')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.specialTimeStart, a.remark,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTimeEnd') or colPickMode == 1 and data.containsKey('specialTimeEnd')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.specialTimeEnd, a.createUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.remark, a.createTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.createUserId, a.updateUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.createTime, a.updateTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialStartTime') or colPickMode == 1 and data.containsKey('specialStartTime')))">
a.updateUserId, a.specialStartTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialEndTime') or colPickMode == 1 and data.containsKey('specialEndTime')))">
a.updateTime, a.specialEndTime,
</if> </if>
</trim> </trim>
</sql> </sql>
<!-- 新增 区分主键自增加还是业务插入 --> <!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="AttendanceGroupFixedworkSpecialEntity" useGeneratedKeys="true" keyProperty="id"> <insert id="insert" parameterType="AttendanceGroupFixedworkSpecialEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_attendance_group_fixedwork_special insert into mortals_xhx_attendance_group_fixedwork_special
(fixedWorkId,must,classId,className,addWay,specialTime,specialTimeStart,specialTimeEnd,remark,createUserId,createTime,updateUserId,updateTime) (fixedWorkId,must,classId,className,addWay,specialTime,remark,createUserId,createTime,updateUserId,updateTime,specialStartTime,specialEndTime)
VALUES VALUES
(#{fixedWorkId},#{must},#{classId},#{className},#{addWay},#{specialTime},#{specialTimeStart},#{specialTimeEnd},#{remark},#{createUserId},#{createTime},#{updateUserId},#{updateTime}) (#{fixedWorkId},#{must},#{classId},#{className},#{addWay},#{specialTime},#{remark},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{specialStartTime},#{specialEndTime})
</insert> </insert>
<!-- 批量新增 --> <!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto"> <insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_attendance_group_fixedwork_special insert into mortals_xhx_attendance_group_fixedwork_special
(fixedWorkId,must,classId,className,addWay,specialTime,specialTimeStart,specialTimeEnd,remark,createUserId,createTime,updateUserId,updateTime) (fixedWorkId,must,classId,className,addWay,specialTime,remark,createUserId,createTime,updateUserId,updateTime,specialStartTime,specialEndTime)
VALUES VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," > <foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.fixedWorkId},#{item.must},#{item.classId},#{item.className},#{item.addWay},#{item.specialTime},#{item.specialTimeStart},#{item.specialTimeEnd},#{item.remark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime}) (#{item.fixedWorkId},#{item.must},#{item.classId},#{item.className},#{item.addWay},#{item.specialTime},#{item.remark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.specialStartTime},#{item.specialEndTime})
</foreach> </foreach>
</insert> </insert>
...@@ -124,12 +124,6 @@ ...@@ -124,12 +124,6 @@
<if test="(colPickMode==0 and data.containsKey('specialTime')) or (colPickMode==1 and !data.containsKey('specialTime'))"> <if test="(colPickMode==0 and data.containsKey('specialTime')) or (colPickMode==1 and !data.containsKey('specialTime'))">
a.specialTime=#{data.specialTime}, a.specialTime=#{data.specialTime},
</if> </if>
<if test="(colPickMode==0 and data.containsKey('specialTimeStart')) or (colPickMode==1 and !data.containsKey('specialTimeStart'))">
a.specialTimeStart=#{data.specialTimeStart},
</if>
<if test="(colPickMode==0 and data.containsKey('specialTimeEnd')) or (colPickMode==1 and !data.containsKey('specialTimeEnd'))">
a.specialTimeEnd=#{data.specialTimeEnd},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))"> <if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark}, a.remark=#{data.remark},
</if> </if>
...@@ -151,6 +145,12 @@ ...@@ -151,6 +145,12 @@
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))"> <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime}, a.updateTime=#{data.updateTime},
</if> </if>
<if test="(colPickMode==0 and data.containsKey('specialStartTime')) or (colPickMode==1 and !data.containsKey('specialStartTime'))">
a.specialStartTime=#{data.specialStartTime},
</if>
<if test="(colPickMode==0 and data.containsKey('specialEndTime')) or (colPickMode==1 and !data.containsKey('specialEndTime'))">
a.specialEndTime=#{data.specialEndTime},
</if>
</trim> </trim>
<trim suffixOverrides="where" suffix=""> <trim suffixOverrides="where" suffix="">
where where
...@@ -163,127 +163,127 @@ ...@@ -163,127 +163,127 @@
<update id="updateBatch" parameterType="paramDto"> <update id="updateBatch" parameterType="paramDto">
update mortals_xhx_attendance_group_fixedwork_special as a update mortals_xhx_attendance_group_fixedwork_special as a
<trim prefix="set" suffixOverrides=","> <trim prefix="set" suffixOverrides=",">
<trim prefix="fixedWorkId=(case" suffix="ELSE fixedWorkId end),"> <trim prefix="fixedWorkId=(case" suffix="ELSE fixedWorkId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('fixedWorkId')) or (colPickMode==1 and !item.containsKey('fixedWorkId'))"> <when test="(colPickMode==0 and item.containsKey('fixedWorkId')) or (colPickMode==1 and !item.containsKey('fixedWorkId'))">
when a.id=#{item.id} then #{item.fixedWorkId} when a.id=#{item.id} then #{item.fixedWorkId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('fixedWorkIdIncrement')) or (colPickMode==1 and !item.containsKey('fixedWorkIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('fixedWorkIdIncrement')) or (colPickMode==1 and !item.containsKey('fixedWorkIdIncrement'))">
when a.id=#{item.id} then ifnull(a.fixedWorkId,0) + #{item.fixedWorkIdIncrement} when a.id=#{item.id} then ifnull(a.fixedWorkId,0) + #{item.fixedWorkIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="must=(case" suffix="ELSE must end),"> <trim prefix="must=(case" suffix="ELSE must end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('must')) or (colPickMode==1 and !item.containsKey('must'))"> <when test="(colPickMode==0 and item.containsKey('must')) or (colPickMode==1 and !item.containsKey('must'))">
when a.id=#{item.id} then #{item.must} when a.id=#{item.id} then #{item.must}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('mustIncrement')) or (colPickMode==1 and !item.containsKey('mustIncrement'))"> <when test="(colPickMode==0 and item.containsKey('mustIncrement')) or (colPickMode==1 and !item.containsKey('mustIncrement'))">
when a.id=#{item.id} then ifnull(a.must,0) + #{item.mustIncrement} when a.id=#{item.id} then ifnull(a.must,0) + #{item.mustIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="classId=(case" suffix="ELSE classId end),"> <trim prefix="classId=(case" suffix="ELSE classId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('classId')) or (colPickMode==1 and !item.containsKey('classId'))"> <when test="(colPickMode==0 and item.containsKey('classId')) or (colPickMode==1 and !item.containsKey('classId'))">
when a.id=#{item.id} then #{item.classId} when a.id=#{item.id} then #{item.classId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('classIdIncrement')) or (colPickMode==1 and !item.containsKey('classIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('classIdIncrement')) or (colPickMode==1 and !item.containsKey('classIdIncrement'))">
when a.id=#{item.id} then ifnull(a.classId,0) + #{item.classIdIncrement} when a.id=#{item.id} then ifnull(a.classId,0) + #{item.classIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="className=(case" suffix="ELSE className end),"> <trim prefix="className=(case" suffix="ELSE className end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('className')) or (colPickMode==1 and !item.containsKey('className'))"> <if test="(colPickMode==0 and item.containsKey('className')) or (colPickMode==1 and !item.containsKey('className'))">
when a.id=#{item.id} then #{item.className} when a.id=#{item.id} then #{item.className}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="addWay=(case" suffix="ELSE addWay end),"> <trim prefix="addWay=(case" suffix="ELSE addWay end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('addWay')) or (colPickMode==1 and !item.containsKey('addWay'))"> <when test="(colPickMode==0 and item.containsKey('addWay')) or (colPickMode==1 and !item.containsKey('addWay'))">
when a.id=#{item.id} then #{item.addWay} when a.id=#{item.id} then #{item.addWay}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('addWayIncrement')) or (colPickMode==1 and !item.containsKey('addWayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('addWayIncrement')) or (colPickMode==1 and !item.containsKey('addWayIncrement'))">
when a.id=#{item.id} then ifnull(a.addWay,0) + #{item.addWayIncrement} when a.id=#{item.id} then ifnull(a.addWay,0) + #{item.addWayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="specialTime=(case" suffix="ELSE specialTime end),"> <trim prefix="specialTime=(case" suffix="ELSE specialTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('specialTime')) or (colPickMode==1 and !item.containsKey('specialTime'))"> <if test="(colPickMode==0 and item.containsKey('specialTime')) or (colPickMode==1 and !item.containsKey('specialTime'))">
when a.id=#{item.id} then #{item.specialTime} when a.id=#{item.id} then #{item.specialTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="specialTimeStart=(case" suffix="ELSE specialTimeStart end),"> <trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('specialTimeStart')) or (colPickMode==1 and !item.containsKey('specialTimeStart'))"> <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.specialTimeStart} when a.id=#{item.id} then #{item.remark}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="specialTimeEnd=(case" suffix="ELSE specialTimeEnd end),"> <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('specialTimeEnd')) or (colPickMode==1 and !item.containsKey('specialTimeEnd'))"> <choose>
when a.id=#{item.id} then #{item.specialTimeEnd} <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
</if> when a.id=#{item.id} then #{item.createUserId}
</foreach> </when>
</trim> <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
<trim prefix="remark=(case" suffix="ELSE remark end),"> when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
<foreach collection="data.dataList" item="item" index="index" separator="" > </when>
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))"> </choose>
when a.id=#{item.id} then #{item.remark} </foreach>
</if> </trim>
</foreach> <trim prefix="createTime=(case" suffix="ELSE createTime end),">
</trim> <foreach collection="data.dataList" item="item" index="index" separator="" >
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),"> <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
<foreach collection="data.dataList" item="item" index="index" separator="" > when a.id=#{item.id} then #{item.createTime}
<choose> </if>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))"> </foreach>
when a.id=#{item.id} then #{item.createUserId} </trim>
</when> <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))"> <foreach collection="data.dataList" item="item" index="index" separator="" >
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement} <choose>
</when> <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
</choose> when a.id=#{item.id} then #{item.updateUserId}
</foreach> </when>
</trim> <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
<trim prefix="createTime=(case" suffix="ELSE createTime end),"> when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
<foreach collection="data.dataList" item="item" index="index" separator="" > </when>
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))"> </choose>
when a.id=#{item.id} then #{item.createTime} </foreach>
</if> </trim>
</foreach> <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
</trim> <foreach collection="data.dataList" item="item" index="index" separator="" >
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),"> <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
<foreach collection="data.dataList" item="item" index="index" separator="" > when a.id=#{item.id} then #{item.updateTime}
<choose> </if>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))"> </foreach>
when a.id=#{item.id} then #{item.updateUserId} </trim>
</when> <trim prefix="specialStartTime=(case" suffix="ELSE specialStartTime end),">
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))"> <foreach collection="data.dataList" item="item" index="index" separator="" >
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement} <if test="(colPickMode==0 and item.containsKey('specialStartTime')) or (colPickMode==1 and !item.containsKey('specialStartTime'))">
</when> when a.id=#{item.id} then #{item.specialStartTime}
</choose> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),"> <trim prefix="specialEndTime=(case" suffix="ELSE specialEndTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))"> <if test="(colPickMode==0 and item.containsKey('specialEndTime')) or (colPickMode==1 and !item.containsKey('specialEndTime'))">
when a.id=#{item.id} then #{item.updateTime} when a.id=#{item.id} then #{item.specialEndTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
</trim> </trim>
where id in where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")"> <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
...@@ -400,395 +400,395 @@ ...@@ -400,395 +400,395 @@
${_conditionType_} a.id=#{${_conditionParam_}.id} ${_conditionType_} a.id=#{${_conditionParam_}.id}
</if> </if>
</if> </if>
<if test="conditionParamRef.containsKey('id')"> <if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null "> <if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id} ${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if> </if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null"> <if test="conditionParamRef.id == null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd} ${_conditionType_} a.id is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('fixedWorkId')"> <if test="conditionParamRef.containsKey('fixedWorkId')">
<if test="conditionParamRef.fixedWorkId != null "> <if test="conditionParamRef.fixedWorkId != null ">
${_conditionType_} a.fixedWorkId = #{${_conditionParam_}.fixedWorkId} ${_conditionType_} a.fixedWorkId = #{${_conditionParam_}.fixedWorkId}
</if>
<if test="conditionParamRef.fixedWorkId == null">
${_conditionType_} a.fixedWorkId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('fixedWorkIdList')"> <if test="conditionParamRef.fixedWorkId == null">
${_conditionType_} a.fixedWorkId in ${_conditionType_} a.fixedWorkId is null
<foreach collection="conditionParamRef.fixedWorkIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdNotList')">
${_conditionType_} a.fixedWorkId not in
<foreach collection="conditionParamRef.fixedWorkIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdStart') and conditionParamRef.fixedWorkIdStart != null">
${_conditionType_} a.fixedWorkId <![CDATA[ >= ]]> #{${_conditionParam_}.fixedWorkIdStart}
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdEnd') and conditionParamRef.fixedWorkIdEnd != null">
${_conditionType_} a.fixedWorkId <![CDATA[ <= ]]> #{${_conditionParam_}.fixedWorkIdEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdList')">
${_conditionType_} a.fixedWorkId in
<foreach collection="conditionParamRef.fixedWorkIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdNotList')">
${_conditionType_} a.fixedWorkId not in
<foreach collection="conditionParamRef.fixedWorkIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdStart') and conditionParamRef.fixedWorkIdStart != null">
${_conditionType_} a.fixedWorkId <![CDATA[ >= ]]> #{${_conditionParam_}.fixedWorkIdStart}
</if>
<if test="conditionParamRef.containsKey('fixedWorkIdEnd') and conditionParamRef.fixedWorkIdEnd != null">
${_conditionType_} a.fixedWorkId <![CDATA[ <= ]]> #{${_conditionParam_}.fixedWorkIdEnd}
</if>
<if test="conditionParamRef.containsKey('must')"> <if test="conditionParamRef.containsKey('must')">
<if test="conditionParamRef.must != null "> <if test="conditionParamRef.must != null ">
${_conditionType_} a.must = #{${_conditionParam_}.must} ${_conditionType_} a.must = #{${_conditionParam_}.must}
</if>
<if test="conditionParamRef.must == null">
${_conditionType_} a.must is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('mustList')"> <if test="conditionParamRef.must == null">
${_conditionType_} a.must in ${_conditionType_} a.must is null
<foreach collection="conditionParamRef.mustList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustNotList')">
${_conditionType_} a.must not in
<foreach collection="conditionParamRef.mustNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustStart') and conditionParamRef.mustStart != null">
${_conditionType_} a.must <![CDATA[ >= ]]> #{${_conditionParam_}.mustStart}
</if>
<if test="conditionParamRef.containsKey('mustEnd') and conditionParamRef.mustEnd != null">
${_conditionType_} a.must <![CDATA[ <= ]]> #{${_conditionParam_}.mustEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('mustList')">
${_conditionType_} a.must in
<foreach collection="conditionParamRef.mustList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustNotList')">
${_conditionType_} a.must not in
<foreach collection="conditionParamRef.mustNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustStart') and conditionParamRef.mustStart != null">
${_conditionType_} a.must <![CDATA[ >= ]]> #{${_conditionParam_}.mustStart}
</if>
<if test="conditionParamRef.containsKey('mustEnd') and conditionParamRef.mustEnd != null">
${_conditionType_} a.must <![CDATA[ <= ]]> #{${_conditionParam_}.mustEnd}
</if>
<if test="conditionParamRef.containsKey('classId')"> <if test="conditionParamRef.containsKey('classId')">
<if test="conditionParamRef.classId != null "> <if test="conditionParamRef.classId != null ">
${_conditionType_} a.classId = #{${_conditionParam_}.classId} ${_conditionType_} a.classId = #{${_conditionParam_}.classId}
</if>
<if test="conditionParamRef.classId == null">
${_conditionType_} a.classId is null
</if>
</if>
<if test="conditionParamRef.containsKey('classIdList')">
${_conditionType_} a.classId in
<foreach collection="conditionParamRef.classIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdNotList')">
${_conditionType_} a.classId not in
<foreach collection="conditionParamRef.classIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdStart') and conditionParamRef.classIdStart != null">
${_conditionType_} a.classId <![CDATA[ >= ]]> #{${_conditionParam_}.classIdStart}
</if> </if>
<if test="conditionParamRef.containsKey('classIdEnd') and conditionParamRef.classIdEnd != null"> <if test="conditionParamRef.classId == null">
${_conditionType_} a.classId <![CDATA[ <= ]]> #{${_conditionParam_}.classIdEnd} ${_conditionType_} a.classId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('classIdList')">
${_conditionType_} a.classId in
<foreach collection="conditionParamRef.classIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdNotList')">
${_conditionType_} a.classId not in
<foreach collection="conditionParamRef.classIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdStart') and conditionParamRef.classIdStart != null">
${_conditionType_} a.classId <![CDATA[ >= ]]> #{${_conditionParam_}.classIdStart}
</if>
<if test="conditionParamRef.containsKey('classIdEnd') and conditionParamRef.classIdEnd != null">
${_conditionType_} a.classId <![CDATA[ <= ]]> #{${_conditionParam_}.classIdEnd}
</if>
<if test="conditionParamRef.containsKey('className')"> <if test="conditionParamRef.containsKey('className')">
<if test="conditionParamRef.className != null and conditionParamRef.className != ''"> <if test="conditionParamRef.className != null and conditionParamRef.className != ''">
${_conditionType_} a.className like #{${_conditionParam_}.className} ${_conditionType_} a.className like #{${_conditionParam_}.className}
</if>
<if test="conditionParamRef.className == null">
${_conditionType_} a.className is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('classNameList')"> <if test="conditionParamRef.className == null">
${_conditionType_} a.className in ${_conditionType_} a.className is null
<foreach collection="conditionParamRef.classNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('classNameNotList')"> </if>
${_conditionType_} a.className not in <if test="conditionParamRef.containsKey('classNameList')">
<foreach collection="conditionParamRef.classNameNotList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.className in
#{item} <foreach collection="conditionParamRef.classNameList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('addWay')"> </if>
<if test="conditionParamRef.addWay != null "> <if test="conditionParamRef.containsKey('classNameNotList')">
${_conditionType_} a.addWay = #{${_conditionParam_}.addWay} ${_conditionType_} a.className not in
</if> <foreach collection="conditionParamRef.classNameNotList" open="(" close=")" index="index" item="item" separator=",">
<if test="conditionParamRef.addWay == null"> #{item}
${_conditionType_} a.addWay is null </foreach>
</if> </if>
</if> <if test="conditionParamRef.containsKey('addWay')">
<if test="conditionParamRef.containsKey('addWayList')"> <if test="conditionParamRef.addWay != null ">
${_conditionType_} a.addWay in ${_conditionType_} a.addWay = #{${_conditionParam_}.addWay}
<foreach collection="conditionParamRef.addWayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayNotList')">
${_conditionType_} a.addWay not in
<foreach collection="conditionParamRef.addWayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayStart') and conditionParamRef.addWayStart != null">
${_conditionType_} a.addWay <![CDATA[ >= ]]> #{${_conditionParam_}.addWayStart}
</if> </if>
<if test="conditionParamRef.containsKey('addWayEnd') and conditionParamRef.addWayEnd != null"> <if test="conditionParamRef.addWay == null">
${_conditionType_} a.addWay <![CDATA[ <= ]]> #{${_conditionParam_}.addWayEnd} ${_conditionType_} a.addWay is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('addWayList')">
${_conditionType_} a.addWay in
<foreach collection="conditionParamRef.addWayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayNotList')">
${_conditionType_} a.addWay not in
<foreach collection="conditionParamRef.addWayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayStart') and conditionParamRef.addWayStart != null">
${_conditionType_} a.addWay <![CDATA[ >= ]]> #{${_conditionParam_}.addWayStart}
</if>
<if test="conditionParamRef.containsKey('addWayEnd') and conditionParamRef.addWayEnd != null">
${_conditionType_} a.addWay <![CDATA[ <= ]]> #{${_conditionParam_}.addWayEnd}
</if>
<if test="conditionParamRef.containsKey('specialTime')"> <if test="conditionParamRef.containsKey('specialTime')">
<if test="conditionParamRef.specialTime != null "> <if test="conditionParamRef.specialTime != null ">
${_conditionType_} a.specialTime = #{${_conditionParam_}.specialTime} ${_conditionType_} a.specialTime = #{${_conditionParam_}.specialTime}
</if>
<if test="conditionParamRef.specialTime == null">
${_conditionType_} a.specialTime is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('specialTimeStart') and conditionParamRef.specialTimeStart != null and conditionParamRef.specialTimeStart!=''"> <if test="conditionParamRef.specialTime == null">
${_conditionType_} a.specialTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.specialTime is null
</if>
<if test="conditionParamRef.containsKey('specialTimeEnd') and conditionParamRef.specialTimeEnd != null and conditionParamRef.specialTimeEnd!=''">
${_conditionType_} a.specialTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialTimeStart') and conditionParamRef.specialTimeStart != null and conditionParamRef.specialTimeStart!=''">
${_conditionType_} a.specialTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialTimeEnd') and conditionParamRef.specialTimeEnd != null and conditionParamRef.specialTimeEnd!=''">
${_conditionType_} a.specialTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialTimeStart')"> <if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.specialTimeStart != null "> <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.specialTimeStart = #{${_conditionParam_}.specialTimeStart} ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.specialTimeStart == null">
${_conditionType_} a.specialTimeStart is null
</if>
</if>
<if test="conditionParamRef.containsKey('specialTimeStartStart') and conditionParamRef.specialTimeStartStart != null and conditionParamRef.specialTimeStartStart!=''">
${_conditionType_} a.specialTimeStart <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStartStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.containsKey('specialTimeStartEnd') and conditionParamRef.specialTimeStartEnd != null and conditionParamRef.specialTimeStartEnd!=''"> <if test="conditionParamRef.remark == null">
${_conditionType_} a.specialTimeStart <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStartEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.remark is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialTimeEnd')"> <if test="conditionParamRef.containsKey('remarkList')">
<if test="conditionParamRef.specialTimeEnd != null "> ${_conditionType_} a.remark in
${_conditionType_} a.specialTimeEnd = #{${_conditionParam_}.specialTimeEnd} <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
</if> #{item}
<if test="conditionParamRef.specialTimeEnd == null"> </foreach>
${_conditionType_} a.specialTimeEnd is null </if>
</if> <if test="conditionParamRef.containsKey('remarkNotList')">
</if> ${_conditionType_} a.remark not in
<if test="conditionParamRef.containsKey('specialTimeEndStart') and conditionParamRef.specialTimeEndStart != null and conditionParamRef.specialTimeEndStart!=''"> <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
${_conditionType_} a.specialTimeEnd <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEndStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') #{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if> </if>
<if test="conditionParamRef.containsKey('specialTimeEndEnd') and conditionParamRef.specialTimeEndEnd != null and conditionParamRef.specialTimeEndEnd!=''"> <if test="conditionParamRef.createUserId == null">
${_conditionType_} a.specialTimeEnd <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEndEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.createUserId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''"> <if test="conditionParamRef.containsKey('createTime')">
${_conditionType_} a.remark like #{${_conditionParam_}.remark} <if test="conditionParamRef.createTime != null ">
</if> ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList')">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdNotList')"> <if test="conditionParamRef.createTime == null">
${_conditionType_} a.createUserId not in ${_conditionType_} a.createTime is null
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null"> </if>
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart} <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>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null"> <if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd} ${_conditionType_} a.updateUserId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList')">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')"> <if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.createTime != null "> <if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime} ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''"> <if test="conditionParamRef.updateTime == null">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.updateTime 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>
<if test="conditionParamRef.containsKey('updateUserIdList')"> </if>
${_conditionType_} a.updateUserId in <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
#{item} </if>
</foreach> <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
</if> ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.containsKey('updateUserIdNotList')"> </if>
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=","> <if test="conditionParamRef.containsKey('specialStartTime')">
#{item} <if test="conditionParamRef.specialStartTime != null ">
</foreach> ${_conditionType_} a.specialStartTime = #{${_conditionParam_}.specialStartTime}
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if> </if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null"> <if test="conditionParamRef.specialStartTime == null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd} ${_conditionType_} a.specialStartTime is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialStartTimeStart') and conditionParamRef.specialStartTimeStart != null and conditionParamRef.specialStartTimeStart!=''">
${_conditionType_} a.specialStartTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialStartTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialStartTimeEnd') and conditionParamRef.specialStartTimeEnd != null and conditionParamRef.specialStartTimeEnd!=''">
${_conditionType_} a.specialStartTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialStartTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialEndTime')">
<if test="conditionParamRef.containsKey('updateTime')"> <if test="conditionParamRef.specialEndTime != null ">
<if test="conditionParamRef.updateTime != null "> ${_conditionType_} a.specialEndTime = #{${_conditionParam_}.specialEndTime}
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''"> <if test="conditionParamRef.specialEndTime == null">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.specialEndTime is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialEndTimeStart') and conditionParamRef.specialEndTimeStart != null and conditionParamRef.specialEndTimeStart!=''">
${_conditionType_} a.specialEndTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialEndTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialEndTimeEnd') and conditionParamRef.specialEndTimeEnd != null and conditionParamRef.specialEndTimeEnd!=''">
${_conditionType_} a.specialEndTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialEndTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql> </sql>
<sql id="_orderCols_"> <sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()"> <if test="orderColList != null and !orderColList.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=","> <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind} ${item.colName} ${item.sortKind}
</foreach> </foreach>
</trim> </trim>
</if> </if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()"> <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')"> <if test="orderCol.containsKey('id')">
a.id a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if> <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('fixedWorkId')"> <if test="orderCol.containsKey('fixedWorkId')">
a.fixedWorkId a.fixedWorkId
<if test='orderCol.fixedWorkId != null and "DESC".equalsIgnoreCase(orderCol.fixedWorkId)'>DESC</if> <if test='orderCol.fixedWorkId != null and "DESC".equalsIgnoreCase(orderCol.fixedWorkId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('must')"> <if test="orderCol.containsKey('must')">
a.must a.must
<if test='orderCol.must != null and "DESC".equalsIgnoreCase(orderCol.must)'>DESC</if> <if test='orderCol.must != null and "DESC".equalsIgnoreCase(orderCol.must)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('classId')"> <if test="orderCol.containsKey('classId')">
a.classId a.classId
<if test='orderCol.classId != null and "DESC".equalsIgnoreCase(orderCol.classId)'>DESC</if> <if test='orderCol.classId != null and "DESC".equalsIgnoreCase(orderCol.classId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('className')"> <if test="orderCol.containsKey('className')">
a.className a.className
<if test='orderCol.className != null and "DESC".equalsIgnoreCase(orderCol.className)'>DESC</if> <if test='orderCol.className != null and "DESC".equalsIgnoreCase(orderCol.className)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('addWay')"> <if test="orderCol.containsKey('addWay')">
a.addWay a.addWay
<if test='orderCol.addWay != null and "DESC".equalsIgnoreCase(orderCol.addWay)'>DESC</if> <if test='orderCol.addWay != null and "DESC".equalsIgnoreCase(orderCol.addWay)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('specialTime')"> <if test="orderCol.containsKey('specialTime')">
a.specialTime a.specialTime
<if test='orderCol.specialTime != null and "DESC".equalsIgnoreCase(orderCol.specialTime)'>DESC</if> <if test='orderCol.specialTime != null and "DESC".equalsIgnoreCase(orderCol.specialTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('specialTimeStart')"> <if test="orderCol.containsKey('remark')">
a.specialTimeStart a.remark
<if test='orderCol.specialTimeStart != null and "DESC".equalsIgnoreCase(orderCol.specialTimeStart)'>DESC</if> <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('specialTimeEnd')"> <if test="orderCol.containsKey('createUserId')">
a.specialTimeEnd a.createUserId
<if test='orderCol.specialTimeEnd != null and "DESC".equalsIgnoreCase(orderCol.specialTimeEnd)'>DESC</if> <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('remark')"> <if test="orderCol.containsKey('createTime')">
a.remark a.createTime
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if> <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createUserId')"> <if test="orderCol.containsKey('updateUserId')">
a.createUserId a.updateUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if> <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createTime')"> <if test="orderCol.containsKey('updateTime')">
a.createTime a.updateTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if> <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateUserId')"> <if test="orderCol.containsKey('specialStartTime')">
a.updateUserId a.specialStartTime
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if> <if test='orderCol.specialStartTime != null and "DESC".equalsIgnoreCase(orderCol.specialStartTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateTime')"> <if test="orderCol.containsKey('specialEndTime')">
a.updateTime a.specialEndTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if> <if test='orderCol.specialEndTime != null and "DESC".equalsIgnoreCase(orderCol.specialEndTime)'>DESC</if>
, ,
</if> </if>
</trim> </trim>
</if> </if>
</sql> </sql>
......
attendance-performance-manager/src/main/resources/sqlmap/module/attendance/AttendanceGroupFreeworkMapper.xml
View file @ 9173472b
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd"> "mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.attendance.dao.ibatis.AttendanceGroupFreeworkDaoImpl"> <mapper namespace="com.mortals.xhx.module.attendance.dao.ibatis.AttendanceGroupFreeworkDaoImpl">
<!-- 字段和属性映射 --> <!-- 字段和属性映射 -->
<resultMap type="AttendanceGroupFreeworkEntity" id="AttendanceGroupFreeworkEntity-Map"> <resultMap type="AttendanceGroupFreeworkEntity" id="AttendanceGroupFreeworkEntity-Map">
<id property="id" column="id" /> <id property="id" column="id" />
<result property="groupId" column="groupId" /> <result property="groupId" column="groupId" />
<result property="groupName" column="groupName" /> <result property="groupName" column="groupName" />
<result property="monday" column="monday" /> <result property="monday" column="monday" />
<result property="tuesday" column="tuesday" /> <result property="tuesday" column="tuesday" />
<result property="wednesday" column="wednesday" /> <result property="wednesday" column="wednesday" />
<result property="thursday" column="thursday" /> <result property="thursday" column="thursday" />
<result property="friday" column="friday" /> <result property="friday" column="friday" />
<result property="saturday" column="saturday" /> <result property="saturday" column="saturday" />
<result property="sunday" column="sunday" /> <result property="sunday" column="sunday" />
<result property="holidays" column="holidays" /> <result property="holidays" column="holidays" />
<result property="workTime" column="workTime" /> <result property="workTime" column="workTime" />
<result property="remark" column="remark" /> <result property="remark" column="remark" />
<result property="createUserId" column="createUserId" /> <result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" /> <result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" /> <result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" /> <result property="updateTime" column="updateTime" />
<collection property="attendanceGroupFreeworkSpecialList" column="id" ofType="AttendanceGroupFreeworkSpecialEntity" javaType="ArrayList" select="getAttendanceGroupFreeworkSpecialByFreeWorkId"></collection> <collection property="attendanceGroupFreeworkSpecialList" column="id" ofType="AttendanceGroupFreeworkSpecialEntity" javaType="ArrayList" select="getAttendanceGroupFreeworkSpecialByFreeWorkId"></collection>
</resultMap> </resultMap>
<resultMap type="AttendanceGroupFreeworkSpecialEntity" id="AttendanceGroupFreeworkSpecialEntity-Map"> <resultMap type="AttendanceGroupFreeworkSpecialEntity" id="AttendanceGroupFreeworkSpecialEntity-Map">
<result property="id" column="id" /> <result property="id" column="id" />
<result property="freeWorkId" column="freeWorkId" /> <result property="freeWorkId" column="freeWorkId" />
<result property="must" column="must" /> <result property="must" column="must" />
<result property="classId" column="classId" /> <result property="classId" column="classId" />
<result property="className" column="className" /> <result property="className" column="className" />
<result property="addWay" column="addWay" /> <result property="addWay" column="addWay" />
<result property="specialTime" column="specialTime" /> <result property="specialTime" column="specialTime" />
<result property="specialTimeStart" column="specialTimeStart" /> <result property="specialTimeStart" column="specialTimeStart" />
<result property="specialTimeEnd" column="specialTimeEnd" /> <result property="specialTimeEnd" column="specialTimeEnd" />
<result property="remark" column="remark" /> <result property="remark" column="remark" />
<result property="createUserId" column="createUserId" /> <result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" /> <result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" /> <result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" /> <result property="updateTime" column="updateTime" />
</resultMap> </resultMap>
<!-- 表所有列 --> <!-- 表所有列 -->
<sql id="_columns"> <sql id="_columns">
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id, a.id,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))">
a.groupId, a.groupId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
a.groupName, a.groupName,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('monday') or colPickMode == 1 and data.containsKey('monday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('monday') or colPickMode == 1 and data.containsKey('monday')))">
a.monday, a.monday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('tuesday') or colPickMode == 1 and data.containsKey('tuesday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('tuesday') or colPickMode == 1 and data.containsKey('tuesday')))">
a.tuesday, a.tuesday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('wednesday') or colPickMode == 1 and data.containsKey('wednesday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('wednesday') or colPickMode == 1 and data.containsKey('wednesday')))">
a.wednesday, a.wednesday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('thursday') or colPickMode == 1 and data.containsKey('thursday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('thursday') or colPickMode == 1 and data.containsKey('thursday')))">
a.thursday, a.thursday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('friday') or colPickMode == 1 and data.containsKey('friday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('friday') or colPickMode == 1 and data.containsKey('friday')))">
a.friday, a.friday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('saturday') or colPickMode == 1 and data.containsKey('saturday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('saturday') or colPickMode == 1 and data.containsKey('saturday')))">
a.saturday, a.saturday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sunday') or colPickMode == 1 and data.containsKey('sunday')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sunday') or colPickMode == 1 and data.containsKey('sunday')))">
a.sunday, a.sunday,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('holidays') or colPickMode == 1 and data.containsKey('holidays')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('holidays') or colPickMode == 1 and data.containsKey('holidays')))">
a.holidays, a.holidays,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('workTime') or colPickMode == 1 and data.containsKey('workTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('workTime') or colPickMode == 1 and data.containsKey('workTime')))">
a.workTime, a.workTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark, a.remark,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId, a.createUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime, a.createTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId, a.updateUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime, a.updateTime,
</if> </if>
</trim> </trim>
</sql> </sql>
<!-- 子表所有列 --> <!-- 子表所有列 -->
...@@ -224,178 +224,178 @@ ...@@ -224,178 +224,178 @@
<update id="updateBatch" parameterType="paramDto"> <update id="updateBatch" parameterType="paramDto">
update mortals_xhx_attendance_group_freework as a update mortals_xhx_attendance_group_freework as a
<trim prefix="set" suffixOverrides=","> <trim prefix="set" suffixOverrides=",">
<trim prefix="groupId=(case" suffix="ELSE groupId end),"> <trim prefix="groupId=(case" suffix="ELSE groupId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('groupId')) or (colPickMode==1 and !item.containsKey('groupId'))"> <when test="(colPickMode==0 and item.containsKey('groupId')) or (colPickMode==1 and !item.containsKey('groupId'))">
when a.id=#{item.id} then #{item.groupId} when a.id=#{item.id} then #{item.groupId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('groupIdIncrement')) or (colPickMode==1 and !item.containsKey('groupIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('groupIdIncrement')) or (colPickMode==1 and !item.containsKey('groupIdIncrement'))">
when a.id=#{item.id} then ifnull(a.groupId,0) + #{item.groupIdIncrement} when a.id=#{item.id} then ifnull(a.groupId,0) + #{item.groupIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="groupName=(case" suffix="ELSE groupName end),"> <trim prefix="groupName=(case" suffix="ELSE groupName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))"> <if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))">
when a.id=#{item.id} then #{item.groupName} when a.id=#{item.id} then #{item.groupName}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="monday=(case" suffix="ELSE monday end),"> <trim prefix="monday=(case" suffix="ELSE monday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('monday')) or (colPickMode==1 and !item.containsKey('monday'))"> <when test="(colPickMode==0 and item.containsKey('monday')) or (colPickMode==1 and !item.containsKey('monday'))">
when a.id=#{item.id} then #{item.monday} when a.id=#{item.id} then #{item.monday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('mondayIncrement')) or (colPickMode==1 and !item.containsKey('mondayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('mondayIncrement')) or (colPickMode==1 and !item.containsKey('mondayIncrement'))">
when a.id=#{item.id} then ifnull(a.monday,0) + #{item.mondayIncrement} when a.id=#{item.id} then ifnull(a.monday,0) + #{item.mondayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="tuesday=(case" suffix="ELSE tuesday end),"> <trim prefix="tuesday=(case" suffix="ELSE tuesday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('tuesday')) or (colPickMode==1 and !item.containsKey('tuesday'))"> <when test="(colPickMode==0 and item.containsKey('tuesday')) or (colPickMode==1 and !item.containsKey('tuesday'))">
when a.id=#{item.id} then #{item.tuesday} when a.id=#{item.id} then #{item.tuesday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('tuesdayIncrement')) or (colPickMode==1 and !item.containsKey('tuesdayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('tuesdayIncrement')) or (colPickMode==1 and !item.containsKey('tuesdayIncrement'))">
when a.id=#{item.id} then ifnull(a.tuesday,0) + #{item.tuesdayIncrement} when a.id=#{item.id} then ifnull(a.tuesday,0) + #{item.tuesdayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="wednesday=(case" suffix="ELSE wednesday end),"> <trim prefix="wednesday=(case" suffix="ELSE wednesday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('wednesday')) or (colPickMode==1 and !item.containsKey('wednesday'))"> <when test="(colPickMode==0 and item.containsKey('wednesday')) or (colPickMode==1 and !item.containsKey('wednesday'))">
when a.id=#{item.id} then #{item.wednesday} when a.id=#{item.id} then #{item.wednesday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('wednesdayIncrement')) or (colPickMode==1 and !item.containsKey('wednesdayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('wednesdayIncrement')) or (colPickMode==1 and !item.containsKey('wednesdayIncrement'))">
when a.id=#{item.id} then ifnull(a.wednesday,0) + #{item.wednesdayIncrement} when a.id=#{item.id} then ifnull(a.wednesday,0) + #{item.wednesdayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="thursday=(case" suffix="ELSE thursday end),"> <trim prefix="thursday=(case" suffix="ELSE thursday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('thursday')) or (colPickMode==1 and !item.containsKey('thursday'))"> <when test="(colPickMode==0 and item.containsKey('thursday')) or (colPickMode==1 and !item.containsKey('thursday'))">
when a.id=#{item.id} then #{item.thursday} when a.id=#{item.id} then #{item.thursday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('thursdayIncrement')) or (colPickMode==1 and !item.containsKey('thursdayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('thursdayIncrement')) or (colPickMode==1 and !item.containsKey('thursdayIncrement'))">
when a.id=#{item.id} then ifnull(a.thursday,0) + #{item.thursdayIncrement} when a.id=#{item.id} then ifnull(a.thursday,0) + #{item.thursdayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="friday=(case" suffix="ELSE friday end),"> <trim prefix="friday=(case" suffix="ELSE friday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('friday')) or (colPickMode==1 and !item.containsKey('friday'))"> <when test="(colPickMode==0 and item.containsKey('friday')) or (colPickMode==1 and !item.containsKey('friday'))">
when a.id=#{item.id} then #{item.friday} when a.id=#{item.id} then #{item.friday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('fridayIncrement')) or (colPickMode==1 and !item.containsKey('fridayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('fridayIncrement')) or (colPickMode==1 and !item.containsKey('fridayIncrement'))">
when a.id=#{item.id} then ifnull(a.friday,0) + #{item.fridayIncrement} when a.id=#{item.id} then ifnull(a.friday,0) + #{item.fridayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="saturday=(case" suffix="ELSE saturday end),"> <trim prefix="saturday=(case" suffix="ELSE saturday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('saturday')) or (colPickMode==1 and !item.containsKey('saturday'))"> <when test="(colPickMode==0 and item.containsKey('saturday')) or (colPickMode==1 and !item.containsKey('saturday'))">
when a.id=#{item.id} then #{item.saturday} when a.id=#{item.id} then #{item.saturday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('saturdayIncrement')) or (colPickMode==1 and !item.containsKey('saturdayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('saturdayIncrement')) or (colPickMode==1 and !item.containsKey('saturdayIncrement'))">
when a.id=#{item.id} then ifnull(a.saturday,0) + #{item.saturdayIncrement} when a.id=#{item.id} then ifnull(a.saturday,0) + #{item.saturdayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="sunday=(case" suffix="ELSE sunday end),"> <trim prefix="sunday=(case" suffix="ELSE sunday end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('sunday')) or (colPickMode==1 and !item.containsKey('sunday'))"> <when test="(colPickMode==0 and item.containsKey('sunday')) or (colPickMode==1 and !item.containsKey('sunday'))">
when a.id=#{item.id} then #{item.sunday} when a.id=#{item.id} then #{item.sunday}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('sundayIncrement')) or (colPickMode==1 and !item.containsKey('sundayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('sundayIncrement')) or (colPickMode==1 and !item.containsKey('sundayIncrement'))">
when a.id=#{item.id} then ifnull(a.sunday,0) + #{item.sundayIncrement} when a.id=#{item.id} then ifnull(a.sunday,0) + #{item.sundayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="holidays=(case" suffix="ELSE holidays end),"> <trim prefix="holidays=(case" suffix="ELSE holidays end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('holidays')) or (colPickMode==1 and !item.containsKey('holidays'))"> <when test="(colPickMode==0 and item.containsKey('holidays')) or (colPickMode==1 and !item.containsKey('holidays'))">
when a.id=#{item.id} then #{item.holidays} when a.id=#{item.id} then #{item.holidays}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('holidaysIncrement')) or (colPickMode==1 and !item.containsKey('holidaysIncrement'))"> <when test="(colPickMode==0 and item.containsKey('holidaysIncrement')) or (colPickMode==1 and !item.containsKey('holidaysIncrement'))">
when a.id=#{item.id} then ifnull(a.holidays,0) + #{item.holidaysIncrement} when a.id=#{item.id} then ifnull(a.holidays,0) + #{item.holidaysIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="workTime=(case" suffix="ELSE workTime end),"> <trim prefix="workTime=(case" suffix="ELSE workTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('workTime')) or (colPickMode==1 and !item.containsKey('workTime'))"> <when test="(colPickMode==0 and item.containsKey('workTime')) or (colPickMode==1 and !item.containsKey('workTime'))">
when a.id=#{item.id} then #{item.workTime} when a.id=#{item.id} then #{item.workTime}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('workTimeIncrement')) or (colPickMode==1 and !item.containsKey('workTimeIncrement'))"> <when test="(colPickMode==0 and item.containsKey('workTimeIncrement')) or (colPickMode==1 and !item.containsKey('workTimeIncrement'))">
when a.id=#{item.id} then ifnull(a.workTime,0) + #{item.workTimeIncrement} when a.id=#{item.id} then ifnull(a.workTime,0) + #{item.workTimeIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="remark=(case" suffix="ELSE remark end),"> <trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))"> <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark} when a.id=#{item.id} then #{item.remark}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),"> <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))"> <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId} when a.id=#{item.id} then #{item.createUserId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement} when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),"> <trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))"> <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime} when a.id=#{item.id} then #{item.createTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),"> <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))"> <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId} when a.id=#{item.id} then #{item.updateUserId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement} when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),"> <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))"> <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime} when a.id=#{item.id} then #{item.updateTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
</trim> </trim>
where id in where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")"> <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
...@@ -520,527 +520,527 @@ ...@@ -520,527 +520,527 @@
${_conditionType_} a.id=#{${_conditionParam_}.id} ${_conditionType_} a.id=#{${_conditionParam_}.id}
</if> </if>
</if> </if>
<if test="conditionParamRef.containsKey('id')"> <if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null "> <if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id} ${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if> </if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null"> <if test="conditionParamRef.id == null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd} ${_conditionType_} a.id is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('groupId')"> <if test="conditionParamRef.containsKey('groupId')">
<if test="conditionParamRef.groupId != null "> <if test="conditionParamRef.groupId != null ">
${_conditionType_} a.groupId = #{${_conditionParam_}.groupId} ${_conditionType_} a.groupId = #{${_conditionParam_}.groupId}
</if>
<if test="conditionParamRef.groupId == null">
${_conditionType_} a.groupId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('groupIdList')"> <if test="conditionParamRef.groupId == null">
${_conditionType_} a.groupId in ${_conditionType_} a.groupId is null
<foreach collection="conditionParamRef.groupIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdNotList')">
${_conditionType_} a.groupId not in
<foreach collection="conditionParamRef.groupIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdStart') and conditionParamRef.groupIdStart != null">
${_conditionType_} a.groupId <![CDATA[ >= ]]> #{${_conditionParam_}.groupIdStart}
</if>
<if test="conditionParamRef.containsKey('groupIdEnd') and conditionParamRef.groupIdEnd != null">
${_conditionType_} a.groupId <![CDATA[ <= ]]> #{${_conditionParam_}.groupIdEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('groupIdList')">
${_conditionType_} a.groupId in
<foreach collection="conditionParamRef.groupIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdNotList')">
${_conditionType_} a.groupId not in
<foreach collection="conditionParamRef.groupIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdStart') and conditionParamRef.groupIdStart != null">
${_conditionType_} a.groupId <![CDATA[ >= ]]> #{${_conditionParam_}.groupIdStart}
</if>
<if test="conditionParamRef.containsKey('groupIdEnd') and conditionParamRef.groupIdEnd != null">
${_conditionType_} a.groupId <![CDATA[ <= ]]> #{${_conditionParam_}.groupIdEnd}
</if>
<if test="conditionParamRef.containsKey('groupName')"> <if test="conditionParamRef.containsKey('groupName')">
<if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''"> <if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
${_conditionType_} a.groupName like #{${_conditionParam_}.groupName} ${_conditionType_} a.groupName like #{${_conditionParam_}.groupName}
</if>
<if test="conditionParamRef.groupName == null">
${_conditionType_} a.groupName is null
</if>
</if>
<if test="conditionParamRef.containsKey('groupNameList')">
${_conditionType_} a.groupName in
<foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupNameNotList')">
${_conditionType_} a.groupName not in
<foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('monday')"> <if test="conditionParamRef.groupName == null">
<if test="conditionParamRef.monday != null "> ${_conditionType_} a.groupName is null
${_conditionType_} a.monday = #{${_conditionParam_}.monday}
</if>
<if test="conditionParamRef.monday == null">
${_conditionType_} a.monday is null
</if>
</if>
<if test="conditionParamRef.containsKey('mondayList')">
${_conditionType_} a.monday in
<foreach collection="conditionParamRef.mondayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('mondayNotList')"> </if>
${_conditionType_} a.monday not in <if test="conditionParamRef.containsKey('groupNameList')">
<foreach collection="conditionParamRef.mondayNotList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.groupName in
#{item} <foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('mondayStart') and conditionParamRef.mondayStart != null"> </if>
${_conditionType_} a.monday <![CDATA[ >= ]]> #{${_conditionParam_}.mondayStart} <if test="conditionParamRef.containsKey('groupNameNotList')">
${_conditionType_} a.groupName not in
<foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('monday')">
<if test="conditionParamRef.monday != null ">
${_conditionType_} a.monday = #{${_conditionParam_}.monday}
</if> </if>
<if test="conditionParamRef.containsKey('mondayEnd') and conditionParamRef.mondayEnd != null"> <if test="conditionParamRef.monday == null">
${_conditionType_} a.monday <![CDATA[ <= ]]> #{${_conditionParam_}.mondayEnd} ${_conditionType_} a.monday is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('mondayList')">
${_conditionType_} a.monday in
<foreach collection="conditionParamRef.mondayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mondayNotList')">
${_conditionType_} a.monday not in
<foreach collection="conditionParamRef.mondayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mondayStart') and conditionParamRef.mondayStart != null">
${_conditionType_} a.monday <![CDATA[ >= ]]> #{${_conditionParam_}.mondayStart}
</if>
<if test="conditionParamRef.containsKey('mondayEnd') and conditionParamRef.mondayEnd != null">
${_conditionType_} a.monday <![CDATA[ <= ]]> #{${_conditionParam_}.mondayEnd}
</if>
<if test="conditionParamRef.containsKey('tuesday')"> <if test="conditionParamRef.containsKey('tuesday')">
<if test="conditionParamRef.tuesday != null "> <if test="conditionParamRef.tuesday != null ">
${_conditionType_} a.tuesday = #{${_conditionParam_}.tuesday} ${_conditionType_} a.tuesday = #{${_conditionParam_}.tuesday}
</if>
<if test="conditionParamRef.tuesday == null">
${_conditionType_} a.tuesday is null
</if>
</if>
<if test="conditionParamRef.containsKey('tuesdayList')">
${_conditionType_} a.tuesday in
<foreach collection="conditionParamRef.tuesdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('tuesdayNotList')">
${_conditionType_} a.tuesday not in
<foreach collection="conditionParamRef.tuesdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('tuesdayStart') and conditionParamRef.tuesdayStart != null"> <if test="conditionParamRef.tuesday == null">
${_conditionType_} a.tuesday <![CDATA[ >= ]]> #{${_conditionParam_}.tuesdayStart} ${_conditionType_} a.tuesday is null
</if>
<if test="conditionParamRef.containsKey('tuesdayEnd') and conditionParamRef.tuesdayEnd != null">
${_conditionType_} a.tuesday <![CDATA[ <= ]]> #{${_conditionParam_}.tuesdayEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('tuesdayList')">
${_conditionType_} a.tuesday in
<foreach collection="conditionParamRef.tuesdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('tuesdayNotList')">
${_conditionType_} a.tuesday not in
<foreach collection="conditionParamRef.tuesdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('tuesdayStart') and conditionParamRef.tuesdayStart != null">
${_conditionType_} a.tuesday <![CDATA[ >= ]]> #{${_conditionParam_}.tuesdayStart}
</if>
<if test="conditionParamRef.containsKey('tuesdayEnd') and conditionParamRef.tuesdayEnd != null">
${_conditionType_} a.tuesday <![CDATA[ <= ]]> #{${_conditionParam_}.tuesdayEnd}
</if>
<if test="conditionParamRef.containsKey('wednesday')"> <if test="conditionParamRef.containsKey('wednesday')">
<if test="conditionParamRef.wednesday != null "> <if test="conditionParamRef.wednesday != null ">
${_conditionType_} a.wednesday = #{${_conditionParam_}.wednesday} ${_conditionType_} a.wednesday = #{${_conditionParam_}.wednesday}
</if>
<if test="conditionParamRef.wednesday == null">
${_conditionType_} a.wednesday is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('wednesdayList')"> <if test="conditionParamRef.wednesday == null">
${_conditionType_} a.wednesday in ${_conditionType_} a.wednesday is null
<foreach collection="conditionParamRef.wednesdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('wednesdayNotList')">
${_conditionType_} a.wednesday not in
<foreach collection="conditionParamRef.wednesdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('wednesdayStart') and conditionParamRef.wednesdayStart != null">
${_conditionType_} a.wednesday <![CDATA[ >= ]]> #{${_conditionParam_}.wednesdayStart}
</if>
<if test="conditionParamRef.containsKey('wednesdayEnd') and conditionParamRef.wednesdayEnd != null">
${_conditionType_} a.wednesday <![CDATA[ <= ]]> #{${_conditionParam_}.wednesdayEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('wednesdayList')">
${_conditionType_} a.wednesday in
<foreach collection="conditionParamRef.wednesdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('wednesdayNotList')">
${_conditionType_} a.wednesday not in
<foreach collection="conditionParamRef.wednesdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('wednesdayStart') and conditionParamRef.wednesdayStart != null">
${_conditionType_} a.wednesday <![CDATA[ >= ]]> #{${_conditionParam_}.wednesdayStart}
</if>
<if test="conditionParamRef.containsKey('wednesdayEnd') and conditionParamRef.wednesdayEnd != null">
${_conditionType_} a.wednesday <![CDATA[ <= ]]> #{${_conditionParam_}.wednesdayEnd}
</if>
<if test="conditionParamRef.containsKey('thursday')"> <if test="conditionParamRef.containsKey('thursday')">
<if test="conditionParamRef.thursday != null "> <if test="conditionParamRef.thursday != null ">
${_conditionType_} a.thursday = #{${_conditionParam_}.thursday} ${_conditionType_} a.thursday = #{${_conditionParam_}.thursday}
</if>
<if test="conditionParamRef.thursday == null">
${_conditionType_} a.thursday is null
</if>
</if>
<if test="conditionParamRef.containsKey('thursdayList')">
${_conditionType_} a.thursday in
<foreach collection="conditionParamRef.thursdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('thursdayNotList')">
${_conditionType_} a.thursday not in
<foreach collection="conditionParamRef.thursdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('thursdayStart') and conditionParamRef.thursdayStart != null"> <if test="conditionParamRef.thursday == null">
${_conditionType_} a.thursday <![CDATA[ >= ]]> #{${_conditionParam_}.thursdayStart} ${_conditionType_} a.thursday is null
</if>
<if test="conditionParamRef.containsKey('thursdayEnd') and conditionParamRef.thursdayEnd != null">
${_conditionType_} a.thursday <![CDATA[ <= ]]> #{${_conditionParam_}.thursdayEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('thursdayList')">
${_conditionType_} a.thursday in
<foreach collection="conditionParamRef.thursdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('thursdayNotList')">
${_conditionType_} a.thursday not in
<foreach collection="conditionParamRef.thursdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('thursdayStart') and conditionParamRef.thursdayStart != null">
${_conditionType_} a.thursday <![CDATA[ >= ]]> #{${_conditionParam_}.thursdayStart}
</if>
<if test="conditionParamRef.containsKey('thursdayEnd') and conditionParamRef.thursdayEnd != null">
${_conditionType_} a.thursday <![CDATA[ <= ]]> #{${_conditionParam_}.thursdayEnd}
</if>
<if test="conditionParamRef.containsKey('friday')"> <if test="conditionParamRef.containsKey('friday')">
<if test="conditionParamRef.friday != null "> <if test="conditionParamRef.friday != null ">
${_conditionType_} a.friday = #{${_conditionParam_}.friday} ${_conditionType_} a.friday = #{${_conditionParam_}.friday}
</if>
<if test="conditionParamRef.friday == null">
${_conditionType_} a.friday is null
</if>
</if>
<if test="conditionParamRef.containsKey('fridayList')">
${_conditionType_} a.friday in
<foreach collection="conditionParamRef.fridayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fridayNotList')">
${_conditionType_} a.friday not in
<foreach collection="conditionParamRef.fridayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('fridayStart') and conditionParamRef.fridayStart != null"> <if test="conditionParamRef.friday == null">
${_conditionType_} a.friday <![CDATA[ >= ]]> #{${_conditionParam_}.fridayStart} ${_conditionType_} a.friday is null
</if>
<if test="conditionParamRef.containsKey('fridayEnd') and conditionParamRef.fridayEnd != null">
${_conditionType_} a.friday <![CDATA[ <= ]]> #{${_conditionParam_}.fridayEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('fridayList')">
${_conditionType_} a.friday in
<foreach collection="conditionParamRef.fridayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fridayNotList')">
${_conditionType_} a.friday not in
<foreach collection="conditionParamRef.fridayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fridayStart') and conditionParamRef.fridayStart != null">
${_conditionType_} a.friday <![CDATA[ >= ]]> #{${_conditionParam_}.fridayStart}
</if>
<if test="conditionParamRef.containsKey('fridayEnd') and conditionParamRef.fridayEnd != null">
${_conditionType_} a.friday <![CDATA[ <= ]]> #{${_conditionParam_}.fridayEnd}
</if>
<if test="conditionParamRef.containsKey('saturday')"> <if test="conditionParamRef.containsKey('saturday')">
<if test="conditionParamRef.saturday != null "> <if test="conditionParamRef.saturday != null ">
${_conditionType_} a.saturday = #{${_conditionParam_}.saturday} ${_conditionType_} a.saturday = #{${_conditionParam_}.saturday}
</if>
<if test="conditionParamRef.saturday == null">
${_conditionType_} a.saturday is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('saturdayList')"> <if test="conditionParamRef.saturday == null">
${_conditionType_} a.saturday in ${_conditionType_} a.saturday is null
<foreach collection="conditionParamRef.saturdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('saturdayNotList')">
${_conditionType_} a.saturday not in
<foreach collection="conditionParamRef.saturdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('saturdayStart') and conditionParamRef.saturdayStart != null">
${_conditionType_} a.saturday <![CDATA[ >= ]]> #{${_conditionParam_}.saturdayStart}
</if>
<if test="conditionParamRef.containsKey('saturdayEnd') and conditionParamRef.saturdayEnd != null">
${_conditionType_} a.saturday <![CDATA[ <= ]]> #{${_conditionParam_}.saturdayEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('saturdayList')">
${_conditionType_} a.saturday in
<foreach collection="conditionParamRef.saturdayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('saturdayNotList')">
${_conditionType_} a.saturday not in
<foreach collection="conditionParamRef.saturdayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('saturdayStart') and conditionParamRef.saturdayStart != null">
${_conditionType_} a.saturday <![CDATA[ >= ]]> #{${_conditionParam_}.saturdayStart}
</if>
<if test="conditionParamRef.containsKey('saturdayEnd') and conditionParamRef.saturdayEnd != null">
${_conditionType_} a.saturday <![CDATA[ <= ]]> #{${_conditionParam_}.saturdayEnd}
</if>
<if test="conditionParamRef.containsKey('sunday')"> <if test="conditionParamRef.containsKey('sunday')">
<if test="conditionParamRef.sunday != null "> <if test="conditionParamRef.sunday != null ">
${_conditionType_} a.sunday = #{${_conditionParam_}.sunday} ${_conditionType_} a.sunday = #{${_conditionParam_}.sunday}
</if>
<if test="conditionParamRef.sunday == null">
${_conditionType_} a.sunday is null
</if>
</if>
<if test="conditionParamRef.containsKey('sundayList')">
${_conditionType_} a.sunday in
<foreach collection="conditionParamRef.sundayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sundayNotList')">
${_conditionType_} a.sunday not in
<foreach collection="conditionParamRef.sundayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('sundayStart') and conditionParamRef.sundayStart != null"> <if test="conditionParamRef.sunday == null">
${_conditionType_} a.sunday <![CDATA[ >= ]]> #{${_conditionParam_}.sundayStart} ${_conditionType_} a.sunday is null
</if>
<if test="conditionParamRef.containsKey('sundayEnd') and conditionParamRef.sundayEnd != null">
${_conditionType_} a.sunday <![CDATA[ <= ]]> #{${_conditionParam_}.sundayEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('sundayList')">
${_conditionType_} a.sunday in
<foreach collection="conditionParamRef.sundayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sundayNotList')">
${_conditionType_} a.sunday not in
<foreach collection="conditionParamRef.sundayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sundayStart') and conditionParamRef.sundayStart != null">
${_conditionType_} a.sunday <![CDATA[ >= ]]> #{${_conditionParam_}.sundayStart}
</if>
<if test="conditionParamRef.containsKey('sundayEnd') and conditionParamRef.sundayEnd != null">
${_conditionType_} a.sunday <![CDATA[ <= ]]> #{${_conditionParam_}.sundayEnd}
</if>
<if test="conditionParamRef.containsKey('holidays')"> <if test="conditionParamRef.containsKey('holidays')">
<if test="conditionParamRef.holidays != null "> <if test="conditionParamRef.holidays != null ">
${_conditionType_} a.holidays = #{${_conditionParam_}.holidays} ${_conditionType_} a.holidays = #{${_conditionParam_}.holidays}
</if>
<if test="conditionParamRef.holidays == null">
${_conditionType_} a.holidays is null
</if>
</if>
<if test="conditionParamRef.containsKey('holidaysList')">
${_conditionType_} a.holidays in
<foreach collection="conditionParamRef.holidaysList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('holidaysNotList')">
${_conditionType_} a.holidays not in
<foreach collection="conditionParamRef.holidaysNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('holidaysStart') and conditionParamRef.holidaysStart != null"> <if test="conditionParamRef.holidays == null">
${_conditionType_} a.holidays <![CDATA[ >= ]]> #{${_conditionParam_}.holidaysStart} ${_conditionType_} a.holidays is null
</if>
<if test="conditionParamRef.containsKey('holidaysEnd') and conditionParamRef.holidaysEnd != null">
${_conditionType_} a.holidays <![CDATA[ <= ]]> #{${_conditionParam_}.holidaysEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('holidaysList')">
${_conditionType_} a.holidays in
<foreach collection="conditionParamRef.holidaysList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('holidaysNotList')">
${_conditionType_} a.holidays not in
<foreach collection="conditionParamRef.holidaysNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('holidaysStart') and conditionParamRef.holidaysStart != null">
${_conditionType_} a.holidays <![CDATA[ >= ]]> #{${_conditionParam_}.holidaysStart}
</if>
<if test="conditionParamRef.containsKey('holidaysEnd') and conditionParamRef.holidaysEnd != null">
${_conditionType_} a.holidays <![CDATA[ <= ]]> #{${_conditionParam_}.holidaysEnd}
</if>
<if test="conditionParamRef.containsKey('workTime')"> <if test="conditionParamRef.containsKey('workTime')">
<if test="conditionParamRef.workTime != null "> <if test="conditionParamRef.workTime != null ">
${_conditionType_} a.workTime = #{${_conditionParam_}.workTime} ${_conditionType_} a.workTime = #{${_conditionParam_}.workTime}
</if>
<if test="conditionParamRef.workTime == null">
${_conditionType_} a.workTime is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('workTimeList')"> <if test="conditionParamRef.workTime == null">
${_conditionType_} a.workTime in ${_conditionType_} a.workTime is null
<foreach collection="conditionParamRef.workTimeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('workTimeNotList')">
${_conditionType_} a.workTime not in
<foreach collection="conditionParamRef.workTimeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('workTimeStart') and conditionParamRef.workTimeStart != null">
${_conditionType_} a.workTime <![CDATA[ >= ]]> #{${_conditionParam_}.workTimeStart}
</if>
<if test="conditionParamRef.containsKey('workTimeEnd') and conditionParamRef.workTimeEnd != null">
${_conditionType_} a.workTime <![CDATA[ <= ]]> #{${_conditionParam_}.workTimeEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('workTimeList')">
${_conditionType_} a.workTime in
<foreach collection="conditionParamRef.workTimeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('workTimeNotList')">
${_conditionType_} a.workTime not in
<foreach collection="conditionParamRef.workTimeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('workTimeStart') and conditionParamRef.workTimeStart != null">
${_conditionType_} a.workTime <![CDATA[ >= ]]> #{${_conditionParam_}.workTimeStart}
</if>
<if test="conditionParamRef.containsKey('workTimeEnd') and conditionParamRef.workTimeEnd != null">
${_conditionType_} a.workTime <![CDATA[ <= ]]> #{${_conditionParam_}.workTimeEnd}
</if>
<if test="conditionParamRef.containsKey('remark')"> <if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''"> <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark} ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList')">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('createUserId')"> <if test="conditionParamRef.remark == null">
<if test="conditionParamRef.createUserId != null "> ${_conditionType_} a.remark is null
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdList')"> </if>
${_conditionType_} a.createUserId in <if test="conditionParamRef.containsKey('remarkList')">
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.remark in
#{item} <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('createUserIdNotList')"> </if>
${_conditionType_} a.createUserId not in <if test="conditionParamRef.containsKey('remarkNotList')">
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.remark not in
#{item} <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null"> </if>
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart} <if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null"> <if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd} ${_conditionType_} a.createUserId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')"> <if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null "> <if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime} ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if 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>
<if test="conditionParamRef.containsKey('updateUserId')"> <if test="conditionParamRef.createTime == null">
<if test="conditionParamRef.updateUserId != null "> ${_conditionType_} a.createTime is null
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('updateUserIdList')"> </if>
${_conditionType_} a.updateUserId in <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
#{item} </if>
</foreach> <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
</if> ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.containsKey('updateUserIdNotList')"> </if>
${_conditionType_} a.updateUserId not in <if test="conditionParamRef.containsKey('updateUserId')">
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=","> <if test="conditionParamRef.updateUserId != null ">
#{item} ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if> </if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null"> <if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd} ${_conditionType_} a.updateUserId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList')">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')"> <if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null "> <if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime} ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''"> <if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.updateTime is null
</if>
<if 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>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql> </sql>
<sql id="_orderCols_"> <sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()"> <if test="orderColList != null and !orderColList.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=","> <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind} ${item.colName} ${item.sortKind}
</foreach> </foreach>
</trim> </trim>
</if> </if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()"> <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')"> <if test="orderCol.containsKey('id')">
a.id a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if> <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('groupId')"> <if test="orderCol.containsKey('groupId')">
a.groupId a.groupId
<if test='orderCol.groupId != null and "DESC".equalsIgnoreCase(orderCol.groupId)'>DESC</if> <if test='orderCol.groupId != null and "DESC".equalsIgnoreCase(orderCol.groupId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('groupName')"> <if test="orderCol.containsKey('groupName')">
a.groupName a.groupName
<if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if> <if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('monday')"> <if test="orderCol.containsKey('monday')">
a.monday a.monday
<if test='orderCol.monday != null and "DESC".equalsIgnoreCase(orderCol.monday)'>DESC</if> <if test='orderCol.monday != null and "DESC".equalsIgnoreCase(orderCol.monday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('tuesday')"> <if test="orderCol.containsKey('tuesday')">
a.tuesday a.tuesday
<if test='orderCol.tuesday != null and "DESC".equalsIgnoreCase(orderCol.tuesday)'>DESC</if> <if test='orderCol.tuesday != null and "DESC".equalsIgnoreCase(orderCol.tuesday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('wednesday')"> <if test="orderCol.containsKey('wednesday')">
a.wednesday a.wednesday
<if test='orderCol.wednesday != null and "DESC".equalsIgnoreCase(orderCol.wednesday)'>DESC</if> <if test='orderCol.wednesday != null and "DESC".equalsIgnoreCase(orderCol.wednesday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('thursday')"> <if test="orderCol.containsKey('thursday')">
a.thursday a.thursday
<if test='orderCol.thursday != null and "DESC".equalsIgnoreCase(orderCol.thursday)'>DESC</if> <if test='orderCol.thursday != null and "DESC".equalsIgnoreCase(orderCol.thursday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('friday')"> <if test="orderCol.containsKey('friday')">
a.friday a.friday
<if test='orderCol.friday != null and "DESC".equalsIgnoreCase(orderCol.friday)'>DESC</if> <if test='orderCol.friday != null and "DESC".equalsIgnoreCase(orderCol.friday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('saturday')"> <if test="orderCol.containsKey('saturday')">
a.saturday a.saturday
<if test='orderCol.saturday != null and "DESC".equalsIgnoreCase(orderCol.saturday)'>DESC</if> <if test='orderCol.saturday != null and "DESC".equalsIgnoreCase(orderCol.saturday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('sunday')"> <if test="orderCol.containsKey('sunday')">
a.sunday a.sunday
<if test='orderCol.sunday != null and "DESC".equalsIgnoreCase(orderCol.sunday)'>DESC</if> <if test='orderCol.sunday != null and "DESC".equalsIgnoreCase(orderCol.sunday)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('holidays')"> <if test="orderCol.containsKey('holidays')">
a.holidays a.holidays
<if test='orderCol.holidays != null and "DESC".equalsIgnoreCase(orderCol.holidays)'>DESC</if> <if test='orderCol.holidays != null and "DESC".equalsIgnoreCase(orderCol.holidays)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('workTime')"> <if test="orderCol.containsKey('workTime')">
a.workTime a.workTime
<if test='orderCol.workTime != null and "DESC".equalsIgnoreCase(orderCol.workTime)'>DESC</if> <if test='orderCol.workTime != null and "DESC".equalsIgnoreCase(orderCol.workTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('remark')"> <if test="orderCol.containsKey('remark')">
a.remark a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if> <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createUserId')"> <if test="orderCol.containsKey('createUserId')">
a.createUserId a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if> <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createTime')"> <if test="orderCol.containsKey('createTime')">
a.createTime a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if> <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateUserId')"> <if test="orderCol.containsKey('updateUserId')">
a.updateUserId a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if> <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateTime')"> <if test="orderCol.containsKey('updateTime')">
a.updateTime a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if> <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
, ,
</if> </if>
</trim> </trim>
</if> </if>
</sql> </sql>
......
attendance-performance-manager/src/main/resources/sqlmap/module/attendance/AttendanceGroupFreeworkSpecialMapper.xml
View file @ 9173472b
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd"> "mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.attendance.dao.ibatis.AttendanceGroupFreeworkSpecialDaoImpl"> <mapper namespace="com.mortals.xhx.module.attendance.dao.ibatis.AttendanceGroupFreeworkSpecialDaoImpl">
<!-- 字段和属性映射 --> <!-- 字段和属性映射 -->
<resultMap type="AttendanceGroupFreeworkSpecialEntity" id="AttendanceGroupFreeworkSpecialEntity-Map"> <resultMap type="AttendanceGroupFreeworkSpecialEntity" id="AttendanceGroupFreeworkSpecialEntity-Map">
<id property="id" column="id" /> <id property="id" column="id" />
<result property="freeWorkId" column="freeWorkId" /> <result property="freeWorkId" column="freeWorkId" />
<result property="must" column="must" /> <result property="must" column="must" />
<result property="classId" column="classId" /> <result property="classId" column="classId" />
<result property="className" column="className" /> <result property="className" column="className" />
<result property="addWay" column="addWay" /> <result property="addWay" column="addWay" />
<result property="specialTime" column="specialTime" /> <result property="specialTime" column="specialTime" />
<result property="specialTimeStart" column="specialTimeStart" /> <result property="remark" column="remark" />
<result property="specialTimeEnd" column="specialTimeEnd" /> <result property="createUserId" column="createUserId" />
<result property="remark" column="remark" /> <result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" /> <result property="updateUserId" column="updateUserId" />
<result property="createTime" column="createTime" /> <result property="updateTime" column="updateTime" />
<result property="updateUserId" column="updateUserId" /> <result property="specialStartTime" column="specialStartTime" />
<result property="updateTime" column="updateTime" /> <result property="specialEndTime" column="specialEndTime" />
</resultMap> </resultMap>
<!-- 表所有列 --> <!-- 表所有列 -->
<sql id="_columns"> <sql id="_columns">
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id, a.id,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('freeWorkId') or colPickMode == 1 and data.containsKey('freeWorkId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('freeWorkId') or colPickMode == 1 and data.containsKey('freeWorkId')))">
a.freeWorkId, a.freeWorkId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('must') or colPickMode == 1 and data.containsKey('must')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('must') or colPickMode == 1 and data.containsKey('must')))">
a.must, a.must,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('classId') or colPickMode == 1 and data.containsKey('classId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('classId') or colPickMode == 1 and data.containsKey('classId')))">
a.classId, a.classId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('className') or colPickMode == 1 and data.containsKey('className')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('className') or colPickMode == 1 and data.containsKey('className')))">
a.className, a.className,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('addWay') or colPickMode == 1 and data.containsKey('addWay')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('addWay') or colPickMode == 1 and data.containsKey('addWay')))">
a.addWay, a.addWay,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTime') or colPickMode == 1 and data.containsKey('specialTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTime') or colPickMode == 1 and data.containsKey('specialTime')))">
a.specialTime, a.specialTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTimeStart') or colPickMode == 1 and data.containsKey('specialTimeStart')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.specialTimeStart, a.remark,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialTimeEnd') or colPickMode == 1 and data.containsKey('specialTimeEnd')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.specialTimeEnd, a.createUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.remark, a.createTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.createUserId, a.updateUserId,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.createTime, a.updateTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialStartTime') or colPickMode == 1 and data.containsKey('specialStartTime')))">
a.updateUserId, a.specialStartTime,
</if> </if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))"> <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('specialEndTime') or colPickMode == 1 and data.containsKey('specialEndTime')))">
a.updateTime, a.specialEndTime,
</if> </if>
</trim> </trim>
</sql> </sql>
<!-- 新增 区分主键自增加还是业务插入 --> <!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="AttendanceGroupFreeworkSpecialEntity" useGeneratedKeys="true" keyProperty="id"> <insert id="insert" parameterType="AttendanceGroupFreeworkSpecialEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_attendance_group_freework_special insert into mortals_xhx_attendance_group_freework_special
(freeWorkId,must,classId,className,addWay,specialTime,specialTimeStart,specialTimeEnd,remark,createUserId,createTime,updateUserId,updateTime) (freeWorkId,must,classId,className,addWay,specialTime,remark,createUserId,createTime,updateUserId,updateTime,specialStartTime,specialEndTime)
VALUES VALUES
(#{freeWorkId},#{must},#{classId},#{className},#{addWay},#{specialTime},#{specialTimeStart},#{specialTimeEnd},#{remark},#{createUserId},#{createTime},#{updateUserId},#{updateTime}) (#{freeWorkId},#{must},#{classId},#{className},#{addWay},#{specialTime},#{remark},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{specialStartTime},#{specialEndTime})
</insert> </insert>
<!-- 批量新增 --> <!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto"> <insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_attendance_group_freework_special insert into mortals_xhx_attendance_group_freework_special
(freeWorkId,must,classId,className,addWay,specialTime,specialTimeStart,specialTimeEnd,remark,createUserId,createTime,updateUserId,updateTime) (freeWorkId,must,classId,className,addWay,specialTime,remark,createUserId,createTime,updateUserId,updateTime,specialStartTime,specialEndTime)
VALUES VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," > <foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.freeWorkId},#{item.must},#{item.classId},#{item.className},#{item.addWay},#{item.specialTime},#{item.specialTimeStart},#{item.specialTimeEnd},#{item.remark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime}) (#{item.freeWorkId},#{item.must},#{item.classId},#{item.className},#{item.addWay},#{item.specialTime},#{item.remark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.specialStartTime},#{item.specialEndTime})
</foreach> </foreach>
</insert> </insert>
...@@ -124,12 +124,6 @@ ...@@ -124,12 +124,6 @@
<if test="(colPickMode==0 and data.containsKey('specialTime')) or (colPickMode==1 and !data.containsKey('specialTime'))"> <if test="(colPickMode==0 and data.containsKey('specialTime')) or (colPickMode==1 and !data.containsKey('specialTime'))">
a.specialTime=#{data.specialTime}, a.specialTime=#{data.specialTime},
</if> </if>
<if test="(colPickMode==0 and data.containsKey('specialTimeStart')) or (colPickMode==1 and !data.containsKey('specialTimeStart'))">
a.specialTimeStart=#{data.specialTimeStart},
</if>
<if test="(colPickMode==0 and data.containsKey('specialTimeEnd')) or (colPickMode==1 and !data.containsKey('specialTimeEnd'))">
a.specialTimeEnd=#{data.specialTimeEnd},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))"> <if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark}, a.remark=#{data.remark},
</if> </if>
...@@ -151,6 +145,12 @@ ...@@ -151,6 +145,12 @@
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))"> <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime}, a.updateTime=#{data.updateTime},
</if> </if>
<if test="(colPickMode==0 and data.containsKey('specialStartTime')) or (colPickMode==1 and !data.containsKey('specialStartTime'))">
a.specialStartTime=#{data.specialStartTime},
</if>
<if test="(colPickMode==0 and data.containsKey('specialEndTime')) or (colPickMode==1 and !data.containsKey('specialEndTime'))">
a.specialEndTime=#{data.specialEndTime},
</if>
</trim> </trim>
<trim suffixOverrides="where" suffix=""> <trim suffixOverrides="where" suffix="">
where where
...@@ -163,127 +163,127 @@ ...@@ -163,127 +163,127 @@
<update id="updateBatch" parameterType="paramDto"> <update id="updateBatch" parameterType="paramDto">
update mortals_xhx_attendance_group_freework_special as a update mortals_xhx_attendance_group_freework_special as a
<trim prefix="set" suffixOverrides=","> <trim prefix="set" suffixOverrides=",">
<trim prefix="freeWorkId=(case" suffix="ELSE freeWorkId end),"> <trim prefix="freeWorkId=(case" suffix="ELSE freeWorkId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('freeWorkId')) or (colPickMode==1 and !item.containsKey('freeWorkId'))"> <when test="(colPickMode==0 and item.containsKey('freeWorkId')) or (colPickMode==1 and !item.containsKey('freeWorkId'))">
when a.id=#{item.id} then #{item.freeWorkId} when a.id=#{item.id} then #{item.freeWorkId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('freeWorkIdIncrement')) or (colPickMode==1 and !item.containsKey('freeWorkIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('freeWorkIdIncrement')) or (colPickMode==1 and !item.containsKey('freeWorkIdIncrement'))">
when a.id=#{item.id} then ifnull(a.freeWorkId,0) + #{item.freeWorkIdIncrement} when a.id=#{item.id} then ifnull(a.freeWorkId,0) + #{item.freeWorkIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="must=(case" suffix="ELSE must end),"> <trim prefix="must=(case" suffix="ELSE must end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('must')) or (colPickMode==1 and !item.containsKey('must'))"> <when test="(colPickMode==0 and item.containsKey('must')) or (colPickMode==1 and !item.containsKey('must'))">
when a.id=#{item.id} then #{item.must} when a.id=#{item.id} then #{item.must}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('mustIncrement')) or (colPickMode==1 and !item.containsKey('mustIncrement'))"> <when test="(colPickMode==0 and item.containsKey('mustIncrement')) or (colPickMode==1 and !item.containsKey('mustIncrement'))">
when a.id=#{item.id} then ifnull(a.must,0) + #{item.mustIncrement} when a.id=#{item.id} then ifnull(a.must,0) + #{item.mustIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="classId=(case" suffix="ELSE classId end),"> <trim prefix="classId=(case" suffix="ELSE classId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('classId')) or (colPickMode==1 and !item.containsKey('classId'))"> <when test="(colPickMode==0 and item.containsKey('classId')) or (colPickMode==1 and !item.containsKey('classId'))">
when a.id=#{item.id} then #{item.classId} when a.id=#{item.id} then #{item.classId}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('classIdIncrement')) or (colPickMode==1 and !item.containsKey('classIdIncrement'))"> <when test="(colPickMode==0 and item.containsKey('classIdIncrement')) or (colPickMode==1 and !item.containsKey('classIdIncrement'))">
when a.id=#{item.id} then ifnull(a.classId,0) + #{item.classIdIncrement} when a.id=#{item.id} then ifnull(a.classId,0) + #{item.classIdIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="className=(case" suffix="ELSE className end),"> <trim prefix="className=(case" suffix="ELSE className end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('className')) or (colPickMode==1 and !item.containsKey('className'))"> <if test="(colPickMode==0 and item.containsKey('className')) or (colPickMode==1 and !item.containsKey('className'))">
when a.id=#{item.id} then #{item.className} when a.id=#{item.id} then #{item.className}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="addWay=(case" suffix="ELSE addWay end),"> <trim prefix="addWay=(case" suffix="ELSE addWay end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<choose> <choose>
<when test="(colPickMode==0 and item.containsKey('addWay')) or (colPickMode==1 and !item.containsKey('addWay'))"> <when test="(colPickMode==0 and item.containsKey('addWay')) or (colPickMode==1 and !item.containsKey('addWay'))">
when a.id=#{item.id} then #{item.addWay} when a.id=#{item.id} then #{item.addWay}
</when> </when>
<when test="(colPickMode==0 and item.containsKey('addWayIncrement')) or (colPickMode==1 and !item.containsKey('addWayIncrement'))"> <when test="(colPickMode==0 and item.containsKey('addWayIncrement')) or (colPickMode==1 and !item.containsKey('addWayIncrement'))">
when a.id=#{item.id} then ifnull(a.addWay,0) + #{item.addWayIncrement} when a.id=#{item.id} then ifnull(a.addWay,0) + #{item.addWayIncrement}
</when> </when>
</choose> </choose>
</foreach> </foreach>
</trim> </trim>
<trim prefix="specialTime=(case" suffix="ELSE specialTime end),"> <trim prefix="specialTime=(case" suffix="ELSE specialTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('specialTime')) or (colPickMode==1 and !item.containsKey('specialTime'))"> <if test="(colPickMode==0 and item.containsKey('specialTime')) or (colPickMode==1 and !item.containsKey('specialTime'))">
when a.id=#{item.id} then #{item.specialTime} when a.id=#{item.id} then #{item.specialTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="specialTimeStart=(case" suffix="ELSE specialTimeStart end),"> <trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('specialTimeStart')) or (colPickMode==1 and !item.containsKey('specialTimeStart'))"> <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.specialTimeStart} when a.id=#{item.id} then #{item.remark}
</if> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="specialTimeEnd=(case" suffix="ELSE specialTimeEnd end),"> <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('specialTimeEnd')) or (colPickMode==1 and !item.containsKey('specialTimeEnd'))"> <choose>
when a.id=#{item.id} then #{item.specialTimeEnd} <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
</if> when a.id=#{item.id} then #{item.createUserId}
</foreach> </when>
</trim> <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
<trim prefix="remark=(case" suffix="ELSE remark end),"> when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
<foreach collection="data.dataList" item="item" index="index" separator="" > </when>
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))"> </choose>
when a.id=#{item.id} then #{item.remark} </foreach>
</if> </trim>
</foreach> <trim prefix="createTime=(case" suffix="ELSE createTime end),">
</trim> <foreach collection="data.dataList" item="item" index="index" separator="" >
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),"> <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
<foreach collection="data.dataList" item="item" index="index" separator="" > when a.id=#{item.id} then #{item.createTime}
<choose> </if>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))"> </foreach>
when a.id=#{item.id} then #{item.createUserId} </trim>
</when> <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))"> <foreach collection="data.dataList" item="item" index="index" separator="" >
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement} <choose>
</when> <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
</choose> when a.id=#{item.id} then #{item.updateUserId}
</foreach> </when>
</trim> <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
<trim prefix="createTime=(case" suffix="ELSE createTime end),"> when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
<foreach collection="data.dataList" item="item" index="index" separator="" > </when>
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))"> </choose>
when a.id=#{item.id} then #{item.createTime} </foreach>
</if> </trim>
</foreach> <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
</trim> <foreach collection="data.dataList" item="item" index="index" separator="" >
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),"> <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
<foreach collection="data.dataList" item="item" index="index" separator="" > when a.id=#{item.id} then #{item.updateTime}
<choose> </if>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))"> </foreach>
when a.id=#{item.id} then #{item.updateUserId} </trim>
</when> <trim prefix="specialStartTime=(case" suffix="ELSE specialStartTime end),">
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))"> <foreach collection="data.dataList" item="item" index="index" separator="" >
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement} <if test="(colPickMode==0 and item.containsKey('specialStartTime')) or (colPickMode==1 and !item.containsKey('specialStartTime'))">
</when> when a.id=#{item.id} then #{item.specialStartTime}
</choose> </if>
</foreach> </foreach>
</trim> </trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),"> <trim prefix="specialEndTime=(case" suffix="ELSE specialEndTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" > <foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))"> <if test="(colPickMode==0 and item.containsKey('specialEndTime')) or (colPickMode==1 and !item.containsKey('specialEndTime'))">
when a.id=#{item.id} then #{item.updateTime} when a.id=#{item.id} then #{item.specialEndTime}
</if> </if>
</foreach> </foreach>
</trim> </trim>
</trim> </trim>
where id in where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")"> <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
...@@ -400,395 +400,395 @@ ...@@ -400,395 +400,395 @@
${_conditionType_} a.id=#{${_conditionParam_}.id} ${_conditionType_} a.id=#{${_conditionParam_}.id}
</if> </if>
</if> </if>
<if test="conditionParamRef.containsKey('id')"> <if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null "> <if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id} ${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if> </if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null"> <if test="conditionParamRef.id == null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd} ${_conditionType_} a.id is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('freeWorkId')"> <if test="conditionParamRef.containsKey('freeWorkId')">
<if test="conditionParamRef.freeWorkId != null "> <if test="conditionParamRef.freeWorkId != null ">
${_conditionType_} a.freeWorkId = #{${_conditionParam_}.freeWorkId} ${_conditionType_} a.freeWorkId = #{${_conditionParam_}.freeWorkId}
</if>
<if test="conditionParamRef.freeWorkId == null">
${_conditionType_} a.freeWorkId is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('freeWorkIdList')"> <if test="conditionParamRef.freeWorkId == null">
${_conditionType_} a.freeWorkId in ${_conditionType_} a.freeWorkId is null
<foreach collection="conditionParamRef.freeWorkIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('freeWorkIdNotList')">
${_conditionType_} a.freeWorkId not in
<foreach collection="conditionParamRef.freeWorkIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('freeWorkIdStart') and conditionParamRef.freeWorkIdStart != null">
${_conditionType_} a.freeWorkId <![CDATA[ >= ]]> #{${_conditionParam_}.freeWorkIdStart}
</if>
<if test="conditionParamRef.containsKey('freeWorkIdEnd') and conditionParamRef.freeWorkIdEnd != null">
${_conditionType_} a.freeWorkId <![CDATA[ <= ]]> #{${_conditionParam_}.freeWorkIdEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('freeWorkIdList')">
${_conditionType_} a.freeWorkId in
<foreach collection="conditionParamRef.freeWorkIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('freeWorkIdNotList')">
${_conditionType_} a.freeWorkId not in
<foreach collection="conditionParamRef.freeWorkIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('freeWorkIdStart') and conditionParamRef.freeWorkIdStart != null">
${_conditionType_} a.freeWorkId <![CDATA[ >= ]]> #{${_conditionParam_}.freeWorkIdStart}
</if>
<if test="conditionParamRef.containsKey('freeWorkIdEnd') and conditionParamRef.freeWorkIdEnd != null">
${_conditionType_} a.freeWorkId <![CDATA[ <= ]]> #{${_conditionParam_}.freeWorkIdEnd}
</if>
<if test="conditionParamRef.containsKey('must')"> <if test="conditionParamRef.containsKey('must')">
<if test="conditionParamRef.must != null "> <if test="conditionParamRef.must != null ">
${_conditionType_} a.must = #{${_conditionParam_}.must} ${_conditionType_} a.must = #{${_conditionParam_}.must}
</if>
<if test="conditionParamRef.must == null">
${_conditionType_} a.must is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('mustList')"> <if test="conditionParamRef.must == null">
${_conditionType_} a.must in ${_conditionType_} a.must is null
<foreach collection="conditionParamRef.mustList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustNotList')">
${_conditionType_} a.must not in
<foreach collection="conditionParamRef.mustNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustStart') and conditionParamRef.mustStart != null">
${_conditionType_} a.must <![CDATA[ >= ]]> #{${_conditionParam_}.mustStart}
</if>
<if test="conditionParamRef.containsKey('mustEnd') and conditionParamRef.mustEnd != null">
${_conditionType_} a.must <![CDATA[ <= ]]> #{${_conditionParam_}.mustEnd}
</if> </if>
</if>
<if test="conditionParamRef.containsKey('mustList')">
${_conditionType_} a.must in
<foreach collection="conditionParamRef.mustList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustNotList')">
${_conditionType_} a.must not in
<foreach collection="conditionParamRef.mustNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mustStart') and conditionParamRef.mustStart != null">
${_conditionType_} a.must <![CDATA[ >= ]]> #{${_conditionParam_}.mustStart}
</if>
<if test="conditionParamRef.containsKey('mustEnd') and conditionParamRef.mustEnd != null">
${_conditionType_} a.must <![CDATA[ <= ]]> #{${_conditionParam_}.mustEnd}
</if>
<if test="conditionParamRef.containsKey('classId')"> <if test="conditionParamRef.containsKey('classId')">
<if test="conditionParamRef.classId != null "> <if test="conditionParamRef.classId != null ">
${_conditionType_} a.classId = #{${_conditionParam_}.classId} ${_conditionType_} a.classId = #{${_conditionParam_}.classId}
</if>
<if test="conditionParamRef.classId == null">
${_conditionType_} a.classId is null
</if>
</if>
<if test="conditionParamRef.containsKey('classIdList')">
${_conditionType_} a.classId in
<foreach collection="conditionParamRef.classIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdNotList')">
${_conditionType_} a.classId not in
<foreach collection="conditionParamRef.classIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdStart') and conditionParamRef.classIdStart != null">
${_conditionType_} a.classId <![CDATA[ >= ]]> #{${_conditionParam_}.classIdStart}
</if> </if>
<if test="conditionParamRef.containsKey('classIdEnd') and conditionParamRef.classIdEnd != null"> <if test="conditionParamRef.classId == null">
${_conditionType_} a.classId <![CDATA[ <= ]]> #{${_conditionParam_}.classIdEnd} ${_conditionType_} a.classId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('classIdList')">
${_conditionType_} a.classId in
<foreach collection="conditionParamRef.classIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdNotList')">
${_conditionType_} a.classId not in
<foreach collection="conditionParamRef.classIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('classIdStart') and conditionParamRef.classIdStart != null">
${_conditionType_} a.classId <![CDATA[ >= ]]> #{${_conditionParam_}.classIdStart}
</if>
<if test="conditionParamRef.containsKey('classIdEnd') and conditionParamRef.classIdEnd != null">
${_conditionType_} a.classId <![CDATA[ <= ]]> #{${_conditionParam_}.classIdEnd}
</if>
<if test="conditionParamRef.containsKey('className')"> <if test="conditionParamRef.containsKey('className')">
<if test="conditionParamRef.className != null and conditionParamRef.className != ''"> <if test="conditionParamRef.className != null and conditionParamRef.className != ''">
${_conditionType_} a.className like #{${_conditionParam_}.className} ${_conditionType_} a.className like #{${_conditionParam_}.className}
</if>
<if test="conditionParamRef.className == null">
${_conditionType_} a.className is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('classNameList')"> <if test="conditionParamRef.className == null">
${_conditionType_} a.className in ${_conditionType_} a.className is null
<foreach collection="conditionParamRef.classNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('classNameNotList')"> </if>
${_conditionType_} a.className not in <if test="conditionParamRef.containsKey('classNameList')">
<foreach collection="conditionParamRef.classNameNotList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.className in
#{item} <foreach collection="conditionParamRef.classNameList" open="(" close=")" index="index" item="item" separator=",">
</foreach> #{item}
</if> </foreach>
<if test="conditionParamRef.containsKey('addWay')"> </if>
<if test="conditionParamRef.addWay != null "> <if test="conditionParamRef.containsKey('classNameNotList')">
${_conditionType_} a.addWay = #{${_conditionParam_}.addWay} ${_conditionType_} a.className not in
</if> <foreach collection="conditionParamRef.classNameNotList" open="(" close=")" index="index" item="item" separator=",">
<if test="conditionParamRef.addWay == null"> #{item}
${_conditionType_} a.addWay is null </foreach>
</if> </if>
</if> <if test="conditionParamRef.containsKey('addWay')">
<if test="conditionParamRef.containsKey('addWayList')"> <if test="conditionParamRef.addWay != null ">
${_conditionType_} a.addWay in ${_conditionType_} a.addWay = #{${_conditionParam_}.addWay}
<foreach collection="conditionParamRef.addWayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayNotList')">
${_conditionType_} a.addWay not in
<foreach collection="conditionParamRef.addWayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayStart') and conditionParamRef.addWayStart != null">
${_conditionType_} a.addWay <![CDATA[ >= ]]> #{${_conditionParam_}.addWayStart}
</if> </if>
<if test="conditionParamRef.containsKey('addWayEnd') and conditionParamRef.addWayEnd != null"> <if test="conditionParamRef.addWay == null">
${_conditionType_} a.addWay <![CDATA[ <= ]]> #{${_conditionParam_}.addWayEnd} ${_conditionType_} a.addWay is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('addWayList')">
${_conditionType_} a.addWay in
<foreach collection="conditionParamRef.addWayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayNotList')">
${_conditionType_} a.addWay not in
<foreach collection="conditionParamRef.addWayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addWayStart') and conditionParamRef.addWayStart != null">
${_conditionType_} a.addWay <![CDATA[ >= ]]> #{${_conditionParam_}.addWayStart}
</if>
<if test="conditionParamRef.containsKey('addWayEnd') and conditionParamRef.addWayEnd != null">
${_conditionType_} a.addWay <![CDATA[ <= ]]> #{${_conditionParam_}.addWayEnd}
</if>
<if test="conditionParamRef.containsKey('specialTime')"> <if test="conditionParamRef.containsKey('specialTime')">
<if test="conditionParamRef.specialTime != null "> <if test="conditionParamRef.specialTime != null ">
${_conditionType_} a.specialTime = #{${_conditionParam_}.specialTime} ${_conditionType_} a.specialTime = #{${_conditionParam_}.specialTime}
</if>
<if test="conditionParamRef.specialTime == null">
${_conditionType_} a.specialTime is null
</if>
</if> </if>
<if test="conditionParamRef.containsKey('specialTimeStart') and conditionParamRef.specialTimeStart != null and conditionParamRef.specialTimeStart!=''"> <if test="conditionParamRef.specialTime == null">
${_conditionType_} a.specialTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.specialTime is null
</if>
<if test="conditionParamRef.containsKey('specialTimeEnd') and conditionParamRef.specialTimeEnd != null and conditionParamRef.specialTimeEnd!=''">
${_conditionType_} a.specialTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialTimeStart') and conditionParamRef.specialTimeStart != null and conditionParamRef.specialTimeStart!=''">
${_conditionType_} a.specialTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialTimeEnd') and conditionParamRef.specialTimeEnd != null and conditionParamRef.specialTimeEnd!=''">
${_conditionType_} a.specialTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialTimeStart')"> <if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.specialTimeStart != null "> <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.specialTimeStart = #{${_conditionParam_}.specialTimeStart} ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.specialTimeStart == null">
${_conditionType_} a.specialTimeStart is null
</if>
</if>
<if test="conditionParamRef.containsKey('specialTimeStartStart') and conditionParamRef.specialTimeStartStart != null and conditionParamRef.specialTimeStartStart!=''">
${_conditionType_} a.specialTimeStart <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStartStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.containsKey('specialTimeStartEnd') and conditionParamRef.specialTimeStartEnd != null and conditionParamRef.specialTimeStartEnd!=''"> <if test="conditionParamRef.remark == null">
${_conditionType_} a.specialTimeStart <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeStartEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.remark is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialTimeEnd')"> <if test="conditionParamRef.containsKey('remarkList')">
<if test="conditionParamRef.specialTimeEnd != null "> ${_conditionType_} a.remark in
${_conditionType_} a.specialTimeEnd = #{${_conditionParam_}.specialTimeEnd} <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
</if> #{item}
<if test="conditionParamRef.specialTimeEnd == null"> </foreach>
${_conditionType_} a.specialTimeEnd is null </if>
</if> <if test="conditionParamRef.containsKey('remarkNotList')">
</if> ${_conditionType_} a.remark not in
<if test="conditionParamRef.containsKey('specialTimeEndStart') and conditionParamRef.specialTimeEndStart != null and conditionParamRef.specialTimeEndStart!=''"> <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
${_conditionType_} a.specialTimeEnd <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEndStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') #{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if> </if>
<if test="conditionParamRef.containsKey('specialTimeEndEnd') and conditionParamRef.specialTimeEndEnd != null and conditionParamRef.specialTimeEndEnd!=''"> <if test="conditionParamRef.createUserId == null">
${_conditionType_} a.specialTimeEnd <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialTimeEndEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.createUserId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''"> <if test="conditionParamRef.containsKey('createTime')">
${_conditionType_} a.remark like #{${_conditionParam_}.remark} <if test="conditionParamRef.createTime != null ">
</if> ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList')">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdNotList')"> <if test="conditionParamRef.createTime == null">
${_conditionType_} a.createUserId not in ${_conditionType_} a.createTime is null
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if> </if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null"> </if>
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart} <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>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null"> <if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd} ${_conditionType_} a.updateUserId is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList')">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')"> <if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.createTime != null "> <if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime} ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''"> <if test="conditionParamRef.updateTime == null">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.updateTime 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>
<if test="conditionParamRef.containsKey('updateUserIdList')"> </if>
${_conditionType_} a.updateUserId in <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=","> ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
#{item} </if>
</foreach> <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
</if> ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.containsKey('updateUserIdNotList')"> </if>
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=","> <if test="conditionParamRef.containsKey('specialStartTime')">
#{item} <if test="conditionParamRef.specialStartTime != null ">
</foreach> ${_conditionType_} a.specialStartTime = #{${_conditionParam_}.specialStartTime}
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if> </if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null"> <if test="conditionParamRef.specialStartTime == null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd} ${_conditionType_} a.specialStartTime is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialStartTimeStart') and conditionParamRef.specialStartTimeStart != null and conditionParamRef.specialStartTimeStart!=''">
${_conditionType_} a.specialStartTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialStartTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialStartTimeEnd') and conditionParamRef.specialStartTimeEnd != null and conditionParamRef.specialStartTimeEnd!=''">
${_conditionType_} a.specialStartTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialStartTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialEndTime')">
<if test="conditionParamRef.containsKey('updateTime')"> <if test="conditionParamRef.specialEndTime != null ">
<if test="conditionParamRef.updateTime != null "> ${_conditionType_} a.specialEndTime = #{${_conditionParam_}.specialEndTime}
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if> </if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''"> <if test="conditionParamRef.specialEndTime == null">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ${_conditionType_} a.specialEndTime is null
</if> </if>
</if>
<if test="conditionParamRef.containsKey('specialEndTimeStart') and conditionParamRef.specialEndTimeStart != null and conditionParamRef.specialEndTimeStart!=''">
${_conditionType_} a.specialEndTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialEndTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('specialEndTimeEnd') and conditionParamRef.specialEndTimeEnd != null and conditionParamRef.specialEndTimeEnd!=''">
${_conditionType_} a.specialEndTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.specialEndTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql> </sql>
<sql id="_orderCols_"> <sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()"> <if test="orderColList != null and !orderColList.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=","> <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind} ${item.colName} ${item.sortKind}
</foreach> </foreach>
</trim> </trim>
</if> </if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()"> <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by order by
<trim suffixOverrides="," suffix=""> <trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')"> <if test="orderCol.containsKey('id')">
a.id a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if> <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('freeWorkId')"> <if test="orderCol.containsKey('freeWorkId')">
a.freeWorkId a.freeWorkId
<if test='orderCol.freeWorkId != null and "DESC".equalsIgnoreCase(orderCol.freeWorkId)'>DESC</if> <if test='orderCol.freeWorkId != null and "DESC".equalsIgnoreCase(orderCol.freeWorkId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('must')"> <if test="orderCol.containsKey('must')">
a.must a.must
<if test='orderCol.must != null and "DESC".equalsIgnoreCase(orderCol.must)'>DESC</if> <if test='orderCol.must != null and "DESC".equalsIgnoreCase(orderCol.must)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('classId')"> <if test="orderCol.containsKey('classId')">
a.classId a.classId
<if test='orderCol.classId != null and "DESC".equalsIgnoreCase(orderCol.classId)'>DESC</if> <if test='orderCol.classId != null and "DESC".equalsIgnoreCase(orderCol.classId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('className')"> <if test="orderCol.containsKey('className')">
a.className a.className
<if test='orderCol.className != null and "DESC".equalsIgnoreCase(orderCol.className)'>DESC</if> <if test='orderCol.className != null and "DESC".equalsIgnoreCase(orderCol.className)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('addWay')"> <if test="orderCol.containsKey('addWay')">
a.addWay a.addWay
<if test='orderCol.addWay != null and "DESC".equalsIgnoreCase(orderCol.addWay)'>DESC</if> <if test='orderCol.addWay != null and "DESC".equalsIgnoreCase(orderCol.addWay)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('specialTime')"> <if test="orderCol.containsKey('specialTime')">
a.specialTime a.specialTime
<if test='orderCol.specialTime != null and "DESC".equalsIgnoreCase(orderCol.specialTime)'>DESC</if> <if test='orderCol.specialTime != null and "DESC".equalsIgnoreCase(orderCol.specialTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('specialTimeStart')"> <if test="orderCol.containsKey('remark')">
a.specialTimeStart a.remark
<if test='orderCol.specialTimeStart != null and "DESC".equalsIgnoreCase(orderCol.specialTimeStart)'>DESC</if> <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('specialTimeEnd')"> <if test="orderCol.containsKey('createUserId')">
a.specialTimeEnd a.createUserId
<if test='orderCol.specialTimeEnd != null and "DESC".equalsIgnoreCase(orderCol.specialTimeEnd)'>DESC</if> <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('remark')"> <if test="orderCol.containsKey('createTime')">
a.remark a.createTime
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if> <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createUserId')"> <if test="orderCol.containsKey('updateUserId')">
a.createUserId a.updateUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if> <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('createTime')"> <if test="orderCol.containsKey('updateTime')">
a.createTime a.updateTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if> <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateUserId')"> <if test="orderCol.containsKey('specialStartTime')">
a.updateUserId a.specialStartTime
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if> <if test='orderCol.specialStartTime != null and "DESC".equalsIgnoreCase(orderCol.specialStartTime)'>DESC</if>
, ,
</if> </if>
<if test="orderCol.containsKey('updateTime')"> <if test="orderCol.containsKey('specialEndTime')">
a.updateTime a.specialEndTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if> <if test='orderCol.specialEndTime != null and "DESC".equalsIgnoreCase(orderCol.specialEndTime)'>DESC</if>
, ,
</if> </if>
</trim> </trim>
</if> </if>
</sql> </sql>
......
db/module.sql
View file @ 9173472b
...@@ -571,16 +571,19 @@ CREATE TABLE mortals_xhx_attendance_group_freework_special( ...@@ -571,16 +571,19 @@ CREATE TABLE mortals_xhx_attendance_group_freework_special(
`className` varchar(128) COMMENT '班次名称', `className` varchar(128) COMMENT '班次名称',
`addWay` tinyint(1) DEFAULT '0' COMMENT '无需打卡的日期类型(0.单个日期,1.时间段)', `addWay` tinyint(1) DEFAULT '0' COMMENT '无需打卡的日期类型(0.单个日期,1.时间段)',
`specialTime` datetime NOT NULL COMMENT '特殊时间', `specialTime` datetime NOT NULL COMMENT '特殊时间',
`specialTimeStart` datetime NOT NULL COMMENT '时间段时候开始时间', `specialStartTime` datetime NOT NULL COMMENT '时间段时候开始时间',
`specialTimeEnd` datetime NOT NULL COMMENT '时间段结束时间', `specialEndTime` datetime NOT NULL COMMENT '时间段结束时间',
`remark` varchar(255) COMMENT '备注', `remark` varchar(255) COMMENT '备注',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户', `createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createTime` datetime NOT NULL COMMENT '创建时间', `createTime` datetime NOT NULL COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户', `updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '更新时间', `updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`) PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考勤组考勤自由工时特殊日期配置'; ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考勤组考勤自由工时特殊日期配置';
-- ---------------------------- -- ----------------------------
-- 考勤组考勤自由工时配置表 -- 考勤组考勤自由工时配置表
-- ---------------------------- -- ----------------------------
...@@ -618,8 +621,8 @@ CREATE TABLE mortals_xhx_attendance_group_fixedwork_special( ...@@ -618,8 +621,8 @@ CREATE TABLE mortals_xhx_attendance_group_fixedwork_special(
`className` varchar(128) COMMENT '班次名称', `className` varchar(128) COMMENT '班次名称',
`addWay` tinyint(1) DEFAULT '0' COMMENT '无需打卡的日期类型(0.单个日期,1.时间段)', `addWay` tinyint(1) DEFAULT '0' COMMENT '无需打卡的日期类型(0.单个日期,1.时间段)',
`specialTime` datetime NOT NULL COMMENT '特殊时间', `specialTime` datetime NOT NULL COMMENT '特殊时间',
`specialTimeStart` datetime NOT NULL COMMENT '时间段时候开始时间', `specialStartTime` datetime NOT NULL COMMENT '时间段时候开始时间',
`specialTimeEnd` datetime NOT NULL COMMENT '时间段结束时间', `specialEndTime` datetime NOT NULL COMMENT '时间段结束时间',
`remark` varchar(255) COMMENT '备注', `remark` varchar(255) COMMENT '备注',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户', `createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createTime` datetime NOT NULL COMMENT '创建时间', `createTime` datetime NOT NULL COMMENT '创建时间',
...@@ -628,6 +631,8 @@ CREATE TABLE mortals_xhx_attendance_group_fixedwork_special( ...@@ -628,6 +631,8 @@ CREATE TABLE mortals_xhx_attendance_group_fixedwork_special(
PRIMARY KEY (`id`) PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考勤组考勤固定班制特殊日期配置'; ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考勤组考勤固定班制特殊日期配置';
-- ---------------------------- -- ----------------------------
-- 考勤组考勤固定工时表 -- 考勤组考勤固定工时表
-- ---------------------------- -- ----------------------------
......
doc/api.md
View file @ 9173472b
...@@ -8576,13 +8576,13 @@ data|object|数据对象 ...@@ -8576,13 +8576,13 @@ data|object|数据对象
&emsp;&emsp;className|String|班次名称 &emsp;&emsp;className|String|班次名称
&emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段) &emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段)
&emsp;&emsp;specialTime|Date|特殊时间 &emsp;&emsp;specialTime|Date|特殊时间
&emsp;&emsp;specialTimeStart|Date|时间段时候开始时间
&emsp;&emsp;specialTimeEnd|Date|时间段结束时间
&emsp;&emsp;remark|String|备注 &emsp;&emsp;remark|String|备注
&emsp;&emsp;createUserId|Long|创建用户 &emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;createTime|Date|创建时间 &emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;updateUserId|Long|更新用户 &emsp;&emsp;updateUserId|Long|更新用户
&emsp;&emsp;updateTime|Date|更新时间 &emsp;&emsp;updateTime|Date|更新时间
&emsp;&emsp;specialStartTime|Date|时间段时候开始时间
&emsp;&emsp;specialEndTime|Date|时间段结束时间
dict|object|字典对象 dict|object|字典对象
&emsp;must|object|字典属性对象，详见附录 &emsp;must|object|字典属性对象，详见附录
&emsp;addWay|object|字典属性对象，详见附录 &emsp;addWay|object|字典属性对象，详见附录
...@@ -8630,13 +8630,13 @@ data|object|数据对象 ...@@ -8630,13 +8630,13 @@ data|object|数据对象
&emsp;className|String|班次名称 &emsp;className|String|班次名称
&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段) &emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段)
&emsp;specialTime|Date|特殊时间 &emsp;specialTime|Date|特殊时间
&emsp;specialTimeStart|Date|时间段时候开始时间
&emsp;specialTimeEnd|Date|时间段结束时间
&emsp;remark|String|备注 &emsp;remark|String|备注
&emsp;createUserId|Long|创建用户 &emsp;createUserId|Long|创建用户
&emsp;createTime|Date|创建时间 &emsp;createTime|Date|创建时间
&emsp;updateUserId|Long|更新用户 &emsp;updateUserId|Long|更新用户
&emsp;updateTime|Date|更新时间 &emsp;updateTime|Date|更新时间
&emsp;specialStartTime|Date|时间段时候开始时间
&emsp;specialEndTime|Date|时间段结束时间
dict|object|字典对象 dict|object|字典对象
&emsp;must|object|字典属性对象，详见附录 &emsp;must|object|字典属性对象，详见附录
&emsp;addWay|object|字典属性对象，详见附录 &emsp;addWay|object|字典属性对象，详见附录
...@@ -8646,20 +8646,20 @@ dict|object|字典对象 ...@@ -8646,20 +8646,20 @@ dict|object|字典对象
{ {
"code": 1, "code": 1,
"data": { "data": {
"id":5248, "id":5076,
"freeWorkId":9666, "freeWorkId":7022,
"must":3613, "must":2824,
"classId":2609, "classId":1549,
"className":"ngw8u1", "className":"nddun6",
"addWay":6162, "addWay":9326,
"specialTime":"2023-04-08", "specialTime":"2023-04-10",
"specialTimeStart":"2023-04-08", "remark":"gfccxk",
"specialTimeEnd":"2023-04-08", "createUserId":1207,
"remark":"jz8f50", "createTime":"2023-04-10",
"createUserId":5403, "updateUserId":480,
"createTime":"2023-04-08", "updateTime":"2023-04-10",
"updateUserId":5469, "specialStartTime":"2023-04-10",
"updateTime":"2023-04-08" "specialEndTime":"2023-04-10"
} }
} }
``` ```
...@@ -8684,22 +8684,22 @@ classId|Long|否|班次ID ...@@ -8684,22 +8684,22 @@ classId|Long|否|班次ID
className|String|否|班次名称 className|String|否|班次名称
addWay|Integer|否|无需打卡的日期类型(0.单个日期,1.时间段) addWay|Integer|否|无需打卡的日期类型(0.单个日期,1.时间段)
specialTime|Date|是|特殊时间 specialTime|Date|是|特殊时间
specialTimeStart|Date|是|时间段时候开始时间
specialTimeEnd|Date|是|时间段结束时间
remark|String|否|备注 remark|String|否|备注
specialStartTime|Date|是|时间段时候开始时间
specialEndTime|Date|是|时间段结束时间
**请求样例:** **请求样例:**
``` ```
{ {
"freeWorkId":1675, "freeWorkId":6139,
"must":5147, "must":8249,
"classId":7952, "classId":2953,
"className":"e0jfo6", "className":"oh2and",
"addWay":2694, "addWay":82,
"specialTime":"2023-04-08", "specialTime":"2023-04-10",
"specialTimeStart":"2023-04-08", "remark":"ypalu8",
"specialTimeEnd":"2023-04-08", "specialStartTime":"2023-04-10",
"remark":"9tfxpf", "specialEndTime":"2023-04-10"
} }
``` ```
...@@ -8719,13 +8719,13 @@ data|object|数据对象 ...@@ -8719,13 +8719,13 @@ data|object|数据对象
&emsp;&emsp;className|String|班次名称 &emsp;&emsp;className|String|班次名称
&emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段) &emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段)
&emsp;&emsp;specialTime|Date|特殊时间 &emsp;&emsp;specialTime|Date|特殊时间
&emsp;&emsp;specialTimeStart|Date|时间段时候开始时间
&emsp;&emsp;specialTimeEnd|Date|时间段结束时间
&emsp;&emsp;remark|String|备注 &emsp;&emsp;remark|String|备注
&emsp;&emsp;createUserId|Long|创建用户 &emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;createTime|Date|创建时间 &emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;updateUserId|Long|更新用户 &emsp;&emsp;updateUserId|Long|更新用户
&emsp;&emsp;updateTime|Date|更新时间 &emsp;&emsp;updateTime|Date|更新时间
&emsp;&emsp;specialStartTime|Date|时间段时候开始时间
&emsp;&emsp;specialEndTime|Date|时间段结束时间
**响应消息样例:** **响应消息样例:**
``` ```
...@@ -9092,13 +9092,13 @@ data|object|数据对象 ...@@ -9092,13 +9092,13 @@ data|object|数据对象
&emsp;&emsp;className|String|班次名称 &emsp;&emsp;className|String|班次名称
&emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段) &emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段)
&emsp;&emsp;specialTime|Date|特殊时间 &emsp;&emsp;specialTime|Date|特殊时间
&emsp;&emsp;specialTimeStart|Date|时间段时候开始时间
&emsp;&emsp;specialTimeEnd|Date|时间段结束时间
&emsp;&emsp;remark|String|备注 &emsp;&emsp;remark|String|备注
&emsp;&emsp;createUserId|Long|创建用户 &emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;createTime|Date|创建时间 &emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;updateUserId|Long|更新用户 &emsp;&emsp;updateUserId|Long|更新用户
&emsp;&emsp;updateTime|Date|更新时间 &emsp;&emsp;updateTime|Date|更新时间
&emsp;&emsp;specialStartTime|Date|时间段时候开始时间
&emsp;&emsp;specialEndTime|Date|时间段结束时间
dict|object|字典对象 dict|object|字典对象
&emsp;must|object|字典属性对象，详见附录 &emsp;must|object|字典属性对象，详见附录
&emsp;addWay|object|字典属性对象，详见附录 &emsp;addWay|object|字典属性对象，详见附录
...@@ -9146,13 +9146,13 @@ data|object|数据对象 ...@@ -9146,13 +9146,13 @@ data|object|数据对象
&emsp;className|String|班次名称 &emsp;className|String|班次名称
&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段) &emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段)
&emsp;specialTime|Date|特殊时间 &emsp;specialTime|Date|特殊时间
&emsp;specialTimeStart|Date|时间段时候开始时间
&emsp;specialTimeEnd|Date|时间段结束时间
&emsp;remark|String|备注 &emsp;remark|String|备注
&emsp;createUserId|Long|创建用户 &emsp;createUserId|Long|创建用户
&emsp;createTime|Date|创建时间 &emsp;createTime|Date|创建时间
&emsp;updateUserId|Long|更新用户 &emsp;updateUserId|Long|更新用户
&emsp;updateTime|Date|更新时间 &emsp;updateTime|Date|更新时间
&emsp;specialStartTime|Date|时间段时候开始时间
&emsp;specialEndTime|Date|时间段结束时间
dict|object|字典对象 dict|object|字典对象
&emsp;must|object|字典属性对象，详见附录 &emsp;must|object|字典属性对象，详见附录
&emsp;addWay|object|字典属性对象，详见附录 &emsp;addWay|object|字典属性对象，详见附录
...@@ -9162,20 +9162,20 @@ dict|object|字典对象 ...@@ -9162,20 +9162,20 @@ dict|object|字典对象
{ {
"code": 1, "code": 1,
"data": { "data": {
"id":8015, "id":7924,
"fixedWorkId":2972, "fixedWorkId":1115,
"must":3802, "must":8070,
"classId":5674, "classId":8139,
"className":"53zlul", "className":"3c4hgu",
"addWay":4124, "addWay":1203,
"specialTime":"2023-04-08", "specialTime":"2023-04-10",
"specialTimeStart":"2023-04-08", "remark":"w614hb",
"specialTimeEnd":"2023-04-08", "createUserId":4288,
"remark":"0rfxq5", "createTime":"2023-04-10",
"createUserId":8082, "updateUserId":6736,
"createTime":"2023-04-08", "updateTime":"2023-04-10",
"updateUserId":2828, "specialStartTime":"2023-04-10",
"updateTime":"2023-04-08" "specialEndTime":"2023-04-10"
} }
} }
``` ```
...@@ -9200,22 +9200,22 @@ classId|Long|否|班次ID ...@@ -9200,22 +9200,22 @@ classId|Long|否|班次ID
className|String|否|班次名称 className|String|否|班次名称
addWay|Integer|否|无需打卡的日期类型(0.单个日期,1.时间段) addWay|Integer|否|无需打卡的日期类型(0.单个日期,1.时间段)
specialTime|Date|是|特殊时间 specialTime|Date|是|特殊时间
specialTimeStart|Date|是|时间段时候开始时间
specialTimeEnd|Date|是|时间段结束时间
remark|String|否|备注 remark|String|否|备注
specialStartTime|Date|是|时间段时候开始时间
specialEndTime|Date|是|时间段结束时间
**请求样例:** **请求样例:**
``` ```
{ {
"fixedWorkId":8982, "fixedWorkId":9498,
"must":7809, "must":2219,
"classId":1902, "classId":5994,
"className":"72xrq3", "className":"0a7u6p",
"addWay":6684, "addWay":3443,
"specialTime":"2023-04-08", "specialTime":"2023-04-10",
"specialTimeStart":"2023-04-08", "remark":"takndm",
"specialTimeEnd":"2023-04-08", "specialStartTime":"2023-04-10",
"remark":"th3m5f", "specialEndTime":"2023-04-10"
} }
``` ```
...@@ -9235,13 +9235,13 @@ data|object|数据对象 ...@@ -9235,13 +9235,13 @@ data|object|数据对象
&emsp;&emsp;className|String|班次名称 &emsp;&emsp;className|String|班次名称
&emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段) &emsp;&emsp;addWay|Integer|无需打卡的日期类型(0.单个日期,1.时间段)
&emsp;&emsp;specialTime|Date|特殊时间 &emsp;&emsp;specialTime|Date|特殊时间
&emsp;&emsp;specialTimeStart|Date|时间段时候开始时间
&emsp;&emsp;specialTimeEnd|Date|时间段结束时间
&emsp;&emsp;remark|String|备注 &emsp;&emsp;remark|String|备注
&emsp;&emsp;createUserId|Long|创建用户 &emsp;&emsp;createUserId|Long|创建用户
&emsp;&emsp;createTime|Date|创建时间 &emsp;&emsp;createTime|Date|创建时间
&emsp;&emsp;updateUserId|Long|更新用户 &emsp;&emsp;updateUserId|Long|更新用户
&emsp;&emsp;updateTime|Date|更新时间 &emsp;&emsp;updateTime|Date|更新时间
&emsp;&emsp;specialStartTime|Date|时间段时候开始时间
&emsp;&emsp;specialEndTime|Date|时间段结束时间
**响应消息样例:** **响应消息样例:**
``` ```
......
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