diff --git a/src/com/engine/attendance/workflow/action/askforleave/BatchAskForLeaveWorkFlowArchivingAction.java b/src/com/engine/attendance/workflow/action/askforleave/BatchAskForLeaveWorkFlowArchivingAction.java new file mode 100644 index 0000000..4a508ac --- /dev/null +++ b/src/com/engine/attendance/workflow/action/askforleave/BatchAskForLeaveWorkFlowArchivingAction.java @@ -0,0 +1,90 @@ +package com.engine.attendance.workflow.action.askforleave; + +import com.engine.common.util.CommonUtil; +import com.engine.common.util.DbTools; +import com.engine.common.util.Utils; +import com.google.common.collect.Maps; +import lombok.extern.slf4j.Slf4j; +import weaver.general.Util; +import weaver.interfaces.workflow.action.Action; +import weaver.soa.workflow.request.RequestInfo; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +/** + * @Author: sy + * @Description: 批量请假-归档节点附加操作 + * @Date: 2024/6/28 + **/ +@Slf4j +public class BatchAskForLeaveWorkFlowArchivingAction implements Action { + @Override + public String execute(RequestInfo requestInfo) { + + // 流程表单主表数据 + HashMap mainTableData = CommonUtil.getMainTableInfo(requestInfo); + log.debug("mainTableData : [{}]",mainTableData); + // 流程表单明细表1数据 + List> detailTableData = CommonUtil.getDetailTableInfo(requestInfo,0); + log.debug("detailTableData : [{}]",detailTableData); + + //流程表单明细表2数据 + List> detailTable2 = CommonUtil.getDetailTableInfo(requestInfo,1); + log.debug("detailTableData : [{}]",detailTable2); + + //第一笔开始时间 + String firstStartDate = detailTableData.get(0).get("ksrq"); + + String sql = "select id,jqid,sxrq,ktsc,yxsc,wxsc,yqsxrq,ztsc from uf_jcl_kq_jqye where and sxrq<=? and yqsxrq>=? order by sxrq"; + + List> holidayBalanceList = DbTools.getSqlToList(sql,firstStartDate,firstStartDate); + + Map holidayBalanceMap = holidayBalanceList.stream().collect(Collectors.toMap(e->e.get("id").toString(), e->e)); + + + try { + if (detailTable2.size() > 0) { + Map balanceMap = Maps.newHashMap(); + for (Map data : detailTable2){ + String jqye = Util.null2String(data.get("jqye")); + double sysc = Double.valueOf(data.get("sysc").toString()); + double havedSysc= balanceMap.get(jqye) ==null?0:Double.valueOf(balanceMap.get(jqye).toString()); + sysc = Utils.add(sysc,havedSysc); + balanceMap.put(jqye,sysc); + } + + for (Map.Entry entry:balanceMap.entrySet()){ + String id = entry.getKey(); + double ztsc = Double.valueOf(entry.getValue().toString()); + Map map = (Map)holidayBalanceMap.get(id); + + double havedztsc = Util.null2String(map.get("ztsc")).equals("") ? 0 : Double.valueOf(map.get("ztsc").toString()); + double havedyxsc = Util.null2String(map.get("yxsc")).equals("") ? 0 : Double.valueOf(map.get("yxsc").toString()); + + double updatedztsc = Utils.subtract(havedztsc,ztsc); + double updatedwxsc = Utils.add(havedyxsc,ztsc); + + String updateSql = "update uf_jcl_kq_jqye set yxsc=?,ztsc=? where id=?"; + if (!DbTools.update(updateSql,updatedwxsc,updatedztsc,id)){ + //更新假期余额失败 + String message = "更新假期余额失败"; + log.error(message); + requestInfo.getRequestManager().setMessageid("11111" + requestInfo.getRequestid() + "22222"); + requestInfo.getRequestManager().setMessagecontent(message); + return Action.FAILURE_AND_CONTINUE; + } + } + } + + }catch (Exception e){ + log.error("AskForLeaveWorkFlowSubmitAction error : [{}]",e); + return Action.FAILURE_AND_CONTINUE; + } + + + return Action.SUCCESS; + } +} diff --git a/src/com/engine/attendance/workflow/action/askforleave/BatchAskForLeaveWorkFlowSubmitAction.java b/src/com/engine/attendance/workflow/action/askforleave/BatchAskForLeaveWorkFlowSubmitAction.java new file mode 100644 index 0000000..33eba70 --- /dev/null +++ b/src/com/engine/attendance/workflow/action/askforleave/BatchAskForLeaveWorkFlowSubmitAction.java @@ -0,0 +1,134 @@ +package com.engine.attendance.workflow.action.askforleave; + +import com.engine.attendance.enums.AccountingUnitEnum; +import com.engine.attendance.enums.CheckBoxEnum; +import com.engine.attendance.workflow.enums.AskAndEvctionWayEnum; +import com.engine.common.util.CommonUtil; +import com.engine.common.util.DateUtil; +import com.engine.common.util.DbTools; +import com.engine.common.util.Utils; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import lombok.extern.slf4j.Slf4j; +import weaver.general.Util; +import weaver.interfaces.workflow.action.Action; +import weaver.soa.workflow.request.RequestInfo; + +import java.util.*; +import java.util.stream.Collectors; + +/** + * @Author: sy + * @Description: 批量请假-提交节点附加操作 + * @Date: 2024/6/28 + **/ +@Slf4j +public class BatchAskForLeaveWorkFlowSubmitAction implements Action { + @Override + public String execute(RequestInfo requestInfo) { + String requestid = requestInfo.getRequestid(); + + try { + // 流程表单主表数据 + HashMap mainTableData = CommonUtil.getMainTableInfo(requestInfo); + log.info("mainTableData : [{}]", mainTableData); + // 流程表单明细表1数据 + List> detailTableData = CommonUtil.getDetailTableInfo(requestInfo, 0); + log.info("detailTableData : [{}]", detailTableData); + + String detail2TableName = requestInfo.getDetailTableInfo().getDetailTable()[1].getTableDBName(); + log.info("detail2TableName : [{}]", detail2TableName); + //第一笔开始时间 + String firstStartDate = detailTableData.get(0).get("ksrq"); + + List> detailTable2 = Lists.newArrayList(); + + Map holidayBalanceMap = new HashMap<>(); + //需要校验假期额度的假期类型 + List checkAmountJqIdList = CommonUtil.getJqInfoWithAmount(); + //根据明细表1，根据请假类型分组，对于需要校验余额的遍历生成明细表2 + Map>> detail1TabDataGroupByJqlx = detailTableData.stream().collect(Collectors.groupingBy(e -> Util.null2String(e.get("jqlx")))); + for(Map.Entry>> entry : detail1TabDataGroupByJqlx.entrySet()) { + if (checkAmountJqIdList.contains(entry.getKey())) { + String sql = "select id,jqid,sxrq,ktsc,yxsc,wxsc,yqsxrq,ztsc from uf_jcl_kq_jqye where jqid=? and sxrq<=? and yqsxrq>=? order by sxrq"; + List> holidayBalanceList = DbTools.getSqlToList(sql, entry.getKey(), firstStartDate, firstStartDate); + if (holidayBalanceList.size() > 0) { + holidayBalanceMap.putAll(holidayBalanceList.stream().collect(Collectors.toMap(e -> e.get("id").toString(), e -> e))); + } + sql = "select id,mc,hsdw,hsl,jcbyxsyqjb,yxsydjb,qzsyyxjb from uf_jcl_kq_kqxm where id=?"; + Map holidayItem = DbTools.getSqlToMap(sql, entry.getKey()); + //假期核算单位 + String hsdw = Util.null2String(holidayItem.get("hsdw")); + //遍历生成明细表2 + for (Map detailData : entry.getValue()) { + String jqyeInfoStr = Util.null2String(detailData.get("id")); + List jqyeInfoList = Arrays.asList(jqyeInfoStr.split(",")); + for (String jqyeInfo : jqyeInfoList) { + Map detail2Map = Maps.newHashMap(); + detail2Map.put("glmxid", detailData.get("id")); + detail2Map.put("jqye", jqyeInfo.split("_")[0]); + detail2Map.put("mainid", mainTableData.get("id")); + detail2Map.put("glrq", detailData.get("ksrq")); + if (hsdw.equals(AccountingUnitEnum.DAY.getKey())) { + detail2Map.put("sysc", Utils.divide(Double.parseDouble(jqyeInfo.split("_")[1]), 8)); + } else { + detail2Map.put("sysc", jqyeInfo.split("_")[1]); + } + detailTable2.add(detail2Map); + } + } + } + } + //明细表2有数据时，更新明细表2入库，并且更新假期余额表 + //更新流程明细表2 + String delteSql = "delete from " + detail2TableName + " where mainid=?"; + DbTools.update(delteSql, requestid); + if (detailTable2.size() > 0 && !CommonUtil.insertBatch(detailTable2, detail2TableName)) { + //更新流程明细表2失败 + String message = "更新流程明细表2失败"; + log.error(message); + requestInfo.getRequestManager().setMessageid("11111" + requestid + "22222"); + requestInfo.getRequestManager().setMessagecontent(message); + return Action.FAILURE_AND_CONTINUE; + } + //更新假期余额在途时长 + Map balanceMap = Maps.newHashMap(); + for (Map data : detailTable2) { + String jqye = Util.null2String(data.get("jqye")); + double sysc = Double.valueOf(data.get("sysc").toString()); + double havedSysc = balanceMap.get(jqye) == null ? 0 : Double.valueOf(balanceMap.get(jqye).toString()); + sysc = Utils.add(sysc, havedSysc); + balanceMap.put(jqye, sysc); + } + log.info("balanceMap : [{}]",balanceMap); + for (Map.Entry entry : balanceMap.entrySet()) { + String id = entry.getKey(); + double ztsc = Double.valueOf(entry.getValue().toString()); + Map map = (Map) holidayBalanceMap.get(id); + + double havedztsc = Util.null2String(map.get("ztsc")).equals("") ? 0 : Double.valueOf(map.get("ztsc").toString()); + double havedwxsc = Util.null2String(map.get("wxsc")).equals("") ? 0 : Double.valueOf(map.get("wxsc").toString()); + + double updatedztsc = Utils.add(havedztsc, ztsc); + + String updateSql = "update uf_jcl_kq_jqye set wxsc=?,ztsc=? where id=?"; + if (!DbTools.update(updateSql, havedwxsc, updatedztsc, id)) { + //更新假期余额失败 + String message = "更新假期余额失败"; + log.error(message); + requestInfo.getRequestManager().setMessageid("11111" + requestid + "22222"); + requestInfo.getRequestManager().setMessagecontent(message); + return Action.FAILURE_AND_CONTINUE; + } + } + //////////////////////////// + + + }catch (Exception e){ + log.error("AskForLeaveWorkFlowSubmitAction error : [{}]",e); + return Action.FAILURE_AND_CONTINUE; + } + + return Action.SUCCESS; + } +} diff --git a/src/com/engine/attendance/workflow/service/AskForLeaveService.java b/src/com/engine/attendance/workflow/service/AskForLeaveService.java index 91d8248..e279bb7 100644 --- a/src/com/engine/attendance/workflow/service/AskForLeaveService.java +++ b/src/com/engine/attendance/workflow/service/AskForLeaveService.java @@ -1,5 +1,6 @@ package com.engine.attendance.workflow.service; +import java.text.ParseException; import java.util.Map; public interface AskForLeaveService { @@ -13,4 +14,11 @@ public interface AskForLeaveService { * @return */ Map getRestDayInterval(Map params); + + /** + * 批量请假-生成请假信息明细表数据 + * @param params + */ + Map generateLeaveInfoList(Map params) throws ParseException; + } diff --git a/src/com/engine/attendance/workflow/service/impl/AskForLeaveServiceImpl.java b/src/com/engine/attendance/workflow/service/impl/AskForLeaveServiceImpl.java index fd2e666..5ae1dfc 100644 --- a/src/com/engine/attendance/workflow/service/impl/AskForLeaveServiceImpl.java +++ b/src/com/engine/attendance/workflow/service/impl/AskForLeaveServiceImpl.java @@ -1,28 +1,33 @@ package com.engine.attendance.workflow.service.impl; +import com.engine.attendance.component.persongroup.service.SchedulingResultsService; +import com.engine.attendance.component.persongroup.service.impl.SchedulingResultsServiceImpl; +import com.engine.attendance.enums.AccountingUnitEnum; import com.engine.attendance.enums.CheckBoxEnum; +import com.engine.attendance.enums.DateTypeEnum; import com.engine.attendance.workflow.cmd.GetAskForLeaveRecordListCmd; -import com.engine.attendance.workflow.cmd.GetKqCycleTimeIntervalCmd; import com.engine.attendance.workflow.cmd.GetRestDayIntervalCmd; +import com.engine.attendance.workflow.enums.AskAndEvctionWayEnum; import com.engine.attendance.workflow.service.AskForLeaveService; +import com.engine.attendance.workflow.service.MakeUpClockInService; import com.engine.common.exception.AttendanceRunTimeException; -import com.engine.common.util.DateUtil; -import com.engine.common.util.DbTools; +import com.engine.common.util.*; import com.engine.core.impl.Service; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import lombok.extern.slf4j.Slf4j; import weaver.general.Util; +import java.text.ParseException; import java.time.ZoneOffset; -import java.util.Comparator; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.stream.Collectors; @Slf4j public class AskForLeaveServiceImpl extends Service implements AskForLeaveService { + private SchedulingResultsService schedulingResultsService = ServiceUtil.getService(SchedulingResultsServiceImpl.class); + + private MakeUpClockInService makeUpClockInService = ServiceUtil.getService(MakeUpClockInServiceImpl.class); @Override public Map getUesdHolidayItem(Map params) { @@ -128,4 +133,602 @@ public class AskForLeaveServiceImpl extends Service implements AskForLeaveServic } return commandExecutor.execute(new GetRestDayIntervalCmd(params,user)); } + + /** + * 批量请假-生成请假信息明细表数据 + * @param params + * @return + */ + @Override + public Map generateLeaveInfoList(Map params) throws ParseException { + Map resultMap = Maps.newHashMap(); + List errorMessage = new ArrayList<>(); + // 流程表单主表数据 + Map mainTableData = (Map)params.get("mainTableData"); + // 流程表单明细表1数据 + List> detailTableData = (List>)params.get("detailTableData"); + //需要校验假期额度的假期类型 + List checkAmountJqIdList = CommonUtil.getJqInfoWithAmount(); + //已编辑内容中的假期额度使用信息 + Map editedUseJqed = new HashMap<>(); + //已编辑内容中的假期类型使用时长_人员信息 + Map editedUseJqlxWithEmp = new HashMap<>(); + //假期余额时长已用完的假期余额id + List unableUseJqyeIdList = new ArrayList<>(); + //记录已编辑的请假记录，<人员id-请假类型-日期, 请假时长> + Map editedLeaveInfo = new HashMap<>(); + //处理明细表1数据，生成之前编辑内容中已使用的假期额度信息 + if (detailTableData != null && detailTableData.size() > 0){ + for (Map detailItem : detailTableData) { + double detailSc = "".equals(Util.null2String(detailItem.get("qjsc"))) ? 0 : Double.parseDouble(Util.null2String(detailItem.get("qjsc"))); + String leaveType = Util.null2String(detailItem.get("qjlx")); + String empId = Util.null2String(detailItem.get("qjr")); + editedUseJqlxWithEmp.merge(leaveType + "_" + empId, detailSc, Double::sum); + + String jqye = Util.null2String(detailItem.get("jqye")); + if ("".equals(jqye)) { + continue; + } else if (jqye.contains(",")) { + List jqyeIds = Arrays.asList(jqye.split(",")); + for (int i = 0; i < jqyeIds.size(); i++ ) { + //假期余额id会用下划线“_”拼接上该假期余额记录被使用的时长 + String jqyeIdStr = jqyeIds.get(i); + String[] jqyeInfo = jqyeIdStr.split("_"); + String jqyeId = jqyeInfo[0]; + double qjsc = Double.parseDouble(jqyeInfo[1]); + editedUseJqed.merge(jqyeId, qjsc, Double::sum); + //最后一个id前的jqye的id都属于额度已使用完的，记录到已用完假期余额id集合中 + if (i < jqyeIds.size() - 1) { + unableUseJqyeIdList.add(jqyeId); + } + } + } else { + String[] jqyeInfo = jqye.split("_"); + String jqyeId = jqyeInfo[0]; + double qjsc = Double.parseDouble(jqyeInfo[1]); + editedUseJqed.merge(jqyeId, qjsc, Double::sum); + } + + } + editedLeaveInfo = detailTableData.stream() + .collect(Collectors.toMap(e-> Util.null2String(e.get("qjr")) + "_" + Util.null2String(e.get("qjlx")) + "_" + Util.null2String(e.get("ksrq")), + e->Util.null2String(e.get("qjsc")))); + } + //处理主表数据 + String qjr = Util.null2String(mainTableData.get("qjr")); + //请假人姓名映射 + Map empIdToName = new HashMap<>(); + //请假人员列表 + List leaveEmpIdList = new ArrayList<>(); + if (!"".equals(qjr)) { + leaveEmpIdList = Arrays.asList(qjr.split(",")); + String sql = "select id, lastname from hrmresource where id in (" + qjr + ")"; + List> data = DbTools.getSqlToList(sql); + empIdToName = data.stream().collect(Collectors.toMap(e->Util.null2String(e.get("id")),e->Util.null2String(e.get("lastname")))); + } + //开始日期、结束日期、请假方式、开始时间、结束时间、假期类型、请假时长 + String startDate = Util.null2String(mainTableData.get("ksrq")); + String endDate = Util.null2String(mainTableData.get("jsrq")); + String startTime = Util.null2String(mainTableData.get("kssj")); + String endTime = Util.null2String(mainTableData.get("jssj")); + String leaveMode = Util.null2String(mainTableData.get("cxjqj")); + String leaveType = Util.null2String(mainTableData.get("jqlx")); + String leaveDuration = Util.null2String(mainTableData.get("qjsc")); + //获取填写的请假类型关联的考勤项目 + String sql = "select id,mc,hsdw,hsl,jcbyxsyqjb,yxsydjb,qzsyyxjb,zdycbcndfgzsd,zdycrqqjndxxb from uf_jcl_kq_kqxm where id=?"; + Map holidayItem = DbTools.getSqlToMap(sql,leaveType); + //判断是否需要自动移除时间区间内的非工作时长、自动移除日期区间内的休息日 + boolean removeNonWorkTimeRange = "1".equals(Util.null2String(holidayItem.get("zdycbcndfgzsd"))); + boolean removeNonWorkDayRange = "1".equals(Util.null2String(holidayItem.get("zdycrqqjndxxb"))); + //判断考勤项目是否需要强制使用“优先使用项目” + boolean useFirstItemSign = CheckBoxEnum.CHECKED.getKey().equals(holidayItem.get("qzsyyxjb")) && CheckBoxEnum.CHECKED.getKey().equals(holidayItem.get("jcbyxsyqjb")); + Map holidayPriorityItem = useFirstItemSign ? DbTools.getSqlToMap(sql,holidayItem.get("yxsydjb")) : null; + //遍历人员、日期，生成人员+日期+请假时长的请假信息 + //获取请假日期集合 + List leaveDateList = DateUtil.getDatesBetween(startDate, endDate); + //请假人的请假区间内每一天的日期类型信息 + Map> restDayInfo = removeNonWorkDayRange ? getRestDayWithEmpId(leaveEmpIdList, leaveType, startDate, endDate) : null; + //请假人的请假区间内的排班结果 + Map>> scheduleInfoMap = (removeNonWorkDayRange || removeNonWorkTimeRange) ? getScheduleInfoWithEmpId(leaveEmpIdList, startDate, endDate) : null; + //实际需要请假的日期集合 + List realLeaveDateList; + //收集未关联假期余额的请假明细数据 + List> simpleLeaveDetailList = new ArrayList<>(); + //收集已关联假期余额的请假明细数据 + List> completeLeaveDetailList = new ArrayList<>(); + Map simpleLeaveDetailItem; + for (String leaveEmpId : leaveEmpIdList) { + //需要自动移除日期区间内的休息日时，去除请假日期区间中的休息日 + List> scheduleInfoList = new ArrayList<>(); + Map dateToBcxxMap = new HashMap<>(); + if (removeNonWorkDayRange || removeNonWorkTimeRange) { + scheduleInfoList = scheduleInfoMap.get(leaveEmpId); + dateToBcxxMap = scheduleInfoList.stream().collect(Collectors.toMap(e->Util.null2String(e.get("bcrq")),e->Util.null2String(e.get("bcxx")))); + } + if (removeNonWorkDayRange) { + //排班结果中休息的日期 + List restDateListFromSchedule = scheduleInfoList.stream() + .filter(f -> Util.null2String(f.get("sfxx")).equals(CheckBoxEnum.CHECKED.getKey())) + .map(e -> Util.null2String(e.get("bcrq"))) + .collect(Collectors.toList()); + + List allDateListFromSchedule = scheduleInfoList.stream().map(e -> Util.null2String(e.get("bcrq"))).collect(Collectors.toList()); + //排班结果中未出现的日期 + List nonSetDateListFromSchedule = leaveDateList.stream().filter(f -> !allDateListFromSchedule.contains(f)).collect(Collectors.toList()); + //企业日历中人员对应日期的休息日 + List restDateList = restDayInfo.get(leaveEmpId); + //筛选排班信息无法辨别的日期，依靠企业日历的日期信息 + restDateList = restDateList.stream().filter(nonSetDateListFromSchedule::contains).collect(Collectors.toList()); + List finalRestDateList = restDateList; + realLeaveDateList = leaveDateList.stream().filter(f -> !finalRestDateList.contains(f) && !restDateListFromSchedule.contains(f)).collect(Collectors.toList()); + } else { + realLeaveDateList = leaveDateList; + } + for (String leaveDate : realLeaveDateList) { + //请假方式为“指定时间区间”时 + if (leaveMode.equals(AskAndEvctionWayEnum.TIME_INTERVAL.getKey())) { + simpleLeaveDetailItem = new HashMap<>(); + //组装初步的请假明细数据 + simpleLeaveDetailItem.put("qjr", leaveEmpId); + simpleLeaveDetailItem.put("ksrq", leaveDate); + simpleLeaveDetailItem.put("jsrq", leaveDate); + simpleLeaveDetailItem.put("kssj", startTime); + simpleLeaveDetailItem.put("jssj", endTime); + //获取班次id + String bcId = Util.null2String(dateToBcxxMap.get(leaveDate)).split("-")[0]; + //需要自动移除时间区间内的非工作时长，且请假方式为“指定时间区间”时，去除当前明细中开始时间、结束时间之间的非工作时长 + if (removeNonWorkTimeRange && !"".equals(bcId)) { + //查询班次明细 + sql = "select id, bdlx, gsrq, kssj as dtkssj, jssj as dtjssj from uf_jcl_kq_bcxx_dt1 where mainid = " + bcId; + List> bcDetailData = DbTools.getSqlToList(sql); + //获取移除后的分钟数 + int scMinutes = Utils.removeRestTime(leaveDate + " " + startTime, leaveDate + " " + endTime, bcDetailData, leaveDate); + //组装初步的请假时长 + simpleLeaveDetailItem.put("qjsc", String.format("%.2f", scMinutes / 60.0)); + } else { + //组装初步的请假时长 + simpleLeaveDetailItem.put("qjsc", leaveDuration); + } + simpleLeaveDetailList.add(simpleLeaveDetailItem); + } else if (leaveMode.equals(AskAndEvctionWayEnum.HOUR.getKey())) { + simpleLeaveDetailItem = new HashMap<>(); + //组装初步的请假明细数据 + simpleLeaveDetailItem.put("qjr", leaveEmpId); + simpleLeaveDetailItem.put("ksrq", leaveDate); + simpleLeaveDetailItem.put("jsrq", leaveDate); + simpleLeaveDetailItem.put("qjsc", leaveDuration); + simpleLeaveDetailList.add(simpleLeaveDetailItem); + } else if (leaveMode.equals(AskAndEvctionWayEnum.ALLDAY.getKey())) { + simpleLeaveDetailItem = new HashMap<>(); + //组装初步的请假明细数据 + simpleLeaveDetailItem.put("qjr", leaveEmpId); + simpleLeaveDetailItem.put("ksrq", leaveDate); + simpleLeaveDetailItem.put("jsrq", leaveDate); + simpleLeaveDetailItem.put("qtj", "1"); + simpleLeaveDetailList.add(simpleLeaveDetailItem); + } else if (leaveMode.equals(AskAndEvctionWayEnum.HALFDAY.getKey())) { + simpleLeaveDetailItem = new HashMap<>(); + //组装初步的请假明细数据 + simpleLeaveDetailItem.put("qjr", leaveEmpId); + simpleLeaveDetailItem.put("ksrq", leaveDate); + simpleLeaveDetailItem.put("jsrq", leaveDate); + simpleLeaveDetailItem.put("btj", "1"); + simpleLeaveDetailList.add(simpleLeaveDetailItem); + } + } + } + //按照人员id分组处理请假明细信息，关联假期余额数据 + Map>> leaveDetailGroupByEmp = simpleLeaveDetailList.stream().collect(Collectors.groupingBy(e -> Util.null2String(e.get("qjr")))); + + for(Map.Entry>> entry : leaveDetailGroupByEmp.entrySet()) { + //校验该人员的考勤周期是否正常 + boolean kqCycleAllow = kqCycleCheck(entry.getKey(), entry.getValue(), errorMessage, empIdToName.get(entry.getKey())); + if (!kqCycleAllow) { + continue; + } + //1-收集使用勾选的关联的可使用的余额，才能够生成请假明细，可使用的条件为，a-满足最小使用时长，b-满足使用次数上限，c-存在未休时长 + List> canUseCheckJqyeInfo = collectUsableHolidayBalance(unableUseJqyeIdList, editedUseJqed, leaveType, startDate, entry.getKey()); + List> detailListItem = new ArrayList<>(); + //判断考勤项目是否需要强制使用“优先使用项目” + if (useFirstItemSign) { + //2-收集优先使用的项目关联的可使用的余额，才能够生成请假明细，可使用的条件为，a-满足最小使用时长，b-满足使用次数上限，c-存在未休时长 + List> canUseFirstJqyeInfo = collectUsableHolidayBalance(unableUseJqyeIdList, editedUseJqed, holidayPriorityItem.get("id").toString(), startDate, entry.getKey()); + detailListItem = matchHolidayBalance(editedLeaveInfo, checkAmountJqIdList, errorMessage, entry.getKey(), empIdToName.get(entry.getKey()), canUseCheckJqyeInfo, canUseFirstJqyeInfo, editedUseJqed, editedUseJqlxWithEmp, entry.getValue(), leaveType, holidayPriorityItem.get("id").toString()); + } else { + detailListItem = matchHolidayBalance(editedLeaveInfo, checkAmountJqIdList, errorMessage, entry.getKey(), empIdToName.get(entry.getKey()), canUseCheckJqyeInfo, null, editedUseJqed, editedUseJqlxWithEmp, entry.getValue(), leaveType, null); + } + if (detailListItem.size() > 0) { + completeLeaveDetailList.addAll(detailListItem); + } + } + + if (errorMessage.size() == 0) { + resultMap.put("status", true); + resultMap.put("data", completeLeaveDetailList); + } else { + resultMap.put("status", false); + resultMap.put("errorInfo", errorMessage); + resultMap.put("data", null); + } + return resultMap; + } + + private boolean kqCycleCheck(String qjry, List> detailTableData, List errorMessage, String empName) { + + /** + * 补打卡日期是否关账 + */ + Map params = Maps.newHashMap(); + params.put("userId",qjry); + params.put("submitDate",DateUtil.getCurrentDate()); + params.put("submitStr","ksrq"); + params.put("submitDataList",detailTableData); + if (detailTableData == null || detailTableData.size() == 0){ + errorMessage.add(empName + "没有请假明细数据！"); + return false; + } + Map dataMap = makeUpClockInService.getKqCycleTimeIntervalCmd(params); + List> closeList = (List>)dataMap.get("closeList"); + List nocycleList = (List)dataMap.get("nocycleList"); + List> dateList = (List>)dataMap.get("dataList"); + + boolean status = (boolean)dataMap.get("status"); + if (!status){ + errorMessage.add(empName + "没有考勤周期！"); + return false; + } + if (closeList.size() > 0 || nocycleList.size() > 0){ + String message = empName + "："; + if (nocycleList.size() > 0){ + message = message +String.join(",",nocycleList)+"未找对对应的考勤周期；"; + } + if (closeList.size() > 0){ + List list = closeList.stream().map(e->e.get("rq").toString()).collect(Collectors.toList()); + message = message +String.join(",",list)+"对应的考勤周期的考勤周期已关账"; + } + errorMessage.add(message); + return false; + } + return true; + } + + private List> matchHolidayBalance(Map editedLeaveInfo, List checkAmountJqIdList, List errorMessage, String empId, String empName, + List> canUseCheckJqyeInfo, List> canUseFirstJqyeInfo, Map editedUseJqed, + Map editedUseJqlxWithEmp,List> leaveDetailList, String checkItemId, String firstItemId) { + List> result = new ArrayList<>(); + //记录分配假期余额的结果 + boolean matchResultSign = true; + //此次遍历请假总时长 + double totalLeaveDuration = 0; + for (Map detailData : leaveDetailList) { + String qtj = Util.null2String(detailData.get("qtj")); + String btj = Util.null2String(detailData.get("btj")); + //请假时间 + double leaveDuration = 0; + if (qtj.equals(CheckBoxEnum.CHECKED.getKey())) { + //全天默认8小时 + leaveDuration = 8; + } else if (btj.equals(CheckBoxEnum.CHECKED.getKey())) { + //半天默认4小时 + leaveDuration = 4; + } else{ + leaveDuration = Double.parseDouble(Util.null2String(detailData.get("qjsc"))); + } + totalLeaveDuration = totalLeaveDuration + leaveDuration; + } + //减去编辑已使用时长 + Double checkItemEditedUseSc = editedUseJqlxWithEmp.get(checkItemId + "_" + empId); + Double firstItemEditedUseSc = editedUseJqlxWithEmp.get(firstItemId + "_" + empId); + totalLeaveDuration = Utils.subtract(totalLeaveDuration, checkItemEditedUseSc == null ? 0 : checkItemEditedUseSc); + totalLeaveDuration = Utils.subtract(totalLeaveDuration, firstItemEditedUseSc == null ? 0 : firstItemEditedUseSc); + //如果总时长为0，则退出 + if (totalLeaveDuration <= 0) { + return result; + } + Map leaveDurationMap = new HashMap<>(); + leaveDurationMap.put("totalLeaveDuration", totalLeaveDuration); + //默认存在优先使用项目时长 + boolean firstItemHaveDuration = true; + //优先使用的假期类型项目是否不需要校验假期余额的额度 + boolean firstItemNonCheck = firstItemId != null && !checkAmountJqIdList.contains(firstItemId); + //勾选的假期类型项目是否不需要校验假期余额的额度 + boolean checkItemNonCheck = !checkAmountJqIdList.contains(checkItemId); + //遍历关联请假余额id和假期类型id + for (Map detailData : leaveDetailList) { + String ksrq = Util.null2String(detailData.get("ksrq")); + String qtj = Util.null2String(detailData.get("qtj")); + String btj = Util.null2String(detailData.get("btj")); + //请假时间 + double leaveDuration = 0; + if (qtj.equals(CheckBoxEnum.CHECKED.getKey())) { + //全天默认8小时 + leaveDuration = 8; + } else if (btj.equals(CheckBoxEnum.CHECKED.getKey())) { + //半天默认4小时 + leaveDuration = 4; + } else{ + leaveDuration = Double.parseDouble(Util.null2String(detailData.get("qjsc"))); + } + log.info("leaveDuration : [{}]", leaveDuration); + //优先使用的的请假项目是否已被编辑 + double firstItemEditedDetailSc = editedLeaveInfo.get(empId + "_" + firstItemId + "_" + ksrq) == null ? 0 : Double.parseDouble(editedLeaveInfo.get(empId + "_" + firstItemId + "_" + ksrq)); + boolean firstItemEditedDetail = editedLeaveInfo.get(empId + "_" + firstItemId + "_" + ksrq) != null; + //勾选的请假项目是否已被编辑 + double checkItemEditedDetailSc = editedLeaveInfo.get(empId + "_" + checkItemId + "_" + ksrq) == null ? 0 : Double.parseDouble(editedLeaveInfo.get(empId + "_" + checkItemId + "_" + ksrq)); + boolean checkItemEditedDetail = editedLeaveInfo.get(empId + "_" + checkItemId + "_" + ksrq) != null || (firstItemEditedDetail && firstItemEditedDetailSc - leaveDuration >= 0); + if (checkItemEditedDetail) { + leaveDuration = Utils.subtract(leaveDuration, firstItemEditedDetailSc); + leaveDuration = Utils.subtract(leaveDuration, checkItemEditedDetailSc); + if (leaveDuration <= 0) { + continue; + } + } + //存在优先使用假期类型时,且该假期类型不需要进行额度校验 + if (firstItemNonCheck && !firstItemEditedDetail) { + detailData.put("qjlx", firstItemId); + detailData.put("qjsc", String.valueOf(leaveDuration)); + result.add(detailData); + continue; + } + //不存在优先使用假期类型时，勾选的假期类型不需要进行额度校验 + if (firstItemId == null && checkItemNonCheck && !checkItemEditedDetail) { + detailData.put("qjlx", checkItemId); + detailData.put("qjsc", String.valueOf(leaveDuration)); + result.add(detailData); + continue; + } + + leaveDurationMap.put("leaveDuration", leaveDuration); + //存在优先使用假期类型时,但是需要进行额度校验 + if (canUseFirstJqyeInfo != null && canUseFirstJqyeInfo.size() > 0 && firstItemHaveDuration && !firstItemEditedDetail) { + dealLeaveDetailWithJqyeInfo(detailData, canUseFirstJqyeInfo, editedUseJqed, leaveDurationMap, ksrq, firstItemId, result); + if (leaveDurationMap.get("leaveDuration") == 0) { + //如果同假期类型出现多假期余额拼接配置一条请假明细时，请假明细的时长需要重新设置下 + //请假明细初始要求时长已配置完成则赋值为初始请假时长，否则为初始时长-剩余未配置时长 + if (Util.null2String(detailData.get("jqye")).contains(",")) { + detailData.put("qjsc", String.valueOf(leaveDuration)); + } + continue; + } else { + firstItemHaveDuration = false; + if (Util.null2String(detailData.get("jqye")).contains(",")) { + detailData.put("qjsc", String.valueOf(leaveDuration - leaveDurationMap.get("leaveDuration"))); + } + } + } + if (!"".equals(Util.null2String(detailData.get("qjlx")))) { + result.add(new HashMap<>(detailData)); + detailData.remove("qjlx"); + detailData.remove("qjsc"); + detailData.remove("jqye"); + } + //不存在优先使用假期类型，或者优先使用假期类型关联的假期余额用完时 + //勾选的假期类型不需要进行额度校验 + if (checkItemNonCheck && !checkItemEditedDetail) { + detailData.put("qjlx", checkItemId); + detailData.put("qjsc", String.valueOf(leaveDurationMap.get("leaveDuration"))); + result.add(detailData); + continue; + } + //勾选的假期类型需要进行额度校验 + if (!checkItemEditedDetail) { + dealLeaveDetailWithJqyeInfo(detailData, canUseCheckJqyeInfo, editedUseJqed, leaveDurationMap, ksrq, checkItemId, result); + } + if (leaveDurationMap.get("leaveDuration") > 0) { + //假期余额不足 + String message = empName + "假期余额不足！"; + errorMessage.add(message); + matchResultSign = false; + break; + } + } + return matchResultSign ? result : new ArrayList<>(); + } + + private void dealLeaveDetailWithJqyeInfo(Map detailData, List> canUseJqyeInfo, + Map editedUseJqed, Map leaveDurationMap, + String ksrq, String itemId, List> result) { + double totalLeaveDuration = leaveDurationMap.get("totalLeaveDuration"); + double leaveDuration = leaveDurationMap.get("leaveDuration"); + //假期类型相关的假期余额记录 + List> holidayBalancefilterList = Lists.newArrayList(); + for (Map map : canUseJqyeInfo){ + if (DateUtil.getTime(map.get("yqsxrq").toString()).compareTo(DateUtil.getTime(ksrq)) >= 0){ + holidayBalancefilterList.add(map); + } + } + //使用的假期类型的额度单位 + String eddw = Util.null2String(holidayBalancefilterList.get(0).get("eddw")); + int multipleNum = eddw.equals(AccountingUnitEnum.DAY.getKey()) ? 8 : 1; + for (Map holidayBalance : holidayBalancefilterList) { + //1-如果已编辑的请假明细中已有该假期余额id的记录，则满足最小使用时长 + boolean minLeaveDurationSign = editedUseJqed.get(holidayBalance.get("id").toString()) != null; + //2-如果编辑记录中不存在，则需要判断是否满足最小使用时长 + if (!minLeaveDurationSign) { + String minLeaveDuration = Util.null2String(holidayBalance.get("minLeaveDuration")); + minLeaveDurationSign = "".equals(minLeaveDuration) || totalLeaveDuration > Double.parseDouble(minLeaveDuration); + } + //不满足最小使用时长，直接执行下一条 + if (!minLeaveDurationSign) { + continue; + } + //额定未休时长 + double wxsc = Util.null2String(holidayBalance.get("wxsc")).equals("") ? 0 : Double.valueOf(holidayBalance.get("wxsc").toString()); + wxsc = multipleNum * wxsc; + if (leaveDuration > 0 && wxsc > 0) { + detailData.put("qjlx", itemId); + String jqyeId = Util.null2String(detailData.get("jqye")); + if (leaveDuration > wxsc) { + detailData.put("qjsc", String.valueOf(wxsc)); + leaveDuration = Utils.subtract(leaveDuration, wxsc); + totalLeaveDuration = Utils.subtract(totalLeaveDuration, wxsc); + if ("".equals(jqyeId)) { + detailData.put("jqye", holidayBalance.get("id").toString() + "_" + wxsc); + } else { + //同一假期类型，当一条假期余额记录不足请假时长需求时，需要拼接上另一条假期余额记录的id + detailData.put("jqye", jqyeId + "," + holidayBalance.get("id").toString() + "_" + wxsc); + } + wxsc = 0; + } else { + detailData.put("qjsc", String.valueOf(leaveDuration)); + wxsc = Utils.subtract(wxsc, leaveDuration); + //可能存在倍数转换 + wxsc = Utils.divide(wxsc, multipleNum); + totalLeaveDuration = Utils.subtract(totalLeaveDuration, leaveDuration); + if ("".equals(jqyeId)) { + detailData.put("jqye", holidayBalance.get("id").toString() + "_" + leaveDuration); + } else { + //同一假期类型，当一条假期余额记录不足请假时长需求时，需要拼接上另一条假期余额记录的id + detailData.put("jqye", jqyeId + "," + holidayBalance.get("id").toString() + "_" + leaveDuration); + } + leaveDuration = 0; + result.add(detailData); + } + + holidayBalance.put("wxsc", wxsc); + } + } + leaveDurationMap.put("totalLeaveDuration", totalLeaveDuration); + leaveDurationMap.put("leaveDuration", leaveDuration); + } + + + /** + * 收集假期类型关联的可使用的假期余额 + * @param unableUseJqyeIdList 不可使用的假期余额id集合 + * @param editedUseJqed 已编辑过的假期余额id和具体使用的时长映射 + * @param itemId 假期类型对应的考勤项目id + * @param startDate + * @param leaveEmpId + * @return + */ + private List> collectUsableHolidayBalance(List unableUseJqyeIdList, Map editedUseJqed, String itemId, String startDate, String leaveEmpId) { + String sql = "select id,jqid,sxrq,ktsc,yxsc,wxsc,yqsxrq,ztsc from uf_jcl_kq_jqye where ygid=? and jqid=? and sxrq<=? and yqsxrq>=? order by sxrq"; + List> holidayBalanceList = DbTools.getSqlToList(sql, leaveEmpId, itemId, startDate, startDate); + //获取假期额度规则中额度可修次数、单次最小休时长、额度单位 + String jqedSql = "select eddw, dczskxsc, edbxdcxw from uf_jcl_kq_jqed where jb = ?"; + Map jqedInfo = DbTools.getSqlToMap(jqedSql, itemId); + //假期额度的额度单位，0-天、1-小时 + String eddw = Util.null2String(jqedInfo.get("eddw")); + //单次最小休时长 + String minDuration = Util.null2String(jqedInfo.get("dczskxsc")); + Double minLeaveDuration = null; + if (!"".equals(eddw) && !"".equals(minDuration)) { + minLeaveDuration = Double.parseDouble(minDuration); + if (eddw.equals(AccountingUnitEnum.DAY.getKey())) { + minLeaveDuration = minLeaveDuration * 8; + } + } + //额度可修次数 + String allowLeaveNumStr = Util.null2String(jqedInfo.get("edbxdcxw")); + if (!"".equals(allowLeaveNumStr) && holidayBalanceList.size() > 0) { + //查询请假记录中，人员id+假期类别id情况下的结果，遍历每条主表数据下的明细数据中使用了哪些假期余额id + sql = "select a.id,dt2.jqye from uf_jcl_kq_qjjl a left join uf_jcl_kq_qjjl_dt1 dt1 on dt1.mainid = a.id left join uf_jcl_kq_qjjl_dt2 dt2 on dt2.glmxid = dt1.glmxid " + + "where a.jqlx = " + itemId + " and qjry = " + leaveEmpId + " and a.cxqj = 0 and dt1.cxqj = 0 and a.jlzt in (0, 1) and dt1.glmxid is not null"; + List> leaveList = DbTools.getSqlToList(sql); + Map jqyeUseNumInfo = new HashMap<>(); + List leaveUseList = new ArrayList<>(); + Integer useNum = 0; + for (Map leaveItem : leaveList) { + String jqyeId = Util.null2String(leaveItem.get("jqye")); + if (!"".equals(jqyeId)) { + String leaveInfo = leaveItem.get("id").toString() + "_" + jqyeId; + if (leaveUseList.size() == 0) { + leaveUseList.add(leaveInfo); + jqyeUseNumInfo.put(jqyeId, 1); + } else if (!leaveUseList.contains(leaveInfo)) { + leaveUseList.add(leaveInfo); + useNum = jqyeUseNumInfo.get(jqyeId); + jqyeUseNumInfo.put(jqyeId, useNum == null ? 1 : ++useNum); + } + } + } + //筛选次数未使用完的假期余额 + holidayBalanceList = holidayBalanceList.stream().filter(f -> { + int beforeUseNum = jqyeUseNumInfo.get(f.get("id").toString()) == null ? 0 : jqyeUseNumInfo.get(f.get("id").toString()); + return Integer.parseInt(allowLeaveNumStr) > beforeUseNum; + }).collect(Collectors.toList()); + } + //遍历可使用的假期余额，去除已编辑请假明细记录中使用的时长 + List> canUseHolidayBalanceList = new ArrayList<>(); + for (Map holidayBalance : holidayBalanceList) { + String jqyeId = Util.null2String(holidayBalance.get("id")); + if (!unableUseJqyeIdList.contains(jqyeId)) { + double wxsc = Utils.convertDouble(holidayBalance.get("wxsc")); + double editedUseSc = Utils.convertDouble(editedUseJqed.get(jqyeId)); + double realWxsc = wxsc - editedUseSc; + if ((minLeaveDuration == null || wxsc >= minLeaveDuration) && realWxsc > 0) { + + holidayBalance.put("wxsc", realWxsc); + holidayBalance.put("minLeaveDuration", minLeaveDuration); + holidayBalance.put("eddw", eddw); + canUseHolidayBalanceList.add(holidayBalance); + } + } + } + return canUseHolidayBalanceList; + } + + /** + * 请假人的请假区间内的排班结果 + * @param leaveEmpIdList + * @param startDate + * @param endDate + * @return + */ + private Map>> getScheduleInfoWithEmpId(List leaveEmpIdList, String startDate, String endDate) { + Map>> scheduleInfo = new HashMap<>(); + Map params = new HashMap<>(); + params.put("tableName", "uf_pbjg"); + params.put("startDate", startDate); + params.put("endDate", endDate); + params.put("pblx", "0"); + params.put("current", "1"); + params.put("pageSize", "999"); + params.put("recurrence", "1"); + for (String empId : leaveEmpIdList) { + params.put("pbdx", empId); + Map schedulingResultsMap = schedulingResultsService.queryDataTableActualUse(params); + scheduleInfo.put(empId, (List>) schedulingResultsMap.get("data")); + } + return scheduleInfo; + } + + /** + * 请假人的请假区间内属于休息日的日期集合 + * @param leaveEmpIdList + * @param leaveType + * @param startDate + * @param endDate + * @return + */ + private Map> getRestDayWithEmpId(List leaveEmpIdList, String leaveType, String startDate, String endDate) { + Map> restDayInfoWithEmpId = new HashMap<>(); + + Map restDayParam = new HashMap<>(); + restDayParam.put("itemId", leaveType); + restDayParam.put("startDate", startDate); + restDayParam.put("endDate", endDate); + + List dateTypeList = new ArrayList<>(); + dateTypeList.add(DateTypeEnum.HOLIDAY.getKey()); + dateTypeList.add(DateTypeEnum.PUBLIC_RESTDAY.getKey()); + dateTypeList.add(DateTypeEnum.EXCHANGE_LEAVEDAY.getKey()); + Map restDayInfo = new HashMap<>(); + List> dataList = new ArrayList<>(); + List restDateList = new ArrayList<>(); + for (String empId : leaveEmpIdList) { + restDayParam.put("userId", empId); + restDayInfo = getRestDayInterval(restDayParam); + dataList = (List>) restDayInfo.get("data"); + if (dataList != null && dataList.size() > 0) { + restDateList = dataList.stream() + .filter(f -> dateTypeList.contains(Util.null2String(f.get("rqlx")))) + .map(e -> Util.null2String(e.get("rq"))) + .collect(Collectors.toList()); + } + restDayInfoWithEmpId.put(empId, restDateList); + } + return restDayInfoWithEmpId; + } } diff --git a/src/com/engine/attendance/workflow/web/AskForLeaveAction.java b/src/com/engine/attendance/workflow/web/AskForLeaveAction.java index fb3833a..34b7a56 100644 --- a/src/com/engine/attendance/workflow/web/AskForLeaveAction.java +++ b/src/com/engine/attendance/workflow/web/AskForLeaveAction.java @@ -95,4 +95,31 @@ public class AskForLeaveAction { return ApiReturnTools.error("500","getBusinessTripsApplyList error"); } } + + /** + * 批量请假-生成请假信息明细表数据 + * @return + */ + @GET + @Path("/generateLeaveInfoList") + @Produces({"text/plain"}) + public String generateLeaveInfoList(@Context HttpServletRequest request, @Context HttpServletResponse response) { + try { + Map param = ParamUtil.request2Map(request); + User user = HrmUserVarify.getUser(request, response); + String mainTableDataStr = Util.null2String(param.get("mainTableData")); + String detailTableDataStr = Util.null2String(param.get("detailTableData")); + Gson gson = new Gson(); + Map mainTableData = gson.fromJson(mainTableDataStr, (Type) Map.class); + List> detailTableData = gson.fromJson(detailTableDataStr, (Type) List.class); + + param.put("mainTableData",mainTableData); + param.put("detailTableData",detailTableData); +// return new ResponseResult, Map>(user).run(getAskForLeaveService(user) :: generateLeaveInfoList,param); + return null; + }catch (Exception e){ + log.error("sync fund status fail,catch error: [{}]",e); + return ApiReturnTools.error("200","查询失败"); + } + } } diff --git a/src/com/engine/common/util/DateUtil.java b/src/com/engine/common/util/DateUtil.java index a3220a6..32643f4 100644 --- a/src/com/engine/common/util/DateUtil.java +++ b/src/com/engine/common/util/DateUtil.java @@ -3,11 +3,15 @@ package com.engine.common.util; import org.apache.commons.lang3.StringUtils; import weaver.general.TimeUtil; +import java.text.ParseException; +import java.text.SimpleDateFormat; import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoUnit; +import java.util.ArrayList; import java.util.Calendar; import java.util.Date; +import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -355,4 +359,27 @@ public class DateUtil { public static boolean checkYearMonth(String yearMonth) { return Pattern.matches(MONTH_REGEX, yearMonth); } + + /** + * 获取两个日期间的日期集合 + * @param startDateStr + * @param endDateStr + * @return + * @throws ParseException + */ + public static List getDatesBetween(String startDateStr, String endDateStr) throws ParseException { + List dates = new ArrayList<>(); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + Date startDate = sdf.parse(startDateStr); + Date endDate = sdf.parse(endDateStr); + + Calendar calendar = Calendar.getInstance(); + calendar.setTime(startDate); + + while (calendar.getTime().before(endDate) || calendar.getTime().equals(endDate)) { + dates.add(sdf.format(calendar.getTime())); + calendar.add(Calendar.DATE, 1); + } + return dates; + } } diff --git a/src/com/engine/common/util/Utils.java b/src/com/engine/common/util/Utils.java index 99d94f1..f51f185 100644 --- a/src/com/engine/common/util/Utils.java +++ b/src/com/engine/common/util/Utils.java @@ -698,6 +698,17 @@ public class Utils { return new BigDecimal(value1).multiply(new BigDecimal(value2),new MathContext(BigDecimal.ROUND_HALF_UP)).doubleValue(); } + /** + * 相除 + * @param value1 + * @param value2 + * @return + */ + public static double divide(double value1, int value2){ + + return new BigDecimal(value1).divide(new BigDecimal(value2), 2, RoundingMode.HALF_UP).doubleValue(); + } + /** * 根据日期和时间组装日期时间 * @param date