添加照片海康下载

attendance-performance-manager/src/main/java/com/mortals/xhx/module/check/model/CheckAttendRecordEntity.java

@@ -9,136 +9,145 @@ import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.check.model.vo.CheckAttendRecordVo;
 import lombok.Data;
 /**
-* 考勤绩效记录核查信息实体对象
-*
-* @author zxfei
-* @date 2023-07-10
-*/
+ * 考勤绩效记录核查信息实体对象
+ *
+ * @author zxfei
+ * @date 2023-07-15
+ */
 @Data
 public class CheckAttendRecordEntity extends CheckAttendRecordVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 记录ID
-    */
+     * 记录ID
+     */
     private Long recordId;
     /**
-    * 员工ID
-    */
+     * 员工ID
+     */
     private Long staffId;
     /**
-    * 员工姓名
-    */
+     * 员工姓名
+     */
     private String staffName;
     /**
-    * 工号
-    */
+     * 工号
+     */
     private String workNum;
     /**
-    * 所属部门
-    */
+     * 所属部门
+     */
     private Long deptId;
     /**
-    * 所属部门名称
-    */
+     * 所属部门名称
+     */
     private String deptName;
     /**
-    * 所属考勤组ID
-    */
+     * 所属考勤组ID
+     */
     private Long attendanceGroupId;
     /**
-    * 所属考勤组名称
-    */
+     * 所属考勤组名称
+     */
     private String attendanceGroupName;
     /**
-    * 考勤时间
-    */
+     * 考勤时间
+     */
     private Date attendanceDate;
     /**
-    * 绩效规则id
-    */
+     * 绩效规则id
+     */
     private Long ruleId;
     /**
-    * 规则名称
-    */
+     * 规则名称
+     */
     private String ruleName;
     /**
-    * 增减类型(1.增加,2.扣除)
-    */
+     * 增减类型(1.增加,2.扣除)
+     */
     private Integer subAddType;
     /**
-    * 扣分或增加分值
-    */
+     * 扣分或增加分值
+     */
     private BigDecimal score;
     /**
-    * 上下班时间
-    */
+     * 上下班时间
+     */
     private String goOffTimeStr;
     /**
-    * 异常时间
-    */
+     * 异常时间
+     */
     private Date errorTime;
     /**
-    * 实际打卡时间
-    */
+     * 实际打卡时间
+     */
     private Date actualAttendTime;
     /**
-    * 异常处理结果
-    */
+     * 异常处理结果
+     */
     private String errorResult;
     /**
-    * 核查人员
-    */
+     * 核查人员
+     */
     @Excel(name = "核查人员")
     private String checkPerson;
     /**
-    * 核查时间
-    */
+     * 核查时间
+     */
     private Date checkTime;
     /**
-    * 核查说明
-    */
+     * 核查说明
+     */
     @Excel(name = "核查说明")
     private String checkDesc;
     /**
-    * 核查结果(1.加分或扣分,2.不扣分)
-    */
+     * 核查结果(1.加分或扣分,2.不扣分)
+     */
     @Excel(name = "核查结果", readConverterExp = "1=加分或扣分,2.不扣分")
     private String checkResult;
     /**
-    * 处理状态(1.未处理,2.已处理)
-    */
+     * 处理状态(1.未处理,2.已处理)
+     */
     private Integer checkStatus;
     /**
-    * 扣分方式(1.系统自动,2.人工添加,3.大厅巡查,4.申诉冲销)
-    */
+     * 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     */
     private Integer subMethod;
     /**
-    * 备注
-    */
+     * 备注
+     */
     @Excel(name = "备注")
     private String remark;
     /**
-    * 附件名称，多个逗号分割
-    */
+     * 附件名称，多个逗号分割
+     */
     @Excel(name = "附件名称，多个逗号分割")
     private String fileNames;
     /**
-    * 附件下载地址，多个逗号分割
-    */
+     * 附件下载地址，多个逗号分割
+     */
     @Excel(name = "附件下载地址，多个逗号分割")
     private String filePaths;
     /**
-    * 绩效规则分类id
-    */
+     * 绩效规则分类id
+     */
     private Long categoryId;
     /**
-    * 规则分类名称
-    */
+     * 规则名称
+     */
     private String categoryName;
+    /**
+     * 扣分人员
+     */
+    @Excel(name = "扣分人员")
+    private String deductPerson;
+    /**
+     * 扣分时间
+     */
+    private Date deductTime;
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -146,7 +155,7 @@ public class CheckAttendRecordEntity extends CheckAttendRecordVo {
         if (obj instanceof CheckAttendRecordEntity) {
             CheckAttendRecordEntity tmp = (CheckAttendRecordEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
@@ -154,60 +163,64 @@ public class CheckAttendRecordEntity extends CheckAttendRecordVo {
 
     public void initAttrValue(){
 
-            this.recordId = -1L;
+        this.recordId = -1L;
+
+        this.staffId = -1L;
+
+        this.staffName = "";
 
-            this.staffId = -1L;
+        this.workNum = "";
 
-            this.staffName = "";
+        this.deptId = -1L;
 
-            this.workNum = "";
+        this.deptName = "";
 
-            this.deptId = -1L;
+        this.attendanceGroupId = -1L;
 
-            this.deptName = "";
+        this.attendanceGroupName = "";
 
-            this.attendanceGroupId = -1L;
+        this.attendanceDate = null;
 
-            this.attendanceGroupName = "";
+        this.ruleId = -1L;
 
-            this.attendanceDate = null;
+        this.ruleName = "";
 
-            this.ruleId = -1L;
+        this.subAddType = 1;
 
-            this.ruleName = "";
+        this.score = BigDecimal.valueOf(0.00);
 
-            this.subAddType = 1;
+        this.goOffTimeStr = "";
 
-            this.score = BigDecimal.valueOf(0.00);
+        this.errorTime = null;
 
-            this.goOffTimeStr = "";
+        this.actualAttendTime = null;
 
-            this.errorTime = null;
+        this.errorResult = "";
 
-            this.actualAttendTime = null;
+        this.checkPerson = "";
 
-            this.errorResult = "";
+        this.checkTime = null;
 
-            this.checkPerson = "";
+        this.checkDesc = "";
 
-            this.checkTime = null;
+        this.checkResult = "";
 
-            this.checkDesc = "";
+        this.checkStatus = 1;
 
-            this.checkResult = "";
+        this.subMethod = 1;
 
-            this.checkStatus = 1;
+        this.remark = "";
 
-            this.subMethod = 1;
+        this.fileNames = "";
 
-            this.remark = "";
+        this.filePaths = "";
 
-            this.fileNames = "";
+        this.categoryId = -1L;
 
-            this.filePaths = "";
+        this.categoryName = "";
 
-            this.categoryId = -1L;
+        this.deductPerson = "";
 
-            this.categoryName = "";
+        this.deductTime = null;
     }
 }
\ No newline at end of file

attendance-performance-manager/src/main/java/com/mortals/xhx/module/check/model/CheckAttendRecordQuery.java

@@ -5,11 +5,11 @@ import java.util.Date;
 import java.util.List;
 import com.mortals.xhx.module.check.model.CheckAttendRecordEntity;
 /**
-* 考勤绩效记录核查信息查询对象
-*
-* @author zxfei
-* @date 2023-07-10
-*/
+ * 考勤绩效记录核查信息查询对象
+ *
+ * @author zxfei
+ * @date 2023-07-15
+ */
 public class CheckAttendRecordQuery extends CheckAttendRecordEntity {
     /** 开始 序号，主键，自增长 */
     private Long idStart;
@@ -312,6 +312,17 @@ public class CheckAttendRecordQuery extends CheckAttendRecordEntity {
 
     /** 规则名称排除列表 */
     private List <String> categoryNameNotList;
+    /** 扣分人员 */
+    private List<String> deductPersonList;
+
+    /** 扣分人员排除列表 */
+    private List <String> deductPersonNotList;
+    /** 开始 扣分时间 */
+    private String deductTimeStart;
+
+    /** 结束 扣分时间 */
+    private String deductTimeEnd;
+
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<CheckAttendRecordQuery> orConditionList;
 
@@ -321,2700 +332,2784 @@ public class CheckAttendRecordQuery extends CheckAttendRecordEntity {
     public CheckAttendRecordQuery(){}
 
     /**
-    * 获取 开始 序号，主键，自增长
-    * @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 recordIdStart
-    */
+     * 获取 开始 记录ID
+     * @return recordIdStart
+     */
     public Long getRecordIdStart(){
         return this.recordIdStart;
     }
 
     /**
-    * 设置 开始 记录ID
-    * @param recordIdStart
-    */
+     * 设置 开始 记录ID
+     * @param recordIdStart
+     */
     public void setRecordIdStart(Long recordIdStart){
         this.recordIdStart = recordIdStart;
     }
 
     /**
-    * 获取 结束 记录ID
-    * @return $recordIdEnd
-    */
+     * 获取 结束 记录ID
+     * @return $recordIdEnd
+     */
     public Long getRecordIdEnd(){
         return this.recordIdEnd;
     }
 
     /**
-    * 设置 结束 记录ID
-    * @param recordIdEnd
-    */
+     * 设置 结束 记录ID
+     * @param recordIdEnd
+     */
     public void setRecordIdEnd(Long recordIdEnd){
         this.recordIdEnd = recordIdEnd;
     }
 
     /**
-    * 获取 增加 记录ID
-    * @return recordIdIncrement
-    */
+     * 获取 增加 记录ID
+     * @return recordIdIncrement
+     */
     public Long getRecordIdIncrement(){
         return this.recordIdIncrement;
     }
 
     /**
-    * 设置 增加 记录ID
-    * @param recordIdIncrement
-    */
+     * 设置 增加 记录ID
+     * @param recordIdIncrement
+     */
     public void setRecordIdIncrement(Long recordIdIncrement){
         this.recordIdIncrement = recordIdIncrement;
     }
 
     /**
-    * 获取 记录ID
-    * @return recordIdList
-    */
+     * 获取 记录ID
+     * @return recordIdList
+     */
     public List<Long> getRecordIdList(){
         return this.recordIdList;
     }
 
     /**
-    * 设置 记录ID
-    * @param recordIdList
-    */
+     * 设置 记录ID
+     * @param recordIdList
+     */
     public void setRecordIdList(List<Long> recordIdList){
         this.recordIdList = recordIdList;
     }
 
     /**
-    * 获取 记录ID
-    * @return recordIdNotList
-    */
+     * 获取 记录ID
+     * @return recordIdNotList
+     */
     public List<Long> getRecordIdNotList(){
         return this.recordIdNotList;
     }
 
     /**
-    * 设置 记录ID
-    * @param recordIdNotList
-    */
+     * 设置 记录ID
+     * @param recordIdNotList
+     */
     public void setRecordIdNotList(List<Long> recordIdNotList){
         this.recordIdNotList = recordIdNotList;
     }
 
 
     /**
-    * 获取 开始 员工ID
-    * @return staffIdStart
-    */
+     * 获取 开始 员工ID
+     * @return staffIdStart
+     */
     public Long getStaffIdStart(){
         return this.staffIdStart;
     }
 
     /**
-    * 设置 开始 员工ID
-    * @param staffIdStart
-    */
+     * 设置 开始 员工ID
+     * @param staffIdStart
+     */
     public void setStaffIdStart(Long staffIdStart){
         this.staffIdStart = staffIdStart;
     }
 
     /**
-    * 获取 结束 员工ID
-    * @return $staffIdEnd
-    */
+     * 获取 结束 员工ID
+     * @return $staffIdEnd
+     */
     public Long getStaffIdEnd(){
         return this.staffIdEnd;
     }
 
     /**
-    * 设置 结束 员工ID
-    * @param staffIdEnd
-    */
+     * 设置 结束 员工ID
+     * @param staffIdEnd
+     */
     public void setStaffIdEnd(Long staffIdEnd){
         this.staffIdEnd = staffIdEnd;
     }
 
     /**
-    * 获取 增加 员工ID
-    * @return staffIdIncrement
-    */
+     * 获取 增加 员工ID
+     * @return staffIdIncrement
+     */
     public Long getStaffIdIncrement(){
         return this.staffIdIncrement;
     }
 
     /**
-    * 设置 增加 员工ID
-    * @param staffIdIncrement
-    */
+     * 设置 增加 员工ID
+     * @param staffIdIncrement
+     */
     public void setStaffIdIncrement(Long staffIdIncrement){
         this.staffIdIncrement = staffIdIncrement;
     }
 
     /**
-    * 获取 员工ID
-    * @return staffIdList
-    */
+     * 获取 员工ID
+     * @return staffIdList
+     */
     public List<Long> getStaffIdList(){
         return this.staffIdList;
     }
 
     /**
-    * 设置 员工ID
-    * @param staffIdList
-    */
+     * 设置 员工ID
+     * @param staffIdList
+     */
     public void setStaffIdList(List<Long> staffIdList){
         this.staffIdList = staffIdList;
     }
 
     /**
-    * 获取 员工ID
-    * @return staffIdNotList
-    */
+     * 获取 员工ID
+     * @return staffIdNotList
+     */
     public List<Long> getStaffIdNotList(){
         return this.staffIdNotList;
     }
 
     /**
-    * 设置 员工ID
-    * @param staffIdNotList
-    */
+     * 设置 员工ID
+     * @param staffIdNotList
+     */
     public void setStaffIdNotList(List<Long> staffIdNotList){
         this.staffIdNotList = staffIdNotList;
     }
 
 
     /**
-    * 获取 员工姓名
-    * @return staffNameList
-    */
+     * 获取 员工姓名
+     * @return staffNameList
+     */
     public List<String> getStaffNameList(){
         return this.staffNameList;
     }
 
     /**
-    * 设置 员工姓名
-    * @param staffNameList
-    */
+     * 设置 员工姓名
+     * @param staffNameList
+     */
     public void setStaffNameList(List<String> staffNameList){
         this.staffNameList = staffNameList;
     }
 
     /**
-    * 获取 员工姓名
-    * @return staffNameNotList
-    */
+     * 获取 员工姓名
+     * @return staffNameNotList
+     */
     public List<String> getStaffNameNotList(){
         return this.staffNameNotList;
     }
 
     /**
-    * 设置 员工姓名
-    * @param staffNameNotList
-    */
+     * 设置 员工姓名
+     * @param staffNameNotList
+     */
     public void setStaffNameNotList(List<String> staffNameNotList){
         this.staffNameNotList = staffNameNotList;
     }
 
     /**
-    * 获取 工号
-    * @return workNumList
-    */
+     * 获取 工号
+     * @return workNumList
+     */
     public List<String> getWorkNumList(){
         return this.workNumList;
     }
 
     /**
-    * 设置 工号
-    * @param workNumList
-    */
+     * 设置 工号
+     * @param workNumList
+     */
     public void setWorkNumList(List<String> workNumList){
         this.workNumList = workNumList;
     }
 
     /**
-    * 获取 工号
-    * @return workNumNotList
-    */
+     * 获取 工号
+     * @return workNumNotList
+     */
     public List<String> getWorkNumNotList(){
         return this.workNumNotList;
     }
 
     /**
-    * 设置 工号
-    * @param workNumNotList
-    */
+     * 设置 工号
+     * @param workNumNotList
+     */
     public void setWorkNumNotList(List<String> workNumNotList){
         this.workNumNotList = workNumNotList;
     }
 
     /**
-    * 获取 开始 所属部门
-    * @return deptIdStart
-    */
+     * 获取 开始 所属部门
+     * @return deptIdStart
+     */
     public Long getDeptIdStart(){
         return this.deptIdStart;
     }
 
     /**
-    * 设置 开始 所属部门
-    * @param deptIdStart
-    */
+     * 设置 开始 所属部门
+     * @param deptIdStart
+     */
     public void setDeptIdStart(Long deptIdStart){
         this.deptIdStart = deptIdStart;
     }
 
     /**
-    * 获取 结束 所属部门
-    * @return $deptIdEnd
-    */
+     * 获取 结束 所属部门
+     * @return $deptIdEnd
+     */
     public Long getDeptIdEnd(){
         return this.deptIdEnd;
     }
 
     /**
-    * 设置 结束 所属部门
-    * @param deptIdEnd
-    */
+     * 设置 结束 所属部门
+     * @param deptIdEnd
+     */
     public void setDeptIdEnd(Long deptIdEnd){
         this.deptIdEnd = deptIdEnd;
     }
 
     /**
-    * 获取 增加 所属部门
-    * @return deptIdIncrement
-    */
+     * 获取 增加 所属部门
+     * @return deptIdIncrement
+     */
     public Long getDeptIdIncrement(){
         return this.deptIdIncrement;
     }
 
     /**
-    * 设置 增加 所属部门
-    * @param deptIdIncrement
-    */
+     * 设置 增加 所属部门
+     * @param deptIdIncrement
+     */
     public void setDeptIdIncrement(Long deptIdIncrement){
         this.deptIdIncrement = deptIdIncrement;
     }
 
     /**
-    * 获取 所属部门
-    * @return deptIdList
-    */
+     * 获取 所属部门
+     * @return deptIdList
+     */
     public List<Long> getDeptIdList(){
         return this.deptIdList;
     }
 
     /**
-    * 设置 所属部门
-    * @param deptIdList
-    */
+     * 设置 所属部门
+     * @param deptIdList
+     */
     public void setDeptIdList(List<Long> deptIdList){
         this.deptIdList = deptIdList;
     }
 
     /**
-    * 获取 所属部门
-    * @return deptIdNotList
-    */
+     * 获取 所属部门
+     * @return deptIdNotList
+     */
     public List<Long> getDeptIdNotList(){
         return this.deptIdNotList;
     }
 
     /**
-    * 设置 所属部门
-    * @param deptIdNotList
-    */
+     * 设置 所属部门
+     * @param deptIdNotList
+     */
     public void setDeptIdNotList(List<Long> deptIdNotList){
         this.deptIdNotList = deptIdNotList;
     }
 
 
     /**
-    * 获取 所属部门名称
-    * @return deptNameList
-    */
+     * 获取 所属部门名称
+     * @return deptNameList
+     */
     public List<String> getDeptNameList(){
         return this.deptNameList;
     }
 
     /**
-    * 设置 所属部门名称
-    * @param deptNameList
-    */
+     * 设置 所属部门名称
+     * @param deptNameList
+     */
     public void setDeptNameList(List<String> deptNameList){
         this.deptNameList = deptNameList;
     }
 
     /**
-    * 获取 所属部门名称
-    * @return deptNameNotList
-    */
+     * 获取 所属部门名称
+     * @return deptNameNotList
+     */
     public List<String> getDeptNameNotList(){
         return this.deptNameNotList;
     }
 
     /**
-    * 设置 所属部门名称
-    * @param deptNameNotList
-    */
+     * 设置 所属部门名称
+     * @param deptNameNotList
+     */
     public void setDeptNameNotList(List<String> deptNameNotList){
         this.deptNameNotList = deptNameNotList;
     }
 
     /**
-    * 获取 开始 所属考勤组ID
-    * @return attendanceGroupIdStart
-    */
+     * 获取 开始 所属考勤组ID
+     * @return attendanceGroupIdStart
+     */
     public Long getAttendanceGroupIdStart(){
         return this.attendanceGroupIdStart;
     }
 
     /**
-    * 设置 开始 所属考勤组ID
-    * @param attendanceGroupIdStart
-    */
+     * 设置 开始 所属考勤组ID
+     * @param attendanceGroupIdStart
+     */
     public void setAttendanceGroupIdStart(Long attendanceGroupIdStart){
         this.attendanceGroupIdStart = attendanceGroupIdStart;
     }
 
     /**
-    * 获取 结束 所属考勤组ID
-    * @return $attendanceGroupIdEnd
-    */
+     * 获取 结束 所属考勤组ID
+     * @return $attendanceGroupIdEnd
+     */
     public Long getAttendanceGroupIdEnd(){
         return this.attendanceGroupIdEnd;
     }
 
     /**
-    * 设置 结束 所属考勤组ID
-    * @param attendanceGroupIdEnd
-    */
+     * 设置 结束 所属考勤组ID
+     * @param attendanceGroupIdEnd
+     */
     public void setAttendanceGroupIdEnd(Long attendanceGroupIdEnd){
         this.attendanceGroupIdEnd = attendanceGroupIdEnd;
     }
 
     /**
-    * 获取 增加 所属考勤组ID
-    * @return attendanceGroupIdIncrement
-    */
+     * 获取 增加 所属考勤组ID
+     * @return attendanceGroupIdIncrement
+     */
     public Long getAttendanceGroupIdIncrement(){
         return this.attendanceGroupIdIncrement;
     }
 
     /**
-    * 设置 增加 所属考勤组ID
-    * @param attendanceGroupIdIncrement
-    */
+     * 设置 增加 所属考勤组ID
+     * @param attendanceGroupIdIncrement
+     */
     public void setAttendanceGroupIdIncrement(Long attendanceGroupIdIncrement){
         this.attendanceGroupIdIncrement = attendanceGroupIdIncrement;
     }
 
     /**
-    * 获取 所属考勤组ID
-    * @return attendanceGroupIdList
-    */
+     * 获取 所属考勤组ID
+     * @return attendanceGroupIdList
+     */
     public List<Long> getAttendanceGroupIdList(){
         return this.attendanceGroupIdList;
     }
 
     /**
-    * 设置 所属考勤组ID
-    * @param attendanceGroupIdList
-    */
+     * 设置 所属考勤组ID
+     * @param attendanceGroupIdList
+     */
     public void setAttendanceGroupIdList(List<Long> attendanceGroupIdList){
         this.attendanceGroupIdList = attendanceGroupIdList;
     }
 
     /**
-    * 获取 所属考勤组ID
-    * @return attendanceGroupIdNotList
-    */
+     * 获取 所属考勤组ID
+     * @return attendanceGroupIdNotList
+     */
     public List<Long> getAttendanceGroupIdNotList(){
         return this.attendanceGroupIdNotList;
     }
 
     /**
-    * 设置 所属考勤组ID
-    * @param attendanceGroupIdNotList
-    */
+     * 设置 所属考勤组ID
+     * @param attendanceGroupIdNotList
+     */
     public void setAttendanceGroupIdNotList(List<Long> attendanceGroupIdNotList){
         this.attendanceGroupIdNotList = attendanceGroupIdNotList;
     }
 
 
     /**
-    * 获取 所属考勤组名称
-    * @return attendanceGroupNameList
-    */
+     * 获取 所属考勤组名称
+     * @return attendanceGroupNameList
+     */
     public List<String> getAttendanceGroupNameList(){
         return this.attendanceGroupNameList;
     }
 
     /**
-    * 设置 所属考勤组名称
-    * @param attendanceGroupNameList
-    */
+     * 设置 所属考勤组名称
+     * @param attendanceGroupNameList
+     */
     public void setAttendanceGroupNameList(List<String> attendanceGroupNameList){
         this.attendanceGroupNameList = attendanceGroupNameList;
     }
 
     /**
-    * 获取 所属考勤组名称
-    * @return attendanceGroupNameNotList
-    */
+     * 获取 所属考勤组名称
+     * @return attendanceGroupNameNotList
+     */
     public List<String> getAttendanceGroupNameNotList(){
         return this.attendanceGroupNameNotList;
     }
 
     /**
-    * 设置 所属考勤组名称
-    * @param attendanceGroupNameNotList
-    */
+     * 设置 所属考勤组名称
+     * @param attendanceGroupNameNotList
+     */
     public void setAttendanceGroupNameNotList(List<String> attendanceGroupNameNotList){
         this.attendanceGroupNameNotList = attendanceGroupNameNotList;
     }
 
     /**
-    * 获取 开始 考勤时间
-    * @return attendanceDateStart
-    */
+     * 获取 开始 考勤时间
+     * @return attendanceDateStart
+     */
     public String getAttendanceDateStart(){
         return this.attendanceDateStart;
     }
 
     /**
-    * 设置 开始 考勤时间
-    * @param attendanceDateStart
-    */
+     * 设置 开始 考勤时间
+     * @param attendanceDateStart
+     */
     public void setAttendanceDateStart(String attendanceDateStart){
         this.attendanceDateStart = attendanceDateStart;
     }
 
     /**
-    * 获取 结束 考勤时间
-    * @return attendanceDateEnd
-    */
+     * 获取 结束 考勤时间
+     * @return attendanceDateEnd
+     */
     public String getAttendanceDateEnd(){
         return this.attendanceDateEnd;
     }
 
     /**
-    * 设置 结束 考勤时间
-    * @param attendanceDateEnd
-    */
+     * 设置 结束 考勤时间
+     * @param attendanceDateEnd
+     */
     public void setAttendanceDateEnd(String attendanceDateEnd){
         this.attendanceDateEnd = attendanceDateEnd;
     }
 
     /**
-    * 获取 开始 绩效规则id
-    * @return ruleIdStart
-    */
+     * 获取 开始 绩效规则id
+     * @return ruleIdStart
+     */
     public Long getRuleIdStart(){
         return this.ruleIdStart;
     }
 
     /**
-    * 设置 开始 绩效规则id
-    * @param ruleIdStart
-    */
+     * 设置 开始 绩效规则id
+     * @param ruleIdStart
+     */
     public void setRuleIdStart(Long ruleIdStart){
         this.ruleIdStart = ruleIdStart;
     }
 
     /**
-    * 获取 结束 绩效规则id
-    * @return $ruleIdEnd
-    */
+     * 获取 结束 绩效规则id
+     * @return $ruleIdEnd
+     */
     public Long getRuleIdEnd(){
         return this.ruleIdEnd;
     }
 
     /**
-    * 设置 结束 绩效规则id
-    * @param ruleIdEnd
-    */
+     * 设置 结束 绩效规则id
+     * @param ruleIdEnd
+     */
     public void setRuleIdEnd(Long ruleIdEnd){
         this.ruleIdEnd = ruleIdEnd;
     }
 
     /**
-    * 获取 增加 绩效规则id
-    * @return ruleIdIncrement
-    */
+     * 获取 增加 绩效规则id
+     * @return ruleIdIncrement
+     */
     public Long getRuleIdIncrement(){
         return this.ruleIdIncrement;
     }
 
     /**
-    * 设置 增加 绩效规则id
-    * @param ruleIdIncrement
-    */
+     * 设置 增加 绩效规则id
+     * @param ruleIdIncrement
+     */
     public void setRuleIdIncrement(Long ruleIdIncrement){
         this.ruleIdIncrement = ruleIdIncrement;
     }
 
     /**
-    * 获取 绩效规则id
-    * @return ruleIdList
-    */
+     * 获取 绩效规则id
+     * @return ruleIdList
+     */
     public List<Long> getRuleIdList(){
         return this.ruleIdList;
     }
 
     /**
-    * 设置 绩效规则id
-    * @param ruleIdList
-    */
+     * 设置 绩效规则id
+     * @param ruleIdList
+     */
     public void setRuleIdList(List<Long> ruleIdList){
         this.ruleIdList = ruleIdList;
     }
 
     /**
-    * 获取 绩效规则id
-    * @return ruleIdNotList
-    */
+     * 获取 绩效规则id
+     * @return ruleIdNotList
+     */
     public List<Long> getRuleIdNotList(){
         return this.ruleIdNotList;
     }
 
     /**
-    * 设置 绩效规则id
-    * @param ruleIdNotList
-    */
+     * 设置 绩效规则id
+     * @param ruleIdNotList
+     */
     public void setRuleIdNotList(List<Long> ruleIdNotList){
         this.ruleIdNotList = ruleIdNotList;
     }
 
 
     /**
-    * 获取 规则名称
-    * @return ruleNameList
-    */
+     * 获取 规则名称
+     * @return ruleNameList
+     */
     public List<String> getRuleNameList(){
         return this.ruleNameList;
     }
 
     /**
-    * 设置 规则名称
-    * @param ruleNameList
-    */
+     * 设置 规则名称
+     * @param ruleNameList
+     */
     public void setRuleNameList(List<String> ruleNameList){
         this.ruleNameList = ruleNameList;
     }
 
     /**
-    * 获取 规则名称
-    * @return ruleNameNotList
-    */
+     * 获取 规则名称
+     * @return ruleNameNotList
+     */
     public List<String> getRuleNameNotList(){
         return this.ruleNameNotList;
     }
 
     /**
-    * 设置 规则名称
-    * @param ruleNameNotList
-    */
+     * 设置 规则名称
+     * @param ruleNameNotList
+     */
     public void setRuleNameNotList(List<String> ruleNameNotList){
         this.ruleNameNotList = ruleNameNotList;
     }
 
     /**
-    * 获取 开始 增减类型(1.增加,2.扣除)
-    * @return subAddTypeStart
-    */
+     * 获取 开始 增减类型(1.增加,2.扣除)
+     * @return subAddTypeStart
+     */
     public Integer getSubAddTypeStart(){
         return this.subAddTypeStart;
     }
 
     /**
-    * 设置 开始 增减类型(1.增加,2.扣除)
-    * @param subAddTypeStart
-    */
+     * 设置 开始 增减类型(1.增加,2.扣除)
+     * @param subAddTypeStart
+     */
     public void setSubAddTypeStart(Integer subAddTypeStart){
         this.subAddTypeStart = subAddTypeStart;
     }
 
     /**
-    * 获取 结束 增减类型(1.增加,2.扣除)
-    * @return $subAddTypeEnd
-    */
+     * 获取 结束 增减类型(1.增加,2.扣除)
+     * @return $subAddTypeEnd
+     */
     public Integer getSubAddTypeEnd(){
         return this.subAddTypeEnd;
     }
 
     /**
-    * 设置 结束 增减类型(1.增加,2.扣除)
-    * @param subAddTypeEnd
-    */
+     * 设置 结束 增减类型(1.增加,2.扣除)
+     * @param subAddTypeEnd
+     */
     public void setSubAddTypeEnd(Integer subAddTypeEnd){
         this.subAddTypeEnd = subAddTypeEnd;
     }
 
     /**
-    * 获取 增加 增减类型(1.增加,2.扣除)
-    * @return subAddTypeIncrement
-    */
+     * 获取 增加 增减类型(1.增加,2.扣除)
+     * @return subAddTypeIncrement
+     */
     public Integer getSubAddTypeIncrement(){
         return this.subAddTypeIncrement;
     }
 
     /**
-    * 设置 增加 增减类型(1.增加,2.扣除)
-    * @param subAddTypeIncrement
-    */
+     * 设置 增加 增减类型(1.增加,2.扣除)
+     * @param subAddTypeIncrement
+     */
     public void setSubAddTypeIncrement(Integer subAddTypeIncrement){
         this.subAddTypeIncrement = subAddTypeIncrement;
     }
 
     /**
-    * 获取 增减类型(1.增加,2.扣除)
-    * @return subAddTypeList
-    */
+     * 获取 增减类型(1.增加,2.扣除)
+     * @return subAddTypeList
+     */
     public List<Integer> getSubAddTypeList(){
         return this.subAddTypeList;
     }
 
     /**
-    * 设置 增减类型(1.增加,2.扣除)
-    * @param subAddTypeList
-    */
+     * 设置 增减类型(1.增加,2.扣除)
+     * @param subAddTypeList
+     */
     public void setSubAddTypeList(List<Integer> subAddTypeList){
         this.subAddTypeList = subAddTypeList;
     }
 
     /**
-    * 获取 增减类型(1.增加,2.扣除)
-    * @return subAddTypeNotList
-    */
+     * 获取 增减类型(1.增加,2.扣除)
+     * @return subAddTypeNotList
+     */
     public List<Integer> getSubAddTypeNotList(){
         return this.subAddTypeNotList;
     }
 
     /**
-    * 设置 增减类型(1.增加,2.扣除)
-    * @param subAddTypeNotList
-    */
+     * 设置 增减类型(1.增加,2.扣除)
+     * @param subAddTypeNotList
+     */
     public void setSubAddTypeNotList(List<Integer> subAddTypeNotList){
         this.subAddTypeNotList = subAddTypeNotList;
     }
 
 
     /**
-    * 获取 开始 扣分或增加分值
-    * @return scoreStart
-    */
+     * 获取 开始 扣分或增加分值
+     * @return scoreStart
+     */
     public BigDecimal getScoreStart(){
         return this.scoreStart;
     }
 
     /**
-    * 设置 开始 扣分或增加分值
-    * @param scoreStart
-    */
+     * 设置 开始 扣分或增加分值
+     * @param scoreStart
+     */
     public void setScoreStart(BigDecimal scoreStart){
         this.scoreStart = scoreStart;
     }
 
     /**
-    * 获取 结束 扣分或增加分值
-    * @return $scoreEnd
-    */
+     * 获取 结束 扣分或增加分值
+     * @return $scoreEnd
+     */
     public BigDecimal getScoreEnd(){
         return this.scoreEnd;
     }
 
     /**
-    * 设置 结束 扣分或增加分值
-    * @param scoreEnd
-    */
+     * 设置 结束 扣分或增加分值
+     * @param scoreEnd
+     */
     public void setScoreEnd(BigDecimal scoreEnd){
         this.scoreEnd = scoreEnd;
     }
 
     /**
-    * 获取 增加 扣分或增加分值
-    * @return scoreIncrement
-    */
+     * 获取 增加 扣分或增加分值
+     * @return scoreIncrement
+     */
     public BigDecimal getScoreIncrement(){
         return this.scoreIncrement;
     }
 
     /**
-    * 设置 增加 扣分或增加分值
-    * @param scoreIncrement
-    */
+     * 设置 增加 扣分或增加分值
+     * @param scoreIncrement
+     */
     public void setScoreIncrement(BigDecimal scoreIncrement){
         this.scoreIncrement = scoreIncrement;
     }
 
     /**
-    * 获取 扣分或增加分值
-    * @return scoreList
-    */
+     * 获取 扣分或增加分值
+     * @return scoreList
+     */
     public List<BigDecimal> getScoreList(){
         return this.scoreList;
     }
 
     /**
-    * 设置 扣分或增加分值
-    * @param scoreList
-    */
+     * 设置 扣分或增加分值
+     * @param scoreList
+     */
     public void setScoreList(List<BigDecimal> scoreList){
         this.scoreList = scoreList;
     }
 
     /**
-    * 获取 扣分或增加分值
-    * @return scoreNotList
-    */
+     * 获取 扣分或增加分值
+     * @return scoreNotList
+     */
     public List<BigDecimal> getScoreNotList(){
         return this.scoreNotList;
     }
 
     /**
-    * 设置 扣分或增加分值
-    * @param scoreNotList
-    */
+     * 设置 扣分或增加分值
+     * @param scoreNotList
+     */
     public void setScoreNotList(List<BigDecimal> scoreNotList){
         this.scoreNotList = scoreNotList;
     }
 
 
     /**
-    * 获取 上下班时间
-    * @return goOffTimeStrList
-    */
+     * 获取 上下班时间
+     * @return goOffTimeStrList
+     */
     public List<String> getGoOffTimeStrList(){
         return this.goOffTimeStrList;
     }
 
     /**
-    * 设置 上下班时间
-    * @param goOffTimeStrList
-    */
+     * 设置 上下班时间
+     * @param goOffTimeStrList
+     */
     public void setGoOffTimeStrList(List<String> goOffTimeStrList){
         this.goOffTimeStrList = goOffTimeStrList;
     }
 
     /**
-    * 获取 上下班时间
-    * @return goOffTimeStrNotList
-    */
+     * 获取 上下班时间
+     * @return goOffTimeStrNotList
+     */
     public List<String> getGoOffTimeStrNotList(){
         return this.goOffTimeStrNotList;
     }
 
     /**
-    * 设置 上下班时间
-    * @param goOffTimeStrNotList
-    */
+     * 设置 上下班时间
+     * @param goOffTimeStrNotList
+     */
     public void setGoOffTimeStrNotList(List<String> goOffTimeStrNotList){
         this.goOffTimeStrNotList = goOffTimeStrNotList;
     }
 
     /**
-    * 获取 开始 异常时间
-    * @return errorTimeStart
-    */
+     * 获取 开始 异常时间
+     * @return errorTimeStart
+     */
     public String getErrorTimeStart(){
         return this.errorTimeStart;
     }
 
     /**
-    * 设置 开始 异常时间
-    * @param errorTimeStart
-    */
+     * 设置 开始 异常时间
+     * @param errorTimeStart
+     */
     public void setErrorTimeStart(String errorTimeStart){
         this.errorTimeStart = errorTimeStart;
     }
 
     /**
-    * 获取 结束 异常时间
-    * @return errorTimeEnd
-    */
+     * 获取 结束 异常时间
+     * @return errorTimeEnd
+     */
     public String getErrorTimeEnd(){
         return this.errorTimeEnd;
     }
 
     /**
-    * 设置 结束 异常时间
-    * @param errorTimeEnd
-    */
+     * 设置 结束 异常时间
+     * @param errorTimeEnd
+     */
     public void setErrorTimeEnd(String errorTimeEnd){
         this.errorTimeEnd = errorTimeEnd;
     }
 
     /**
-    * 获取 开始 实际打卡时间
-    * @return actualAttendTimeStart
-    */
+     * 获取 开始 实际打卡时间
+     * @return actualAttendTimeStart
+     */
     public String getActualAttendTimeStart(){
         return this.actualAttendTimeStart;
     }
 
     /**
-    * 设置 开始 实际打卡时间
-    * @param actualAttendTimeStart
-    */
+     * 设置 开始 实际打卡时间
+     * @param actualAttendTimeStart
+     */
     public void setActualAttendTimeStart(String actualAttendTimeStart){
         this.actualAttendTimeStart = actualAttendTimeStart;
     }
 
     /**
-    * 获取 结束 实际打卡时间
-    * @return actualAttendTimeEnd
-    */
+     * 获取 结束 实际打卡时间
+     * @return actualAttendTimeEnd
+     */
     public String getActualAttendTimeEnd(){
         return this.actualAttendTimeEnd;
     }
 
     /**
-    * 设置 结束 实际打卡时间
-    * @param actualAttendTimeEnd
-    */
+     * 设置 结束 实际打卡时间
+     * @param actualAttendTimeEnd
+     */
     public void setActualAttendTimeEnd(String actualAttendTimeEnd){
         this.actualAttendTimeEnd = actualAttendTimeEnd;
     }
 
     /**
-    * 获取 异常处理结果
-    * @return errorResultList
-    */
+     * 获取 异常处理结果
+     * @return errorResultList
+     */
     public List<String> getErrorResultList(){
         return this.errorResultList;
     }
 
     /**
-    * 设置 异常处理结果
-    * @param errorResultList
-    */
+     * 设置 异常处理结果
+     * @param errorResultList
+     */
     public void setErrorResultList(List<String> errorResultList){
         this.errorResultList = errorResultList;
     }
 
     /**
-    * 获取 异常处理结果
-    * @return errorResultNotList
-    */
+     * 获取 异常处理结果
+     * @return errorResultNotList
+     */
     public List<String> getErrorResultNotList(){
         return this.errorResultNotList;
     }
 
     /**
-    * 设置 异常处理结果
-    * @param errorResultNotList
-    */
+     * 设置 异常处理结果
+     * @param errorResultNotList
+     */
     public void setErrorResultNotList(List<String> errorResultNotList){
         this.errorResultNotList = errorResultNotList;
     }
 
     /**
-    * 获取 核查人员
-    * @return checkPersonList
-    */
+     * 获取 核查人员
+     * @return checkPersonList
+     */
     public List<String> getCheckPersonList(){
         return this.checkPersonList;
     }
 
     /**
-    * 设置 核查人员
-    * @param checkPersonList
-    */
+     * 设置 核查人员
+     * @param checkPersonList
+     */
     public void setCheckPersonList(List<String> checkPersonList){
         this.checkPersonList = checkPersonList;
     }
 
     /**
-    * 获取 核查人员
-    * @return checkPersonNotList
-    */
+     * 获取 核查人员
+     * @return checkPersonNotList
+     */
     public List<String> getCheckPersonNotList(){
         return this.checkPersonNotList;
     }
 
     /**
-    * 设置 核查人员
-    * @param checkPersonNotList
-    */
+     * 设置 核查人员
+     * @param checkPersonNotList
+     */
     public void setCheckPersonNotList(List<String> checkPersonNotList){
         this.checkPersonNotList = checkPersonNotList;
     }
 
     /**
-    * 获取 开始 核查时间
-    * @return checkTimeStart
-    */
+     * 获取 开始 核查时间
+     * @return checkTimeStart
+     */
     public String getCheckTimeStart(){
         return this.checkTimeStart;
     }
 
     /**
-    * 设置 开始 核查时间
-    * @param checkTimeStart
-    */
+     * 设置 开始 核查时间
+     * @param checkTimeStart
+     */
     public void setCheckTimeStart(String checkTimeStart){
         this.checkTimeStart = checkTimeStart;
     }
 
     /**
-    * 获取 结束 核查时间
-    * @return checkTimeEnd
-    */
+     * 获取 结束 核查时间
+     * @return checkTimeEnd
+     */
     public String getCheckTimeEnd(){
         return this.checkTimeEnd;
     }
 
     /**
-    * 设置 结束 核查时间
-    * @param checkTimeEnd
-    */
+     * 设置 结束 核查时间
+     * @param checkTimeEnd
+     */
     public void setCheckTimeEnd(String checkTimeEnd){
         this.checkTimeEnd = checkTimeEnd;
     }
 
     /**
-    * 获取 核查说明
-    * @return checkDescList
-    */
+     * 获取 核查说明
+     * @return checkDescList
+     */
     public List<String> getCheckDescList(){
         return this.checkDescList;
     }
 
     /**
-    * 设置 核查说明
-    * @param checkDescList
-    */
+     * 设置 核查说明
+     * @param checkDescList
+     */
     public void setCheckDescList(List<String> checkDescList){
         this.checkDescList = checkDescList;
     }
 
     /**
-    * 获取 核查说明
-    * @return checkDescNotList
-    */
+     * 获取 核查说明
+     * @return checkDescNotList
+     */
     public List<String> getCheckDescNotList(){
         return this.checkDescNotList;
     }
 
     /**
-    * 设置 核查说明
-    * @param checkDescNotList
-    */
+     * 设置 核查说明
+     * @param checkDescNotList
+     */
     public void setCheckDescNotList(List<String> checkDescNotList){
         this.checkDescNotList = checkDescNotList;
     }
 
     /**
-    * 获取 核查结果(1.加分或扣分,2.不扣分)
-    * @return checkResultList
-    */
+     * 获取 核查结果(1.加分或扣分,2.不扣分)
+     * @return checkResultList
+     */
     public List<String> getCheckResultList(){
         return this.checkResultList;
     }
 
     /**
-    * 设置 核查结果(1.加分或扣分,2.不扣分)
-    * @param checkResultList
-    */
+     * 设置 核查结果(1.加分或扣分,2.不扣分)
+     * @param checkResultList
+     */
     public void setCheckResultList(List<String> checkResultList){
         this.checkResultList = checkResultList;
     }
 
     /**
-    * 获取 核查结果(1.加分或扣分,2.不扣分)
-    * @return checkResultNotList
-    */
+     * 获取 核查结果(1.加分或扣分,2.不扣分)
+     * @return checkResultNotList
+     */
     public List<String> getCheckResultNotList(){
         return this.checkResultNotList;
     }
 
     /**
-    * 设置 核查结果(1.加分或扣分,2.不扣分)
-    * @param checkResultNotList
-    */
+     * 设置 核查结果(1.加分或扣分,2.不扣分)
+     * @param checkResultNotList
+     */
     public void setCheckResultNotList(List<String> checkResultNotList){
         this.checkResultNotList = checkResultNotList;
     }
 
     /**
-    * 获取 开始 处理状态(1.未处理,2.已处理)
-    * @return checkStatusStart
-    */
+     * 获取 开始 处理状态(1.未处理,2.已处理)
+     * @return checkStatusStart
+     */
     public Integer getCheckStatusStart(){
         return this.checkStatusStart;
     }
 
     /**
-    * 设置 开始 处理状态(1.未处理,2.已处理)
-    * @param checkStatusStart
-    */
+     * 设置 开始 处理状态(1.未处理,2.已处理)
+     * @param checkStatusStart
+     */
     public void setCheckStatusStart(Integer checkStatusStart){
         this.checkStatusStart = checkStatusStart;
     }
 
     /**
-    * 获取 结束 处理状态(1.未处理,2.已处理)
-    * @return $checkStatusEnd
-    */
+     * 获取 结束 处理状态(1.未处理,2.已处理)
+     * @return $checkStatusEnd
+     */
     public Integer getCheckStatusEnd(){
         return this.checkStatusEnd;
     }
 
     /**
-    * 设置 结束 处理状态(1.未处理,2.已处理)
-    * @param checkStatusEnd
-    */
+     * 设置 结束 处理状态(1.未处理,2.已处理)
+     * @param checkStatusEnd
+     */
     public void setCheckStatusEnd(Integer checkStatusEnd){
         this.checkStatusEnd = checkStatusEnd;
     }
 
     /**
-    * 获取 增加 处理状态(1.未处理,2.已处理)
-    * @return checkStatusIncrement
-    */
+     * 获取 增加 处理状态(1.未处理,2.已处理)
+     * @return checkStatusIncrement
+     */
     public Integer getCheckStatusIncrement(){
         return this.checkStatusIncrement;
     }
 
     /**
-    * 设置 增加 处理状态(1.未处理,2.已处理)
-    * @param checkStatusIncrement
-    */
+     * 设置 增加 处理状态(1.未处理,2.已处理)
+     * @param checkStatusIncrement
+     */
     public void setCheckStatusIncrement(Integer checkStatusIncrement){
         this.checkStatusIncrement = checkStatusIncrement;
     }
 
     /**
-    * 获取 处理状态(1.未处理,2.已处理)
-    * @return checkStatusList
-    */
+     * 获取 处理状态(1.未处理,2.已处理)
+     * @return checkStatusList
+     */
     public List<Integer> getCheckStatusList(){
         return this.checkStatusList;
     }
 
     /**
-    * 设置 处理状态(1.未处理,2.已处理)
-    * @param checkStatusList
-    */
+     * 设置 处理状态(1.未处理,2.已处理)
+     * @param checkStatusList
+     */
     public void setCheckStatusList(List<Integer> checkStatusList){
         this.checkStatusList = checkStatusList;
     }
 
     /**
-    * 获取 处理状态(1.未处理,2.已处理)
-    * @return checkStatusNotList
-    */
+     * 获取 处理状态(1.未处理,2.已处理)
+     * @return checkStatusNotList
+     */
     public List<Integer> getCheckStatusNotList(){
         return this.checkStatusNotList;
     }
 
     /**
-    * 设置 处理状态(1.未处理,2.已处理)
-    * @param checkStatusNotList
-    */
+     * 设置 处理状态(1.未处理,2.已处理)
+     * @param checkStatusNotList
+     */
     public void setCheckStatusNotList(List<Integer> checkStatusNotList){
         this.checkStatusNotList = checkStatusNotList;
     }
 
 
     /**
-    * 获取 开始 创建用户
-    * @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;
     }
 
     /**
-    * 获取 开始 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @return subMethodStart
-    */
+     * 获取 开始 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @return subMethodStart
+     */
     public Integer getSubMethodStart(){
         return this.subMethodStart;
     }
 
     /**
-    * 设置 开始 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodStart
-    */
+     * 设置 开始 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodStart
+     */
     public void setSubMethodStart(Integer subMethodStart){
         this.subMethodStart = subMethodStart;
     }
 
     /**
-    * 获取 结束 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @return $subMethodEnd
-    */
+     * 获取 结束 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @return $subMethodEnd
+     */
     public Integer getSubMethodEnd(){
         return this.subMethodEnd;
     }
 
     /**
-    * 设置 结束 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodEnd
-    */
+     * 设置 结束 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodEnd
+     */
     public void setSubMethodEnd(Integer subMethodEnd){
         this.subMethodEnd = subMethodEnd;
     }
 
     /**
-    * 获取 增加 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @return subMethodIncrement
-    */
+     * 获取 增加 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @return subMethodIncrement
+     */
     public Integer getSubMethodIncrement(){
         return this.subMethodIncrement;
     }
 
     /**
-    * 设置 增加 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodIncrement
-    */
+     * 设置 增加 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodIncrement
+     */
     public void setSubMethodIncrement(Integer subMethodIncrement){
         this.subMethodIncrement = subMethodIncrement;
     }
 
     /**
-    * 获取 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @return subMethodList
-    */
+     * 获取 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @return subMethodList
+     */
     public List<Integer> getSubMethodList(){
         return this.subMethodList;
     }
 
     /**
-    * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodList
-    */
+     * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodList
+     */
     public void setSubMethodList(List<Integer> subMethodList){
         this.subMethodList = subMethodList;
     }
 
     /**
-    * 获取 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @return subMethodNotList
-    */
+     * 获取 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @return subMethodNotList
+     */
     public List<Integer> getSubMethodNotList(){
         return this.subMethodNotList;
     }
 
     /**
-    * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodNotList
-    */
+     * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodNotList
+     */
     public void setSubMethodNotList(List<Integer> subMethodNotList){
         this.subMethodNotList = subMethodNotList;
     }
 
 
     /**
-    * 获取 备注
-    * @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 fileNamesList
-    */
+     * 获取 附件名称，多个逗号分割
+     * @return fileNamesList
+     */
     public List<String> getFileNamesList(){
         return this.fileNamesList;
     }
 
     /**
-    * 设置 附件名称，多个逗号分割
-    * @param fileNamesList
-    */
+     * 设置 附件名称，多个逗号分割
+     * @param fileNamesList
+     */
     public void setFileNamesList(List<String> fileNamesList){
         this.fileNamesList = fileNamesList;
     }
 
     /**
-    * 获取 附件名称，多个逗号分割
-    * @return fileNamesNotList
-    */
+     * 获取 附件名称，多个逗号分割
+     * @return fileNamesNotList
+     */
     public List<String> getFileNamesNotList(){
         return this.fileNamesNotList;
     }
 
     /**
-    * 设置 附件名称，多个逗号分割
-    * @param fileNamesNotList
-    */
+     * 设置 附件名称，多个逗号分割
+     * @param fileNamesNotList
+     */
     public void setFileNamesNotList(List<String> fileNamesNotList){
         this.fileNamesNotList = fileNamesNotList;
     }
 
     /**
-    * 获取 附件下载地址，多个逗号分割
-    * @return filePathsList
-    */
+     * 获取 附件下载地址，多个逗号分割
+     * @return filePathsList
+     */
     public List<String> getFilePathsList(){
         return this.filePathsList;
     }
 
     /**
-    * 设置 附件下载地址，多个逗号分割
-    * @param filePathsList
-    */
+     * 设置 附件下载地址，多个逗号分割
+     * @param filePathsList
+     */
     public void setFilePathsList(List<String> filePathsList){
         this.filePathsList = filePathsList;
     }
 
     /**
-    * 获取 附件下载地址，多个逗号分割
-    * @return filePathsNotList
-    */
+     * 获取 附件下载地址，多个逗号分割
+     * @return filePathsNotList
+     */
     public List<String> getFilePathsNotList(){
         return this.filePathsNotList;
     }
 
     /**
-    * 设置 附件下载地址，多个逗号分割
-    * @param filePathsNotList
-    */
+     * 设置 附件下载地址，多个逗号分割
+     * @param filePathsNotList
+     */
     public void setFilePathsNotList(List<String> filePathsNotList){
         this.filePathsNotList = filePathsNotList;
     }
 
     /**
-    * 获取 开始 绩效规则分类id
-    * @return categoryIdStart
-    */
+     * 获取 开始 绩效规则分类id
+     * @return categoryIdStart
+     */
     public Long getCategoryIdStart(){
         return this.categoryIdStart;
     }
 
     /**
-    * 设置 开始 绩效规则分类id
-    * @param categoryIdStart
-    */
+     * 设置 开始 绩效规则分类id
+     * @param categoryIdStart
+     */
     public void setCategoryIdStart(Long categoryIdStart){
         this.categoryIdStart = categoryIdStart;
     }
 
     /**
-    * 获取 结束 绩效规则分类id
-    * @return $categoryIdEnd
-    */
+     * 获取 结束 绩效规则分类id
+     * @return $categoryIdEnd
+     */
     public Long getCategoryIdEnd(){
         return this.categoryIdEnd;
     }
 
     /**
-    * 设置 结束 绩效规则分类id
-    * @param categoryIdEnd
-    */
+     * 设置 结束 绩效规则分类id
+     * @param categoryIdEnd
+     */
     public void setCategoryIdEnd(Long categoryIdEnd){
         this.categoryIdEnd = categoryIdEnd;
     }
 
     /**
-    * 获取 增加 绩效规则分类id
-    * @return categoryIdIncrement
-    */
+     * 获取 增加 绩效规则分类id
+     * @return categoryIdIncrement
+     */
     public Long getCategoryIdIncrement(){
         return this.categoryIdIncrement;
     }
 
     /**
-    * 设置 增加 绩效规则分类id
-    * @param categoryIdIncrement
-    */
+     * 设置 增加 绩效规则分类id
+     * @param categoryIdIncrement
+     */
     public void setCategoryIdIncrement(Long categoryIdIncrement){
         this.categoryIdIncrement = categoryIdIncrement;
     }
 
     /**
-    * 获取 绩效规则分类id
-    * @return categoryIdList
-    */
+     * 获取 绩效规则分类id
+     * @return categoryIdList
+     */
     public List<Long> getCategoryIdList(){
         return this.categoryIdList;
     }
 
     /**
-    * 设置 绩效规则分类id
-    * @param categoryIdList
-    */
+     * 设置 绩效规则分类id
+     * @param categoryIdList
+     */
     public void setCategoryIdList(List<Long> categoryIdList){
         this.categoryIdList = categoryIdList;
     }
 
     /**
-    * 获取 绩效规则分类id
-    * @return categoryIdNotList
-    */
+     * 获取 绩效规则分类id
+     * @return categoryIdNotList
+     */
     public List<Long> getCategoryIdNotList(){
         return this.categoryIdNotList;
     }
 
     /**
-    * 设置 绩效规则分类id
-    * @param categoryIdNotList
-    */
+     * 设置 绩效规则分类id
+     * @param categoryIdNotList
+     */
     public void setCategoryIdNotList(List<Long> categoryIdNotList){
         this.categoryIdNotList = categoryIdNotList;
     }
 
 
     /**
-    * 获取 规则名称
-    * @return categoryNameList
-    */
+     * 获取 规则名称
+     * @return categoryNameList
+     */
     public List<String> getCategoryNameList(){
         return this.categoryNameList;
     }
 
     /**
-    * 设置 规则名称
-    * @param categoryNameList
-    */
+     * 设置 规则名称
+     * @param categoryNameList
+     */
     public void setCategoryNameList(List<String> categoryNameList){
         this.categoryNameList = categoryNameList;
     }
 
     /**
-    * 获取 规则名称
-    * @return categoryNameNotList
-    */
+     * 获取 规则名称
+     * @return categoryNameNotList
+     */
     public List<String> getCategoryNameNotList(){
         return this.categoryNameNotList;
     }
 
     /**
-    * 设置 规则名称
-    * @param categoryNameNotList
-    */
+     * 设置 规则名称
+     * @param categoryNameNotList
+     */
     public void setCategoryNameNotList(List<String> categoryNameNotList){
         this.categoryNameNotList = categoryNameNotList;
     }
 
     /**
-    * 设置  序号，主键，自增长
-    * @param id
-    */
+     * 获取 扣分人员
+     * @return deductPersonList
+     */
+    public List<String> getDeductPersonList(){
+        return this.deductPersonList;
+    }
+
+    /**
+     * 设置 扣分人员
+     * @param deductPersonList
+     */
+    public void setDeductPersonList(List<String> deductPersonList){
+        this.deductPersonList = deductPersonList;
+    }
+
+    /**
+     * 获取 扣分人员
+     * @return deductPersonNotList
+     */
+    public List<String> getDeductPersonNotList(){
+        return this.deductPersonNotList;
+    }
+
+    /**
+     * 设置 扣分人员
+     * @param deductPersonNotList
+     */
+    public void setDeductPersonNotList(List<String> deductPersonNotList){
+        this.deductPersonNotList = deductPersonNotList;
+    }
+
+    /**
+     * 获取 开始 扣分时间
+     * @return deductTimeStart
+     */
+    public String getDeductTimeStart(){
+        return this.deductTimeStart;
+    }
+
+    /**
+     * 设置 开始 扣分时间
+     * @param deductTimeStart
+     */
+    public void setDeductTimeStart(String deductTimeStart){
+        this.deductTimeStart = deductTimeStart;
+    }
+
+    /**
+     * 获取 结束 扣分时间
+     * @return deductTimeEnd
+     */
+    public String getDeductTimeEnd(){
+        return this.deductTimeEnd;
+    }
+
+    /**
+     * 设置 结束 扣分时间
+     * @param deductTimeEnd
+     */
+    public void setDeductTimeEnd(String deductTimeEnd){
+        this.deductTimeEnd = deductTimeEnd;
+    }
+
+    /**
+     * 设置  序号，主键，自增长
+     * @param id
+     */
     public CheckAttendRecordQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public CheckAttendRecordQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public CheckAttendRecordQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public CheckAttendRecordQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public CheckAttendRecordQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 序号，主键，自增长
-        * @param idNotList
-        */
-        public CheckAttendRecordQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public CheckAttendRecordQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  记录ID
-    * @param recordId
-    */
+     * 设置  记录ID
+     * @param recordId
+     */
     public CheckAttendRecordQuery recordId(Long recordId){
-	    setRecordId(recordId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 记录ID
-    * @param recordIdStart
-    */
+        setRecordId(recordId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 记录ID
+     * @param recordIdStart
+     */
     public CheckAttendRecordQuery recordIdStart(Long recordIdStart){
-		this.recordIdStart = recordIdStart;
-		return this;
+        this.recordIdStart = recordIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 记录ID
-    * @param recordIdEnd
-    */
+     * 设置 结束 记录ID
+     * @param recordIdEnd
+     */
     public CheckAttendRecordQuery recordIdEnd(Long recordIdEnd){
-		this.recordIdEnd = recordIdEnd;
-		return this;
+        this.recordIdEnd = recordIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 记录ID
-    * @param recordIdIncrement
-    */
+     * 设置 增加 记录ID
+     * @param recordIdIncrement
+     */
     public CheckAttendRecordQuery recordIdIncrement(Long recordIdIncrement){
-		this.recordIdIncrement = recordIdIncrement;
-		return this;
+        this.recordIdIncrement = recordIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 记录ID
-    * @param recordIdList
-    */
+     * 设置 记录ID
+     * @param recordIdList
+     */
     public CheckAttendRecordQuery recordIdList(List<Long> recordIdList){
         this.recordIdList = recordIdList;
-		return this;
-        }
-
-        /**
-        * 设置 记录ID
-        * @param recordIdNotList
-        */
-        public CheckAttendRecordQuery recordIdNotList(List<Long> recordIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 记录ID
+     * @param recordIdNotList
+     */
+    public CheckAttendRecordQuery recordIdNotList(List<Long> recordIdNotList){
         this.recordIdNotList = recordIdNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  员工ID
-    * @param staffId
-    */
+     * 设置  员工ID
+     * @param staffId
+     */
     public CheckAttendRecordQuery staffId(Long staffId){
-	    setStaffId(staffId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 员工ID
-    * @param staffIdStart
-    */
+        setStaffId(staffId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 员工ID
+     * @param staffIdStart
+     */
     public CheckAttendRecordQuery staffIdStart(Long staffIdStart){
-		this.staffIdStart = staffIdStart;
-		return this;
+        this.staffIdStart = staffIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 员工ID
-    * @param staffIdEnd
-    */
+     * 设置 结束 员工ID
+     * @param staffIdEnd
+     */
     public CheckAttendRecordQuery staffIdEnd(Long staffIdEnd){
-		this.staffIdEnd = staffIdEnd;
-		return this;
+        this.staffIdEnd = staffIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 员工ID
-    * @param staffIdIncrement
-    */
+     * 设置 增加 员工ID
+     * @param staffIdIncrement
+     */
     public CheckAttendRecordQuery staffIdIncrement(Long staffIdIncrement){
-		this.staffIdIncrement = staffIdIncrement;
-		return this;
+        this.staffIdIncrement = staffIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 员工ID
-    * @param staffIdList
-    */
+     * 设置 员工ID
+     * @param staffIdList
+     */
     public CheckAttendRecordQuery staffIdList(List<Long> staffIdList){
         this.staffIdList = staffIdList;
-		return this;
-        }
-
-        /**
-        * 设置 员工ID
-        * @param staffIdNotList
-        */
-        public CheckAttendRecordQuery staffIdNotList(List<Long> staffIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 员工ID
+     * @param staffIdNotList
+     */
+    public CheckAttendRecordQuery staffIdNotList(List<Long> staffIdNotList){
         this.staffIdNotList = staffIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 员工姓名
-    * @param staffName
-    */
+    /**
+     * 设置 员工姓名
+     * @param staffName
+     */
     public CheckAttendRecordQuery staffName(String staffName){
         setStaffName(staffName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 员工姓名
-    * @param staffNameList
-    */
+     * 设置 员工姓名
+     * @param staffNameList
+     */
     public CheckAttendRecordQuery staffNameList(List<String> staffNameList){
         this.staffNameList = staffNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 工号
-    * @param workNum
-    */
+    /**
+     * 设置 工号
+     * @param workNum
+     */
     public CheckAttendRecordQuery workNum(String workNum){
         setWorkNum(workNum);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 工号
-    * @param workNumList
-    */
+     * 设置 工号
+     * @param workNumList
+     */
     public CheckAttendRecordQuery workNumList(List<String> workNumList){
         this.workNumList = workNumList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  所属部门
-    * @param deptId
-    */
+     * 设置  所属部门
+     * @param deptId
+     */
     public CheckAttendRecordQuery deptId(Long deptId){
-	    setDeptId(deptId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 所属部门
-    * @param deptIdStart
-    */
+        setDeptId(deptId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 所属部门
+     * @param deptIdStart
+     */
     public CheckAttendRecordQuery deptIdStart(Long deptIdStart){
-		this.deptIdStart = deptIdStart;
-		return this;
+        this.deptIdStart = deptIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 所属部门
-    * @param deptIdEnd
-    */
+     * 设置 结束 所属部门
+     * @param deptIdEnd
+     */
     public CheckAttendRecordQuery deptIdEnd(Long deptIdEnd){
-		this.deptIdEnd = deptIdEnd;
-		return this;
+        this.deptIdEnd = deptIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 所属部门
-    * @param deptIdIncrement
-    */
+     * 设置 增加 所属部门
+     * @param deptIdIncrement
+     */
     public CheckAttendRecordQuery deptIdIncrement(Long deptIdIncrement){
-		this.deptIdIncrement = deptIdIncrement;
-		return this;
+        this.deptIdIncrement = deptIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 所属部门
-    * @param deptIdList
-    */
+     * 设置 所属部门
+     * @param deptIdList
+     */
     public CheckAttendRecordQuery deptIdList(List<Long> deptIdList){
         this.deptIdList = deptIdList;
-		return this;
-        }
-
-        /**
-        * 设置 所属部门
-        * @param deptIdNotList
-        */
-        public CheckAttendRecordQuery deptIdNotList(List<Long> deptIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 所属部门
+     * @param deptIdNotList
+     */
+    public CheckAttendRecordQuery deptIdNotList(List<Long> deptIdNotList){
         this.deptIdNotList = deptIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 所属部门名称
-    * @param deptName
-    */
+    /**
+     * 设置 所属部门名称
+     * @param deptName
+     */
     public CheckAttendRecordQuery deptName(String deptName){
         setDeptName(deptName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 所属部门名称
-    * @param deptNameList
-    */
+     * 设置 所属部门名称
+     * @param deptNameList
+     */
     public CheckAttendRecordQuery deptNameList(List<String> deptNameList){
         this.deptNameList = deptNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  所属考勤组ID
-    * @param attendanceGroupId
-    */
+     * 设置  所属考勤组ID
+     * @param attendanceGroupId
+     */
     public CheckAttendRecordQuery attendanceGroupId(Long attendanceGroupId){
-	    setAttendanceGroupId(attendanceGroupId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 所属考勤组ID
-    * @param attendanceGroupIdStart
-    */
+        setAttendanceGroupId(attendanceGroupId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 所属考勤组ID
+     * @param attendanceGroupIdStart
+     */
     public CheckAttendRecordQuery attendanceGroupIdStart(Long attendanceGroupIdStart){
-		this.attendanceGroupIdStart = attendanceGroupIdStart;
-		return this;
+        this.attendanceGroupIdStart = attendanceGroupIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 所属考勤组ID
-    * @param attendanceGroupIdEnd
-    */
+     * 设置 结束 所属考勤组ID
+     * @param attendanceGroupIdEnd
+     */
     public CheckAttendRecordQuery attendanceGroupIdEnd(Long attendanceGroupIdEnd){
-		this.attendanceGroupIdEnd = attendanceGroupIdEnd;
-		return this;
+        this.attendanceGroupIdEnd = attendanceGroupIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 所属考勤组ID
-    * @param attendanceGroupIdIncrement
-    */
+     * 设置 增加 所属考勤组ID
+     * @param attendanceGroupIdIncrement
+     */
     public CheckAttendRecordQuery attendanceGroupIdIncrement(Long attendanceGroupIdIncrement){
-		this.attendanceGroupIdIncrement = attendanceGroupIdIncrement;
-		return this;
+        this.attendanceGroupIdIncrement = attendanceGroupIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 所属考勤组ID
-    * @param attendanceGroupIdList
-    */
+     * 设置 所属考勤组ID
+     * @param attendanceGroupIdList
+     */
     public CheckAttendRecordQuery attendanceGroupIdList(List<Long> attendanceGroupIdList){
         this.attendanceGroupIdList = attendanceGroupIdList;
-		return this;
-        }
-
-        /**
-        * 设置 所属考勤组ID
-        * @param attendanceGroupIdNotList
-        */
-        public CheckAttendRecordQuery attendanceGroupIdNotList(List<Long> attendanceGroupIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 所属考勤组ID
+     * @param attendanceGroupIdNotList
+     */
+    public CheckAttendRecordQuery attendanceGroupIdNotList(List<Long> attendanceGroupIdNotList){
         this.attendanceGroupIdNotList = attendanceGroupIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 所属考勤组名称
-    * @param attendanceGroupName
-    */
+    /**
+     * 设置 所属考勤组名称
+     * @param attendanceGroupName
+     */
     public CheckAttendRecordQuery attendanceGroupName(String attendanceGroupName){
         setAttendanceGroupName(attendanceGroupName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 所属考勤组名称
-    * @param attendanceGroupNameList
-    */
+     * 设置 所属考勤组名称
+     * @param attendanceGroupNameList
+     */
     public CheckAttendRecordQuery attendanceGroupNameList(List<String> attendanceGroupNameList){
         this.attendanceGroupNameList = attendanceGroupNameList;
-		return this;
+        return this;
     }
 
 
     /**
-    * 设置  绩效规则id
-    * @param ruleId
-    */
+     * 设置  绩效规则id
+     * @param ruleId
+     */
     public CheckAttendRecordQuery ruleId(Long ruleId){
-	    setRuleId(ruleId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 绩效规则id
-    * @param ruleIdStart
-    */
+        setRuleId(ruleId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 绩效规则id
+     * @param ruleIdStart
+     */
     public CheckAttendRecordQuery ruleIdStart(Long ruleIdStart){
-		this.ruleIdStart = ruleIdStart;
-		return this;
+        this.ruleIdStart = ruleIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 绩效规则id
-    * @param ruleIdEnd
-    */
+     * 设置 结束 绩效规则id
+     * @param ruleIdEnd
+     */
     public CheckAttendRecordQuery ruleIdEnd(Long ruleIdEnd){
-		this.ruleIdEnd = ruleIdEnd;
-		return this;
+        this.ruleIdEnd = ruleIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 绩效规则id
-    * @param ruleIdIncrement
-    */
+     * 设置 增加 绩效规则id
+     * @param ruleIdIncrement
+     */
     public CheckAttendRecordQuery ruleIdIncrement(Long ruleIdIncrement){
-		this.ruleIdIncrement = ruleIdIncrement;
-		return this;
+        this.ruleIdIncrement = ruleIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 绩效规则id
-    * @param ruleIdList
-    */
+     * 设置 绩效规则id
+     * @param ruleIdList
+     */
     public CheckAttendRecordQuery ruleIdList(List<Long> ruleIdList){
         this.ruleIdList = ruleIdList;
-		return this;
-        }
-
-        /**
-        * 设置 绩效规则id
-        * @param ruleIdNotList
-        */
-        public CheckAttendRecordQuery ruleIdNotList(List<Long> ruleIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 绩效规则id
+     * @param ruleIdNotList
+     */
+    public CheckAttendRecordQuery ruleIdNotList(List<Long> ruleIdNotList){
         this.ruleIdNotList = ruleIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 规则名称
-    * @param ruleName
-    */
+    /**
+     * 设置 规则名称
+     * @param ruleName
+     */
     public CheckAttendRecordQuery ruleName(String ruleName){
         setRuleName(ruleName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 规则名称
-    * @param ruleNameList
-    */
+     * 设置 规则名称
+     * @param ruleNameList
+     */
     public CheckAttendRecordQuery ruleNameList(List<String> ruleNameList){
         this.ruleNameList = ruleNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  增减类型(1.增加,2.扣除)
-    * @param subAddType
-    */
+     * 设置  增减类型(1.增加,2.扣除)
+     * @param subAddType
+     */
     public CheckAttendRecordQuery subAddType(Integer subAddType){
-	    setSubAddType(subAddType);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 增减类型(1.增加,2.扣除)
-    * @param subAddTypeStart
-    */
+        setSubAddType(subAddType);
+        return this;
+    }
+
+    /**
+     * 设置 开始 增减类型(1.增加,2.扣除)
+     * @param subAddTypeStart
+     */
     public CheckAttendRecordQuery subAddTypeStart(Integer subAddTypeStart){
-		this.subAddTypeStart = subAddTypeStart;
-		return this;
+        this.subAddTypeStart = subAddTypeStart;
+        return this;
     }
 
     /**
-    * 设置 结束 增减类型(1.增加,2.扣除)
-    * @param subAddTypeEnd
-    */
+     * 设置 结束 增减类型(1.增加,2.扣除)
+     * @param subAddTypeEnd
+     */
     public CheckAttendRecordQuery subAddTypeEnd(Integer subAddTypeEnd){
-		this.subAddTypeEnd = subAddTypeEnd;
-		return this;
+        this.subAddTypeEnd = subAddTypeEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 增减类型(1.增加,2.扣除)
-    * @param subAddTypeIncrement
-    */
+     * 设置 增加 增减类型(1.增加,2.扣除)
+     * @param subAddTypeIncrement
+     */
     public CheckAttendRecordQuery subAddTypeIncrement(Integer subAddTypeIncrement){
-		this.subAddTypeIncrement = subAddTypeIncrement;
-		return this;
+        this.subAddTypeIncrement = subAddTypeIncrement;
+        return this;
     }
 
     /**
-    * 设置 增减类型(1.增加,2.扣除)
-    * @param subAddTypeList
-    */
+     * 设置 增减类型(1.增加,2.扣除)
+     * @param subAddTypeList
+     */
     public CheckAttendRecordQuery subAddTypeList(List<Integer> subAddTypeList){
         this.subAddTypeList = subAddTypeList;
-		return this;
-        }
-
-        /**
-        * 设置 增减类型(1.增加,2.扣除)
-        * @param subAddTypeNotList
-        */
-        public CheckAttendRecordQuery subAddTypeNotList(List<Integer> subAddTypeNotList){
+        return this;
+    }
+
+    /**
+     * 设置 增减类型(1.增加,2.扣除)
+     * @param subAddTypeNotList
+     */
+    public CheckAttendRecordQuery subAddTypeNotList(List<Integer> subAddTypeNotList){
         this.subAddTypeNotList = subAddTypeNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  扣分或增加分值
-    * @param score
-    */
+     * 设置  扣分或增加分值
+     * @param score
+     */
     public CheckAttendRecordQuery score(BigDecimal score){
-	    setScore(score);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 扣分或增加分值
-    * @param scoreStart
-    */
+        setScore(score);
+        return this;
+    }
+
+    /**
+     * 设置 开始 扣分或增加分值
+     * @param scoreStart
+     */
     public CheckAttendRecordQuery scoreStart(BigDecimal scoreStart){
-		this.scoreStart = scoreStart;
-		return this;
+        this.scoreStart = scoreStart;
+        return this;
     }
 
     /**
-    * 设置 结束 扣分或增加分值
-    * @param scoreEnd
-    */
+     * 设置 结束 扣分或增加分值
+     * @param scoreEnd
+     */
     public CheckAttendRecordQuery scoreEnd(BigDecimal scoreEnd){
-		this.scoreEnd = scoreEnd;
-		return this;
+        this.scoreEnd = scoreEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 扣分或增加分值
-    * @param scoreIncrement
-    */
+     * 设置 增加 扣分或增加分值
+     * @param scoreIncrement
+     */
     public CheckAttendRecordQuery scoreIncrement(BigDecimal scoreIncrement){
-		this.scoreIncrement = scoreIncrement;
-		return this;
+        this.scoreIncrement = scoreIncrement;
+        return this;
     }
 
     /**
-    * 设置 扣分或增加分值
-    * @param scoreList
-    */
+     * 设置 扣分或增加分值
+     * @param scoreList
+     */
     public CheckAttendRecordQuery scoreList(List<BigDecimal> scoreList){
         this.scoreList = scoreList;
-		return this;
-        }
-
-        /**
-        * 设置 扣分或增加分值
-        * @param scoreNotList
-        */
-        public CheckAttendRecordQuery scoreNotList(List<BigDecimal> scoreNotList){
+        return this;
+    }
+
+    /**
+     * 设置 扣分或增加分值
+     * @param scoreNotList
+     */
+    public CheckAttendRecordQuery scoreNotList(List<BigDecimal> scoreNotList){
         this.scoreNotList = scoreNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 上下班时间
-    * @param goOffTimeStr
-    */
+    /**
+     * 设置 上下班时间
+     * @param goOffTimeStr
+     */
     public CheckAttendRecordQuery goOffTimeStr(String goOffTimeStr){
         setGoOffTimeStr(goOffTimeStr);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 上下班时间
-    * @param goOffTimeStrList
-    */
+     * 设置 上下班时间
+     * @param goOffTimeStrList
+     */
     public CheckAttendRecordQuery goOffTimeStrList(List<String> goOffTimeStrList){
         this.goOffTimeStrList = goOffTimeStrList;
-		return this;
+        return this;
     }
 
 
 
 
-	/**
-    * 设置 异常处理结果
-    * @param errorResult
-    */
+    /**
+     * 设置 异常处理结果
+     * @param errorResult
+     */
     public CheckAttendRecordQuery errorResult(String errorResult){
         setErrorResult(errorResult);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 异常处理结果
-    * @param errorResultList
-    */
+     * 设置 异常处理结果
+     * @param errorResultList
+     */
     public CheckAttendRecordQuery errorResultList(List<String> errorResultList){
         this.errorResultList = errorResultList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 核查人员
-    * @param checkPerson
-    */
+    /**
+     * 设置 核查人员
+     * @param checkPerson
+     */
     public CheckAttendRecordQuery checkPerson(String checkPerson){
         setCheckPerson(checkPerson);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 核查人员
-    * @param checkPersonList
-    */
+     * 设置 核查人员
+     * @param checkPersonList
+     */
     public CheckAttendRecordQuery checkPersonList(List<String> checkPersonList){
         this.checkPersonList = checkPersonList;
-		return this;
+        return this;
     }
 
 
 
-	/**
-    * 设置 核查说明
-    * @param checkDesc
-    */
+    /**
+     * 设置 核查说明
+     * @param checkDesc
+     */
     public CheckAttendRecordQuery checkDesc(String checkDesc){
         setCheckDesc(checkDesc);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 核查说明
-    * @param checkDescList
-    */
+     * 设置 核查说明
+     * @param checkDescList
+     */
     public CheckAttendRecordQuery checkDescList(List<String> checkDescList){
         this.checkDescList = checkDescList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 核查结果(1.加分或扣分,2.不扣分)
-    * @param checkResult
-    */
+    /**
+     * 设置 核查结果(1.加分或扣分,2.不扣分)
+     * @param checkResult
+     */
     public CheckAttendRecordQuery checkResult(String checkResult){
         setCheckResult(checkResult);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 核查结果(1.加分或扣分,2.不扣分)
-    * @param checkResultList
-    */
+     * 设置 核查结果(1.加分或扣分,2.不扣分)
+     * @param checkResultList
+     */
     public CheckAttendRecordQuery checkResultList(List<String> checkResultList){
         this.checkResultList = checkResultList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  处理状态(1.未处理,2.已处理)
-    * @param checkStatus
-    */
+     * 设置  处理状态(1.未处理,2.已处理)
+     * @param checkStatus
+     */
     public CheckAttendRecordQuery checkStatus(Integer checkStatus){
-	    setCheckStatus(checkStatus);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 处理状态(1.未处理,2.已处理)
-    * @param checkStatusStart
-    */
+        setCheckStatus(checkStatus);
+        return this;
+    }
+
+    /**
+     * 设置 开始 处理状态(1.未处理,2.已处理)
+     * @param checkStatusStart
+     */
     public CheckAttendRecordQuery checkStatusStart(Integer checkStatusStart){
-		this.checkStatusStart = checkStatusStart;
-		return this;
+        this.checkStatusStart = checkStatusStart;
+        return this;
     }
 
     /**
-    * 设置 结束 处理状态(1.未处理,2.已处理)
-    * @param checkStatusEnd
-    */
+     * 设置 结束 处理状态(1.未处理,2.已处理)
+     * @param checkStatusEnd
+     */
     public CheckAttendRecordQuery checkStatusEnd(Integer checkStatusEnd){
-		this.checkStatusEnd = checkStatusEnd;
-		return this;
+        this.checkStatusEnd = checkStatusEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 处理状态(1.未处理,2.已处理)
-    * @param checkStatusIncrement
-    */
+     * 设置 增加 处理状态(1.未处理,2.已处理)
+     * @param checkStatusIncrement
+     */
     public CheckAttendRecordQuery checkStatusIncrement(Integer checkStatusIncrement){
-		this.checkStatusIncrement = checkStatusIncrement;
-		return this;
+        this.checkStatusIncrement = checkStatusIncrement;
+        return this;
     }
 
     /**
-    * 设置 处理状态(1.未处理,2.已处理)
-    * @param checkStatusList
-    */
+     * 设置 处理状态(1.未处理,2.已处理)
+     * @param checkStatusList
+     */
     public CheckAttendRecordQuery checkStatusList(List<Integer> checkStatusList){
         this.checkStatusList = checkStatusList;
-		return this;
-        }
-
-        /**
-        * 设置 处理状态(1.未处理,2.已处理)
-        * @param checkStatusNotList
-        */
-        public CheckAttendRecordQuery checkStatusNotList(List<Integer> checkStatusNotList){
+        return this;
+    }
+
+    /**
+     * 设置 处理状态(1.未处理,2.已处理)
+     * @param checkStatusNotList
+     */
+    public CheckAttendRecordQuery checkStatusNotList(List<Integer> checkStatusNotList){
         this.checkStatusNotList = checkStatusNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public CheckAttendRecordQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public CheckAttendRecordQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public CheckAttendRecordQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public CheckAttendRecordQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public CheckAttendRecordQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建用户
-        * @param createUserIdNotList
-        */
-        public CheckAttendRecordQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public CheckAttendRecordQuery createUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 设置  更新用户
-    * @param updateUserId
-    */
+     * 设置  更新用户
+     * @param updateUserId
+     */
     public CheckAttendRecordQuery updateUserId(Long updateUserId){
-	    setUpdateUserId(updateUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public CheckAttendRecordQuery updateUserIdStart(Long updateUserIdStart){
-		this.updateUserIdStart = updateUserIdStart;
-		return this;
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public CheckAttendRecordQuery updateUserIdEnd(Long updateUserIdEnd){
-		this.updateUserIdEnd = updateUserIdEnd;
-		return this;
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public CheckAttendRecordQuery updateUserIdIncrement(Long updateUserIdIncrement){
-		this.updateUserIdIncrement = updateUserIdIncrement;
-		return this;
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public CheckAttendRecordQuery updateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 更新用户
-        * @param updateUserIdNotList
-        */
-        public CheckAttendRecordQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public CheckAttendRecordQuery updateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 设置  扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethod
-    */
+     * 设置  扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethod
+     */
     public CheckAttendRecordQuery subMethod(Integer subMethod){
-	    setSubMethod(subMethod);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodStart
-    */
+        setSubMethod(subMethod);
+        return this;
+    }
+
+    /**
+     * 设置 开始 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodStart
+     */
     public CheckAttendRecordQuery subMethodStart(Integer subMethodStart){
-		this.subMethodStart = subMethodStart;
-		return this;
+        this.subMethodStart = subMethodStart;
+        return this;
     }
 
     /**
-    * 设置 结束 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodEnd
-    */
+     * 设置 结束 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodEnd
+     */
     public CheckAttendRecordQuery subMethodEnd(Integer subMethodEnd){
-		this.subMethodEnd = subMethodEnd;
-		return this;
+        this.subMethodEnd = subMethodEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodIncrement
-    */
+     * 设置 增加 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodIncrement
+     */
     public CheckAttendRecordQuery subMethodIncrement(Integer subMethodIncrement){
-		this.subMethodIncrement = subMethodIncrement;
-		return this;
+        this.subMethodIncrement = subMethodIncrement;
+        return this;
     }
 
     /**
-    * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-    * @param subMethodList
-    */
+     * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodList
+     */
     public CheckAttendRecordQuery subMethodList(List<Integer> subMethodList){
         this.subMethodList = subMethodList;
-		return this;
-        }
-
-        /**
-        * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
-        * @param subMethodNotList
-        */
-        public CheckAttendRecordQuery subMethodNotList(List<Integer> subMethodNotList){
+        return this;
+    }
+
+    /**
+     * 设置 扣分方式(1.系统自动,2.人工添加,3.大厅巡查)
+     * @param subMethodNotList
+     */
+    public CheckAttendRecordQuery subMethodNotList(List<Integer> subMethodNotList){
         this.subMethodNotList = subMethodNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 备注
-    * @param remark
-    */
+    /**
+     * 设置 备注
+     * @param remark
+     */
     public CheckAttendRecordQuery remark(String remark){
         setRemark(remark);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 备注
-    * @param remarkList
-    */
+     * 设置 备注
+     * @param remarkList
+     */
     public CheckAttendRecordQuery remarkList(List<String> remarkList){
         this.remarkList = remarkList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 附件名称，多个逗号分割
-    * @param fileNames
-    */
+    /**
+     * 设置 附件名称，多个逗号分割
+     * @param fileNames
+     */
     public CheckAttendRecordQuery fileNames(String fileNames){
         setFileNames(fileNames);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 附件名称，多个逗号分割
-    * @param fileNamesList
-    */
+     * 设置 附件名称，多个逗号分割
+     * @param fileNamesList
+     */
     public CheckAttendRecordQuery fileNamesList(List<String> fileNamesList){
         this.fileNamesList = fileNamesList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 附件下载地址，多个逗号分割
-    * @param filePaths
-    */
+    /**
+     * 设置 附件下载地址，多个逗号分割
+     * @param filePaths
+     */
     public CheckAttendRecordQuery filePaths(String filePaths){
         setFilePaths(filePaths);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 附件下载地址，多个逗号分割
-    * @param filePathsList
-    */
+     * 设置 附件下载地址，多个逗号分割
+     * @param filePathsList
+     */
     public CheckAttendRecordQuery filePathsList(List<String> filePathsList){
         this.filePathsList = filePathsList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  绩效规则分类id
-    * @param categoryId
-    */
+     * 设置  绩效规则分类id
+     * @param categoryId
+     */
     public CheckAttendRecordQuery categoryId(Long categoryId){
-	    setCategoryId(categoryId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 绩效规则分类id
-    * @param categoryIdStart
-    */
+        setCategoryId(categoryId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 绩效规则分类id
+     * @param categoryIdStart
+     */
     public CheckAttendRecordQuery categoryIdStart(Long categoryIdStart){
-		this.categoryIdStart = categoryIdStart;
-		return this;
+        this.categoryIdStart = categoryIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 绩效规则分类id
-    * @param categoryIdEnd
-    */
+     * 设置 结束 绩效规则分类id
+     * @param categoryIdEnd
+     */
     public CheckAttendRecordQuery categoryIdEnd(Long categoryIdEnd){
-		this.categoryIdEnd = categoryIdEnd;
-		return this;
+        this.categoryIdEnd = categoryIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 绩效规则分类id
-    * @param categoryIdIncrement
-    */
+     * 设置 增加 绩效规则分类id
+     * @param categoryIdIncrement
+     */
     public CheckAttendRecordQuery categoryIdIncrement(Long categoryIdIncrement){
-		this.categoryIdIncrement = categoryIdIncrement;
-		return this;
+        this.categoryIdIncrement = categoryIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 绩效规则分类id
-    * @param categoryIdList
-    */
+     * 设置 绩效规则分类id
+     * @param categoryIdList
+     */
     public CheckAttendRecordQuery categoryIdList(List<Long> categoryIdList){
         this.categoryIdList = categoryIdList;
-		return this;
-        }
-
-        /**
-        * 设置 绩效规则分类id
-        * @param categoryIdNotList
-        */
-        public CheckAttendRecordQuery categoryIdNotList(List<Long> categoryIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 绩效规则分类id
+     * @param categoryIdNotList
+     */
+    public CheckAttendRecordQuery categoryIdNotList(List<Long> categoryIdNotList){
         this.categoryIdNotList = categoryIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 规则名称
-    * @param categoryName
-    */
+    /**
+     * 设置 规则名称
+     * @param categoryName
+     */
     public CheckAttendRecordQuery categoryName(String categoryName){
         setCategoryName(categoryName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 规则名称
-    * @param categoryNameList
-    */
+     * 设置 规则名称
+     * @param categoryNameList
+     */
     public CheckAttendRecordQuery categoryNameList(List<String> categoryNameList){
         this.categoryNameList = categoryNameList;
-		return this;
+        return this;
     }
 
+
+    /**
+     * 设置 扣分人员
+     * @param deductPerson
+     */
+    public CheckAttendRecordQuery deductPerson(String deductPerson){
+        setDeductPerson(deductPerson);
+        return this;
+    }
+
+    /**
+     * 设置 扣分人员
+     * @param deductPersonList
+     */
+    public CheckAttendRecordQuery deductPersonList(List<String> deductPersonList){
+        this.deductPersonList = deductPersonList;
+        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<CheckAttendRecordQuery> 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<CheckAttendRecordQuery> 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<CheckAttendRecordQuery> 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<CheckAttendRecordQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

db/add.sql

@@ -651,3 +651,9 @@ ALTER TABLE mortals_xhx_perform_attend_appeal ADD COLUMN `deductPerson` varchar(
 ALTER TABLE mortals_xhx_perform_attend_appeal ADD COLUMN  `deductTime` datetime      COMMENT '扣分时间' AFTER deductPerson;
 
 ALTER TABLE mortals_xhx_user ADD COLUMN  `dingUserId` varchar(64) DEFAULT ''     COMMENT '钉钉userId' AFTER customerId;
+
+
+
+ALTER TABLE mortals_xhx_check_attend_record ADD COLUMN `deductPerson` varchar(128) DEFAULT ''     COMMENT '扣分人员' AFTER subMethod;
+ALTER TABLE mortals_xhx_check_attend_record ADD COLUMN  `deductTime` datetime      COMMENT '扣分时间' AFTER deductPerson;
+