实现类的常规业务

查询-实现类

// 调数据引擎进行数据校验
/** 查询操作 */
// 组装排序信息
// 如果分页条件为null，查询全部条数
// 查库操作
// 组装分页信息
// 查库操作
// 返回实体转换

    @Override
    @BueEvent(name = BueEventConstant.EVENT_GENERAL_QUERY_DEP_INCOME, remark = "EVENT_GENERAL_QUERY_DEP_INCOME")
    public PaginationInfo<BgtAttachmentDto> generalQuery(BgtAttachmentSearchForm form) {
        // 调数据引擎进行数据校验
        validateDataApdater.validateBgtAttachmentGeneralQueryForm(form);
        /** 查询操作 */
        PaginationInfo<BgtAttachmentDto> result = new PaginationInfo<>();
        List<BgtAttachmentDO> bgtAttachmentDOList = new ArrayList<>();

        // 组装排序信息
        BgtAttachmentPageForm attachmentBgtRequest = form.getAttachmentRequest();
        BgtAttachmentDO attachmentDO = new BgtAttachmentDO();
        Copier.copy(attachmentBgtRequest, attachmentDO);
        String orderBy = ComponentUtils.assembleOrderInfo(attachmentBgtRequest.getOrderList(), attachmentDO);
        // 如果分页条件为null，查询全部条数
        if (attachmentBgtRequest.getIsAllData() != null && attachmentBgtRequest.getIsAllData().equals(YesOrNoIntegerEnum.YES.getCode())) {
            // 查库操作
            bgtAttachmentDOList.addAll(bgtAttachmentExtDAO.search(attachmentDO, attachmentBgtRequest.getEw(), orderBy));
            result.setPageInfo(BasConstant.INT_ONE, bgtAttachmentDOList.size(), bgtAttachmentDOList.size());
        } else {
            // 组装分页信息
            Page<?> page = PageUtil.startBizPage(attachmentBgtRequest, orderBy, null);
            // 查库操作
            bgtAttachmentDOList.addAll(bgtAttachmentExtDAO.search(attachmentDO, attachmentBgtRequest.getEw(), orderBy));
            result.setPageInfo(attachmentBgtRequest.getPageNumber(), attachmentBgtRequest.getPageSize(), page.getTotal());
            page.close();
        }
        // 返回实体转换
        List<BgtAttachmentDto> bgtAttachmentDtos = ModelMapperUtil.batchConvertTo(bgtAttachmentDOList, BgtAttachmentDto.class);
        result.setCurrentPageResult(bgtAttachmentDtos);
        return result;
    }

支出预算-综合新增

    @Override
    @Transactional
    public BgtPmAnnualSaveResultDto creation(BgtPmAnnualCompositeForm form) {
        if (form == null) {
            throw new BizException("参数不能为空");
        }
        if (form.getProjectInfo() == null) {
            throw new BizException("项目信息不能为空");
        }
        if (form.getBudgetInfo() == null || EmptyChecker.isEmpty(form.getBudgetInfo().getBgtPmAnnuals())) {
            throw new BizException("预算信息不能为空");
        }
        // 保存项目
        PmProjectAllInfoForm projectInfo = form.getProjectInfo();
        PmProjectCreationForm projectForm = new PmProjectCreationForm();
        projectForm.setProjectInfos(Lists.newArrayList(projectInfo));
        projectForm.setIsStartWflow(BasConstant.STRING_ZERO);
        String url = bgtLibProperties.getProjectUrl() + "/api/project/creation";
        String response = HttpUtils.post(projectForm, url);
        List<?> saveProjResult = new Gson().fromJson(response, List.class);
        if (CollUtil.isEmpty(saveProjResult)) {
            throw new BizException("操作失败");
        }
        // 保存支出预算
        BgtPmAnnualUpsertForm budgetInfo = form.getBudgetInfo();
        List<BgtPmAnnualForm> bgtPmAnnuals = budgetInfo.getBgtPmAnnuals();
        if (CollUtil.isEmpty(bgtPmAnnuals)) {
            return null;
        }
        String agencyCode = projectInfo.getProjectBaseInfo().getAgencyCode();
        Object object = saveProjResult.get(0);
        String jsonStr = JSONUtil.toJsonStr(object);
        log.info("jsonStr={}", jsonStr);
        PmSaveReturnDto pmSaveReturnDto = JSONUtil.toBean(jsonStr, PmSaveReturnDto.class);
        for (BgtPmAnnualForm bgtPmAnnual : bgtPmAnnuals) {
            setPmAnnualFieldValue(projectInfo.getProjectBaseInfo(), pmSaveReturnDto, bgtPmAnnual);
        }
        List<BgtProperfGoalInfoForm> bgtProperfGoals = budgetInfo.getBgtProperfGoals();
        if (CollUtil.isNotEmpty(bgtProperfGoals)) {
            for (BgtProperfGoalInfoForm bgtProperfGoal : bgtProperfGoals) {
                bgtProperfGoal.setAgencyCode(agencyCode);
                bgtProperfGoal.setProId(pmSaveReturnDto.getProId());
                bgtProperfGoal.setProCode(pmSaveReturnDto.getProCode());
            }
        }

        List<BgtProperfIndicatorForm> bgtProperfKpis = budgetInfo.getBgtProperfKpis();
        if (CollUtil.isNotEmpty(bgtProperfKpis)) {
            for (BgtProperfIndicatorForm bgtProperfKpi : bgtProperfKpis) {
                bgtProperfKpi.setAgencyCode(agencyCode);
                bgtProperfKpi.setProId(pmSaveReturnDto.getProId());
                bgtProperfKpi.setProCode(pmSaveReturnDto.getProCode());
            }
        }

        List<BgtProperfImplPlanForm> bgtProperfImplPlans = budgetInfo.getBgtProperfImplPlans();
        if (CollUtil.isNotEmpty(bgtProperfImplPlans)) {
            for (BgtProperfImplPlanForm bgtProperfImplPlan : bgtProperfImplPlans) {
                bgtProperfImplPlan.setAgencyCode(agencyCode);
                bgtProperfImplPlan.setProId(pmSaveReturnDto.getProId());
                bgtProperfImplPlan.setProCode(pmSaveReturnDto.getProCode());
            }
        }

        List<BgtAttachmentForm> attachmentInfos = budgetInfo.getAttachmentInfos();
        if (CollUtil.isNotEmpty(attachmentInfos)) {
            for (BgtAttachmentForm attachmentInfo : attachmentInfos) {
                attachmentInfo.setProCode(pmSaveReturnDto.getProCode());
            }
        }

        List<BgtPmAnnualUpsertForm> formList = new ArrayList<>(1);
        formList.add(form.getBudgetInfo());
        List<BgtPmAnnualSaveResultDto> resultList = this.bgtPmAnnualService.creation(formList);

        // 发起流程
        createBgtBill(projectInfo.getProjectBaseInfo(), bgtPmAnnuals.get(0), pmSaveReturnDto);

        return resultList.get(0);
    }

部门整体绩效实现类 -更新 (操作三个表)

  @Override
    @BueEvent(name = BueEventConstant.EVENT_UPDATE_ABROAD_PLAN, remark = "因公出国计划表更新事件")
    @Transactional(rollbackFor = Exception.class)
    public void update(BgtPerfGoalInfoListForm form) {
        // 调数据引擎进行数据校验
        validateDataApdater.validateBgtPerfGoalInfoUpdateForm(form);
        // 业务逻辑处理
        Map<String, List<BgtPerfGoalInfoDO>> bgtPerfGoalInfoMap = buildBusiObjectApdater.buildBgtPerfGoalInfoUpdate(form);
        Map<String, List<BgtPerfIndicatorDO>> bgtPerfIndicatorMap = buildBusiObjectApdater.buildBgtPerfIndicatorUpdate(form);
        Map<String, List<BgtPerfTaskDO>> bgtPerfTaskMap = buildBusiObjectApdater.buildBgtPerfTaskUpdate(form);

        /** 库操作 */
        // 新增部门整体绩效目标数据
        if (EmptyChecker.notEmpty(bgtPerfGoalInfoMap.get(BasConstant.CREATION))) {
            bgtPerfGoalInfoExtDAO.batchInsert(bgtPerfGoalInfoMap.get(BasConstant.CREATION));
        }
        // 新增部门整体绩效指标表数据
        if (EmptyChecker.notEmpty(bgtPerfIndicatorMap.get(BasConstant.CREATION))) {
            bgtPerfIndicatorExtDAO.batchInsert(bgtPerfIndicatorMap.get(BasConstant.CREATION));
        }
        // 新增部门工作任务表数据
        if (EmptyChecker.notEmpty(bgtPerfTaskMap.get(BasConstant.CREATION))) {
            bgtPerfTaskExtDAO.batchInsert(bgtPerfTaskMap.get(BasConstant.CREATION));
        }

        // 修改部门整体绩效目标数据
        if (EmptyChecker.notEmpty(bgtPerfGoalInfoMap.get(BasConstant.MODIFY))) { 
            // 创建modifyDo list对象
            List<BgtPerfGoalInfoDO> modifyDo = bgtPerfGoalInfoMap.get(BasConstant.MODIFY);
            // 创建modifyIds ArrayList对象 (计数)
            List<String> modifyIds = new ArrayList<>(modifyDos.size());
            for (BgtPerfGoalInfoDO modifyDo : modifyDos) {  // 循环 x : x
                modifyIds.add(modifyDo.getKpiDepId());      // x.添加(x.部门绩效目标主键)
            }
            // 查询需要修改的数据做数据存在校验
            Map<String, BgtPerfGoalInfoDO> modifyDataMap = bgtPerfGoalInfoExtDAO
                    .queryDataMapByBids(modifyIds);  // 创建map集合存储查询modifyIds的数据
            if (EmptyChecker.isEmpty(modifyDataMap)) {
                throw new BizException("修改的部门整体绩效数据不存在");
            }
            for (String modifyId : modifyIds) {
                if (modifyDataMap.get(modifyId) == null) {
                    throw new BizException("修改部门整体绩效目标的主键为：" + modifyId + "，数据不存在");
                }
            }
            bgtPerfGoalInfoExtDAO.batchUpdateByBids(bgtPerfGoalInfoMap.get(BasConstant.MODIFY));
        }
        // 修改部门整体绩效指标表数据
        if (EmptyChecker.notEmpty(bgtPerfIndicatorMap.get(BasConstant.MODIFY))) {
            List<BgtPerfIndicatorDO> modifyDos = bgtPerfIndicatorMap.get(BasConstant.MODIFY);
            List<String> modifyIds = new ArrayList<>(modifyDos.size());
            for (BgtPerfIndicatorDO modifyDo : modifyDos) {
                modifyIds.add(modifyDo.getKpiId());
            }
            // 查询需要修改的数据做数据存在校验
            Map<String, BgtPerfIndicatorDO> modifyDataMap = bgtPerfIndicatorExtDAO
                    .queryDataMapByBids(modifyIds);
            if (EmptyChecker.isEmpty(modifyDataMap)) {
                throw new BizException("修改的部门整体绩效指标数据不存在");
            }
            for (String modifyId : modifyIds) {
                if (modifyDataMap.get(modifyId) == null) {
                    throw new BizException("修改的部门整体绩效指标的主键为：" + modifyId + "，数据不存在");
                }
            }
            bgtPerfIndicatorExtDAO.batchUpdateByBids(bgtPerfIndicatorMap.get(BasConstant.MODIFY));
        }
        // 修改部门工作任务表数据
        if (EmptyChecker.notEmpty(bgtPerfTaskMap.get(BasConstant.MODIFY))) {
            List<BgtPerfTaskDO> modifyDos = bgtPerfTaskMap.get(BasConstant.MODIFY);
            List<String> modifyIds = new ArrayList<>(modifyDos.size());
            for (BgtPerfTaskDO modifyDo : modifyDos) {
                modifyIds.add(modifyDo.getTaskId());
            }
            // 查询需要修改的数据做数据存在校验
            Map<String, BgtPerfTaskDO> modifyDataMap = bgtPerfTaskExtDAO
                    .queryDataMapByBids(modifyIds);
            if (EmptyChecker.isEmpty(modifyDataMap)) {
                throw new BizException("修改的部门工作任务数据不存在");
            }
            for (String modifyId : modifyIds) {
                if (modifyDataMap.get(modifyId) == null) {
                    throw new BizException("修改的部门工作任务的主键为：" + modifyId + "，数据不存在");
                }
            }
            bgtPerfTaskExtDAO.batchUpdateByBids(bgtPerfTaskMap.get(BasConstant.MODIFY));
        }
        // 删除部门整体绩效目标数据
        if (EmptyChecker.notEmpty(bgtPerfGoalInfoMap.get(BasConstant.INVALID))) {
            // 删除数据
            List<BgtPerfGoalInfoDO> invalidDos = bgtPerfGoalInfoMap.get(BasConstant.INVALID);
            List<String> invalidIds = new ArrayList<>(invalidDos.size());
            for (BgtPerfGoalInfoDO invalidDo : invalidDos) {
                invalidIds.add(invalidDo.getKpiDepId());
            }
            // 查询需要修改的数据做数据存在校验
            Map<String, BgtPerfGoalInfoDO> invalidDataMap = bgtPerfGoalInfoExtDAO
                    .queryDataMapByBids(invalidIds);
            if (EmptyChecker.isEmpty(invalidDataMap)) {
                throw new BizException("删除的部门整体绩效目标数据不存在");
            }
            for (String invalidId : invalidIds) {
                if (invalidDataMap.get(invalidId) == null) {
                    throw new BizException("删除的部门整体绩效目标数据业务主键为：" + invalidId + "，数据不存在");
                }
            }
            // 删除数据
            bgtPerfGoalInfoExtDAO.batchSoftDeleteByBid(invalidIds);
        }
        // 删除部门整体绩效指标表数据
        if (EmptyChecker.notEmpty(bgtPerfIndicatorMap.get(BasConstant.INVALID))) {
            // 删除数据
            List<BgtPerfIndicatorDO> invalidDos = bgtPerfIndicatorMap.get(BasConstant.INVALID);
            List<String> invalidIds = new ArrayList<>(invalidDos.size());
            for (BgtPerfIndicatorDO invalidDo : invalidDos) {
                invalidIds.add(invalidDo.getKpiId());
            }
            // 查询需要修改的数据做数据存在校验
            Map<String, BgtPerfIndicatorDO> invalidDataMap = bgtPerfIndicatorExtDAO
                    .queryDataMapByBids(invalidIds);
            if (EmptyChecker.isEmpty(invalidDataMap)) {
                throw new BizException("删除的部门整体绩效指标数据不存在");
            }
            for (String invalidId : invalidIds) {
                if (invalidDataMap.get(invalidId) == null) {
                    throw new BizException("删除的部门整体绩效指标数据业务主键为：" + invalidId + "，数据不存在");
                }
            }
            // 删除数据
            bgtPerfIndicatorExtDAO.batchSoftDeleteByBid(invalidIds);
        }
        // 删除部门工作任务表数据
        if (EmptyChecker.notEmpty(bgtPerfTaskMap.get(BasConstant.INVALID))) {
            // 删除数据
            List<BgtPerfTaskDO> invalidDos = bgtPerfTaskMap.get(BasConstant.INVALID);
            List<String> invalidIds = new ArrayList<>(invalidDos.size());
            for (BgtPerfTaskDO invalidDo : invalidDos) {
                invalidIds.add(invalidDo.getTaskId());
            }
            // 查询需要修改的数据做数据存在校验
            Map<String, BgtPerfTaskDO> invalidDataMap = bgtPerfTaskExtDAO
                    .queryDataMapByBids(invalidIds);
            if (EmptyChecker.isEmpty(invalidDataMap)) {
                throw new BizException("删除的部门工作任务数据不存在");
            }
            for (String invalidId : invalidIds) {
                if (invalidDataMap.get(invalidId) == null) {
                    throw new BizException("删除的部门工作任务数据业务主键为：" + invalidId + "，数据不存在");
                }
            }
            // 删除数据
            bgtPerfTaskExtDAO.batchSoftDeleteByBid(invalidIds);
        }
    }

修改-实现类

 @Override
    public void modify(BgtGovBgtListForm form) {
        // 校验参数
        validateDataApdater.validateBgtGovBgtModifyForm(form);
        // 业务处理
        List<BgtGovBgtDO> bgtGovBgtDOS = buildBusiObjectApdater.buildBgtGovBgtModify(form);

        /** 库操作 */
        List<String> modifyIds = new ArrayList<>(bgtGovBgtDOS.size());
        for (BgtGovBgtDO modifyDo : bgtGovBgtDOS) {
            // 添加主键
            modifyIds.add(modifyDo.getBgtProId());  
        }
        // 查询需要修改的数据做数据存在校验
        Map<String, BgtGovBgtDO> modifyDataMap = bgtGovBgtExtDAO
                .queryDataMapByBids(modifyIds);
        if (EmptyChecker.isEmpty(modifyDataMap)) {  // 是为空就抛异常
            throw new BizException("修改数据不存在");
        }
        for (String modifyId : modifyIds) {
            if (modifyDataMap.get(modifyId) == null) {
                throw new BizException("修改数据业务主键为：" + modifyId + "的数据不存在");
            }
        }
        // 修改数据
        bgtGovBgtExtDAO.batchUpdateByBids(bgtGovBgtDOS);
    }

支出预算删除事件

@Override
@Transactional(rollbackFor = Exception.class)
@BueEvent(name = BueEventConstant.EVENT_DELETE_PAYOUT, remark = "支出预算删除事件")
public Integer deletion(BgtPmAnnualForm form) {
    // 调数据引擎进行数据校验
    validateDataApdater.validateBgtPmAnnualDeleteForm(form);

    List<String> bgtPmanIds = form.getBgtPmanIds();
    // 作废支出预算表数据
    int count = bgtPmAnnualExtDAO.batchSoftDeleteByBid(bgtPmanIds);
    if (count == form.getBgtPmanIds().size()) {
        // 删除支出预算表关联表数据（资产配置预算表，政府采购预算表，政府购买服务表）
        bgtAssetAllocPlanExtDAO.batchSoftDeleteByBgtPmanId(form.getBgtPmanIds());
        bgtGovpurExtDAO.batchSoftDeleteByBgtPmanId(form.getBgtPmanIds());
        bgtGovpurServExtDAO.batchSoftDeleteByBgtPmanId(form.getBgtPmanIds());
    } else {
        // 作废数据条数与传入作废数据id数量不符合，抛出异常回滚
        throw new BizException("部分数据不满足作废条件，请重新操作");
    }
    return count;
}