package com.engine.salary.service.impl; import com.cloudstore.dev.api.util.Util_DataCache; import com.cloudstore.eccom.pc.table.WeaTableColumn; import com.engine.common.util.ServiceUtil; import com.engine.core.impl.Service; import com.engine.salary.biz.SIArchivesBiz; import com.engine.salary.cmd.siarchives.SIArchivesTipsCmd; import com.engine.salary.entity.siarchives.bo.InsuranceArchivesBaseInfoBO; import com.engine.salary.entity.siarchives.dto.InsuranceArchivesBaseHistoryDTO; import com.engine.salary.entity.siarchives.param.InsuranceArchivesListParam; import com.engine.salary.entity.siarchives.param.InsuranceArchivesSaveParam; import com.engine.salary.entity.siarchives.param.SIArchiveBaseHistoryListParam; import com.engine.salary.entity.siarchives.po.*; import com.engine.salary.entity.taxagent.dto.TaxAgentEmployeeDTO; import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO; import com.engine.salary.entity.taxagent.po.TaxAgentEmpChangePO; import com.engine.salary.entity.taxagent.po.TaxAgentPO; import com.engine.salary.enums.salaryaccounting.EmployeeTypeEnum; import com.engine.salary.enums.siaccount.EmployeeStatusEnum; import com.engine.salary.enums.sicategory.DeleteTypeEnum; import com.engine.salary.enums.sicategory.NonPaymentEnum; import com.engine.salary.enums.sicategory.PaymentScopeEnum; import com.engine.salary.enums.sicategory.WelfareTypeEnum; import com.engine.salary.enums.taxagent.TaxAgentEmpChangeModuleEnum; import com.engine.salary.exception.SalaryRunTimeException; import com.engine.salary.mapper.siarchives.FundSchemeMapper; import com.engine.salary.mapper.siarchives.InsuranceBaseInfoMapper; import com.engine.salary.mapper.siarchives.OtherSchemeMapper; import com.engine.salary.mapper.siarchives.SocialSchemeMapper; import com.engine.salary.service.SIArchivesService; import com.engine.salary.service.TaxAgentEmpChangeService; import com.engine.salary.service.TaxAgentService; import com.engine.salary.sys.constant.SalarySysConstant; import com.engine.salary.sys.entity.po.SalarySysConfPO; import com.engine.salary.sys.entity.vo.OrderRuleVO; import com.engine.salary.sys.service.SalarySysConfService; import com.engine.salary.sys.service.impl.SalarySysConfServiceImpl; import com.engine.salary.util.SalaryEntityUtil; import com.engine.salary.util.SalaryI18nUtil; import com.engine.salary.util.db.MapperProxyFactory; import com.engine.salary.util.excel.ExcelUtil; import com.engine.salary.util.page.PageInfo; import com.engine.salary.util.page.SalaryPageUtil; import com.google.common.collect.Lists; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.springframework.transaction.annotation.Transactional; import org.springframework.util.StopWatch; import weaver.general.BaseBean; import weaver.general.Util; import weaver.hrm.User; import java.text.SimpleDateFormat; import java.util.*; import java.util.stream.Collectors; /** * @Author weaver_cl * @Description: * @Date 2022/3/11 * @Version V1.0 **/ @Slf4j public class SIArchivesServiceImpl extends Service implements SIArchivesService { private final BaseBean baseBean = new BaseBean(); private final Boolean isLog = "true".equals(baseBean.getPropValue("hrmSalary", "log")); private SIArchivesBiz siArchivesBiz = new SIArchivesBiz(); private TaxAgentService getTaxAgentService(User user) { return ServiceUtil.getService(TaxAgentServiceImpl.class, user); } private SalarySysConfService getSalarySysConfService(User user) { return ServiceUtil.getService(SalarySysConfServiceImpl.class, user); } private InsuranceBaseInfoMapper getInsuranceBaseInfoMapper() { return MapperProxyFactory.getProxy(InsuranceBaseInfoMapper.class); } private TaxAgentEmpChangeService getTaxAgentEmpChangeService(User user) { return ServiceUtil.getService(TaxAgentEmpChangeServiceImpl.class, user); } private SocialSchemeMapper getSocialSchemeMapper() { return MapperProxyFactory.getProxy(SocialSchemeMapper.class); } private FundSchemeMapper getFundSchemeMapper() { return MapperProxyFactory.getProxy(FundSchemeMapper.class); } private OtherSchemeMapper getOtherSchemeMapper() { return MapperProxyFactory.getProxy(OtherSchemeMapper.class); } @Override public Map getTips(Map params) { return commandExecutor.execute(new SIArchivesTipsCmd(params, user)); } @Override public Map getBaseForm(Map params) { long currentEmployeeId = user.getUID(); Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId); Collection taxAgentPOS = getTaxAgentService(user).listAllTaxAgentsAsAdmin(currentEmployeeId); Map apidatas = new HashMap<>(16); SIArchivesBiz siArchivesBiz = new SIArchivesBiz(); siArchivesBiz.setNeedAuth(needAuth); siArchivesBiz.setTaxAgentPOS(taxAgentPOS); WelfareTypeEnum welfareTypeEnum = (WelfareTypeEnum) params.get("welfareTypeEnum"); Long employeeId = Long.valueOf(Util.null2String(params.get("employeeId"))); Long paymentOrganization = welfareTypeEnum != null ? Long.valueOf(Util.null2String(params.get("paymentOrganization"))) : null; apidatas = siArchivesBiz.getBaseForm(welfareTypeEnum, employeeId, (long) user.getUID(), user, paymentOrganization); return apidatas; } @Override public Map getPaymentForm(Map params) { Map apidatas = new HashMap<>(16); SIArchivesBiz siArchivesBiz = new SIArchivesBiz(); WelfareTypeEnum welfareTypeEnum = (WelfareTypeEnum) params.get("welfareTypeEnum"); Long employeeId = Long.valueOf(Util.null2String(params.get("employeeId"))); String schemeIdStr = Util.null2String(params.get("schemeId")); Long paymentOrganization = Long.valueOf(Util.null2String(params.get("paymentOrganization"))); Long schemeId = null; if (StringUtils.isNotBlank(schemeIdStr)) { schemeId = Long.valueOf(schemeIdStr); } apidatas = siArchivesBiz.getPaymentForm(user, welfareTypeEnum, employeeId, (long) user.getUID(), schemeId, paymentOrganization); return apidatas; } @Override public String insert(InsuranceArchivesSaveParam param) { SIArchivesBiz siArchivesBiz = new SIArchivesBiz(); siArchivesBiz.insert(param, user); return null; } @Override public Map listPage(InsuranceArchivesListParam param) { long currentEmployeeId = user.getUID(); log.info("获取福利档案列表逻辑开始： {}", param); StopWatch sw = new StopWatch(); sw.start("福利档案-历史数据处理"); // 1.历史数据处理 handleHistoryData(currentEmployeeId); sw.stop(); sw.start("福利档案-待减员自动处理"); // 2.待减员自动处理 handleStayDelData(currentEmployeeId); sw.stop(); // sw.start("福利档案-增量数据处理"); // // 3.增量数据处理 // String welSign = (String) Util_DataCache.getObjVal("welfareChangeSign"); // if (welSign == null || "0".equals(welSign)) { // handleChangeData(currentEmployeeId); // } // sw.stop(); //排序配置 OrderRuleVO orderRule = getSalarySysConfService(user).orderRule(); param.setOrderRule(orderRule); Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId); param.setNeedAuth(needAuth); if (needAuth) { List taxAgentEmployeeDTOS = getTaxAgentService(user).listTaxAgentAndEmployee(currentEmployeeId); Set employeeIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getEmployeeId); Set taxAgentIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getTaxAgentId); param.setTaxAgentEmployeeIds(employeeIds); param.setTaxAgentIds(taxAgentIds); } Map apidatas = new HashMap<>(16); SIArchivesBiz siArchivesBiz = new SIArchivesBiz(); apidatas = siArchivesBiz.listPage(param, (long) user.getUID()); log.info("各操作计时 {}", sw.prettyPrint()); return apidatas; } /** * 福利档案中历史数据自动处理 * @param currentEmployeeId */ private void handleHistoryData(long currentEmployeeId) { //如果触发历史数据处理，则进行一次全量增员 if (siArchivesBiz.createOldInsuranceBaseInfo(currentEmployeeId)) { //批量增员 List allBaseInfoList = getInsuranceBaseInfoMapper().listAll(); Collection stayAddIds = allBaseInfoList.stream().filter(f->f.getRunStatus().equals(EmployeeStatusEnum.STAY_ADD.getValue())) .map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); if (stayAddIds.size() > 0) { stayAddToPay(stayAddIds); } } } /** * 福利档案中待减员数据自动处理 * @param currentEmployeeId */ @Override @Transactional(rollbackFor = Exception.class) public void handleStayDelData(long currentEmployeeId) { log.info("福利档案中待减员数据自动处理逻辑开始："); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM"); String today = simpleDateFormat.format(new Date()); //part1，员工维护了社保/公积金/其他福利最后缴纳日,且任一类信息大于今天的，自动将待减员状态置为正在缴纳状态 List rePayList = getInsuranceBaseInfoMapper().getRePayList(today); updateInsuranceBaseInfoRunStatus(rePayList, EmployeeStatusEnum.PAYING.getValue()); log.info("自动将待减员状态置为正在缴纳状态的档案数量 {}：", rePayList.size()); //part2，员工维护了社保/公积金/其他福利最后缴纳日,且三类信息都小于今天的，自动置为待减员状态 List reStayDelList = getInsuranceBaseInfoMapper().getReStayDelList(today); updateInsuranceBaseInfoRunStatus(reStayDelList, EmployeeStatusEnum.STAY_DEL.getValue()); log.info("自动置为待减员状态的档案数量 {}：", reStayDelList.size()); //part3，非在职员工且处于正常缴纳的福利档案置为待减员状态 //定义非在职的人事状态 List personnelStatuses = new ArrayList() {{ add("5"); add("6"); add("7"); }}; if (CollectionUtils.isNotEmpty(personnelStatuses)) { //获取非在职员工的福利档案基础信息 InsuranceArchivesListParam insuranceArchivesListParam = new InsuranceArchivesListParam(); insuranceArchivesListParam.setPersonnelStatuses(personnelStatuses); insuranceArchivesListParam.setRunStatuses(Collections.singletonList(EmployeeStatusEnum.PAYING.getValue())); List noNormalList = getInsuranceBaseInfoMapper().getAbnormalList(insuranceArchivesListParam); updateInsuranceBaseInfoRunStatus(noNormalList, EmployeeStatusEnum.STAY_DEL.getValue()); log.info("自动处理非在职员工的档案数量 {}：", noNormalList.size()); } } /** * 福利档案中增量数据处理 * @param currentEmployeeId */ @Transactional(rollbackFor = Exception.class) @Override public void handleChangeData(long currentEmployeeId) { try { Util_DataCache.setObjVal("welfareChangeSign", "1"); log.info("福利档案中增量数据处理逻辑开始："); // 所有增量人员列表 List taxAgentEmpChangeList = getTaxAgentEmpChangeService(user).listAllByModule(TaxAgentEmpChangeModuleEnum.INSURANCE_ARCHIVE); log.info("待处理的福利档案增量数据数量 {}：", taxAgentEmpChangeList.size()); if (CollectionUtils.isEmpty(taxAgentEmpChangeList)) { Util_DataCache.setObjVal("welfareChangeSign", "0"); return; } // 当前可以管辖的人员 Collection taxAgentList = new ArrayList<>(); if (currentEmployeeId != 1L) { taxAgentList = getTaxAgentService(user).listAllTaxAgents(currentEmployeeId); Collection finalTaxAgentList = taxAgentList; taxAgentEmpChangeList = taxAgentEmpChangeList.stream().filter(f -> finalTaxAgentList.stream().anyMatch(e -> e.getId().equals(f.getTaxAgentId()))).collect(Collectors.toList()); if (CollectionUtils.isEmpty(taxAgentEmpChangeList)) { Util_DataCache.setObjVal("welfareChangeSign", "0"); return; } } // Collection taxAgentList = getTaxAgentService(user).listAllTaxAgents(currentEmployeeId); // log.info("当前可以管辖的个税扣缴义务人数量 {}：", taxAgentList.size()); // taxAgentEmpChangeList = taxAgentEmpChangeList.stream().filter(f -> taxAgentList.stream().anyMatch(e -> e.getId().equals(f.getTaxAgentId()))).collect(Collectors.toList()); // if (CollectionUtils.isEmpty(taxAgentEmpChangeList)) { // Util_DataCache.setObjVal("welfareChangeSign", "0"); // return; // } log.info("根据当前可以管辖的个税扣缴义务人筛选出的可处理增量数据数量 {}：", taxAgentEmpChangeList.size()); // 所有福利档案基础信息数据 List baseInfoPOList = getInsuranceBaseInfoMapper().listAll(); log.info("当前数据库中所有福利档案基础信息数据数量 {}：", baseInfoPOList.size()); StopWatch sw = new StopWatch(); sw.start("将增量数据进一步处理为新增、更新两类数据"); InsuranceArchivesBaseInfoBO.ChangeData changeData = InsuranceArchivesBaseInfoBO.buildChangeData(taxAgentEmpChangeList, baseInfoPOList, currentEmployeeId); sw.stop(); // 批量修改福利档案 if (CollectionUtils.isNotEmpty(changeData.getBaseInfoUpdateTodoList())) { log.info("增量数据中待更新的数据数量 {}：", changeData.getBaseInfoUpdateTodoList().size()); //对于即将调整为“待减员”的数据，更新社保、公积金、其他福利档案的停止缴纳时间 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM"); String today = simpleDateFormat.format(new Date()); sw.start("生成增量数据中即将置为“待减员”的数据"); List toStayDelList = changeData.getBaseInfoUpdateTodoList().stream() .filter(f -> f.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue())) .collect(Collectors.toList()); if (isLog) { log.info("福利档案-待减员明细:{}", toStayDelList); } if (toStayDelList.size() > 0) { List> partitionUpdateEndTime = Lists.partition(toStayDelList, 100); partitionUpdateEndTime.forEach(part->{ List socialIds = part.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList()); List fundIds = part.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList()); List otherIds = part.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList()); getSocialSchemeMapper().batchUpdateEndTime(socialIds, today); getFundSchemeMapper().batchUpdateEndTime(fundIds, today); getOtherSchemeMapper().batchUpdateEndTime(otherIds, today); }); } sw.stop(); sw.start("生成增量数据中即将置为“逻辑删除”的数据"); //对于逻辑删除的数据，同样逻辑删除相关的社保、公积金、其他福利档案 List delList = changeData.getBaseInfoUpdateTodoList().stream() .filter(f -> f.getDeleteType().equals(DeleteTypeEnum.DELETED.getValue())) .collect(Collectors.toList()); if (isLog) { log.info("福利档案-逻辑删除明细:{}", delList); } if (delList.size() > 0) { for (InsuranceArchivesBaseInfoPO po : delList) { getSocialSchemeMapper().deleteByEmployeeIdAndPayOrg(InsuranceArchivesSocialSchemePO.builder() .employeeId(po.getEmployeeId()) .paymentOrganization(po.getPaymentOrganization()) .build()); getFundSchemeMapper().deleteByEmployeeIdAndPayOrg(InsuranceArchivesFundSchemePO.builder() .employeeId(po.getEmployeeId()) .paymentOrganization(po.getPaymentOrganization()) .build()); getOtherSchemeMapper().deleteByEmployeeIdAndPayOrg(InsuranceArchivesOtherSchemePO.builder() .employeeId(po.getEmployeeId()) .paymentOrganization(po.getPaymentOrganization()) .build()); } } sw.stop(); //修改福利档案基础信息 sw.start("增量数据中待更新数据入库"); if (isLog) { log.info("福利档案-增量数据中待更新数据入库明细:{}", changeData.getBaseInfoUpdateTodoList()); } List> partitionUpdateBase = Lists.partition(changeData.getBaseInfoUpdateTodoList(), 100); partitionUpdateBase.forEach(part-> getInsuranceBaseInfoMapper().batchUpdate(part)); sw.stop(); log.info("增量数据中待更新的数据处理完成！"); } sw.start("处理增量数据中待新增的数据"); // 批量新增福利档案 if (CollectionUtils.isNotEmpty(changeData.getBaseInfoAddTodoList())) { log.info("增量数据中待新增的数据数量 {}：", changeData.getBaseInfoAddTodoList().size()); //新增社保、公积金、其他福利档案、福利档案基础信息 addNewInsuranceBaseInfo(changeData.getBaseInfoAddTodoList(), currentEmployeeId); log.info("增量数据中待新增的数据处理完成！"); } sw.stop(); // 删除增量数据 if (CollectionUtils.isNotEmpty(changeData.getChangeIds())) { getTaxAgentEmpChangeService(user).deleleByIds(changeData.getChangeIds()); } log.info("各操作计时 {}", sw.prettyPrint()); Util_DataCache.setObjVal("welfareChangeSign", "0"); } catch (Exception e) { log.info("福利档案-增量数据处理出错：{}", e.getMessage(), e); throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "福利档案-增量数据处理出错")); } } /** * 删除档案 * @param archiveIds */ @Override public void deleteArchive(Collection archiveIds) { if(CollectionUtils.isEmpty(archiveIds)){ throw new SalaryRunTimeException("社保福利档案参数为空!"); } SalarySysConfPO canDelete = getSalarySysConfService(user).getOneByCode(SalarySysConstant.SALARY_ARCHIVE_DELETE); if(Objects.isNull(canDelete) || StringUtils.equals(canDelete.getConfValue(),"0") ){ throw new SalaryRunTimeException("不允许删除社保福利档案，请先开启删除档案规则配置！"); } List insuranceArchivesList = getInsuranceBaseInfoMapper().listByIds(archiveIds); //查询当前登录人员管理的个税扣缴义务人 List canDeleteTaxAgentIds = getTaxAgentService(user).listAllTaxAgentsAsAdmin((long) user.getUID()) .stream().map(TaxAgentPO::getId).collect(Collectors.toList()); boolean err = insuranceArchivesList.stream().anyMatch(po -> !canDeleteTaxAgentIds.contains(po.getPaymentOrganization())); if (CollectionUtils.isEmpty(insuranceArchivesList) || err) { throw new SalaryRunTimeException("社保档案不存在，或没有权限删除该社保案！"); } Optional fixedList = insuranceArchivesList.stream().filter(archive -> !StringUtils.equals(archive.getRunStatus(), EmployeeStatusEnum.STAY_ADD.getValue()) && !StringUtils.equals(archive.getRunStatus(), EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue())).findFirst(); if(fixedList.isPresent()){ throw new SalaryRunTimeException("在缴员工、待减员、停止缴纳-来自待减员，无法删除薪资档案！"); } List archiveDelIds = insuranceArchivesList.stream().map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); List socialArchiveDelIds = insuranceArchivesList.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList()); List fundArchiveDelIds = insuranceArchivesList.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList()); List otherArchiveDelIds = insuranceArchivesList.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList()); // 删除社保档案主表及3张明细表数据 if(CollectionUtils.isNotEmpty(archiveDelIds)){ getInsuranceBaseInfoMapper().deleteByIds(archiveDelIds); } if(CollectionUtils.isNotEmpty(socialArchiveDelIds)){ getSocialSchemeMapper().deleteByIds(socialArchiveDelIds); } if(CollectionUtils.isNotEmpty(fundArchiveDelIds)){ getFundSchemeMapper().deleteByIds(fundArchiveDelIds); } if(CollectionUtils.isNotEmpty(otherArchiveDelIds)){ getOtherSchemeMapper().deleteByIds(otherArchiveDelIds); } } //新增社保、公积金、其他福利档案、福利档案基础信息 private List addNewInsuranceBaseInfo(List baseInfoPOList, Long currentEmployeeId) { try { List socialList = new ArrayList<>(); List fundList = new ArrayList<>(); List otherList = new ArrayList<>(); for (InsuranceArchivesBaseInfoPO baseInfoPO : baseInfoPOList) { InsuranceArchivesSocialSchemePO insuranceArchivesSocialSchemePO = new InsuranceArchivesSocialSchemePO(); insuranceArchivesSocialSchemePO.setTenantKey(""); insuranceArchivesSocialSchemePO.setWelfareType(WelfareTypeEnum.SOCIAL_SECURITY.getValue()); insuranceArchivesSocialSchemePO.setPaymentOrganization(baseInfoPO.getPaymentOrganization()); insuranceArchivesSocialSchemePO.setNonPayment(NonPaymentEnum.YES.getValue()); insuranceArchivesSocialSchemePO.setCreator(currentEmployeeId); insuranceArchivesSocialSchemePO.setCreateTime(new Date()); insuranceArchivesSocialSchemePO.setUpdateTime(new Date()); insuranceArchivesSocialSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue()); insuranceArchivesSocialSchemePO.setEmployeeId(baseInfoPO.getEmployeeId()); socialList.add(insuranceArchivesSocialSchemePO); InsuranceArchivesFundSchemePO insuranceArchivesFundSchemePO = new InsuranceArchivesFundSchemePO(); insuranceArchivesFundSchemePO.setTenantKey(""); insuranceArchivesFundSchemePO.setWelfareType(WelfareTypeEnum.ACCUMULATION_FUND.getValue()); insuranceArchivesFundSchemePO.setPaymentOrganization(baseInfoPO.getPaymentOrganization()); insuranceArchivesFundSchemePO.setNonPayment(NonPaymentEnum.YES.getValue()); insuranceArchivesFundSchemePO.setCreator(currentEmployeeId); insuranceArchivesFundSchemePO.setCreateTime(new Date()); insuranceArchivesFundSchemePO.setUpdateTime(new Date()); insuranceArchivesFundSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue()); insuranceArchivesFundSchemePO.setEmployeeId(baseInfoPO.getEmployeeId()); fundList.add(insuranceArchivesFundSchemePO); InsuranceArchivesOtherSchemePO insuranceArchivesOtherSchemePO = new InsuranceArchivesOtherSchemePO(); insuranceArchivesOtherSchemePO.setTenantKey(""); insuranceArchivesOtherSchemePO.setWelfareType(WelfareTypeEnum.OTHER.getValue()); insuranceArchivesOtherSchemePO.setPaymentOrganization(baseInfoPO.getPaymentOrganization()); insuranceArchivesOtherSchemePO.setNonPayment(NonPaymentEnum.YES.getValue()); insuranceArchivesOtherSchemePO.setCreator(currentEmployeeId); insuranceArchivesOtherSchemePO.setCreateTime(new Date()); insuranceArchivesOtherSchemePO.setUpdateTime(new Date()); insuranceArchivesOtherSchemePO.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue()); insuranceArchivesOtherSchemePO.setEmployeeId(baseInfoPO.getEmployeeId()); otherList.add(insuranceArchivesOtherSchemePO); } //导入社保档案 if (CollectionUtils.isNotEmpty(socialList)) { log.info("新增社保档案数量：{}", socialList.size()); //根据人员id和个税扣缴义务人id删除对应档案 socialList.forEach(getSocialSchemeMapper()::deleteByEmployeeIdAndPayOrg); log.info("删除历史社保档案"); if (isLog) { log.info("新增社保档案明细:{}", socialList); } List> partition = Lists.partition(socialList, 100); partition.forEach(getSocialSchemeMapper()::batchSave); log.info("新增社保档案成功"); } //导入公积金档案 if (CollectionUtils.isNotEmpty(fundList)) { log.info("新增公积金档案数量：{}", fundList.size()); //根据人员id和个税扣缴义务人id删除对应档案 fundList.forEach(getFundSchemeMapper()::deleteByEmployeeIdAndPayOrg); log.info("删除历史公积金档案"); if (isLog) { log.info("新增公积金档案明细:{}", fundList); } List> partition = Lists.partition(fundList, 100); partition.forEach(getFundSchemeMapper()::batchSave); log.info("新增公积金档案成功"); } //导入其他福利档案 if (CollectionUtils.isNotEmpty(otherList)) { log.info("新增其他福利档案数量：{}", otherList.size()); //根据人员id和个税扣缴义务人id删除对应档案 otherList.forEach(getOtherSchemeMapper()::deleteByEmployeeIdAndPayOrg); log.info("删除历史其他福利档案"); if (isLog) { log.info("新增其他福利档案明细:{}", otherList); } List> partition = Lists.partition(otherList, 100); partition.forEach(getOtherSchemeMapper()::batchSave); log.info("新增其他福利档案成功"); } //导入福利档案基础信息 if (CollectionUtils.isNotEmpty(baseInfoPOList)) { //根据人员id和个税扣缴义务人id删除对应档案 baseInfoPOList.forEach(getInsuranceBaseInfoMapper()::deleteByEmployeeIdAndPayOrg); log.info("删除历史福利档案基础信息"); // //分批批量删除 List baseInfoEmployeeIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getEmployeeId).collect(Collectors.toList()); //查询目标人员的剩余的福利档案基础信息（社保、公积金、其他福利档案id） List moreBaseInfoPOS = new ArrayList<>(); log.info("查询目标人员的剩余的福利档案基础信息（社保、公积金、其他福利档案id）"); List> partitionInfo = Lists.partition((List) baseInfoEmployeeIds, 1000); partitionInfo.forEach(part -> moreBaseInfoPOS.addAll( getInsuranceBaseInfoMapper().getInsuranceBaseInfoListByInsuranceDetail(part))); List newInsuranceArchivesBaseInfoList = new ArrayList<>(); //设置社保、公积金、其他福利档案id log.info("设置社保、公积金、其他福利档案id"); for (InsuranceArchivesBaseInfoPO po : baseInfoPOList) { InsuranceArchivesBaseInfoPO moreBaseInfo = moreBaseInfoPOS.stream().filter(s -> Objects.equals(s.getEmployeeId(), po.getEmployeeId()) && Objects.equals(s.getPaymentOrganization(), po.getPaymentOrganization())).findFirst().orElse(null); po.setSocialArchivesId(moreBaseInfo.getSocialArchivesId()); po.setFundArchivesId(moreBaseInfo.getFundArchivesId()); po.setOtherArchivesId(moreBaseInfo.getOtherArchivesId()); newInsuranceArchivesBaseInfoList.add(po); } log.info("福利档案基础信息分批批量入库，入库数量：{}", newInsuranceArchivesBaseInfoList.size()); //分批批量入库 if (isLog) { log.info("新增福利档案基础信息明细:{}", newInsuranceArchivesBaseInfoList); } List> partition = Lists.partition(newInsuranceArchivesBaseInfoList, 100); partition.forEach(getInsuranceBaseInfoMapper()::batchSave); } return baseInfoPOList; } catch (Exception e) { log.info("新增福利档案出错：{}", e.getMessage(), e); throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "福利档案新增失败")); } } /** * 分批更新福利档案基础信息的runStatus * @param baseInfoPOList * @param runStatus */ private void updateInsuranceBaseInfoRunStatus(List baseInfoPOList, String runStatus) { if (CollectionUtils.isNotEmpty(baseInfoPOList)) { List idList = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); List> partition = Lists.partition(idList, 999); partition.forEach( part -> { InsuranceArchivesBaseInfoPO baseInfoPO = new InsuranceArchivesBaseInfoPO(); baseInfoPO.setIds(part); baseInfoPO.setRunStatus(runStatus); getInsuranceBaseInfoMapper().updateRunStatusByIds(baseInfoPO); } ); } } @Override public Map getSearchCondition(Map param) { Map apidatas = new HashMap<>(16); SIArchivesBiz siArchivesBiz = new SIArchivesBiz(); apidatas = siArchivesBiz.getSearchCondition(user); return apidatas; } @Override public XSSFWorkbook export(InsuranceArchivesListParam param) { InsuranceArchivesListParam request = InsuranceArchivesListParam.builder().build(); if (param.getHireDate() != null && param.getHireDate().length == 2) { param.setHiredateStart(param.getHireDate()[0]); param.setHiredateEnd(param.getHireDate()[1]); } if (param.getDimissionDate() != null && param.getDimissionDate().length == 2) { param.setDimissionDateStart(param.getDimissionDate()[0]); param.setDimissionDateEnd(param.getDimissionDate()[1]); } if (Objects.equals("fromQuickSearch", param.getDataSource())) { // request.setStatuses(param.getStatuses()); if (StringUtils.isNotBlank(param.getStatusesStr())) { request.setStatuses(Arrays.stream(param.getStatusesStr().split(",")).map(String::new).collect(Collectors.toList())); } request.setKeyword(param.getUserName()); } else { request = param; } request.setPageSize(null); request.setStartNum(null); List insuranceArchivesEmployeePOS = listPageEmployeePOS(request); if (insuranceArchivesEmployeePOS == null) { insuranceArchivesEmployeePOS = new ArrayList<>(); } List> records = siArchivesBiz.buildTableData(insuranceArchivesEmployeePOS); List columns = siArchivesBiz.buildWeaTableColumns(insuranceArchivesEmployeePOS, user.getUID()); //工作簿list List> excelSheetData = new ArrayList<>(); //工作簿名称 String sheetName = SalaryI18nUtil.getI18nLabel(85368, "社保福利档案"); //表头 //表头 excelSheetData.add(Arrays.asList(columns.stream().map(WeaTableColumn::getText).toArray(String[]::new))); //工作簿数据 List> rows = new LinkedList<>(); for (Map recordData : records) { List row = new LinkedList<>(); for (WeaTableColumn column : columns) { row.add(recordData.get(column.getColumn())); } rows.add(row); } excelSheetData.addAll(rows); return ExcelUtil.genWorkbookV2(excelSheetData, sheetName); } @Override public List listPageEmployeePOS(InsuranceArchivesListParam param) { long currentEmployeeId = user.getUID(); Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId); if (needAuth) { List taxAgentEmployeeDTOS = getTaxAgentService(user).listTaxAgentAndEmployee(currentEmployeeId); Set employeeIds = SalaryEntityUtil.properties(taxAgentEmployeeDTOS, TaxAgentEmployeeDTO::getEmployeeId); List list = getSocialSchemeMapper().queryEmployeeList(param); return list.stream().filter(f -> employeeIds.contains(f.getEmployeeId())).collect(Collectors.toList()); } return getSocialSchemeMapper().queryEmployeeList(param); } /** * 获取福利档案各tab总人数 */ @Override public Map queryInsuranceTabTotal() { long currentEmployeeId = user.getUID(); // tab页签数量 Map result = new HashMap<>(); Boolean needAuth = getTaxAgentService(user).isNeedAuth(currentEmployeeId); //获取管理的人员范围 List taxAgentEmployeeDTOS = getTaxAgentService(user).listTaxAgentAndEmployeeTree(currentEmployeeId); Map> taxAgentEmployeesMap = SalaryEntityUtil.convert2Map(taxAgentEmployeeDTOS, TaxAgentManageRangeEmployeeDTO::getTaxAgentId, TaxAgentManageRangeEmployeeDTO::getEmployeeList); List list = null; if (needAuth) { // 获取作为管理员的所有个税扣缴义务人列表 Collection taxAgentPOS = getTaxAgentService(user).listAllTaxAgentsAsAdmin(currentEmployeeId); Set taxAgentIds = SalaryEntityUtil.properties(taxAgentPOS, TaxAgentPO::getId); //获取所有福利档案基础信息 List archiveListDTOS = getInsuranceBaseInfoMapper().listAll(); list = archiveListDTOS.stream().filter(dto -> taxAgentIds.contains(dto.getPaymentOrganization())).collect(Collectors.toList()); Boolean adminEnable = getTaxAgentService(user).isAdminEnable(currentEmployeeId); //不是管理员看不到数据，返回空 if (!adminEnable) { list = new ArrayList<>(); } } else { list = getInsuranceBaseInfoMapper().listAll(); } long stayAddTotal = 0L; long payTotal = 0L; long stayDelTotal = 0L; long stopTotal = 0L; long extTotal = 0L; for (InsuranceArchivesBaseInfoPO baseInfoPO : list) { Integer employeeType = baseInfoPO.getEmployeeType(); if (employeeType == null || employeeType == 0) { if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_ADD.getValue())) { stayAddTotal += 1; } else if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.PAYING.getValue()) || baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue())) { payTotal += 1; if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue())) { stayDelTotal += 1; } } else if (baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue()) || baseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue())) { stopTotal += 1; } } else { extTotal += 1; } } result.put("stayAdd", stayAddTotal); result.put("paying", payTotal); result.put("stayDel", stayDelTotal); result.put("stopPay", stopTotal); result.put("ext", extTotal); return result; } /** * 批量变更档案列表的runStatus */ @Override public void updateRunStatus(InsuranceArchivesBaseInfoPO po) { getInsuranceBaseInfoMapper().updateRunStatusByIds(po); } @Override public void cancelStopPayment(Collection ids) { if (CollectionUtils.isEmpty(ids)) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } List pos = getInsuranceBaseInfoMapper().listByIds(ids); List stayAddIds = new ArrayList<>(); List stayDelIds = new ArrayList<>(); List taxAgentManageRangeEmployees = getTaxAgentService(user).listTaxAgentAndEmployee((long) user.getUID()); List oldStayAddList = pos.stream().filter(f -> f.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue())).collect(Collectors.toList()); boolean isNotExist = oldStayAddList.stream().anyMatch(te -> taxAgentManageRangeEmployees.stream().noneMatch(p -> p.getEmployeeId() != null && p.getEmployeeId().equals(te.getEmployeeId()) && p.getTaxAgentId().equals(te.getPaymentOrganization()))); if (isNotExist) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(116196, "不在当前个税扣缴义人的人员范围中，不可取消停缴")); } for(InsuranceArchivesBaseInfoPO po : pos) { if (po.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_ADD.getValue())) { //来自待增员的停缴->待增员 stayAddIds.add(po.getId()); } else if (po.getRunStatus().equals(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue())) { //来自待减员的停缴->待减员 stayDelIds.add(po.getId()); } } //更新调整为待增员的数据 InsuranceArchivesBaseInfoPO stayAddPO = InsuranceArchivesBaseInfoPO.builder().ids(stayAddIds).runStatus(EmployeeStatusEnum.STAY_ADD.getValue()).build(); if (stayAddPO.getIds().size() > 0) { getInsuranceBaseInfoMapper().updateRunStatusByIds(stayAddPO); } //更新调整为待减员的数据 InsuranceArchivesBaseInfoPO stayDelPO = InsuranceArchivesBaseInfoPO.builder().ids(stayDelIds).runStatus(EmployeeStatusEnum.STAY_DEL.getValue()).build(); if (stayDelPO.getIds().size() > 0) { getInsuranceBaseInfoMapper().updateRunStatusByIds(stayDelPO); } } /** * 批量减员 */ @Override public Map stayDelToStop(Collection ids) { if (CollectionUtils.isEmpty(ids)) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } List baseInfoPOList = getInsuranceBaseInfoMapper().listByIds(ids); //分别新建福利档案基础信息相关的社保、公积金、其他福利档案列表 List socialList = new ArrayList<>(); List fundList = new ArrayList<>(); List otherList = new ArrayList<>(); //新建最终可以进行减员的福利档案基础信息id列表 List toStopBaseInfoIdList = new ArrayList<>(); //新建最终不可以进行减员的福利档案基础信息id列表 List noStopBaseInfoIds = new ArrayList<>(); //获取待处理的福利档案基础信息id列表 List baseInfoIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); //设置最后缴纳月的比较月份 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM"); String todayMonth = simpleDateFormat.format(new Date()); //分别获取福利档案基础信息相关的社保、公积金、其他福利档案id列表 List socialIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList()); List fundIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList()); List otherIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList()); List toStopSocialIds = new ArrayList<>(); List toStopFundIds = new ArrayList<>(); List toStopOtherIds = new ArrayList<>(); //获取可进行减员的社保档案相关人员数据 if (socialIds.size() > 0) { //获取社保档案 socialList = getSocialSchemeMapper().getSocialById(socialIds); //筛选可减员的社保档案相关信息 toStopSocialIds = socialList.stream().filter(f-> f.getSocialSchemeId() == null || (f.getSocialEndTime() != null && f.getSocialEndTime().length() > 0 && (f.getSocialEndTime().compareTo(todayMonth)) <= 0)) .map(InsuranceArchivesSocialSchemePO::getId).collect(Collectors.toList()); // List finalToStopSocialIds = toStopSocialIds; noStopBaseInfoIds = baseInfoPOList.stream().filter(f -> !finalToStopSocialIds.contains(f.getSocialArchivesId())).map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); } if (fundIds.size() > 0) { fundList = getFundSchemeMapper().getFundById(fundIds); toStopFundIds = fundList.stream().filter(f->f.getFundSchemeId() == null || (f.getFundEndTime() != null && f.getFundEndTime().length() > 0 && (f.getFundEndTime().compareTo(todayMonth)) <= 0)) .map(InsuranceArchivesFundSchemePO::getId).collect(Collectors.toList()); List finalToStopFundIds = toStopFundIds; noStopBaseInfoIds = (List) CollectionUtils.union(noStopBaseInfoIds, baseInfoPOList.stream().filter(f -> !finalToStopFundIds.contains(f.getFundArchivesId())).map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList())); } if (otherIds.size() > 0) { otherList = getOtherSchemeMapper().getOtherById(otherIds); toStopOtherIds= otherList.stream().filter(f->f.getOtherSchemeId() == null || (f.getOtherEndTime() != null && f.getOtherEndTime().length() > 0 && (f.getOtherEndTime().compareTo(todayMonth)) <= 0)) .map(InsuranceArchivesOtherSchemePO::getId).collect(Collectors.toList()); List finalToStopOtherIds = toStopOtherIds; noStopBaseInfoIds = (List) CollectionUtils.union(noStopBaseInfoIds, baseInfoPOList.stream().filter(f -> !finalToStopOtherIds.contains(f.getOtherArchivesId())).map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList())); } //获取最终基础信息表中的可减员数据 if (noStopBaseInfoIds.size() == 0) { //社保、公积金、其他福利档案的可减员的人员信息与入参中的人员信息一致时 toStopBaseInfoIdList = baseInfoIds; } else { //与最终不可减员的baseInfoId信息做差集 toStopBaseInfoIdList = (List) CollectionUtils.subtract(baseInfoIds, noStopBaseInfoIds); } //进行减员操作 if (toStopBaseInfoIdList.size() > 0) { getInsuranceBaseInfoMapper().updateRunStatusByIds(InsuranceArchivesBaseInfoPO.builder() .ids(toStopBaseInfoIdList).runStatus(EmployeeStatusEnum.STOP_PAYMENT_FROM_DEL.getValue()).build()); } Map resultMap = new HashMap<>(2); String resultMsg = "操作成功"; String resultType = "success"; // 批量设为定薪提示 //输出结果，此处需区分单一减员和批量减员 if (baseInfoPOList.size() == toStopBaseInfoIdList.size()) { //减员成功 if (baseInfoPOList.size() == 1) { resultMsg = "减员成功"; } else { resultMsg = "批量减员成功"; } } else { //减员失败 resultType = "fail"; if (baseInfoPOList.size() == 1) { resultMsg = "减员失败，失败原因：最后缴纳月数据未正常维护"; } else { resultMsg = "部分或全部失败：【共提交减员数据" + baseInfoIds.size() +"条，成功" + toStopBaseInfoIdList.size() +"条，失败" + noStopBaseInfoIds.size() +"条，失败原因：最后缴纳月数据未正常维护】"; } } resultMap.put("type", resultType); resultMap.put("msg", resultMsg); return resultMap; } /** * 全量减员 */ @Override public Map allStayDelToStop() { long currentEmployeeId = user.getUID(); List allBaseInfoList = getInsuranceBaseInfoMapper().listAll(); if (allBaseInfoList.size() > 0) { //筛选当前人员可管辖（个税扣缴义务人）范围 Collection taxAgentList = getTaxAgentService(user).listAllTaxAgents(currentEmployeeId); List paymentOrganizationList = taxAgentList.stream().map(TaxAgentPO::getId).collect(Collectors.toList()); Collection stayDelIds = allBaseInfoList.stream().filter(f->f.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue()) && paymentOrganizationList.contains(f.getPaymentOrganization()) && (f.getEmployeeType() == null || Objects.equals(f.getEmployeeType(), EmployeeTypeEnum.ORGANIZATION.getValue()))) .map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); if (stayDelIds.size() > 0) { return stayDelToStop(stayDelIds); } else { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } } else { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } } /** * 批量增员 */ @Override public Map stayAddToPay(Collection ids) { if (CollectionUtils.isEmpty(ids)) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } // List baseInfoPOList = new ArrayList<>(); List> partitionInfo = Lists.partition((List) ids, 100); partitionInfo.forEach(part -> baseInfoPOList.addAll( getInsuranceBaseInfoMapper().listByIds(part))); // //分别新建福利档案基础信息相关的社保、公积金、其他福利档案列表 List socialList = new ArrayList<>(); List fundList = new ArrayList<>(); List otherList = new ArrayList<>(); //新建最终可以进行增员的福利档案基础信息id列表 List toPayBaseInfoIdList = new ArrayList<>(); //新建最终不可以进行增员的福利档案基础信息id列表 List noPayBaseInfoIds = new ArrayList<>(); //获取待处理的福利档案基础信息id列表 List baseInfoIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); //设置最后缴纳月的比较月份 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM"); String todayMonth = simpleDateFormat.format(new Date()); //分别获取福利档案基础信息相关的社保、公积金、其他福利档案id列表 List socialIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList()); List fundIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList()); List otherIds = baseInfoPOList.stream().map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList()); List toStopSocialIds = new ArrayList<>(); List toStopFundIds = new ArrayList<>(); List toStopOtherIds = new ArrayList<>(); //获取可进行增员的社保档案相关人员数据 if (socialIds.size() > 0) { //获取社保档案 List> partitionSocial = Lists.partition((List) socialIds, 100); partitionSocial.forEach(part -> socialList.addAll( getSocialSchemeMapper().getSocialById(part))); //筛选可增员的社保档案相关人员信息 toStopSocialIds = socialList.stream().filter(f-> { boolean flag = true; if (f.getSocialStartTime() == null || f.getSocialStartTime().length() == 0 || f.getSocialSchemeId() == null) { flag = false; } if (f.getSocialEndTime() != null && f.getSocialEndTime().length() > 0 && (f.getSocialEndTime().compareTo(todayMonth)) <= 0) { flag = false; } return flag; }) .map(InsuranceArchivesSocialSchemePO::getId).collect(Collectors.toList()); List finalToStopSocialIds = toStopSocialIds; toPayBaseInfoIdList = baseInfoPOList.stream().filter(f -> finalToStopSocialIds.contains(f.getSocialArchivesId())).map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); } if (fundIds.size() > 0) { List> partitionFund = Lists.partition((List) fundIds, 100); partitionFund.forEach(part -> fundList.addAll( getFundSchemeMapper().getFundById(part))); toStopFundIds = fundList.stream().filter(f-> { boolean flag = true; if (f.getFundStartTime() == null || f.getFundStartTime().length() == 0 || f.getFundSchemeId() == null) { flag = false; } if (f.getFundEndTime() != null && f.getFundEndTime().length() > 0 && (f.getFundEndTime().compareTo(todayMonth)) <= 0) { flag = false; } return flag; }) .map(InsuranceArchivesFundSchemePO::getId).collect(Collectors.toList()); List finalToStopFundIds = toStopFundIds; toPayBaseInfoIdList = (List) CollectionUtils.union(toPayBaseInfoIdList, baseInfoPOList.stream().filter(f -> finalToStopFundIds.contains(f.getFundArchivesId())).map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList())); } if (otherIds.size() > 0) { List> partitionOther = Lists.partition((List) otherIds, 100); partitionOther.forEach(part -> otherList.addAll( getOtherSchemeMapper().getOtherById(part))); toStopOtherIds = otherList.stream().filter(f-> { boolean flag = true; if (f.getOtherStartTime() == null || f.getOtherStartTime().length() == 0 || f.getOtherSchemeId() == null) { flag = false; } if (f.getOtherEndTime() != null && f.getOtherEndTime().length() > 0 && (f.getOtherEndTime().compareTo(todayMonth)) <= 0) { flag = false; } return flag; }) .map(InsuranceArchivesOtherSchemePO::getId).collect(Collectors.toList()); List finalToStopOtherIds = toStopOtherIds; toPayBaseInfoIdList = (List) CollectionUtils.union(toPayBaseInfoIdList, baseInfoPOList.stream().filter(f -> finalToStopOtherIds.contains(f.getOtherArchivesId())).map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList())); } //获取最终基础信息表中的不可增员数据 noPayBaseInfoIds = (List) CollectionUtils.subtract(baseInfoIds, toPayBaseInfoIdList); //其他的个税扣缴义务人下的在缴员工中存在该员工，在缴员工未进入停缴员工时，不可进行增员 //进行增员操作 if (toPayBaseInfoIdList.size() > 0) { List> partitionToPay = Lists.partition((List) toPayBaseInfoIdList, 100); partitionToPay.forEach(part -> { getInsuranceBaseInfoMapper().updateRunStatusByIds(InsuranceArchivesBaseInfoPO.builder() .ids(part).runStatus(EmployeeStatusEnum.PAYING.getValue()).build()); }); } Map resultMap = new HashMap<>(2); String resultMsg = "操作成功"; String resultType = "success"; // 批量设为定薪提示 //输出结果，此处需区分单一增员和批量增员 if (baseInfoPOList.size() == toPayBaseInfoIdList.size()) { //增员成功 if (baseInfoPOList.size() == 1) { resultMsg = "增员成功"; } else { resultMsg = "批量增员成功"; } } else { //增员失败 resultType = "fail"; if (baseInfoPOList.size() == 1) { resultMsg = "增员失败，失败原因：起始缴纳月/福利方案数据未正常维护"; } else { resultMsg = "部分或全部失败：【共提交增员数据" + baseInfoIds.size() +"条，成功" + toPayBaseInfoIdList.size() +"条，失败" + noPayBaseInfoIds.size() +"条，失败原因：起始缴纳月/福利方案数据未正常维护】"; } } resultMap.put("type", resultType); resultMap.put("msg", resultMsg); return resultMap; } /** * 全量增员 */ @Override public Map allStayAddToPay() { long currentEmployeeId = user.getUID(); List allBaseInfoList = getInsuranceBaseInfoMapper().listAll(); if (allBaseInfoList.size() > 0) { //筛选当前人员可管辖（个税扣缴义务人）范围 Collection taxAgentList = getTaxAgentService(user).listAllTaxAgents(currentEmployeeId); List paymentOrganizationList = taxAgentList.stream().map(TaxAgentPO::getId).collect(Collectors.toList()); Collection stayAddIds = allBaseInfoList.stream().filter(f->f.getRunStatus().equals(EmployeeStatusEnum.STAY_ADD.getValue()) && paymentOrganizationList.contains(f.getPaymentOrganization()) && (f.getEmployeeType() == null || Objects.equals(f.getEmployeeType(), EmployeeTypeEnum.ORGANIZATION.getValue()))) .map(InsuranceArchivesBaseInfoPO::getId).collect(Collectors.toList()); if (stayAddIds.size() > 0) { return stayAddToPay(stayAddIds); } else { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } } else { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145969, "没有可以操作的记录")); } } /** * 待减员页面的删除待办 */ @Override public void cancelStayDel(InsuranceArchivesBaseInfoPO insuranceArchivesBaseInfoPO) { if (insuranceArchivesBaseInfoPO.getIds() == null || StringUtils.isBlank(insuranceArchivesBaseInfoPO.getRunStatus())) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误")); } if (insuranceArchivesBaseInfoPO.getRunStatus().equals(EmployeeStatusEnum.STAY_DEL.getValue())) { List> baseInfoIdsPartition = Lists.partition((List) insuranceArchivesBaseInfoPO.getIds(), 100); List nowList = new ArrayList<>(); baseInfoIdsPartition.forEach(part -> { nowList.addAll(getInsuranceBaseInfoMapper().listByIds(part)); }); //判断当前被操作人员是否都在对应的个税扣缴义务人下 List taxAgentManageRangeEmployees = getTaxAgentService(user).listTaxAgentAndEmployee((long) user.getUID()); boolean isNotExist = nowList.stream().anyMatch(te -> taxAgentManageRangeEmployees.stream().noneMatch(p -> p.getEmployeeId() != null && p.getEmployeeId().equals(te.getEmployeeId()) && p.getTaxAgentId().equals(te.getPaymentOrganization()))); if (isNotExist) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(116196, "个税扣缴义务人不存在或不在权限范围内，删除失败！")); } //置空社保、公积金、其他福利档案的最后缴纳月信息，并将福利档案基础信息表的状态置为“正在缴纳” if (nowList.size() > 0) { List socialIds = nowList.stream() .map(InsuranceArchivesBaseInfoPO::getSocialArchivesId).collect(Collectors.toList()); List fundIds = nowList.stream() .map(InsuranceArchivesBaseInfoPO::getFundArchivesId).collect(Collectors.toList()); List otherIds = nowList.stream() .map(InsuranceArchivesBaseInfoPO::getOtherArchivesId).collect(Collectors.toList()); List> socialIdsPartition = Lists.partition(socialIds, 100); socialIdsPartition.forEach(getSocialSchemeMapper()::batchUpdateEndTimeToNull); List> fundIdsPartition = Lists.partition(fundIds, 100); fundIdsPartition.forEach(getFundSchemeMapper()::batchUpdateEndTimeToNull); List> otherIdsPartition = Lists.partition(otherIds, 100); otherIdsPartition.forEach(getOtherSchemeMapper()::batchUpdateEndTimeToNull); baseInfoIdsPartition.forEach(part -> { getInsuranceBaseInfoMapper().updateRunStatusByIds(InsuranceArchivesBaseInfoPO.builder() .ids(part) .runStatus(EmployeeStatusEnum.PAYING.getValue()) .build()); }); } } } @Override public PageInfo getAdjustHistoryList(SIArchiveBaseHistoryListParam param) { if (param.getWelfareTypeEnum() == null) { throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "参数错误")); } List adjustHistoryDTOS = siArchivesBiz.getAdjustHistoryList(param.getPaymentOrganization(), param.getEmployeeId()); List targetHistory = adjustHistoryDTOS.stream() .filter(f -> f.getWelfareType().equals(param.getWelfareTypeEnum().getValue())).collect(Collectors.toList()); PageInfo listPage = SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), targetHistory , InsuranceArchivesBaseHistoryDTO.class); return listPage; } @Override public PageInfo historyListByEmployeeIdAndOperator(SIArchiveBaseHistoryListParam param) { List adjustHistoryDTOS = siArchivesBiz.getBaseHistoryByEmployeeIdAndOperator(param.getOperator(), param.getEmployeeId()); adjustHistoryDTOS.forEach(f -> { if (StringUtils.isNotBlank(f.getPaymentScope())) { if(f.getPaymentScope().equals(PaymentScopeEnum.SCOPE_PERSON.getValue().toString())) { f.setPaymentScope(SalaryI18nUtil.getI18nLabel(0, "个人")); } else if(f.getPaymentScope().equals(PaymentScopeEnum.SCOPE_COMPANY.getValue().toString())) { f.setPaymentScope(SalaryI18nUtil.getI18nLabel(0, "公司")); } else { f.setPaymentScope(SalaryI18nUtil.getI18nLabel(0, "个人") + "," + SalaryI18nUtil.getI18nLabel(0, "公司")); } } else { f.setPaymentScope(SalaryI18nUtil.getI18nLabel(0, "个人") + "," + SalaryI18nUtil.getI18nLabel(0, "公司")); } }); PageInfo listPage = SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), adjustHistoryDTOS , InsuranceArchivesBaseHistoryDTO.class); return listPage; } }