Skip to content

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

添加请假跨天判读

parent d1d8f0e2
Hide whitespace changes
Inline Side-by-side
Showing with 5145 additions and 103 deletions
attendance-performance-manager/src/main/java/com/mortals/xhx/base/login/web/LoginController.java
View file @ 7e4da754
......@@ -3,10 +3,12 @@ package com.mortals.xhx.base.login.web;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.ap.CookieService;
import com.mortals.framework.ap.GlobalSysInfo;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.service.IAuthTokenService;
import com.mortals.framework.service.ICacheService;
import com.mortals.framework.service.IUser;
......@@ -19,12 +21,11 @@ import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.service.MenuService;
import com.mortals.xhx.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.user.model.UserEntity;
import com.mortals.xhx.base.system.user.model.UserQuery;
import com.mortals.xhx.base.system.user.service.UserService;
import com.mortals.xhx.base.system.valid.service.ValidCodeService;
import com.mortals.xhx.common.code.GoWorkResultEnum;
import com.mortals.xhx.common.code.OffWorkResultEnum;
import com.mortals.xhx.common.code.ProcessStatusEnum;
import com.mortals.xhx.common.code.SourceType;
import com.mortals.xhx.busiz.h5.req.DingTalkReq;
import com.mortals.xhx.common.code.*;
import com.mortals.xhx.common.key.RedisKey;
import com.mortals.xhx.common.pdu.HomeStatInfo;
import com.mortals.xhx.common.pdu.user.UserPdu;
......@@ -54,8 +55,7 @@ import java.util.Date;
import java.util.List;
import java.util.Set;
import static com.mortals.xhx.common.key.ErrorCode.ERROR_TOKEN_EXPIRED;
import static com.mortals.xhx.common.key.ErrorCode.ERROR_TOKEN_EXPIRED_CONTENT;
import static com.mortals.xhx.common.key.ErrorCode.*;
@RestController
@Slf4j
......@@ -70,43 +70,25 @@ public class LoginController extends BaseCRUDJsonBodyMappingController<UserServi
private ResourceService resourceService;
@Autowired
private MenuService menuService;
// @Autowired
// private ITokenService tokenService;
@Autowired
private ICacheService cacheService;
@Autowired
private IAuthTokenService authTokenService;
@Autowired
private AttendanceRecordService recordService;
@Autowired
private AttendanceRecordHikService recordHikService;
@Autowired
private AttendanceVacationRecordService vacationRecordService;
@Autowired
private AttendanceLeaveRecordService leaveRecordService;
@Autowired
private StaffService staffService;
@Autowired
private DeptService deptService;
@Autowired
private IUserFeign userFeign;
private static final String AES_KEY = "0000000671595991";
private static final String AES_IV = "tdrdadq59tbss5n7";
private static final String AES_IV = "tdrdadq59tbss5n7";
@RequestMapping("login")
public String login(@RequestBody LoginForm loginForm) throws Exception {
String loginName = loginForm.getLoginName();
String password = loginForm.getPassword();
if(loginForm.getType()!=null && loginForm.getType()==2){
loginName = LoginAESUtil.decrypt(loginName,AES_KEY,AES_IV,LoginAESUtil.AES_CBC);
password = LoginAESUtil.decrypt(password,AES_KEY,AES_IV,LoginAESUtil.AES_CBC);
if (loginForm.getType() != null && loginForm.getType() == 2) {
loginName = LoginAESUtil.decrypt(loginName, AES_KEY, AES_IV, LoginAESUtil.AES_CBC);
password = LoginAESUtil.decrypt(password, AES_KEY, AES_IV, LoginAESUtil.AES_CBC);
}
UserPdu userPdu = new UserPdu();
userPdu.setLoginName(loginName);
......@@ -174,6 +156,56 @@ public class LoginController extends BaseCRUDJsonBodyMappingController<UserServi
}*/
}
@RequestMapping("locallogin")
@UnAuth
public String authlogin(@RequestBody LoginForm loginForm) throws Exception {
JSONObject ret = new JSONObject();
JSONObject data = new JSONObject();
String loginName = loginForm.getLoginName();
String password = loginForm.getPassword();
String ip = super.getRequestIP(request);
if (StringUtils.isEmpty(loginName) || StringUtils.isEmpty(password)) {
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, "未获取到用户信息，请重新登录");
return ret.toJSONString();
}
UserEntity userEntity = null;
try {
loginForm.validate();
userEntity = userService.doLogin(loginName, password, ip);
userEntity.setLastLoginAddress(ip);
recordSysLog(request, userEntity, "用户登录系统成功!");
data.put("id", userEntity.getId());
data.put("userType", userEntity.getUserType());
userEntity.setLoginTime(System.currentTimeMillis());
userEntity.setToken(IdUtil.fastSimpleUUID());
userEntity.setExpireTime(DateUtils.addCurrDate(1).getTime());
String token = authTokenService.createToken(userEntity);
data.put("token", token);
ret.put(KEY_RESULT_DATA, data);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_MSG, "用户登录系统成功!");
recordSysLog(request, userEntity, "钉钉用户登录系统成功!");
return ret.toJSONString();
} catch (AppException e) {
log.error("login error ", e);
ret.put(KEY_RESULT_CODE, e.getCode());
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
} catch (Exception e) {
log.error("系统异常 error ", e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
@RequestMapping("logout")
public void logout(HttpServletRequest request, HttpServletResponse response) throws Exception {
recordSysLog(request, "退出登录");
......@@ -238,7 +270,7 @@ public class LoginController extends BaseCRUDJsonBodyMappingController<UserServi
cacheService.hset(RedisKey.KEY_ATTENC_TOTOAL_CACHE, DateUtil.format(new Date(), "yyyy-MM"), totalCache);
}*//*
*//* Long totalCache = cacheService.hget(RedisKey.KEY_ATTENC_TOTOAL_CACHE, DateUtil.yesterday().toDateStr(), Long.class);
*//* Long totalCache = cacheService.hget(RedisKey.KEY_ATTENC_TOTOAL_CACHE, DateUtil.yesterday().toDateStr(), Long.class);
if (ObjectUtils.isEmpty(totalCache)) {
totalCache = recordHikService.find(hikQuery).parallelStream().map(item -> item.getStaffId()).distinct().count();
cacheService.hset(RedisKey.KEY_ATTENC_TOTOAL_CACHE, DateUtil.yesterday().toDateStr(), totalCache);
......
attendance-performance-manager/src/main/java/com/mortals/xhx/busiz/h5/web/ApiWebPerformController.java
View file @ 7e4da754
......@@ -55,6 +55,8 @@ public class ApiWebPerformController extends AbstractBaseController<PerformReq>
private PerformStaffConfService performStaffConfService;
@Autowired
private PerformStaffConfDetailService performStaffConfDetailService;
@Autowired
private PerformErrorRecordService errorRecordService;
/**
......@@ -167,14 +169,26 @@ public class ApiWebPerformController extends AbstractBaseController<PerformReq>
@UnAuth
public Rest<Void> effectSave(@RequestBody EffectSaveReq req) {
log.info("web Api req==>{}", JSON.toJSONString(req));
// log.info("web Api req==>{}", JSON.toJSONString(req));
String busiDesc = "外部效能新增";
Rest rest = Rest.ok(busiDesc + "成功！");
try {
if (ObjectUtils.isEmpty(req.getPhone())) throw new AppException("手机号码不能为空！");
if (ObjectUtils.isEmpty(req.getRuleCode())) throw new AppException("绩效规则编码不能为空！");
boolean bool = effect(req);
if (bool) throw new AppException(busiDesc + "失败！");
//如果手机号码为空 将当前记录保存到临时表中，人工手动处理
if (ObjectUtils.isEmpty(req.getPhone())) {
//保存异常数据
effectErrorSave(req);
rest = Rest.fail("手机号码为空！");
} else {
if (ObjectUtils.isEmpty(req.getRuleCode())) {
throw new AppException("绩效规则编码不能为空！");
} else {
effect(req);
}
}
//if (ObjectUtils.isEmpty(req.getPhone())) throw new AppException("手机号码不能为空！");
//if (ObjectUtils.isEmpty(req.getRuleCode())) throw new AppException("绩效规则编码不能为空！");
// boolean bool = effect(req);
// if (bool) throw new AppException(busiDesc + "失败！");
} catch (Exception e) {
log.error(busiDesc, e);
return Rest.fail(e.getMessage());
......@@ -290,7 +304,7 @@ public class ApiWebPerformController extends AbstractBaseController<PerformReq>
//查询当前规则
List<PerformStaffConfDetailEntity> staffConfDetailEntities = performStaffConfDetailService.find(new PerformStaffConfDetailQuery().staffConfId(performStaffConfEntity.getId()));
for (PerformStaffConfDetailEntity staffConfDetailEntity : staffConfDetailEntities) {
if (staffConfDetailEntity.getRuleId() == rule.getId()){
if (staffConfDetailEntity.getRuleId() == rule.getId()) {
rulePass = true;
break;
}
......@@ -298,7 +312,7 @@ public class ApiWebPerformController extends AbstractBaseController<PerformReq>
}
if (rulePass) break;
}
if(rulePass) throw new AppException("当前用户与绩效规则未配置自动核查，请在后台配置后再新增！");
if (rulePass) throw new AppException("当前用户与绩效规则未配置自动核查，请在后台配置后再新增！");
}
private boolean complain(ComplainSaveReq req) throws AppException {
......@@ -399,6 +413,35 @@ public class ApiWebPerformController extends AbstractBaseController<PerformReq>
return save.newEntity();
}
private void effectErrorSave(EffectSaveReq req) throws AppException {
//效能异常保存
//StaffEntity staffEntity = getStaff(req.getPhone());
PerformRulesEntity rule = getRule(req.getRuleCode());
//checkStaffAutoConf(staffEntity, rule);
PerformErrorRecordEntity recordEntity = new PerformErrorRecordEntity();
recordEntity.initAttrValue();
recordEntity.setSubMethod(SubMethodEnum.系统自动.getValue());
BeanUtils.copyProperties(req, recordEntity);
recordEntity.setSubAddType(rule.getSubAddType());
recordEntity.setScore(rule.getScore());
recordEntity.setRuleId(rule.getId());
recordEntity.setRuleName(rule.getName());
recordEntity.setCategoryId(rule.getCategoryId());
recordEntity.setCategoryName(rule.getCategoryName());
recordEntity.setDeductPerson("系统管理员");
recordEntity.setDeductTime(new Date());
recordEntity.setWindowNum(req.getWindowNum());
recordEntity.setCreateUserId(1L);
recordEntity.setCreateTime(new Date());
PerformRulesCategoryEntity categoryEntity = categoryService.get(rule.getCategoryId());
recordEntity.setCategoryName(categoryEntity == null ? "" : categoryEntity.getName());
errorRecordService.save(recordEntity);
}
private boolean other(OtherSaveReq req) throws AppException {
//其它保存
StaffEntity staffEntity = getStaff(req.getPhone());
......
attendance-performance-manager/src/main/java/com/mortals/xhx/busiz/h5/web/FeedbackApiController.java
View file @ 7e4da754
......@@ -49,8 +49,6 @@ public class FeedbackApiController extends AbstractBaseController<FeedbackReq> {
@Autowired
private FeedbackAnswerService answerService;
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "processStatus", FeedProcessStatusEnum.getEnumMap());
}
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/work/FixWorkOtherAttendance.java
View file @ 7e4da754
package com.mortals.xhx.module.attendance.service.work;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.mortals.framework.model.Context;
......@@ -104,16 +106,40 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
}
}
//判断当天是否请假
//判断当天是否请假 请假分为多个区间段与请假类型。
AttendanceLeaveRecordQuery leaveRecordQuery = new AttendanceLeaveRecordQuery();
leaveRecordQuery.setLeavePersonId(commonData.getStaffId());
leaveRecordQuery.setAuditResult(AuditStatusEnum.通过.getValue());
leaveRecordQuery.setStartTimeStart(commonData.getDateStr());
leaveRecordQuery.setStartTimeEnd(commonData.getDateStr());
leaveRecordQuery.setAuditResultList(Arrays.asList(1, 4));
// leaveRecordQuery.setAuditResult(AuditStatusEnum.通过.getValue());
// leaveRecordQuery.setEndTimeEnd(commonData.getDateStr());
// leaveRecordQuery.setStartTimeStart(commonData.getDateStr());
// leaveRecordQuery.setStartTimeEnd(commonData.getDateStr());
boolean isLeave = false;
List<AttendanceLeaveRecordEntity> leaveRecordEntities = attendanceLeaveRecordService.find(leaveRecordQuery);
List<AttendanceLeaveRecordEntity> leaveRecords = null;
if (!ObjectUtils.isEmpty(leaveRecordEntities)) {
//判断当日日期中 是否有请假记录
leaveRecords = leaveRecordEntities.stream().filter(f -> {
String curDateStr = commonData.getDateStr();
DateTime dateTime = DateUtil.parseDate(curDateStr);
DateTime start = DateUtil.parseDate(DateUtil.formatDate(f.getStartTime()));
DateTime end = DateUtil.parseDate(DateUtil.formatDate(f.getEndTime()));
boolean in = DateUtil.isIn(dateTime, start, end);
return in;
}).collect(Collectors.toList());
if (!ObjectUtils.isEmpty(leaveRecords)) {
//当前日期范围内 存在请假。判断请假计入考勤。目前只有事件计入
isLeave = true;
}
}
AttendanceLeaveRecordEntity attendanceLeaveRecordEntity = attendanceLeaveRecordService.selectOne(leaveRecordQuery);
/*AttendanceLeaveRecordEntity attendanceLeaveRecordEntity = attendanceLeaveRecordService.selectOne(leaveRecordQuery);
if (!ObjectUtils.isEmpty(attendanceLeaveRecordEntity)) {
// log.info("当天员工请假，不做考勤处理！staffId:{},name:{}", commonData.getStaffId(), attendanceLeaveRecordEntity.getLeavePerson());
// log.info("当天员工请假，不做考勤处理！staffId:{},name:{}", commonData.getStaffId(), attendanceLeaveRecordEntity.getLeavePerson());
//删除当日考勤记录与详细
AttendanceRecordQuery attendanceRecordQuery = new AttendanceRecordQuery();
attendanceRecordQuery.setStaffId(commonData.getStaffId());
......@@ -134,11 +160,6 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
//删除当天该员工的异常记录与打卡考勤记录
deleteErrorRecord(commonData.getDateStr(), commonData.getStaffId(), commonData.getContext());
return;
}
/* if (weekClassId == -1L) {
//跳过本次循环
return;
}*/
//特殊日期考勤配置
......@@ -215,10 +236,8 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
recordDetailEntity.setGoWorkResult(GoWorkResultEnum.缺卡.getValue());
//recordDetailEntity.setGoWorkDate(DateUtil.parse(commonData.getDateStr() + " " + DateUtil.formatTime(classDetailEntity.getGoWorkDate())));
recordDetailEntity.setOffWorkResult(GoWorkResultEnum.缺卡.getValue());
//recordDetailEntity.setOffWorkDate(DateUtil.parse(commonData.getDateStr() + " " + DateUtil.formatTime(classDetailEntity.getOffWorkDate())));
recordDetailEntity.setOrderNum(orderNum);
commonData.getDetailEntityList().add(recordDetailEntity);
}
......@@ -245,23 +264,10 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
boolean goInTime = DateUtil.isIn(curDateTime, goWorkDateBefore, goWorkDateAfter);
//判断考勤时间是否在下班打卡区间内
boolean offInTime = DateUtil.isIn(curDateTime, offWorkDateBefore, offWorkDateAfter);
//判断在上班与下班区间访问内 在上班的最后时间 与下班的开始时间
boolean goOffBetweenTime = DateUtil.isIn(curDateTime, goWorkDateAfter, offWorkDateBefore);
boolean updateCheck = false;
// if(goOffBetweenTime){
// //如果考勤时间在上班与下班区间内 则将考勤状态改为迟到 如果已经存在 在改为早退
// // commonData.setAttendanceStatus(AttendanceStatusEnum.LATE.getCode());
//
// }
// if (goInTime == false && offInTime == false) {
// log.info("考勤时间不在上班区间与下班区间中，不做处理！attendDate:{}", DateUtil.formatDateTime(commonData.getAttendanceDate()));
// // continue;
// }
if (goInTime) {
//如果是上班打卡区间范围,判断是否迟到
for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
......@@ -271,22 +277,6 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
updateCheck = true;
}
}
// boolean inTime = DateUtil.isIn(curDateTime, goWorkDateBefore, goWorkDateAfter);
// if (inTime) {
// for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
// if (attendanceRecordDetailEntity.getShiftsId() == classDetail.getId()) {
// attendanceRecordDetailEntity.setGoWorkResult(GoWorkResultEnum.正常.getValue());
// attendanceRecordDetailEntity.setGoWorkDate(recordHikEntity.getAttendanceDate());
// }
// }
// } else {
// for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
// if (attendanceRecordDetailEntity.getShiftsId() == classDetail.getId()) {
// attendanceRecordDetailEntity.setGoWorkResult(GoWorkResultEnum.迟到.getValue());
// attendanceRecordDetailEntity.setGoWorkDate(recordHikEntity.getAttendanceDate());
// }
// }
// }
} else {
if (goOffBetweenTime) {
for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
......@@ -305,23 +295,6 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
attendanceRecordDetailEntity.setOffWorkDate(recordHikEntity.getAttendanceDate());
}
}
/* boolean inTime = DateUtil.isIn(curDateTime, offWorkDateBefore, offWorkDateAfter);
if (inTime) {
for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
if (attendanceRecordDetailEntity.getShiftsId() == classDetail.getId()) {
attendanceRecordDetailEntity.setOffWorkResult(OffWorkResultEnum.正常.getValue());
attendanceRecordDetailEntity.setOffWorkDate(recordHikEntity.getAttendanceDate());
}
}
} else {
for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
if (attendanceRecordDetailEntity.getShiftsId() == classDetail.getId()) {
attendanceRecordDetailEntity.setOffWorkResult(OffWorkResultEnum.早退.getValue());
attendanceRecordDetailEntity.setOffWorkDate(recordHikEntity.getAttendanceDate());
}
}
}*/
} else {
if (goOffBetweenTime) {
for (AttendanceRecordDetailEntity attendanceRecordDetailEntity : commonData.getDetailEntityList()) {
......@@ -331,7 +304,6 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
}
}
}
}
}
}
......@@ -361,11 +333,75 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
commonData.getAttendanceRecordEntity().setClassId(attendanceClassDetailEntity == null ? 0L : attendanceClassDetailEntity.getClassId());
commonData.getAttendanceRecordEntity().setClassName(attendanceClassDetailEntity == null ? "" : attendanceClassDetailEntity.getClassName());
}
//todo 判断当日当前人员是否存在请假，有请假则重新计算考勤
if (isLeave) {
//查看请假时间段，是否为跨天记录
AttendanceLeaveRecordEntity leaveRecord = leaveRecords.get(0);
long between = DateUtil.between(leaveRecord.getStartTime(), leaveRecord.getEndTime(), DateUnit.DAY);
if (between > 0) {
//跨天 判断当前日期是否在全天，没在 就
//判断日期是否在最后一天 不是的话 为全天
long betweened = DateUtil.between(DateUtil.parseDate(commonData.getDateStr()), leaveRecord.getEndTime(), DateUnit.DAY);
if (betweened > 0) {
//全天
calLeaveDate(commonData, DateUtil.parseDate(commonData.getDateStr()+" 00:00:00"),DateUtil.parseDate(commonData.getDateStr()+" 23:59:59"));
} else if (betweened == 0) {
//最后一天
calLeaveDate(commonData, DateUtil.parseDate(commonData.getDateStr()+" 00:00:00"),leaveRecord.getEndTime());
}
} else if (between == 0) {
calLeaveDate(commonData, leaveRecord.getStartTime(),leaveRecord.getEndTime());
} else {
//错误
}
}
//生成异常记录
genErrorAttendRecord(commonData.getContext(), commonData.getDateStr(), commonData.getAttendanceRecordEntity(), commonData.getDetailEntityList());
}
/**
* 计算异常
* @param commonData
* @param startLeaveTime
* @param endLeaveTime
*/
private void calLeaveDate(CommonData commonData, Date startLeaveTime, Date endLeaveTime) {
//当日 请假开始时间
/* Date startLeaveTime = leaveRecord.getStartTime();
Date endLeaveTime = leaveRecord.getEndTime();*/
//修改当日记录集
List<AttendanceRecordDetailEntity> detailEntityList = commonData.getDetailEntityList();
for (AttendanceRecordDetailEntity detail : detailEntityList) {
Integer goWorkResult = detail.getGoWorkResult();
Integer offWorkResult = detail.getOffWorkResult();
Date goWorkDate = detail.getGoWorkDate();
Date offWorkDate = detail.getOffWorkDate();
if (GoWorkResultEnum.正常.getValue() != goWorkResult) {
//判断 异常记录是否在请假时间段内
// DateUtil.between()
boolean in = DateUtil.isIn(goWorkDate, startLeaveTime, endLeaveTime);
if (in) {
detail.setGoWorkResult(GoWorkResultEnum.正常.getValue());
}
}
if (GoWorkResultEnum.正常.getValue() != offWorkResult) {
//判断 异常记录是否在请假时间段内
// DateUtil.between()
boolean in = DateUtil.isIn(offWorkDate, startLeaveTime, endLeaveTime);
if (in) {
detail.setOffWorkResult(GoWorkResultEnum.正常.getValue());
}
}
}
}
private void deleteErrorRecord(String dateStr, Long staffId, Context context) {
//删除当前员工当日未处理的异常后，重新添加
AttendanceRecordErrorQuery errorQuery = new AttendanceRecordErrorQuery();
......@@ -517,4 +553,28 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
return bool;
}
public static void main(String[] args) {
String date = "2021-05-01 09:00:00";
String endDate = "2021-05-02 18:00:00";
long between = DateUtil.between(DateUtil.parseDate(date), DateUtil.parseDate(endDate), DateUnit.DAY);
System.out.println(between);
String curDateStr = "2024-01-05";
DateTime dateTime = DateUtil.parseDate(curDateStr);
DateTime start = DateUtil.parseDate("2024-01-05 18:45:15");
DateTime end = DateUtil.parseDate("2024-01-05 08:45:15");
boolean in = DateUtil.isIn(dateTime, start, end);
System.out.println(in);
}
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/dao/PerformErrorRecordDao.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
import java.util.List;
/**
* 绩效异常记录信息Dao
* 绩效异常记录信息 DAO接口
*
* @author zxfei
* @date 2024-01-24
*/
public interface PerformErrorRecordDao extends ICRUDDao<PerformErrorRecordEntity,Long>{
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/dao/ibatis/PerformErrorRecordDaoImpl.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.perform.dao.PerformErrorRecordDao;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 绩效异常记录信息DaoImpl DAO接口
*
* @author zxfei
* @date 2024-01-24
*/
@Repository("performErrorRecordDao")
public class PerformErrorRecordDaoImpl extends BaseCRUDDaoMybatis<PerformErrorRecordEntity,Long> implements PerformErrorRecordDao {
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/PerformErrorRecordEntity.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.model;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;
import cn.hutool.core.date.DateUtil;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.perform.model.vo.PerformErrorRecordVo;
import lombok.Data;
/**
* 绩效异常记录信息实体对象
*
* @author zxfei
* @date 2024-01-24
*/
@Data
public class PerformErrorRecordEntity extends PerformErrorRecordVo {
private static final long serialVersionUID = 1L;
/**
* 员工ID
*/
private Long staffId;
/**
* 员工姓名
*/
@Excel(name = "员工姓名")
private String staffName;
/**
* 工号
*/
@Excel(name = "工号")
private String workNum;
/**
* 窗口编号
*/
@Excel(name = "窗口编号")
private String windowNum;
/**
* 所属部门
*/
private Long deptId;
/**
* 所属部门名称
*/
@Excel(name = "所属部门名称")
private String deptName;
/**
* 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
*/
@Excel(name = "违规类型", readConverterExp = "1=脱岗,2=离岗,3=玩手机,4=睡觉")
private Integer irregularType;
/**
* 发生时间
*/
@Excel(name = "发生时间", width = 30, dateFormat = "yyyy-MM-dd")
private Date happenTime;
/**
* 持续时间，秒
*/
private Integer duration;
/**
* 报警时间
*/
private Date alarmTime;
/**
* 图片凭证地址
*/
private String snapPath;
/**
* 绩效规则分类id
*/
private Long categoryId;
/**
* 规则名称
*/
private String categoryName;
/**
* 绩效规则id
*/
private Long ruleId;
/**
* 规则名称
*/
private String ruleName;
/**
* 扣分方式(1.系统自动,2.人工添加)
*/
private Integer subMethod;
/**
* 扣分人员
*/
@Excel(name = "扣分人员")
private String deductPerson;
/**
* 扣分时间
*/
private Date deductTime;
/**
* 增减类型(1.增加,2.扣除)
*/
private Integer subAddType;
/**
* 扣分或增加分值
*/
private BigDecimal score;
/**
* 处理状态(1.未处理,2.已处理)
*/
@Excel(name = "处理状态", readConverterExp = "1=未处理,2=已处理")
private Integer processStatus;
/**
* 附件名称，多个逗号分割
*/
@Excel(name = "附件名称，多个逗号分割")
private String fileNames;
/**
* 附件下载地址，多个逗号分割
*/
@Excel(name = "附件下载地址，多个逗号分割")
private String filePaths;
/**
* 备注
*/
private String remark;
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof PerformErrorRecordEntity) {
PerformErrorRecordEntity tmp = (PerformErrorRecordEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.staffId = null;
this.staffName = "";
this.workNum = "";
this.windowNum = "";
this.deptId = null;
this.deptName = "";
this.irregularType = 0;
this.happenTime = new Date();
this.duration = 0;
this.alarmTime = new Date();
this.snapPath = "";
this.categoryId = null;
this.categoryName = "";
this.ruleId = null;
this.ruleName = "";
this.subMethod = 2;
this.deductPerson = "";
this.deductTime = new Date();
this.subAddType = 1;
this.score = BigDecimal.ZERO;
this.processStatus = 1;
this.fileNames = "";
this.filePaths = "";
this.remark = "";
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/PerformErrorRecordQuery.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.model;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
/**
* 绩效异常记录信息查询对象
*
* @author zxfei
* @date 2024-01-24
*/
public class PerformErrorRecordQuery extends PerformErrorRecordEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 序号，主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 员工ID */
private Long staffIdStart;
/** 结束 员工ID */
private Long staffIdEnd;
/** 增加 员工ID */
private Long staffIdIncrement;
/** 员工ID列表 */
private List <Long> staffIdList;
/** 员工ID排除列表 */
private List <Long> staffIdNotList;
/** 员工姓名 */
private List<String> staffNameList;
/** 员工姓名排除列表 */
private List <String> staffNameNotList;
/** 工号 */
private List<String> workNumList;
/** 工号排除列表 */
private List <String> workNumNotList;
/** 窗口编号 */
private List<String> windowNumList;
/** 窗口编号排除列表 */
private List <String> windowNumNotList;
/** 开始 所属部门 */
private Long deptIdStart;
/** 结束 所属部门 */
private Long deptIdEnd;
/** 增加 所属部门 */
private Long deptIdIncrement;
/** 所属部门列表 */
private List <Long> deptIdList;
/** 所属部门排除列表 */
private List <Long> deptIdNotList;
/** 所属部门名称 */
private List<String> deptNameList;
/** 所属部门名称排除列表 */
private List <String> deptNameNotList;
/** 开始 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉) */
private Integer irregularTypeStart;
/** 结束 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉) */
private Integer irregularTypeEnd;
/** 增加 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉) */
private Integer irregularTypeIncrement;
/** 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)列表 */
private List <Integer> irregularTypeList;
/** 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)排除列表 */
private List <Integer> irregularTypeNotList;
/** 开始 发生时间 */
private String happenTimeStart;
/** 结束 发生时间 */
private String happenTimeEnd;
/** 开始 持续时间，秒 */
private Integer durationStart;
/** 结束 持续时间，秒 */
private Integer durationEnd;
/** 增加 持续时间，秒 */
private Integer durationIncrement;
/** 持续时间，秒列表 */
private List <Integer> durationList;
/** 持续时间，秒排除列表 */
private List <Integer> durationNotList;
/** 开始 报警时间 */
private String alarmTimeStart;
/** 结束 报警时间 */
private String alarmTimeEnd;
/** 图片凭证地址 */
private List<String> snapPathList;
/** 图片凭证地址排除列表 */
private List <String> snapPathNotList;
/** 开始 绩效规则分类id */
private Long categoryIdStart;
/** 结束 绩效规则分类id */
private Long categoryIdEnd;
/** 增加 绩效规则分类id */
private Long categoryIdIncrement;
/** 绩效规则分类id列表 */
private List <Long> categoryIdList;
/** 绩效规则分类id排除列表 */
private List <Long> categoryIdNotList;
/** 规则名称 */
private List<String> categoryNameList;
/** 规则名称排除列表 */
private List <String> categoryNameNotList;
/** 开始 绩效规则id */
private Long ruleIdStart;
/** 结束 绩效规则id */
private Long ruleIdEnd;
/** 增加 绩效规则id */
private Long ruleIdIncrement;
/** 绩效规则id列表 */
private List <Long> ruleIdList;
/** 绩效规则id排除列表 */
private List <Long> ruleIdNotList;
/** 规则名称 */
private List<String> ruleNameList;
/** 规则名称排除列表 */
private List <String> ruleNameNotList;
/** 开始 扣分方式(1.系统自动,2.人工添加) */
private Integer subMethodStart;
/** 结束 扣分方式(1.系统自动,2.人工添加) */
private Integer subMethodEnd;
/** 增加 扣分方式(1.系统自动,2.人工添加) */
private Integer subMethodIncrement;
/** 扣分方式(1.系统自动,2.人工添加)列表 */
private List <Integer> subMethodList;
/** 扣分方式(1.系统自动,2.人工添加)排除列表 */
private List <Integer> subMethodNotList;
/** 扣分人员 */
private List<String> deductPersonList;
/** 扣分人员排除列表 */
private List <String> deductPersonNotList;
/** 开始 扣分时间 */
private String deductTimeStart;
/** 结束 扣分时间 */
private String deductTimeEnd;
/** 开始 增减类型(1.增加,2.扣除) */
private Integer subAddTypeStart;
/** 结束 增减类型(1.增加,2.扣除) */
private Integer subAddTypeEnd;
/** 增加 增减类型(1.增加,2.扣除) */
private Integer subAddTypeIncrement;
/** 增减类型(1.增加,2.扣除)列表 */
private List <Integer> subAddTypeList;
/** 增减类型(1.增加,2.扣除)排除列表 */
private List <Integer> subAddTypeNotList;
/** 开始 扣分或增加分值 */
private BigDecimal scoreStart;
/** 结束 扣分或增加分值 */
private BigDecimal scoreEnd;
/** 增加 扣分或增加分值 */
private BigDecimal scoreIncrement;
/** 扣分或增加分值列表 */
private List <BigDecimal> scoreList;
/** 扣分或增加分值排除列表 */
private List <BigDecimal> scoreNotList;
/** 开始 处理状态(1.未处理,2.已处理) */
private Integer processStatusStart;
/** 结束 处理状态(1.未处理,2.已处理) */
private Integer processStatusEnd;
/** 增加 处理状态(1.未处理,2.已处理) */
private Integer processStatusIncrement;
/** 处理状态(1.未处理,2.已处理)列表 */
private List <Integer> processStatusList;
/** 处理状态(1.未处理,2.已处理)排除列表 */
private List <Integer> processStatusNotList;
/** 附件名称，多个逗号分割 */
private List<String> fileNamesList;
/** 附件名称，多个逗号分割排除列表 */
private List <String> fileNamesNotList;
/** 附件下载地址，多个逗号分割 */
private List<String> filePathsList;
/** 附件下载地址，多个逗号分割排除列表 */
private List <String> filePathsNotList;
/** 备注 */
private List<String> remarkList;
/** 备注排除列表 */
private List <String> remarkNotList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<PerformErrorRecordQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<PerformErrorRecordQuery> andConditionList;
public PerformErrorRecordQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 员工ID
* @return staffIdStart
*/
public Long getStaffIdStart(){
return this.staffIdStart;
}
/**
* 设置 开始 员工ID
* @param staffIdStart
*/
public void setStaffIdStart(Long staffIdStart){
this.staffIdStart = staffIdStart;
}
/**
* 获取 结束 员工ID
* @return $staffIdEnd
*/
public Long getStaffIdEnd(){
return this.staffIdEnd;
}
/**
* 设置 结束 员工ID
* @param staffIdEnd
*/
public void setStaffIdEnd(Long staffIdEnd){
this.staffIdEnd = staffIdEnd;
}
/**
* 获取 增加 员工ID
* @return staffIdIncrement
*/
public Long getStaffIdIncrement(){
return this.staffIdIncrement;
}
/**
* 设置 增加 员工ID
* @param staffIdIncrement
*/
public void setStaffIdIncrement(Long staffIdIncrement){
this.staffIdIncrement = staffIdIncrement;
}
/**
* 获取 员工ID
* @return staffIdList
*/
public List<Long> getStaffIdList(){
return this.staffIdList;
}
/**
* 设置 员工ID
* @param staffIdList
*/
public void setStaffIdList(List<Long> staffIdList){
this.staffIdList = staffIdList;
}
/**
* 获取 员工ID
* @return staffIdNotList
*/
public List<Long> getStaffIdNotList(){
return this.staffIdNotList;
}
/**
* 设置 员工ID
* @param staffIdNotList
*/
public void setStaffIdNotList(List<Long> staffIdNotList){
this.staffIdNotList = staffIdNotList;
}
/**
* 获取 员工姓名
* @return staffNameList
*/
public List<String> getStaffNameList(){
return this.staffNameList;
}
/**
* 设置 员工姓名
* @param staffNameList
*/
public void setStaffNameList(List<String> staffNameList){
this.staffNameList = staffNameList;
}
/**
* 获取 员工姓名
* @return staffNameNotList
*/
public List<String> getStaffNameNotList(){
return this.staffNameNotList;
}
/**
* 设置 员工姓名
* @param staffNameNotList
*/
public void setStaffNameNotList(List<String> staffNameNotList){
this.staffNameNotList = staffNameNotList;
}
/**
* 获取 工号
* @return workNumList
*/
public List<String> getWorkNumList(){
return this.workNumList;
}
/**
* 设置 工号
* @param workNumList
*/
public void setWorkNumList(List<String> workNumList){
this.workNumList = workNumList;
}
/**
* 获取 工号
* @return workNumNotList
*/
public List<String> getWorkNumNotList(){
return this.workNumNotList;
}
/**
* 设置 工号
* @param workNumNotList
*/
public void setWorkNumNotList(List<String> workNumNotList){
this.workNumNotList = workNumNotList;
}
/**
* 获取 窗口编号
* @return windowNumList
*/
public List<String> getWindowNumList(){
return this.windowNumList;
}
/**
* 设置 窗口编号
* @param windowNumList
*/
public void setWindowNumList(List<String> windowNumList){
this.windowNumList = windowNumList;
}
/**
* 获取 窗口编号
* @return windowNumNotList
*/
public List<String> getWindowNumNotList(){
return this.windowNumNotList;
}
/**
* 设置 窗口编号
* @param windowNumNotList
*/
public void setWindowNumNotList(List<String> windowNumNotList){
this.windowNumNotList = windowNumNotList;
}
/**
* 获取 开始 所属部门
* @return deptIdStart
*/
public Long getDeptIdStart(){
return this.deptIdStart;
}
/**
* 设置 开始 所属部门
* @param deptIdStart
*/
public void setDeptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
}
/**
* 获取 结束 所属部门
* @return $deptIdEnd
*/
public Long getDeptIdEnd(){
return this.deptIdEnd;
}
/**
* 设置 结束 所属部门
* @param deptIdEnd
*/
public void setDeptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
}
/**
* 获取 增加 所属部门
* @return deptIdIncrement
*/
public Long getDeptIdIncrement(){
return this.deptIdIncrement;
}
/**
* 设置 增加 所属部门
* @param deptIdIncrement
*/
public void setDeptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
}
/**
* 获取 所属部门
* @return deptIdList
*/
public List<Long> getDeptIdList(){
return this.deptIdList;
}
/**
* 设置 所属部门
* @param deptIdList
*/
public void setDeptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
}
/**
* 获取 所属部门
* @return deptIdNotList
*/
public List<Long> getDeptIdNotList(){
return this.deptIdNotList;
}
/**
* 设置 所属部门
* @param deptIdNotList
*/
public void setDeptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
}
/**
* 获取 所属部门名称
* @return deptNameList
*/
public List<String> getDeptNameList(){
return this.deptNameList;
}
/**
* 设置 所属部门名称
* @param deptNameList
*/
public void setDeptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
}
/**
* 获取 所属部门名称
* @return deptNameNotList
*/
public List<String> getDeptNameNotList(){
return this.deptNameNotList;
}
/**
* 设置 所属部门名称
* @param deptNameNotList
*/
public void setDeptNameNotList(List<String> deptNameNotList){
this.deptNameNotList = deptNameNotList;
}
/**
* 获取 开始 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @return irregularTypeStart
*/
public Integer getIrregularTypeStart(){
return this.irregularTypeStart;
}
/**
* 设置 开始 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeStart
*/
public void setIrregularTypeStart(Integer irregularTypeStart){
this.irregularTypeStart = irregularTypeStart;
}
/**
* 获取 结束 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @return $irregularTypeEnd
*/
public Integer getIrregularTypeEnd(){
return this.irregularTypeEnd;
}
/**
* 设置 结束 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeEnd
*/
public void setIrregularTypeEnd(Integer irregularTypeEnd){
this.irregularTypeEnd = irregularTypeEnd;
}
/**
* 获取 增加 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @return irregularTypeIncrement
*/
public Integer getIrregularTypeIncrement(){
return this.irregularTypeIncrement;
}
/**
* 设置 增加 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeIncrement
*/
public void setIrregularTypeIncrement(Integer irregularTypeIncrement){
this.irregularTypeIncrement = irregularTypeIncrement;
}
/**
* 获取 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @return irregularTypeList
*/
public List<Integer> getIrregularTypeList(){
return this.irregularTypeList;
}
/**
* 设置 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeList
*/
public void setIrregularTypeList(List<Integer> irregularTypeList){
this.irregularTypeList = irregularTypeList;
}
/**
* 获取 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @return irregularTypeNotList
*/
public List<Integer> getIrregularTypeNotList(){
return this.irregularTypeNotList;
}
/**
* 设置 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeNotList
*/
public void setIrregularTypeNotList(List<Integer> irregularTypeNotList){
this.irregularTypeNotList = irregularTypeNotList;
}
/**
* 获取 开始 发生时间
* @return happenTimeStart
*/
public String getHappenTimeStart(){
return this.happenTimeStart;
}
/**
* 设置 开始 发生时间
* @param happenTimeStart
*/
public void setHappenTimeStart(String happenTimeStart){
this.happenTimeStart = happenTimeStart;
}
/**
* 获取 结束 发生时间
* @return happenTimeEnd
*/
public String getHappenTimeEnd(){
return this.happenTimeEnd;
}
/**
* 设置 结束 发生时间
* @param happenTimeEnd
*/
public void setHappenTimeEnd(String happenTimeEnd){
this.happenTimeEnd = happenTimeEnd;
}
/**
* 获取 开始 持续时间，秒
* @return durationStart
*/
public Integer getDurationStart(){
return this.durationStart;
}
/**
* 设置 开始 持续时间，秒
* @param durationStart
*/
public void setDurationStart(Integer durationStart){
this.durationStart = durationStart;
}
/**
* 获取 结束 持续时间，秒
* @return $durationEnd
*/
public Integer getDurationEnd(){
return this.durationEnd;
}
/**
* 设置 结束 持续时间，秒
* @param durationEnd
*/
public void setDurationEnd(Integer durationEnd){
this.durationEnd = durationEnd;
}
/**
* 获取 增加 持续时间，秒
* @return durationIncrement
*/
public Integer getDurationIncrement(){
return this.durationIncrement;
}
/**
* 设置 增加 持续时间，秒
* @param durationIncrement
*/
public void setDurationIncrement(Integer durationIncrement){
this.durationIncrement = durationIncrement;
}
/**
* 获取 持续时间，秒
* @return durationList
*/
public List<Integer> getDurationList(){
return this.durationList;
}
/**
* 设置 持续时间，秒
* @param durationList
*/
public void setDurationList(List<Integer> durationList){
this.durationList = durationList;
}
/**
* 获取 持续时间，秒
* @return durationNotList
*/
public List<Integer> getDurationNotList(){
return this.durationNotList;
}
/**
* 设置 持续时间，秒
* @param durationNotList
*/
public void setDurationNotList(List<Integer> durationNotList){
this.durationNotList = durationNotList;
}
/**
* 获取 开始 报警时间
* @return alarmTimeStart
*/
public String getAlarmTimeStart(){
return this.alarmTimeStart;
}
/**
* 设置 开始 报警时间
* @param alarmTimeStart
*/
public void setAlarmTimeStart(String alarmTimeStart){
this.alarmTimeStart = alarmTimeStart;
}
/**
* 获取 结束 报警时间
* @return alarmTimeEnd
*/
public String getAlarmTimeEnd(){
return this.alarmTimeEnd;
}
/**
* 设置 结束 报警时间
* @param alarmTimeEnd
*/
public void setAlarmTimeEnd(String alarmTimeEnd){
this.alarmTimeEnd = alarmTimeEnd;
}
/**
* 获取 图片凭证地址
* @return snapPathList
*/
public List<String> getSnapPathList(){
return this.snapPathList;
}
/**
* 设置 图片凭证地址
* @param snapPathList
*/
public void setSnapPathList(List<String> snapPathList){
this.snapPathList = snapPathList;
}
/**
* 获取 图片凭证地址
* @return snapPathNotList
*/
public List<String> getSnapPathNotList(){
return this.snapPathNotList;
}
/**
* 设置 图片凭证地址
* @param snapPathNotList
*/
public void setSnapPathNotList(List<String> snapPathNotList){
this.snapPathNotList = snapPathNotList;
}
/**
* 获取 开始 绩效规则分类id
* @return categoryIdStart
*/
public Long getCategoryIdStart(){
return this.categoryIdStart;
}
/**
* 设置 开始 绩效规则分类id
* @param categoryIdStart
*/
public void setCategoryIdStart(Long categoryIdStart){
this.categoryIdStart = categoryIdStart;
}
/**
* 获取 结束 绩效规则分类id
* @return $categoryIdEnd
*/
public Long getCategoryIdEnd(){
return this.categoryIdEnd;
}
/**
* 设置 结束 绩效规则分类id
* @param categoryIdEnd
*/
public void setCategoryIdEnd(Long categoryIdEnd){
this.categoryIdEnd = categoryIdEnd;
}
/**
* 获取 增加 绩效规则分类id
* @return categoryIdIncrement
*/
public Long getCategoryIdIncrement(){
return this.categoryIdIncrement;
}
/**
* 设置 增加 绩效规则分类id
* @param categoryIdIncrement
*/
public void setCategoryIdIncrement(Long categoryIdIncrement){
this.categoryIdIncrement = categoryIdIncrement;
}
/**
* 获取 绩效规则分类id
* @return categoryIdList
*/
public List<Long> getCategoryIdList(){
return this.categoryIdList;
}
/**
* 设置 绩效规则分类id
* @param categoryIdList
*/
public void setCategoryIdList(List<Long> categoryIdList){
this.categoryIdList = categoryIdList;
}
/**
* 获取 绩效规则分类id
* @return categoryIdNotList
*/
public List<Long> getCategoryIdNotList(){
return this.categoryIdNotList;
}
/**
* 设置 绩效规则分类id
* @param categoryIdNotList
*/
public void setCategoryIdNotList(List<Long> categoryIdNotList){
this.categoryIdNotList = categoryIdNotList;
}
/**
* 获取 规则名称
* @return categoryNameList
*/
public List<String> getCategoryNameList(){
return this.categoryNameList;
}
/**
* 设置 规则名称
* @param categoryNameList
*/
public void setCategoryNameList(List<String> categoryNameList){
this.categoryNameList = categoryNameList;
}
/**
* 获取 规则名称
* @return categoryNameNotList
*/
public List<String> getCategoryNameNotList(){
return this.categoryNameNotList;
}
/**
* 设置 规则名称
* @param categoryNameNotList
*/
public void setCategoryNameNotList(List<String> categoryNameNotList){
this.categoryNameNotList = categoryNameNotList;
}
/**
* 获取 开始 绩效规则id
* @return ruleIdStart
*/
public Long getRuleIdStart(){
return this.ruleIdStart;
}
/**
* 设置 开始 绩效规则id
* @param ruleIdStart
*/
public void setRuleIdStart(Long ruleIdStart){
this.ruleIdStart = ruleIdStart;
}
/**
* 获取 结束 绩效规则id
* @return $ruleIdEnd
*/
public Long getRuleIdEnd(){
return this.ruleIdEnd;
}
/**
* 设置 结束 绩效规则id
* @param ruleIdEnd
*/
public void setRuleIdEnd(Long ruleIdEnd){
this.ruleIdEnd = ruleIdEnd;
}
/**
* 获取 增加 绩效规则id
* @return ruleIdIncrement
*/
public Long getRuleIdIncrement(){
return this.ruleIdIncrement;
}
/**
* 设置 增加 绩效规则id
* @param ruleIdIncrement
*/
public void setRuleIdIncrement(Long ruleIdIncrement){
this.ruleIdIncrement = ruleIdIncrement;
}
/**
* 获取 绩效规则id
* @return ruleIdList
*/
public List<Long> getRuleIdList(){
return this.ruleIdList;
}
/**
* 设置 绩效规则id
* @param ruleIdList
*/
public void setRuleIdList(List<Long> ruleIdList){
this.ruleIdList = ruleIdList;
}
/**
* 获取 绩效规则id
* @return ruleIdNotList
*/
public List<Long> getRuleIdNotList(){
return this.ruleIdNotList;
}
/**
* 设置 绩效规则id
* @param ruleIdNotList
*/
public void setRuleIdNotList(List<Long> ruleIdNotList){
this.ruleIdNotList = ruleIdNotList;
}
/**
* 获取 规则名称
* @return ruleNameList
*/
public List<String> getRuleNameList(){
return this.ruleNameList;
}
/**
* 设置 规则名称
* @param ruleNameList
*/
public void setRuleNameList(List<String> ruleNameList){
this.ruleNameList = ruleNameList;
}
/**
* 获取 规则名称
* @return ruleNameNotList
*/
public List<String> getRuleNameNotList(){
return this.ruleNameNotList;
}
/**
* 设置 规则名称
* @param ruleNameNotList
*/
public void setRuleNameNotList(List<String> ruleNameNotList){
this.ruleNameNotList = ruleNameNotList;
}
/**
* 获取 开始 扣分方式(1.系统自动,2.人工添加)
* @return subMethodStart
*/
public Integer getSubMethodStart(){
return this.subMethodStart;
}
/**
* 设置 开始 扣分方式(1.系统自动,2.人工添加)
* @param subMethodStart
*/
public void setSubMethodStart(Integer subMethodStart){
this.subMethodStart = subMethodStart;
}
/**
* 获取 结束 扣分方式(1.系统自动,2.人工添加)
* @return $subMethodEnd
*/
public Integer getSubMethodEnd(){
return this.subMethodEnd;
}
/**
* 设置 结束 扣分方式(1.系统自动,2.人工添加)
* @param subMethodEnd
*/
public void setSubMethodEnd(Integer subMethodEnd){
this.subMethodEnd = subMethodEnd;
}
/**
* 获取 增加 扣分方式(1.系统自动,2.人工添加)
* @return subMethodIncrement
*/
public Integer getSubMethodIncrement(){
return this.subMethodIncrement;
}
/**
* 设置 增加 扣分方式(1.系统自动,2.人工添加)
* @param subMethodIncrement
*/
public void setSubMethodIncrement(Integer subMethodIncrement){
this.subMethodIncrement = subMethodIncrement;
}
/**
* 获取 扣分方式(1.系统自动,2.人工添加)
* @return subMethodList
*/
public List<Integer> getSubMethodList(){
return this.subMethodList;
}
/**
* 设置 扣分方式(1.系统自动,2.人工添加)
* @param subMethodList
*/
public void setSubMethodList(List<Integer> subMethodList){
this.subMethodList = subMethodList;
}
/**
* 获取 扣分方式(1.系统自动,2.人工添加)
* @return subMethodNotList
*/
public List<Integer> getSubMethodNotList(){
return this.subMethodNotList;
}
/**
* 设置 扣分方式(1.系统自动,2.人工添加)
* @param subMethodNotList
*/
public void setSubMethodNotList(List<Integer> subMethodNotList){
this.subMethodNotList = subMethodNotList;
}
/**
* 获取 扣分人员
* @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;
}
/**
* 获取 开始 增减类型(1.增加,2.扣除)
* @return subAddTypeStart
*/
public Integer getSubAddTypeStart(){
return this.subAddTypeStart;
}
/**
* 设置 开始 增减类型(1.增加,2.扣除)
* @param subAddTypeStart
*/
public void setSubAddTypeStart(Integer subAddTypeStart){
this.subAddTypeStart = subAddTypeStart;
}
/**
* 获取 结束 增减类型(1.增加,2.扣除)
* @return $subAddTypeEnd
*/
public Integer getSubAddTypeEnd(){
return this.subAddTypeEnd;
}
/**
* 设置 结束 增减类型(1.增加,2.扣除)
* @param subAddTypeEnd
*/
public void setSubAddTypeEnd(Integer subAddTypeEnd){
this.subAddTypeEnd = subAddTypeEnd;
}
/**
* 获取 增加 增减类型(1.增加,2.扣除)
* @return subAddTypeIncrement
*/
public Integer getSubAddTypeIncrement(){
return this.subAddTypeIncrement;
}
/**
* 设置 增加 增减类型(1.增加,2.扣除)
* @param subAddTypeIncrement
*/
public void setSubAddTypeIncrement(Integer subAddTypeIncrement){
this.subAddTypeIncrement = subAddTypeIncrement;
}
/**
* 获取 增减类型(1.增加,2.扣除)
* @return subAddTypeList
*/
public List<Integer> getSubAddTypeList(){
return this.subAddTypeList;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeList
*/
public void setSubAddTypeList(List<Integer> subAddTypeList){
this.subAddTypeList = subAddTypeList;
}
/**
* 获取 增减类型(1.增加,2.扣除)
* @return subAddTypeNotList
*/
public List<Integer> getSubAddTypeNotList(){
return this.subAddTypeNotList;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeNotList
*/
public void setSubAddTypeNotList(List<Integer> subAddTypeNotList){
this.subAddTypeNotList = subAddTypeNotList;
}
/**
* 获取 开始 扣分或增加分值
* @return scoreStart
*/
public BigDecimal getScoreStart(){
return this.scoreStart;
}
/**
* 设置 开始 扣分或增加分值
* @param scoreStart
*/
public void setScoreStart(BigDecimal scoreStart){
this.scoreStart = scoreStart;
}
/**
* 获取 结束 扣分或增加分值
* @return $scoreEnd
*/
public BigDecimal getScoreEnd(){
return this.scoreEnd;
}
/**
* 设置 结束 扣分或增加分值
* @param scoreEnd
*/
public void setScoreEnd(BigDecimal scoreEnd){
this.scoreEnd = scoreEnd;
}
/**
* 获取 增加 扣分或增加分值
* @return scoreIncrement
*/
public BigDecimal getScoreIncrement(){
return this.scoreIncrement;
}
/**
* 设置 增加 扣分或增加分值
* @param scoreIncrement
*/
public void setScoreIncrement(BigDecimal scoreIncrement){
this.scoreIncrement = scoreIncrement;
}
/**
* 获取 扣分或增加分值
* @return scoreList
*/
public List<BigDecimal> getScoreList(){
return this.scoreList;
}
/**
* 设置 扣分或增加分值
* @param scoreList
*/
public void setScoreList(List<BigDecimal> scoreList){
this.scoreList = scoreList;
}
/**
* 获取 扣分或增加分值
* @return scoreNotList
*/
public List<BigDecimal> getScoreNotList(){
return this.scoreNotList;
}
/**
* 设置 扣分或增加分值
* @param scoreNotList
*/
public void setScoreNotList(List<BigDecimal> scoreNotList){
this.scoreNotList = scoreNotList;
}
/**
* 获取 开始 处理状态(1.未处理,2.已处理)
* @return processStatusStart
*/
public Integer getProcessStatusStart(){
return this.processStatusStart;
}
/**
* 设置 开始 处理状态(1.未处理,2.已处理)
* @param processStatusStart
*/
public void setProcessStatusStart(Integer processStatusStart){
this.processStatusStart = processStatusStart;
}
/**
* 获取 结束 处理状态(1.未处理,2.已处理)
* @return $processStatusEnd
*/
public Integer getProcessStatusEnd(){
return this.processStatusEnd;
}
/**
* 设置 结束 处理状态(1.未处理,2.已处理)
* @param processStatusEnd
*/
public void setProcessStatusEnd(Integer processStatusEnd){
this.processStatusEnd = processStatusEnd;
}
/**
* 获取 增加 处理状态(1.未处理,2.已处理)
* @return processStatusIncrement
*/
public Integer getProcessStatusIncrement(){
return this.processStatusIncrement;
}
/**
* 设置 增加 处理状态(1.未处理,2.已处理)
* @param processStatusIncrement
*/
public void setProcessStatusIncrement(Integer processStatusIncrement){
this.processStatusIncrement = processStatusIncrement;
}
/**
* 获取 处理状态(1.未处理,2.已处理)
* @return processStatusList
*/
public List<Integer> getProcessStatusList(){
return this.processStatusList;
}
/**
* 设置 处理状态(1.未处理,2.已处理)
* @param processStatusList
*/
public void setProcessStatusList(List<Integer> processStatusList){
this.processStatusList = processStatusList;
}
/**
* 获取 处理状态(1.未处理,2.已处理)
* @return processStatusNotList
*/
public List<Integer> getProcessStatusNotList(){
return this.processStatusNotList;
}
/**
* 设置 处理状态(1.未处理,2.已处理)
* @param processStatusNotList
*/
public void setProcessStatusNotList(List<Integer> processStatusNotList){
this.processStatusNotList = processStatusNotList;
}
/**
* 获取 附件名称，多个逗号分割
* @return fileNamesList
*/
public List<String> getFileNamesList(){
return this.fileNamesList;
}
/**
* 设置 附件名称，多个逗号分割
* @param fileNamesList
*/
public void setFileNamesList(List<String> fileNamesList){
this.fileNamesList = fileNamesList;
}
/**
* 获取 附件名称，多个逗号分割
* @return fileNamesNotList
*/
public List<String> getFileNamesNotList(){
return this.fileNamesNotList;
}
/**
* 设置 附件名称，多个逗号分割
* @param fileNamesNotList
*/
public void setFileNamesNotList(List<String> fileNamesNotList){
this.fileNamesNotList = fileNamesNotList;
}
/**
* 获取 附件下载地址，多个逗号分割
* @return filePathsList
*/
public List<String> getFilePathsList(){
return this.filePathsList;
}
/**
* 设置 附件下载地址，多个逗号分割
* @param filePathsList
*/
public void setFilePathsList(List<String> filePathsList){
this.filePathsList = filePathsList;
}
/**
* 获取 附件下载地址，多个逗号分割
* @return filePathsNotList
*/
public List<String> getFilePathsNotList(){
return this.filePathsNotList;
}
/**
* 设置 附件下载地址，多个逗号分割
* @param filePathsNotList
*/
public void setFilePathsNotList(List<String> filePathsNotList){
this.filePathsNotList = filePathsNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public PerformErrorRecordQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public PerformErrorRecordQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public PerformErrorRecordQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public PerformErrorRecordQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public PerformErrorRecordQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public PerformErrorRecordQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 员工ID
* @param staffId
*/
public PerformErrorRecordQuery staffId(Long staffId){
setStaffId(staffId);
return this;
}
/**
* 设置 开始 员工ID
* @param staffIdStart
*/
public PerformErrorRecordQuery staffIdStart(Long staffIdStart){
this.staffIdStart = staffIdStart;
return this;
}
/**
* 设置 结束 员工ID
* @param staffIdEnd
*/
public PerformErrorRecordQuery staffIdEnd(Long staffIdEnd){
this.staffIdEnd = staffIdEnd;
return this;
}
/**
* 设置 增加 员工ID
* @param staffIdIncrement
*/
public PerformErrorRecordQuery staffIdIncrement(Long staffIdIncrement){
this.staffIdIncrement = staffIdIncrement;
return this;
}
/**
* 设置 员工ID
* @param staffIdList
*/
public PerformErrorRecordQuery staffIdList(List<Long> staffIdList){
this.staffIdList = staffIdList;
return this;
}
/**
* 设置 员工ID
* @param staffIdNotList
*/
public PerformErrorRecordQuery staffIdNotList(List<Long> staffIdNotList){
this.staffIdNotList = staffIdNotList;
return this;
}
/**
* 设置 员工姓名
* @param staffName
*/
public PerformErrorRecordQuery staffName(String staffName){
setStaffName(staffName);
return this;
}
/**
* 设置 员工姓名
* @param staffNameList
*/
public PerformErrorRecordQuery staffNameList(List<String> staffNameList){
this.staffNameList = staffNameList;
return this;
}
/**
* 设置 工号
* @param workNum
*/
public PerformErrorRecordQuery workNum(String workNum){
setWorkNum(workNum);
return this;
}
/**
* 设置 工号
* @param workNumList
*/
public PerformErrorRecordQuery workNumList(List<String> workNumList){
this.workNumList = workNumList;
return this;
}
/**
* 设置 窗口编号
* @param windowNum
*/
public PerformErrorRecordQuery windowNum(String windowNum){
setWindowNum(windowNum);
return this;
}
/**
* 设置 窗口编号
* @param windowNumList
*/
public PerformErrorRecordQuery windowNumList(List<String> windowNumList){
this.windowNumList = windowNumList;
return this;
}
/**
* 设置 所属部门
* @param deptId
*/
public PerformErrorRecordQuery deptId(Long deptId){
setDeptId(deptId);
return this;
}
/**
* 设置 开始 所属部门
* @param deptIdStart
*/
public PerformErrorRecordQuery deptIdStart(Long deptIdStart){
this.deptIdStart = deptIdStart;
return this;
}
/**
* 设置 结束 所属部门
* @param deptIdEnd
*/
public PerformErrorRecordQuery deptIdEnd(Long deptIdEnd){
this.deptIdEnd = deptIdEnd;
return this;
}
/**
* 设置 增加 所属部门
* @param deptIdIncrement
*/
public PerformErrorRecordQuery deptIdIncrement(Long deptIdIncrement){
this.deptIdIncrement = deptIdIncrement;
return this;
}
/**
* 设置 所属部门
* @param deptIdList
*/
public PerformErrorRecordQuery deptIdList(List<Long> deptIdList){
this.deptIdList = deptIdList;
return this;
}
/**
* 设置 所属部门
* @param deptIdNotList
*/
public PerformErrorRecordQuery deptIdNotList(List<Long> deptIdNotList){
this.deptIdNotList = deptIdNotList;
return this;
}
/**
* 设置 所属部门名称
* @param deptName
*/
public PerformErrorRecordQuery deptName(String deptName){
setDeptName(deptName);
return this;
}
/**
* 设置 所属部门名称
* @param deptNameList
*/
public PerformErrorRecordQuery deptNameList(List<String> deptNameList){
this.deptNameList = deptNameList;
return this;
}
/**
* 设置 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularType
*/
public PerformErrorRecordQuery irregularType(Integer irregularType){
setIrregularType(irregularType);
return this;
}
/**
* 设置 开始 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeStart
*/
public PerformErrorRecordQuery irregularTypeStart(Integer irregularTypeStart){
this.irregularTypeStart = irregularTypeStart;
return this;
}
/**
* 设置 结束 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeEnd
*/
public PerformErrorRecordQuery irregularTypeEnd(Integer irregularTypeEnd){
this.irregularTypeEnd = irregularTypeEnd;
return this;
}
/**
* 设置 增加 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeIncrement
*/
public PerformErrorRecordQuery irregularTypeIncrement(Integer irregularTypeIncrement){
this.irregularTypeIncrement = irregularTypeIncrement;
return this;
}
/**
* 设置 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeList
*/
public PerformErrorRecordQuery irregularTypeList(List<Integer> irregularTypeList){
this.irregularTypeList = irregularTypeList;
return this;
}
/**
* 设置 违规类型(1.脱岗,2.离岗,3.玩手机,4.睡觉)
* @param irregularTypeNotList
*/
public PerformErrorRecordQuery irregularTypeNotList(List<Integer> irregularTypeNotList){
this.irregularTypeNotList = irregularTypeNotList;
return this;
}
/**
* 设置 持续时间，秒
* @param duration
*/
public PerformErrorRecordQuery duration(Integer duration){
setDuration(duration);
return this;
}
/**
* 设置 开始 持续时间，秒
* @param durationStart
*/
public PerformErrorRecordQuery durationStart(Integer durationStart){
this.durationStart = durationStart;
return this;
}
/**
* 设置 结束 持续时间，秒
* @param durationEnd
*/
public PerformErrorRecordQuery durationEnd(Integer durationEnd){
this.durationEnd = durationEnd;
return this;
}
/**
* 设置 增加 持续时间，秒
* @param durationIncrement
*/
public PerformErrorRecordQuery durationIncrement(Integer durationIncrement){
this.durationIncrement = durationIncrement;
return this;
}
/**
* 设置 持续时间，秒
* @param durationList
*/
public PerformErrorRecordQuery durationList(List<Integer> durationList){
this.durationList = durationList;
return this;
}
/**
* 设置 持续时间，秒
* @param durationNotList
*/
public PerformErrorRecordQuery durationNotList(List<Integer> durationNotList){
this.durationNotList = durationNotList;
return this;
}
/**
* 设置 图片凭证地址
* @param snapPath
*/
public PerformErrorRecordQuery snapPath(String snapPath){
setSnapPath(snapPath);
return this;
}
/**
* 设置 图片凭证地址
* @param snapPathList
*/
public PerformErrorRecordQuery snapPathList(List<String> snapPathList){
this.snapPathList = snapPathList;
return this;
}
/**
* 设置 绩效规则分类id
* @param categoryId
*/
public PerformErrorRecordQuery categoryId(Long categoryId){
setCategoryId(categoryId);
return this;
}
/**
* 设置 开始 绩效规则分类id
* @param categoryIdStart
*/
public PerformErrorRecordQuery categoryIdStart(Long categoryIdStart){
this.categoryIdStart = categoryIdStart;
return this;
}
/**
* 设置 结束 绩效规则分类id
* @param categoryIdEnd
*/
public PerformErrorRecordQuery categoryIdEnd(Long categoryIdEnd){
this.categoryIdEnd = categoryIdEnd;
return this;
}
/**
* 设置 增加 绩效规则分类id
* @param categoryIdIncrement
*/
public PerformErrorRecordQuery categoryIdIncrement(Long categoryIdIncrement){
this.categoryIdIncrement = categoryIdIncrement;
return this;
}
/**
* 设置 绩效规则分类id
* @param categoryIdList
*/
public PerformErrorRecordQuery categoryIdList(List<Long> categoryIdList){
this.categoryIdList = categoryIdList;
return this;
}
/**
* 设置 绩效规则分类id
* @param categoryIdNotList
*/
public PerformErrorRecordQuery categoryIdNotList(List<Long> categoryIdNotList){
this.categoryIdNotList = categoryIdNotList;
return this;
}
/**
* 设置 规则名称
* @param categoryName
*/
public PerformErrorRecordQuery categoryName(String categoryName){
setCategoryName(categoryName);
return this;
}
/**
* 设置 规则名称
* @param categoryNameList
*/
public PerformErrorRecordQuery categoryNameList(List<String> categoryNameList){
this.categoryNameList = categoryNameList;
return this;
}
/**
* 设置 绩效规则id
* @param ruleId
*/
public PerformErrorRecordQuery ruleId(Long ruleId){
setRuleId(ruleId);
return this;
}
/**
* 设置 开始 绩效规则id
* @param ruleIdStart
*/
public PerformErrorRecordQuery ruleIdStart(Long ruleIdStart){
this.ruleIdStart = ruleIdStart;
return this;
}
/**
* 设置 结束 绩效规则id
* @param ruleIdEnd
*/
public PerformErrorRecordQuery ruleIdEnd(Long ruleIdEnd){
this.ruleIdEnd = ruleIdEnd;
return this;
}
/**
* 设置 增加 绩效规则id
* @param ruleIdIncrement
*/
public PerformErrorRecordQuery ruleIdIncrement(Long ruleIdIncrement){
this.ruleIdIncrement = ruleIdIncrement;
return this;
}
/**
* 设置 绩效规则id
* @param ruleIdList
*/
public PerformErrorRecordQuery ruleIdList(List<Long> ruleIdList){
this.ruleIdList = ruleIdList;
return this;
}
/**
* 设置 绩效规则id
* @param ruleIdNotList
*/
public PerformErrorRecordQuery ruleIdNotList(List<Long> ruleIdNotList){
this.ruleIdNotList = ruleIdNotList;
return this;
}
/**
* 设置 规则名称
* @param ruleName
*/
public PerformErrorRecordQuery ruleName(String ruleName){
setRuleName(ruleName);
return this;
}
/**
* 设置 规则名称
* @param ruleNameList
*/
public PerformErrorRecordQuery ruleNameList(List<String> ruleNameList){
this.ruleNameList = ruleNameList;
return this;
}
/**
* 设置 扣分方式(1.系统自动,2.人工添加)
* @param subMethod
*/
public PerformErrorRecordQuery subMethod(Integer subMethod){
setSubMethod(subMethod);
return this;
}
/**
* 设置 开始 扣分方式(1.系统自动,2.人工添加)
* @param subMethodStart
*/
public PerformErrorRecordQuery subMethodStart(Integer subMethodStart){
this.subMethodStart = subMethodStart;
return this;
}
/**
* 设置 结束 扣分方式(1.系统自动,2.人工添加)
* @param subMethodEnd
*/
public PerformErrorRecordQuery subMethodEnd(Integer subMethodEnd){
this.subMethodEnd = subMethodEnd;
return this;
}
/**
* 设置 增加 扣分方式(1.系统自动,2.人工添加)
* @param subMethodIncrement
*/
public PerformErrorRecordQuery subMethodIncrement(Integer subMethodIncrement){
this.subMethodIncrement = subMethodIncrement;
return this;
}
/**
* 设置 扣分方式(1.系统自动,2.人工添加)
* @param subMethodList
*/
public PerformErrorRecordQuery subMethodList(List<Integer> subMethodList){
this.subMethodList = subMethodList;
return this;
}
/**
* 设置 扣分方式(1.系统自动,2.人工添加)
* @param subMethodNotList
*/
public PerformErrorRecordQuery subMethodNotList(List<Integer> subMethodNotList){
this.subMethodNotList = subMethodNotList;
return this;
}
/**
* 设置 扣分人员
* @param deductPerson
*/
public PerformErrorRecordQuery deductPerson(String deductPerson){
setDeductPerson(deductPerson);
return this;
}
/**
* 设置 扣分人员
* @param deductPersonList
*/
public PerformErrorRecordQuery deductPersonList(List<String> deductPersonList){
this.deductPersonList = deductPersonList;
return this;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddType
*/
public PerformErrorRecordQuery subAddType(Integer subAddType){
setSubAddType(subAddType);
return this;
}
/**
* 设置 开始 增减类型(1.增加,2.扣除)
* @param subAddTypeStart
*/
public PerformErrorRecordQuery subAddTypeStart(Integer subAddTypeStart){
this.subAddTypeStart = subAddTypeStart;
return this;
}
/**
* 设置 结束 增减类型(1.增加,2.扣除)
* @param subAddTypeEnd
*/
public PerformErrorRecordQuery subAddTypeEnd(Integer subAddTypeEnd){
this.subAddTypeEnd = subAddTypeEnd;
return this;
}
/**
* 设置 增加 增减类型(1.增加,2.扣除)
* @param subAddTypeIncrement
*/
public PerformErrorRecordQuery subAddTypeIncrement(Integer subAddTypeIncrement){
this.subAddTypeIncrement = subAddTypeIncrement;
return this;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeList
*/
public PerformErrorRecordQuery subAddTypeList(List<Integer> subAddTypeList){
this.subAddTypeList = subAddTypeList;
return this;
}
/**
* 设置 增减类型(1.增加,2.扣除)
* @param subAddTypeNotList
*/
public PerformErrorRecordQuery subAddTypeNotList(List<Integer> subAddTypeNotList){
this.subAddTypeNotList = subAddTypeNotList;
return this;
}
/**
* 设置 扣分或增加分值
* @param score
*/
public PerformErrorRecordQuery score(BigDecimal score){
setScore(score);
return this;
}
/**
* 设置 开始 扣分或增加分值
* @param scoreStart
*/
public PerformErrorRecordQuery scoreStart(BigDecimal scoreStart){
this.scoreStart = scoreStart;
return this;
}
/**
* 设置 结束 扣分或增加分值
* @param scoreEnd
*/
public PerformErrorRecordQuery scoreEnd(BigDecimal scoreEnd){
this.scoreEnd = scoreEnd;
return this;
}
/**
* 设置 增加 扣分或增加分值
* @param scoreIncrement
*/
public PerformErrorRecordQuery scoreIncrement(BigDecimal scoreIncrement){
this.scoreIncrement = scoreIncrement;
return this;
}
/**
* 设置 扣分或增加分值
* @param scoreList
*/
public PerformErrorRecordQuery scoreList(List<BigDecimal> scoreList){
this.scoreList = scoreList;
return this;
}
/**
* 设置 扣分或增加分值
* @param scoreNotList
*/
public PerformErrorRecordQuery scoreNotList(List<BigDecimal> scoreNotList){
this.scoreNotList = scoreNotList;
return this;
}
/**
* 设置 处理状态(1.未处理,2.已处理)
* @param processStatus
*/
public PerformErrorRecordQuery processStatus(Integer processStatus){
setProcessStatus(processStatus);
return this;
}
/**
* 设置 开始 处理状态(1.未处理,2.已处理)
* @param processStatusStart
*/
public PerformErrorRecordQuery processStatusStart(Integer processStatusStart){
this.processStatusStart = processStatusStart;
return this;
}
/**
* 设置 结束 处理状态(1.未处理,2.已处理)
* @param processStatusEnd
*/
public PerformErrorRecordQuery processStatusEnd(Integer processStatusEnd){
this.processStatusEnd = processStatusEnd;
return this;
}
/**
* 设置 增加 处理状态(1.未处理,2.已处理)
* @param processStatusIncrement
*/
public PerformErrorRecordQuery processStatusIncrement(Integer processStatusIncrement){
this.processStatusIncrement = processStatusIncrement;
return this;
}
/**
* 设置 处理状态(1.未处理,2.已处理)
* @param processStatusList
*/
public PerformErrorRecordQuery processStatusList(List<Integer> processStatusList){
this.processStatusList = processStatusList;
return this;
}
/**
* 设置 处理状态(1.未处理,2.已处理)
* @param processStatusNotList
*/
public PerformErrorRecordQuery processStatusNotList(List<Integer> processStatusNotList){
this.processStatusNotList = processStatusNotList;
return this;
}
/**
* 设置 附件名称，多个逗号分割
* @param fileNames
*/
public PerformErrorRecordQuery fileNames(String fileNames){
setFileNames(fileNames);
return this;
}
/**
* 设置 附件名称，多个逗号分割
* @param fileNamesList
*/
public PerformErrorRecordQuery fileNamesList(List<String> fileNamesList){
this.fileNamesList = fileNamesList;
return this;
}
/**
* 设置 附件下载地址，多个逗号分割
* @param filePaths
*/
public PerformErrorRecordQuery filePaths(String filePaths){
setFilePaths(filePaths);
return this;
}
/**
* 设置 附件下载地址，多个逗号分割
* @param filePathsList
*/
public PerformErrorRecordQuery filePathsList(List<String> filePathsList){
this.filePathsList = filePathsList;
return this;
}
/**
* 设置 备注
* @param remark
*/
public PerformErrorRecordQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public PerformErrorRecordQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public PerformErrorRecordQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public PerformErrorRecordQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public PerformErrorRecordQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public PerformErrorRecordQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public PerformErrorRecordQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public PerformErrorRecordQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public PerformErrorRecordQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public PerformErrorRecordQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public PerformErrorRecordQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public PerformErrorRecordQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public PerformErrorRecordQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public PerformErrorRecordQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<PerformErrorRecordQuery> getOrConditionList(){
return this.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<PerformErrorRecordQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<PerformErrorRecordQuery> getAndConditionList(){
return this.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<PerformErrorRecordQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/model/vo/PerformErrorRecordVo.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 绩效异常记录信息视图对象
*
* @author zxfei
* @date 2024-01-24
*/
@Data
public class PerformErrorRecordVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/service/PerformErrorRecordService.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
import com.mortals.xhx.module.perform.dao.PerformErrorRecordDao;
/**
* PerformErrorRecordService
*
* 绩效异常记录信息 service接口
*
* @author zxfei
* @date 2024-01-24
*/
public interface PerformErrorRecordService extends ICRUDService<PerformErrorRecordEntity,Long>{
PerformErrorRecordDao getDao();
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/service/impl/PerformErrorRecordServiceImpl.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.service.impl;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.perform.dao.PerformErrorRecordDao;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
import com.mortals.xhx.module.perform.service.PerformErrorRecordService;
import lombok.extern.slf4j.Slf4j;
/**
* PerformErrorRecordService
* 绩效异常记录信息 service实现
*
* @author zxfei
* @date 2024-01-24
*/
@Service("performErrorRecordService")
@Slf4j
public class PerformErrorRecordServiceImpl extends AbstractCRUDServiceImpl<PerformErrorRecordDao, PerformErrorRecordEntity, Long> implements PerformErrorRecordService {
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/perform/web/PerformErrorRecordController.java 0 → 100644
View file @ 7e4da754
package com.mortals.xhx.module.perform.web;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.perform.model.PerformErrorRecordEntity;
import com.mortals.xhx.module.perform.service.PerformErrorRecordService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
import com.mortals.xhx.common.code.*;
/**
*
* 绩效异常记录信息
*
* @author zxfei
* @date 2024-01-24
*/
@RestController
@RequestMapping("perform/error/record")
public class PerformErrorRecordController extends BaseCRUDJsonBodyMappingController<PerformErrorRecordService,PerformErrorRecordEntity,Long> {
@Autowired
private ParamService paramService;
public PerformErrorRecordController(){
super.setModuleDesc( "绩效异常记录信息");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "irregularType", IrregularTypeEnum.getEnumMap());
this.addDict(model, "subMethod", SubMethodEnum.getEnumMap());
this.addDict(model, "subAddType", SubAddTypeEnum.getEnumMap());
this.addDict(model, "processStatus", ProcessStatusEnum.getEnumMap());
super.init(model, context);
}
}
\ No newline at end of file
attendance-performance-manager/src/main/resources/sqlmap/module/perform/PerformErrorRecordMapper.xml 0 → 100644
View file @ 7e4da754
This source diff could not be displayed because it is too large. You can view the blob instead.
attendance-performance-manager/src/test/java/com/mortals/httpclient/http-client.env.json
View file @ 7e4da754
......@@ -3,7 +3,7 @@
"baseUrl": "http://127.0.0.1:17500/attendance"
},
"test": {
"baseUrl": "http://192.168.0.98:11039/attendance",
"baseUrl": "http://8.136.255.30:11039/attendance",
"baseLogin": "http://192.168.0.98:11078/base"
},
"yibin": {
......
attendance-performance-manager/src/test/java/com/mortals/httpclient/perform/PerformErrorRecordController.http 0 → 100644
View file @ 7e4da754
###登录
POST {{baseUrl}}/login/login
Content-Type: application/json
{
"loginName":"admin",
"password":"admin",
"securityCode":"8888"
}
> {%
client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
client.global.set("authToken", JSON.parse(response.body).data.token);
%}
###绩效异常记录信息列表
POST {{baseUrl}}/perform/error/record/list
Content-Type: application/json
{
"staffName":"w4fqca",
"workNum":"v4mob9",
"windowNum":"i9nauz",
"deptName":"gxxv48",
"irregularType":181,
"happenTime":"1706025600000",
"duration":0,
"ruleName":"t6r2x1",
"deductPerson":"ty0q2g",
"score":0.00,
"processStatus":1,
"page":1,
"size":10
}
###绩效异常记录信息更新与保存
POST {{baseUrl}}/perform/error/record/save
Authorization: {{authToken}}
Content-Type: application/json
{
"staffId":260,
"staffName":"t40p8f",
"workNum":"7518ud",
"windowNum":"18i5r3",
"deptId":966,
"deptName":"js12ry",
"irregularType":512,
"happenTime":"1706025600000",
"duration":0,
"alarmTime":"1706025600000",
"snapPath":"9k91eq",
"categoryId":292,
"categoryName":"oix6e8",
"ruleId":975,
"ruleName":"73prp5",
"subMethod":2,
"deductPerson":"tp6byl",
"deductTime":"1706025600000",
"subAddType":1,
"score":0.00,
"processStatus":1,
"fileNames":"5qw28j",
"filePaths":"72lefs",
"remark":"zq2ovs",
}
> {%
client.global.set("PerformErrorRecord_id", JSON.parse(response.body).data.id);
%}
###绩效异常记录信息查看
GET {{baseUrl}}/perform/error/record/info?id={{PerformErrorRecord_id}}
Accept: application/json
###绩效异常记录信息编辑
GET {{baseUrl}}/perform/error/record/edit?id={{PerformErrorRecord_id}}
Accept: application/json
###绩效异常记录信息删除
GET {{baseUrl}}/perform/error/record/delete?id={{PerformErrorRecord_id}}
Authorization: {{authToken}}
Accept: application/json
attendance-performance-manager/src/test/java/com/mortals/httpclient/system.http
View file @ 7e4da754
......@@ -4,8 +4,8 @@ POST {{baseUrl}}/login/login
Content-Type: application/json
{
"loginName":"admin",
"password":"admin",
"loginName":"admin1",
"password":"aA123!@#",
"securityCode":"admin"
}
......@@ -16,6 +16,14 @@ client.global.set("authToken", JSON.parse(response.body).data.token);
###修改用户密码
POST {{baseUrl}}/user/change/password
Authorization: {{authToken}}
Content-Type: application/x-www-form-urlencoded
oldPwd=aA123!@#&newPwd=aA123!@#.
###首页
POST {{baseUrl}}/login/index
Authorization: {{authToken}}
......@@ -30,8 +38,8 @@ Authorization: {{authToken}}
Content-Type: application/json
{
"attendanceDateStart":"2023-12-20",
"attendanceDateEnd":"2023-12-20"
"attendanceDateStart":"2023-12-01",
"attendanceDateEnd":"2024-01-23"
}
###海康考勤打卡记录计算1
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment