|
|
package com.engine.kq.biz;
|
|
|
|
|
|
import com.engine.kq.biz.chain.shiftinfo.ShiftInfoBean;
|
|
|
import com.engine.kq.entity.KQOvertimeRulesDetailEntity;
|
|
|
import com.engine.kq.log.KQLog;
|
|
|
import com.engine.kq.util.KQDurationCalculatorUtil;
|
|
|
import com.engine.kq.wfset.bean.OvertimeBalanceTimeBean;
|
|
|
import com.engine.kq.wfset.bean.SplitBean;
|
|
|
import com.engine.kq.wfset.util.KQFlowUtil;
|
|
|
import com.google.common.collect.Lists;
|
|
|
import com.google.common.collect.Maps;
|
|
|
import java.io.PrintWriter;
|
|
|
import java.io.StringWriter;
|
|
|
import java.time.LocalDate;
|
|
|
import java.time.format.DateTimeFormatter;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.List;
|
|
|
import java.util.Map;
|
|
|
import org.springframework.beans.BeanUtils;
|
|
|
import weaver.general.Util;
|
|
|
|
|
|
/**
|
|
|
* 加班流程 非工作时长计算 重新搞一把
|
|
|
* 现在是根据归属来拆分流程
|
|
|
*/
|
|
|
public class KQOverTimeFlowBiz {
|
|
|
private KQLog kqLog = new KQLog();
|
|
|
|
|
|
/**
|
|
|
* 之前的加班拆分是根据每一天进行拆分的，但是我们是有个默认归属的，就是上班前是属于前一天的，再加上这次标准改造，加了临界点，
|
|
|
* 加班的拆分改造一下，改成和请假拆分一样，根据归属区间来拆分
|
|
|
* 未设置加班归属的逻辑是
|
|
|
* 工作日A-工作日B ，从工作日A的上班时间往后加24小时，都算工作日A的加班区间
|
|
|
* 工作日A-非工作日，从工作日A的上班时间往后加24小时，都算工作日A的加班区间
|
|
|
* 非工作日-工作日A，从非工作日的0点到工作日A的上班前，都属于非工作日的区间
|
|
|
*
|
|
|
* 计算加班逻辑很特殊，
|
|
|
* 需要知道昨日，今日和明日的类型，是工作日还是非工作日
|
|
|
* @param splitBean
|
|
|
* @param splitBeans
|
|
|
*/
|
|
|
public void getSplitDurationBean_new(SplitBean splitBean,List<SplitBean> splitBeans) {
|
|
|
try{
|
|
|
long a = System.currentTimeMillis();
|
|
|
|
|
|
double oneDayHour = KQFlowUtil.getOneDayHour(splitBean.getDurationTypeEnum(),"");
|
|
|
int workmins = (int)(oneDayHour * 60);
|
|
|
String resourceid = splitBean.getResourceId();
|
|
|
String fromDate = splitBean.getFromdatedb();
|
|
|
String toDate = splitBean.getTodatedb();
|
|
|
String overtime_type = splitBean.getOvertime_type();
|
|
|
|
|
|
LocalDate localFromDate = LocalDate.parse(fromDate);
|
|
|
LocalDate localToDate = LocalDate.parse(toDate);
|
|
|
DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
|
|
LocalDate preFromDate = localFromDate.minusDays(1);
|
|
|
KQTimesArrayComInfo kqTimesArrayComInfo = new KQTimesArrayComInfo();
|
|
|
|
|
|
KQOvertimeRulesBiz kqOvertimeRulesBiz = new KQOvertimeRulesBiz();
|
|
|
KQOverTimeRuleCalBiz kqOverTimeRuleCalBiz = new KQOverTimeRuleCalBiz();
|
|
|
Map<String,Integer> changeTypeMap = Maps.newHashMap();
|
|
|
Map<String, KQOvertimeRulesDetailEntity> overRulesDetailMap = Maps.newHashMap();
|
|
|
Map<String,List<String[]>> restTimeMap = Maps.newHashMap();
|
|
|
Map<String,Integer> computingModeMap = Maps.newHashMap();
|
|
|
kqOverTimeRuleCalBiz.getOverTimeDataMap(resourceid, fromDate, toDate, dateFormatter,changeTypeMap,overRulesDetailMap,restTimeMap,computingModeMap);
|
|
|
|
|
|
if(overRulesDetailMap.isEmpty()){
|
|
|
return;
|
|
|
}
|
|
|
String fromTime = splitBean.getFromtimedb();
|
|
|
String toTime = splitBean.getTotimedb();
|
|
|
long betweenDays = localToDate.toEpochDay() - preFromDate.toEpochDay();
|
|
|
//默认是从加班开始日期的前一天开始计算 需要特殊处理的就三个情况，i=0的时候，i=1的时候就是加班流程开始日期那一天，i=最后一天就是加班流程结束日期那一天
|
|
|
for (int i = 0; i <= betweenDays; i++) {
|
|
|
SplitBean overSplitBean = new SplitBean();
|
|
|
//然后把bean重新赋值下，根据拆分后的时间
|
|
|
BeanUtils.copyProperties(splitBean, overSplitBean);
|
|
|
|
|
|
//从加班流程开始的前一天开始算归属
|
|
|
LocalDate curLocalDate = preFromDate.plusDays(i);
|
|
|
String splitDate = curLocalDate.format(dateFormatter);
|
|
|
String preSplitDate = LocalDate.parse(splitDate).minusDays(1).format(dateFormatter);
|
|
|
LocalDate nextLocalDate = curLocalDate.plusDays(1);
|
|
|
String nextSplitDate = nextLocalDate.format(dateFormatter);
|
|
|
String change_key = splitDate+"_"+resourceid;
|
|
|
String pre_change_key = preSplitDate+"_"+resourceid;
|
|
|
String next_change_key = nextSplitDate+"_"+resourceid;
|
|
|
int changeType = Util.getIntValue(""+changeTypeMap.get(change_key),-1);
|
|
|
int preChangeType = Util.getIntValue(""+changeTypeMap.get(pre_change_key),-1);
|
|
|
int next_changeType = Util.getIntValue(""+changeTypeMap.get(next_change_key),-1);
|
|
|
|
|
|
boolean shouldAcross = false;
|
|
|
String changeType_key = splitDate+"_"+changeType;
|
|
|
String preChangeType_key = preSplitDate+"_"+preChangeType;
|
|
|
String nextChangeType_key = nextSplitDate+"_"+next_changeType;
|
|
|
if(!computingModeMap.containsKey(changeType_key)){
|
|
|
continue;
|
|
|
}
|
|
|
int computingMode = computingModeMap.get(changeType_key);
|
|
|
if(computingMode == 3){
|
|
|
//如果是纯打卡为主的不生成加班
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
int[] initArrays = kqTimesArrayComInfo.getInitArr();
|
|
|
//当前日期的加班分割点 分割点都是次日的
|
|
|
String overtime_cut_point = "";
|
|
|
int before_startTime = 0;
|
|
|
int startTime = 0;
|
|
|
int curMins = 0 ;
|
|
|
//排除休息类型
|
|
|
int restTimeType = -1;
|
|
|
String next_beginwork_time = "";
|
|
|
String cur_beginwork_time = "";
|
|
|
String serialid = "";
|
|
|
//需要知道明日的类型:如果今天是工作日的话，那么今天的加班临界点可能和明日的上班时间冲突，需要知道明日的上班时间进行比较，
|
|
|
// 如果今天是休息日，那么明天如果是工作日的话，默认规则下，明天的上班前都是属于今天的加班区间
|
|
|
if(next_changeType == 2){
|
|
|
ShiftInfoBean next_shiftInfoBean = KQDurationCalculatorUtil.getWorkTime(resourceid, nextSplitDate, false);
|
|
|
if(next_shiftInfoBean != null){
|
|
|
List<int[]> workLongTimeIndex = next_shiftInfoBean.getWorkLongTimeIndex();
|
|
|
List<int[]> real_workLongTimeIndex = Lists.newArrayList();
|
|
|
get_real_workLongTimeIndex(workLongTimeIndex,real_workLongTimeIndex,next_shiftInfoBean,kqTimesArrayComInfo,splitBean);
|
|
|
|
|
|
if(real_workLongTimeIndex != null && !real_workLongTimeIndex.isEmpty()){
|
|
|
next_beginwork_time = kqTimesArrayComInfo.getTimesByArrayindex(real_workLongTimeIndex.get(0)[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(changeType == 2){
|
|
|
ShiftInfoBean cur_shiftInfoBean = KQDurationCalculatorUtil.getWorkTime(resourceid, splitDate, false);
|
|
|
if(cur_shiftInfoBean != null){
|
|
|
List<int[]> workLongTimeIndex = cur_shiftInfoBean.getWorkLongTimeIndex();
|
|
|
List<int[]> real_workLongTimeIndex = Lists.newArrayList();
|
|
|
get_real_workLongTimeIndex(workLongTimeIndex,real_workLongTimeIndex,cur_shiftInfoBean,kqTimesArrayComInfo,splitBean);
|
|
|
|
|
|
if(real_workLongTimeIndex != null && !real_workLongTimeIndex.isEmpty()){
|
|
|
cur_beginwork_time = kqTimesArrayComInfo.getTimesByArrayindex(real_workLongTimeIndex.get(0)[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
boolean needSplitByTime = false;
|
|
|
// 按照加班时长转调休的 时长设置
|
|
|
List<String> timepointList = null;
|
|
|
List<OvertimeBalanceTimeBean> overtimeBalanceTimeBeans = Lists.newArrayList();
|
|
|
KQOvertimeRulesDetailEntity curKqOvertimeRulesDetailEntity = overRulesDetailMap.get(changeType_key);
|
|
|
if(curKqOvertimeRulesDetailEntity != null){
|
|
|
int has_cut_point = curKqOvertimeRulesDetailEntity.getHas_cut_point();
|
|
|
before_startTime = curKqOvertimeRulesDetailEntity.getBefore_startTime();
|
|
|
int overtimeEnable = curKqOvertimeRulesDetailEntity.getOvertimeEnable();
|
|
|
if(overtimeEnable != 1){
|
|
|
continue;
|
|
|
}
|
|
|
if(has_cut_point != 1){
|
|
|
before_startTime = -1;
|
|
|
}
|
|
|
startTime = curKqOvertimeRulesDetailEntity.getStartTime();
|
|
|
restTimeType = curKqOvertimeRulesDetailEntity.getRestTimeType();
|
|
|
int paidLeaveEnable = kqOverTimeRuleCalBiz.getPaidLeaveEnable(curKqOvertimeRulesDetailEntity,overtime_type);
|
|
|
needSplitByTime = kqOverTimeRuleCalBiz.getNeedSplitByTime(curKqOvertimeRulesDetailEntity,paidLeaveEnable);
|
|
|
if(needSplitByTime){
|
|
|
int ruleDetailid = curKqOvertimeRulesDetailEntity.getId();
|
|
|
Map<String,List<String>> balanceTimethDetailMap = kqOvertimeRulesBiz.getBalanceTimeDetailMap(ruleDetailid);
|
|
|
if(balanceTimethDetailMap != null && !balanceTimethDetailMap.isEmpty()){
|
|
|
timepointList = balanceTimethDetailMap.get("timepointList");
|
|
|
}
|
|
|
}
|
|
|
if(has_cut_point == 0){
|
|
|
if(changeType == 2){
|
|
|
overtime_cut_point = cur_beginwork_time;
|
|
|
}else {
|
|
|
if(next_beginwork_time.length() > 0){
|
|
|
overtime_cut_point = next_beginwork_time;
|
|
|
}
|
|
|
}
|
|
|
}else{
|
|
|
overtime_cut_point = curKqOvertimeRulesDetailEntity.getCut_point();
|
|
|
if(next_beginwork_time.length() > 0){
|
|
|
int next_beginwork_time_index = kqTimesArrayComInfo.getArrayindexByTimes(next_beginwork_time);
|
|
|
int overtime_cut_point_index = kqTimesArrayComInfo.getArrayindexByTimes(overtime_cut_point);
|
|
|
if(overtime_cut_point_index > next_beginwork_time_index){
|
|
|
overtime_cut_point = next_beginwork_time;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(overtime_cut_point.length() == 0){
|
|
|
overtime_cut_point = "00:00";
|
|
|
}
|
|
|
}else{
|
|
|
continue;
|
|
|
}
|
|
|
int fromTime_index = 0;
|
|
|
int toTime_index = 0;
|
|
|
if(i == 0){
|
|
|
//i=0就是加班开始日期的前一天，只有当加班临界点超过了加班流程开始时间的话，i=0才会有可能计算出时长
|
|
|
if(overtime_cut_point.compareTo(fromTime) > 0){
|
|
|
fromTime_index = kqTimesArrayComInfo.getArrayindexByTimes(kqTimesArrayComInfo.turn24to48Time(fromTime));
|
|
|
toTime_index = kqTimesArrayComInfo.getArrayindexByTimes(kqTimesArrayComInfo.turn24to48Time(overtime_cut_point));
|
|
|
if(fromDate.equalsIgnoreCase(toDate)){
|
|
|
//如果开始日期和结束日期是同一天，还需要比较流程的结束时间和归属点的大小
|
|
|
int oriTotime_index = kqTimesArrayComInfo.getArrayindexByTimes(kqTimesArrayComInfo.turn24to48Time(toTime));
|
|
|
if(toTime_index > oriTotime_index){
|
|
|
toTime_index = oriTotime_index;
|
|
|
}
|
|
|
}
|
|
|
Arrays.fill(initArrays, fromTime_index, toTime_index, 0);
|
|
|
// 1-节假日、2-工作日、3-休息日
|
|
|
if(changeType == 1){
|
|
|
handle_changeType_1(initArrays,overRulesDetailMap,nextChangeType_key,next_changeType,next_beginwork_time);
|
|
|
}else if(changeType == 2){
|
|
|
boolean isok = handle_changeType_2(initArrays, resourceid, splitDate, before_startTime, startTime, fromTime_index,kqTimesArrayComInfo,splitBean,
|
|
|
toTime_index);
|
|
|
serialid = splitBean.getSerialid();
|
|
|
if(!isok){
|
|
|
continue;
|
|
|
}
|
|
|
}else if(changeType == 3){
|
|
|
handle_changeType_3(initArrays,overRulesDetailMap,nextChangeType_key,next_changeType,next_beginwork_time);
|
|
|
}
|
|
|
if(restTimeType == 1){
|
|
|
//如果排除设置的休息时间
|
|
|
handle_resttime(restTimeMap,changeType_key,kqTimesArrayComInfo,shouldAcross,initArrays);
|
|
|
}
|
|
|
curMins = kqTimesArrayComInfo.getCnt(initArrays, fromTime_index,toTime_index,0);
|
|
|
if(restTimeType == 2){
|
|
|
//如果排除休息时间是扣除时长
|
|
|
curMins = handle_restlength(curMins,restTimeMap,changeType_key);
|
|
|
}
|
|
|
}else{
|
|
|
continue;
|
|
|
}
|
|
|
}else{
|
|
|
//除了i=0的情况，其他的每一天都是要获取一下昨日的临界点的
|
|
|
String pre_overtime_cut_point = get_pre_overtime_cut_point(overRulesDetailMap,preChangeType_key,resourceid,preSplitDate,splitDate,preChangeType,kqTimesArrayComInfo,splitBean,changeType);
|
|
|
if(changeType == 2){
|
|
|
//如果今天是工作日，昨日的打卡归属会受到今日的上班前开始加班分钟数的影响
|
|
|
int cur_beginwork_time_index = kqTimesArrayComInfo.getArrayindexByTimes(cur_beginwork_time);
|
|
|
if(before_startTime > -1){
|
|
|
int pre_overtime_cut_point_index = kqTimesArrayComInfo.getArrayindexByTimes(pre_overtime_cut_point);
|
|
|
int before_cur_beginwork_time_index = cur_beginwork_time_index - before_startTime;
|
|
|
}
|
|
|
}
|
|
|
//计算区间加班开始日期和加班结束日期这两天都是要特殊处理的
|
|
|
fromTime_index = kqTimesArrayComInfo.getArrayindexByTimes(pre_overtime_cut_point);
|
|
|
if(i == 1){
|
|
|
if(fromTime.compareTo(pre_overtime_cut_point) > 0){
|
|
|
fromTime_index = kqTimesArrayComInfo.getArrayindexByTimes(fromTime);
|
|
|
}
|
|
|
}
|
|
|
if(i == betweenDays){
|
|
|
toTime_index = kqTimesArrayComInfo.getArrayindexByTimes(toTime);
|
|
|
}else{
|
|
|
toTime_index = kqTimesArrayComInfo.turn24to48TimeIndex(kqTimesArrayComInfo.getArrayindexByTimes(overtime_cut_point));
|
|
|
if(next_beginwork_time.length() > 0){
|
|
|
int overtime_cut_point_index = kqTimesArrayComInfo.getArrayindexByTimes(overtime_cut_point);
|
|
|
int next_beginwork_time_index = kqTimesArrayComInfo.getArrayindexByTimes(next_beginwork_time);
|
|
|
//如果临界点都已经超过第二天上班的开始时间了，要相应的缩短成第二天上班时间
|
|
|
if(overtime_cut_point_index > next_beginwork_time_index){
|
|
|
toTime_index = kqTimesArrayComInfo.turn24to48TimeIndex(next_beginwork_time_index);
|
|
|
}
|
|
|
}
|
|
|
if(i == betweenDays-1){
|
|
|
int ori_totime_index = kqTimesArrayComInfo.turn48to24TimeIndex(toTime_index);
|
|
|
int last_toTime_index = kqTimesArrayComInfo.getArrayindexByTimes(toTime);
|
|
|
if(ori_totime_index > last_toTime_index){
|
|
|
toTime_index = kqTimesArrayComInfo.turn24to48TimeIndex(last_toTime_index);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
System.out.println(i+":betweenDays:"+betweenDays+":fromTime_index:"+fromTime_index+":toTime_index:"+toTime_index+":changeType:"+changeType);
|
|
|
|
|
|
if(fromTime_index > toTime_index){
|
|
|
continue;
|
|
|
}
|
|
|
Arrays.fill(initArrays, fromTime_index, toTime_index, 0);
|
|
|
|
|
|
if(changeType == 1){
|
|
|
handle_changeType_1(initArrays, overRulesDetailMap, nextChangeType_key, next_changeType,
|
|
|
next_beginwork_time);
|
|
|
}else if(changeType == 2){
|
|
|
serialid = splitBean.getSerialid();
|
|
|
boolean isok = handle_changeType_2(initArrays, resourceid, splitDate, before_startTime, startTime, fromTime_index,
|
|
|
kqTimesArrayComInfo, splitBean, toTime_index);
|
|
|
if(!isok){
|
|
|
continue;
|
|
|
}
|
|
|
}else if(changeType == 3){
|
|
|
handle_changeType_3(initArrays, overRulesDetailMap, nextChangeType_key, next_changeType,
|
|
|
overtime_cut_point);
|
|
|
}
|
|
|
if(restTimeType == 1) {
|
|
|
//如果排除设置的休息时间
|
|
|
handle_resttime(restTimeMap, changeType_key, kqTimesArrayComInfo, shouldAcross,initArrays);
|
|
|
}
|
|
|
curMins = kqTimesArrayComInfo.getCnt(initArrays, fromTime_index,toTime_index,0);
|
|
|
|
|
|
if(restTimeType == 2){
|
|
|
//如果排除休息时间是扣除时长
|
|
|
curMins = handle_restlength(curMins,restTimeMap,changeType_key);
|
|
|
}
|
|
|
}
|
|
|
int minimumUnit = curKqOvertimeRulesDetailEntity.getMinimumLen();
|
|
|
if(curMins < minimumUnit){
|
|
|
continue;
|
|
|
}
|
|
|
if(needSplitByTime){
|
|
|
kqOverTimeRuleCalBiz.get_overtimeBalanceTimeBeans(timepointList,overtimeBalanceTimeBeans,kqTimesArrayComInfo,initArrays,toTime_index,fromTime_index,0);
|
|
|
|
|
|
if(overtimeBalanceTimeBeans != null && !overtimeBalanceTimeBeans.isEmpty()){
|
|
|
String bean_cross_fromtime = kqTimesArrayComInfo.getTimesByArrayindex(fromTime_index);
|
|
|
String bean_cross_totime = kqTimesArrayComInfo.getTimesByArrayindex(toTime_index);
|
|
|
for(int timeIndex = 0 ; timeIndex < overtimeBalanceTimeBeans.size() ;timeIndex++) {
|
|
|
OvertimeBalanceTimeBean overtimeBalanceTimeBean = overtimeBalanceTimeBeans.get(timeIndex);
|
|
|
String timePointStart = overtimeBalanceTimeBean.getTimepoint_start();
|
|
|
String timePointEnd = overtimeBalanceTimeBean.getTimepoint_end();
|
|
|
boolean isNeedTX = overtimeBalanceTimeBean.isNeedTX();
|
|
|
int timePointStart_index = kqTimesArrayComInfo.getArrayindexByTimes(timePointStart);
|
|
|
int timePointEnd_index = kqTimesArrayComInfo.getArrayindexByTimes(timePointEnd);
|
|
|
if(timePointStart_index > fromTime_index){
|
|
|
bean_cross_fromtime = kqTimesArrayComInfo.getTimesByArrayindex(timePointStart_index);
|
|
|
}else{
|
|
|
bean_cross_fromtime = kqTimesArrayComInfo.getTimesByArrayindex(fromTime_index);
|
|
|
}
|
|
|
if(timePointEnd_index < toTime_index){
|
|
|
bean_cross_totime = kqTimesArrayComInfo.getTimesByArrayindex(timePointEnd_index);
|
|
|
}else{
|
|
|
bean_cross_totime = kqTimesArrayComInfo.getTimesByArrayindex(toTime_index);
|
|
|
}
|
|
|
int timepoint_mins = overtimeBalanceTimeBean.getTimepoint_mins();
|
|
|
if(isNeedTX){
|
|
|
if(timepoint_mins > 0){
|
|
|
overSplitBean = new SplitBean();
|
|
|
//然后把bean重新赋值下，根据拆分后的时间
|
|
|
BeanUtils.copyProperties(splitBean, overSplitBean);
|
|
|
overSplitBean.setChangeType(changeType);
|
|
|
overSplitBean.setPreChangeType(preChangeType);
|
|
|
overSplitBean.setOneDayHour(oneDayHour);
|
|
|
overSplitBean.setWorkmins(workmins);
|
|
|
overSplitBean.setComputingMode(computingMode+"");
|
|
|
overSplitBean.setChangeType(changeType);
|
|
|
overSplitBean.setFromDate(splitDate);
|
|
|
overSplitBean.setFromTime(bean_cross_fromtime);
|
|
|
overSplitBean.setToDate(splitDate);
|
|
|
overSplitBean.setToTime(bean_cross_totime);
|
|
|
overSplitBean.setBelongDate(splitDate);
|
|
|
overSplitBean.setD_Mins(timepoint_mins);
|
|
|
overSplitBean.setOvertimeBalanceTimeBeans(overtimeBalanceTimeBeans);
|
|
|
overSplitBean.setSerialid(serialid);
|
|
|
getDurationByRule(overSplitBean);
|
|
|
splitBeans.add(overSplitBean);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}else{
|
|
|
curMins = (int) kqOverTimeRuleCalBiz.getD_MinsByUnit(curMins);
|
|
|
overSplitBean.setChangeType(changeType);
|
|
|
overSplitBean.setPreChangeType(preChangeType);
|
|
|
overSplitBean.setOneDayHour(oneDayHour);
|
|
|
overSplitBean.setWorkmins(workmins);
|
|
|
overSplitBean.setComputingMode(computingMode+"");
|
|
|
overSplitBean.setChangeType(changeType);
|
|
|
overSplitBean.setFromDate(splitDate);
|
|
|
overSplitBean.setFromTime(kqTimesArrayComInfo.getTimesByArrayindex(fromTime_index));
|
|
|
overSplitBean.setToDate(splitDate);
|
|
|
overSplitBean.setToTime(kqTimesArrayComInfo.getTimesByArrayindex(toTime_index));
|
|
|
overSplitBean.setBelongDate(splitDate);
|
|
|
overSplitBean.setD_Mins(curMins);
|
|
|
overSplitBean.setOvertimeBalanceTimeBeans(overtimeBalanceTimeBeans);
|
|
|
overSplitBean.setSerialid(serialid);
|
|
|
getDurationByRule(overSplitBean);
|
|
|
splitBeans.add(overSplitBean);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
long b = System.currentTimeMillis();
|
|
|
System.out.println("::"+(b-a));
|
|
|
|
|
|
}catch (Exception e){
|
|
|
StringWriter errorsWriter = new StringWriter();
|
|
|
e.printStackTrace(new PrintWriter(errorsWriter));
|
|
|
kqLog.info(errorsWriter.toString());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 被个性化设置处理下 得到实际的上下班时间
|
|
|
* @param workLongTimeIndex
|
|
|
* @param real_workLongTimeIndex
|
|
|
* @param shiftInfoBean
|
|
|
* @param kqTimesArrayComInfo
|
|
|
* @param splitBean
|
|
|
*/
|
|
|
public void get_real_workLongTimeIndex(List<int[]> workLongTimeIndex,
|
|
|
List<int[]> real_workLongTimeIndex,
|
|
|
ShiftInfoBean shiftInfoBean, KQTimesArrayComInfo kqTimesArrayComInfo,
|
|
|
SplitBean splitBean) {
|
|
|
|
|
|
//list带数组，这里要深拷贝
|
|
|
for(int[] tmp : workLongTimeIndex){
|
|
|
int[] real_tmp = new int[tmp.length];
|
|
|
System.arraycopy(tmp, 0, real_tmp, 0, tmp.length);
|
|
|
real_workLongTimeIndex.add(real_tmp);
|
|
|
}
|
|
|
if(real_workLongTimeIndex.size() == 1){
|
|
|
//个性化设置只支持一次打卡的
|
|
|
KQShiftRuleInfoBiz kqShiftRuleInfoBiz = new KQShiftRuleInfoBiz();
|
|
|
kqShiftRuleInfoBiz.rest_workLongTimeIndex(shiftInfoBean,splitBean,real_workLongTimeIndex,kqTimesArrayComInfo,null);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取一下昨日的临界点
|
|
|
* @param overRulesDetailMap
|
|
|
* @param preChangeType_key
|
|
|
* @param resourceid
|
|
|
* @param preSplitDate
|
|
|
* @param splitDate
|
|
|
* @param preChangeType
|
|
|
* @param kqTimesArrayComInfo
|
|
|
* @param splitBean
|
|
|
* @param changeType
|
|
|
* @return
|
|
|
*/
|
|
|
private String get_pre_overtime_cut_point(
|
|
|
Map<String, KQOvertimeRulesDetailEntity> overRulesDetailMap,
|
|
|
String preChangeType_key, String resourceid, String preSplitDate, String splitDate,
|
|
|
int preChangeType, KQTimesArrayComInfo kqTimesArrayComInfo,
|
|
|
SplitBean splitBean, int changeType) {
|
|
|
|
|
|
String pre_overtime_cut_point = "";
|
|
|
KQOvertimeRulesDetailEntity preKqOvertimeRulesDetailEntity = overRulesDetailMap.get(preChangeType_key);
|
|
|
if(preKqOvertimeRulesDetailEntity != null){
|
|
|
int has_cut_point = preKqOvertimeRulesDetailEntity.getHas_cut_point();
|
|
|
if(has_cut_point == 0){
|
|
|
if(preChangeType == 2){
|
|
|
ShiftInfoBean pre_shiftInfoBean = KQDurationCalculatorUtil.getWorkTime(resourceid, preSplitDate, false);
|
|
|
if(pre_shiftInfoBean != null){
|
|
|
List<int[]> workLongTimeIndex = pre_shiftInfoBean.getWorkLongTimeIndex();
|
|
|
List<int[]> real_workLongTimeIndex = Lists.newArrayList();
|
|
|
get_real_workLongTimeIndex(workLongTimeIndex,real_workLongTimeIndex,pre_shiftInfoBean,kqTimesArrayComInfo,splitBean);
|
|
|
|
|
|
if(real_workLongTimeIndex != null && !real_workLongTimeIndex.isEmpty()){
|
|
|
pre_overtime_cut_point = kqTimesArrayComInfo.getTimesByArrayindex(real_workLongTimeIndex.get(0)[0]);
|
|
|
}
|
|
|
}
|
|
|
}else {
|
|
|
String next_beginwork_time = "";
|
|
|
if(changeType == 2){
|
|
|
ShiftInfoBean next_shiftInfoBean = KQDurationCalculatorUtil.getWorkTime(resourceid, splitDate, false);
|
|
|
if(next_shiftInfoBean != null){
|
|
|
List<int[]> workLongTimeIndex = next_shiftInfoBean.getWorkLongTimeIndex();
|
|
|
List<int[]> real_workLongTimeIndex = Lists.newArrayList();
|
|
|
get_real_workLongTimeIndex(workLongTimeIndex,real_workLongTimeIndex,next_shiftInfoBean,kqTimesArrayComInfo,splitBean);
|
|
|
|
|
|
if(real_workLongTimeIndex != null && !real_workLongTimeIndex.isEmpty()){
|
|
|
next_beginwork_time = kqTimesArrayComInfo.getTimesByArrayindex(real_workLongTimeIndex.get(0)[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(next_beginwork_time.length() > 0){
|
|
|
pre_overtime_cut_point = next_beginwork_time;
|
|
|
}
|
|
|
}
|
|
|
}else{
|
|
|
pre_overtime_cut_point = preKqOvertimeRulesDetailEntity.getCut_point();
|
|
|
}
|
|
|
if(pre_overtime_cut_point.length() == 0){
|
|
|
pre_overtime_cut_point = "00:00";
|
|
|
}
|
|
|
}
|
|
|
return pre_overtime_cut_point;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 处理节假日的加班
|
|
|
* @param initArrays
|
|
|
* @param overRulesDetailMap
|
|
|
* @param nextChangeType_key
|
|
|
* @param next_changeType
|
|
|
* @param next_beginwork_time
|
|
|
*/
|
|
|
public void handle_changeType_1(int[] initArrays,
|
|
|
Map<String, KQOvertimeRulesDetailEntity> overRulesDetailMap,
|
|
|
String nextChangeType_key, int next_changeType, String next_beginwork_time){
|
|
|
KQOvertimeRulesDetailEntity nextKqOvertimeRulesDetailEntity = overRulesDetailMap.get(nextChangeType_key);
|
|
|
// if(nextKqOvertimeRulesDetailEntity != null){
|
|
|
// if(next_changeType == 2){
|
|
|
// //如果明日是工作日 工作日如果设置了上班前分钟，会导致加班归属被设置的分钟数给切断，上班前某些部分属于今天不属于昨日
|
|
|
// int overtimeEnable = nextKqOvertimeRulesDetailEntity.getOvertimeEnable();
|
|
|
// if(overtimeEnable == 1){
|
|
|
// KQTimesArrayComInfo kqTimesArrayComInfo = new KQTimesArrayComInfo();
|
|
|
// int before_startTime = nextKqOvertimeRulesDetailEntity.getBefore_startTime();
|
|
|
// int has_cut_point = nextKqOvertimeRulesDetailEntity.getHas_cut_point();
|
|
|
// if(has_cut_point != 1){
|
|
|
// before_startTime = -1;
|
|
|
// }
|
|
|
// int next_beginwork_time_index = kqTimesArrayComInfo.getArrayindexByTimes(next_beginwork_time);
|
|
|
// if(before_startTime > -1){
|
|
|
// int before_next_beginwork_time_index = next_beginwork_time_index - before_startTime;
|
|
|
// if(before_next_beginwork_time_index > 0 && before_next_beginwork_time_index < next_beginwork_time_index){
|
|
|
// before_next_beginwork_time_index = kqTimesArrayComInfo.turn24to48TimeIndex(before_next_beginwork_time_index);
|
|
|
// next_beginwork_time_index = kqTimesArrayComInfo.turn24to48TimeIndex(next_beginwork_time_index);
|
|
|
// Arrays.fill(initArrays, before_next_beginwork_time_index,next_beginwork_time_index,-1);
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 排除休息时间 现在工作日，节假日和休息日都可以设置排除休息时间
|
|
|
* @param restTimeMap
|
|
|
* @param changeType_key
|
|
|
* @param kqTimesArrayComInfo
|
|
|
* @param shouldAcross
|
|
|
* @param initArrays
|
|
|
*/
|
|
|
public void handle_resttime(Map<String, List<String[]>> restTimeMap, String changeType_key, KQTimesArrayComInfo kqTimesArrayComInfo, boolean shouldAcross, int[] initArrays) {
|
|
|
|
|
|
if(restTimeMap.containsKey(changeType_key)){
|
|
|
List<String[]> restTimeList = restTimeMap.get(changeType_key);
|
|
|
//再把休息时间填充上去
|
|
|
if(!restTimeList.isEmpty()){
|
|
|
for(int k =0 ; k < restTimeList.size() ; k++){
|
|
|
String[] restTimes = restTimeList.get(k);
|
|
|
if(restTimes.length == 2){
|
|
|
int restStart = kqTimesArrayComInfo.getArrayindexByTimes(restTimes[0]);
|
|
|
int restEnd = kqTimesArrayComInfo.getArrayindexByTimes(restTimes[1]);
|
|
|
if(shouldAcross && restEnd == 1439){
|
|
|
//针对跨天的休息时段单独处理排除掉23:59-00:00的时间
|
|
|
restEnd = 1440;
|
|
|
}
|
|
|
Arrays.fill(initArrays, restStart, restEnd, 1);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 排除休息时长 根据加班时长排除指定时长
|
|
|
* @param curMins
|
|
|
* @param restTimeMap
|
|
|
* @param changeType_key
|
|
|
* @return
|
|
|
*/
|
|
|
public int handle_restlength(int curMins, Map<String, List<String[]>> restTimeMap, String changeType_key) {
|
|
|
if(restTimeMap.containsKey(changeType_key)) {
|
|
|
List<String[]> restTimeList = restTimeMap.get(changeType_key);
|
|
|
//再把休息时间填充上去
|
|
|
if (!restTimeList.isEmpty()) {
|
|
|
for(int k = restTimeList.size()-1 ; k >= 0 ; k--) {
|
|
|
String[] restTimes = restTimeList.get(k);
|
|
|
if (restTimes.length == 2) {
|
|
|
//overlength 是满多少小时 cutlength是减去多少小时
|
|
|
double overlength = Util.getDoubleValue(restTimes[0],-1);
|
|
|
double cutlength = Util.getDoubleValue(restTimes[1],-1);
|
|
|
if(overlength > 0 && cutlength > 0){
|
|
|
double min_overlength = overlength * 60;
|
|
|
double min_cutlength = cutlength * 60;
|
|
|
if(curMins >= min_overlength){
|
|
|
curMins = (int) (curMins-min_cutlength);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
return curMins;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 处理工作日的加班
|
|
|
* @param initArrays
|
|
|
* @param resourceid
|
|
|
* @param splitDate
|
|
|
* @param before_startTime
|
|
|
* @param startTime
|
|
|
* @param fromTime_index
|
|
|
* @param kqTimesArrayComInfo
|
|
|
* @param splitBean
|
|
|
* @param toTime_index
|
|
|
* @return
|
|
|
*/
|
|
|
public boolean handle_changeType_2(int[] initArrays, String resourceid, String splitDate,
|
|
|
int before_startTime, int startTime, int fromTime_index,
|
|
|
KQTimesArrayComInfo kqTimesArrayComInfo, SplitBean splitBean, int toTime_index){
|
|
|
|
|
|
boolean isok = true;
|
|
|
ShiftInfoBean cur_shiftInfoBean = KQDurationCalculatorUtil.getWorkTime(resourceid, splitDate, false);
|
|
|
if(cur_shiftInfoBean != null){
|
|
|
splitBean.setSerialid(cur_shiftInfoBean.getSerialid());
|
|
|
List<int[]> workLongTimeIndex = cur_shiftInfoBean.getWorkLongTimeIndex();
|
|
|
List<int[]> real_workLongTimeIndex = Lists.newArrayList();
|
|
|
get_real_workLongTimeIndex(workLongTimeIndex,real_workLongTimeIndex,cur_shiftInfoBean,kqTimesArrayComInfo,splitBean);
|
|
|
if(real_workLongTimeIndex != null && !real_workLongTimeIndex.isEmpty()){
|
|
|
int all_firstworktime = 0;
|
|
|
int all_lastworktime = 0;
|
|
|
boolean need_middle_time = false;
|
|
|
for(int k = 0 ; k < real_workLongTimeIndex.size() ; k++){
|
|
|
int workLongTimeStartIndex = real_workLongTimeIndex.get(k)[0];
|
|
|
int workLongTimeEndIndex = real_workLongTimeIndex.get(k)[1];
|
|
|
if(k == 0){
|
|
|
if(before_startTime > -1){
|
|
|
int before_workLongTimeStartIndex = workLongTimeStartIndex-before_startTime;
|
|
|
if(before_workLongTimeStartIndex > 0){
|
|
|
//从前一天的加班归属点到今天的上班前开始加班点，这段时间属于两不靠。需要排除
|
|
|
if(fromTime_index < before_workLongTimeStartIndex){
|
|
|
Arrays.fill(initArrays, fromTime_index,before_workLongTimeStartIndex,-1);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
all_firstworktime = workLongTimeStartIndex;
|
|
|
}
|
|
|
if(k == real_workLongTimeIndex.size()-1){
|
|
|
if(startTime > -1){
|
|
|
int after_workLongTimeEndIndex = workLongTimeEndIndex+startTime;
|
|
|
if(workLongTimeEndIndex < after_workLongTimeEndIndex){
|
|
|
Arrays.fill(initArrays, workLongTimeEndIndex,after_workLongTimeEndIndex,-1);
|
|
|
}
|
|
|
}
|
|
|
all_lastworktime = workLongTimeEndIndex;
|
|
|
}
|
|
|
if(!need_middle_time){
|
|
|
//目前标准加班，一天多次打卡的话是不算中间时间的，只算上班前和下班后的加班
|
|
|
}else{
|
|
|
//这个里面是可以算一天多次打卡的话是中间时间的
|
|
|
Arrays.fill(initArrays, workLongTimeStartIndex,workLongTimeEndIndex,1);
|
|
|
}
|
|
|
}
|
|
|
if(!need_middle_time){
|
|
|
Arrays.fill(initArrays, all_firstworktime,all_lastworktime,1);
|
|
|
}
|
|
|
List<int[]> restLongTimeIndex = cur_shiftInfoBean.getRestLongTimeIndex();
|
|
|
if(restLongTimeIndex != null && !restLongTimeIndex.isEmpty()){
|
|
|
for (int k = 0; k < restLongTimeIndex.size(); k++) {
|
|
|
//休息时段填充2
|
|
|
Arrays.fill(initArrays, restLongTimeIndex.get(k)[0], restLongTimeIndex.get(k)[1], 2);
|
|
|
}
|
|
|
}
|
|
|
}else {
|
|
|
System.out.println("error");
|
|
|
isok = false;
|
|
|
}
|
|
|
}else {
|
|
|
System.out.println("error");
|
|
|
isok = false;
|
|
|
}
|
|
|
|
|
|
return isok;
|
|
|
}
|
|
|
/**
|
|
|
* 处理休息日的加班
|
|
|
* @param restTimeMap
|
|
|
* @param initArrays
|
|
|
* @param overRulesDetailMap
|
|
|
* @param nextChangeType_key
|
|
|
* @param next_changeType
|
|
|
* @param next_beginwork_time
|
|
|
*/
|
|
|
public void handle_changeType_3(int[] initArrays,
|
|
|
Map<String, KQOvertimeRulesDetailEntity> overRulesDetailMap,
|
|
|
String nextChangeType_key, int next_changeType, String next_beginwork_time){
|
|
|
KQOvertimeRulesDetailEntity nextKqOvertimeRulesDetailEntity = overRulesDetailMap.get(nextChangeType_key);
|
|
|
// if(nextKqOvertimeRulesDetailEntity != null){
|
|
|
// if(next_changeType == 2){
|
|
|
// //如果明日是工作日 工作日如果设置了上班前分钟，会导致加班归属被设置的分钟数给切断，上班前某些部分属于今天不属于昨日
|
|
|
// int overtimeEnable = nextKqOvertimeRulesDetailEntity.getOvertimeEnable();
|
|
|
// if(overtimeEnable == 1){
|
|
|
// KQTimesArrayComInfo kqTimesArrayComInfo = new KQTimesArrayComInfo();
|
|
|
// int before_startTime = nextKqOvertimeRulesDetailEntity.getBefore_startTime();
|
|
|
// int has_cut_point = nextKqOvertimeRulesDetailEntity.getHas_cut_point();
|
|
|
// if(has_cut_point != 1){
|
|
|
// before_startTime = -1;
|
|
|
// }
|
|
|
// int next_beginwork_time_index = kqTimesArrayComInfo.getArrayindexByTimes(next_beginwork_time);
|
|
|
// if(before_startTime > -1){
|
|
|
// int before_next_beginwork_time_index = next_beginwork_time_index - before_startTime;
|
|
|
// if(before_next_beginwork_time_index > 0 && before_next_beginwork_time_index < next_beginwork_time_index){
|
|
|
// before_next_beginwork_time_index = kqTimesArrayComInfo.turn24to48TimeIndex(before_next_beginwork_time_index);
|
|
|
// next_beginwork_time_index = kqTimesArrayComInfo.turn24to48TimeIndex(next_beginwork_time_index);
|
|
|
// Arrays.fill(initArrays, before_next_beginwork_time_index,next_beginwork_time_index,-1);
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
public void getDurationByRule(SplitBean splitBean) {
|
|
|
double D_Mins = splitBean.getD_Mins();
|
|
|
int workmins = splitBean.getWorkmins();
|
|
|
String durationrule = splitBean.getDurationrule();
|
|
|
if("3".equalsIgnoreCase(durationrule) || "5".equalsIgnoreCase(durationrule)
|
|
|
|| "6".equalsIgnoreCase(durationrule)){
|
|
|
double d_hour = D_Mins/60.0;
|
|
|
splitBean.setDuration(KQDurationCalculatorUtil.getDurationRound5(""+d_hour));
|
|
|
}else if("1".equalsIgnoreCase(durationrule)){
|
|
|
double d_day = D_Mins/workmins;
|
|
|
splitBean.setDuration(KQDurationCalculatorUtil.getDurationRound5(""+d_day));
|
|
|
}
|
|
|
}
|
|
|
}
|
