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