会审起草节点校验+JMS任务分发至集成平台

会审与采购检验

/**
     * 会审与采购检验
     * @param approvalParamDto
     * @return Boolean
     */
    @Override
    public Boolean checkAuditAndPurchase(ApprovalParamDto approvalParamDto) {
        final LoginAuthDto loginAuthDto = approvalParamDto.getLoginAuthDto();
        final ResponseDto<List<SysDict>> itemByDicCode = this.dicFeignApi.getItemByDicCode(CommonConstant.MDSG_PROVINCE_CONFIG);
        final List<SysDict> body = itemByDicCode.getBody();
        final SysDict sysDict = body.stream().filter(item -> CommonConstant.MDSG_AUDIT_CHECK.equalsIgnoreCase(item.getItemCode())).findFirst().orElse(null);
        if (Objects.isNull(sysDict)){
            //字典项不存在
            return true;
        }else {
            log.info("当前用户省份信息：{}，字典项省份信息：{}",loginAuthDto.getAreaId(),sysDict.getItemValue());
            if (CommonConstant.ZERO.equals(sysDict.getItemFlag())){
                log.info("字典项已停用，无需校验！");
                return true;
            }
            final List<String> dictList = Arrays.asList(sysDict.getItemValue().split(","));
            //分省校验 若字典值中存在当前用户省份则进行会审采购校验，不存在则直接返回
            if (!dictList.contains(loginAuthDto.getAreaId())){
                log.info("当前省份用户无需进行会审采购校验!");
                return true;
            }
        }
        final QueryPurchaseOrderInfo queryPurchaseOrderInfo = new QueryPurchaseOrderInfo();
        final List<String> expenseTypeList = new ArrayList<>();
        queryPurchaseOrderInfo.setCompanyCode(loginAuthDto.getCompanyCode());
        queryPurchaseOrderInfo.setMicroserviceIdentification(CommonConstant.MDSG);
        expenseTypeList.add(CommonConstant.EXPENSES_TYPE_SJ);
        expenseTypeList.add(CommonConstant.EXPENSES_TYPE_SG);
        expenseTypeList.add(CommonConstant.EXPENSES_TYPE_JL);
        queryPurchaseOrderInfo.setExpenseTypes(expenseTypeList);
        final Audit audit = (Audit) new Audit().selectById(approvalParamDto.getBusinessId());
        final List<TaskStatus> taskStatusList = this.taskStatusService.list(Wrappers.<TaskStatus>lambdaQuery().eq(TaskStatus::getAuditId, audit.getId()).eq(BaseEntity::getDeleteFlag, 0));
        queryPurchaseOrderInfo.setProjectCode(taskStatusList.get(0).getProjectCode());
        queryPurchaseOrderInfo.setProjectName(taskStatusList.get(0).getProjectName());
        log.info("taskStatusList:{}",JSON.toJSONString(taskStatusList));
        final List<TaskDto> taskDtoList = taskStatusList.stream().map(item -> {
            TaskDto taskDto = new TaskDto();
            taskDto.setTaskCode(item.getTaskCode());
            taskDto.setTaskName(item.getTaskName());
            return taskDto;
        }).collect(Collectors.toList());
        queryPurchaseOrderInfo.setTaskDtos(taskDtoList);
        ResponseDto<QueryPurchaseOrderOutInfo> responseDto = purchaseFeignApi.queryPurchaseOrderInfo(queryPurchaseOrderInfo);
        log.info("查询PMS采购订单信息：{}", JSON.toJSONString(responseDto));
        if (Objects.nonNull(responseDto.getBody())){
            QueryPurchaseOrderOutInfo queryPurchaseOrderOutInfo = JSON.parseObject(JSON.toJSONString(responseDto.getBody()), QueryPurchaseOrderOutInfo.class);
            if (Objects.nonNull(queryPurchaseOrderOutInfo)){
                //当code为FALSE时，返回采购接口错误信息
                if(CommonConstant.FALSE.equalsIgnoreCase(queryPurchaseOrderOutInfo.getCode())){
                    throw new BusinessException(queryPurchaseOrderOutInfo.getMessage());
                }
                //允许提交不做操作，不允许提交则抛异常
                if (CommonConstant.TRUE.equalsIgnoreCase(queryPurchaseOrderOutInfo.getCode()) && Objects.nonNull(queryPurchaseOrderOutInfo.getBody())){
                    final Map<String, List<RequLineDto>> taskMap = queryPurchaseOrderOutInfo.getBody().stream().collect(Collectors.groupingBy(RequLineDto::getTaskCode));
                    //采购只会返回做了派工的数据，未做派工的费用类型就不去控制
                    new ArrayList<>(taskMap.keySet()).forEach(taskCode -> {
                        taskMap.get(taskCode).forEach(res -> {
                            if (Objects.isNull(res.getDispatchAmt())){
                                log.info("派工金额不存在，不做控制！");
                                return;
                            }
                            //未生成PMS订单 && 派工金额不为0
                            if (CommonConstant.POOL_REQU_STATUS_ZERO.equals(res.getPoolRequStatus()) && !(CommonConstant.DISPATCH_AMT_ZERO.compareTo(res.getDispatchAmt()) == 0)){
                                final String exceptionMsg = taskCode + CommonConstant.APPEND_EXP_MSG + convertThreeFeeMsg(res.getExpenseType()) + ExceptionEnum.NO_GENERATED_PMS_ORDERS.getMessage();
                                throw new BusinessException(ExceptionEnum.NO_GENERATED_PMS_ORDERS.getCode(),exceptionMsg);
                            }
                            //已生成PMS订单 && 未生成ERP订单
                            if (CommonConstant.POOL_REQU_STATUS_ONE.equals(res.getPoolRequStatus()) && CommonConstant.ERP_ORDER_ZERO.equals(res.getErpOrder())){
                                final String exceptionMsg = taskCode + CommonConstant.APPEND_EXP_MSG + convertThreeFeeMsg(res.getExpenseType()) + ExceptionEnum.NO_GENERATED_ERP_ORDERS.getMessage();
                                throw new BusinessException(ExceptionEnum.NO_GENERATED_ERP_ORDERS.getCode(),exceptionMsg);
                            }
                        });
                    });
                    log.info("会审采购校验完成！");
                }
            }
        }
        return true;
    }
    private static String convertThreeFeeMsg(String threeFee) {
        String reStr = "";
        switch (threeFee) {
            case "SG":
                reStr = CommonConstant.COOPERATION_MSG;
                break;
            case "SJ":
                reStr = CommonConstant.SUPERVISOR_MSG;
                break;
            case "JL":
                reStr = CommonConstant.CONSTRUCTION_MSG;
                break;
        }
        return reStr;
    }

集中化PMS系统将新增、修改的任务信息发送到集成平台

   /**
     * 集中化PMS系统将新增、修改的任务信息发送到集成平台
     * @param distTaskDot
     * @return String
     */
    @Override
    public String dictTaskInfoToSoa(final DistTaskDot distTaskDot) {
        final DistTaskInfoInputParameters distTaskInfoInputParameters = new DistTaskInfoInputParameters();
        final InputCollectionItem<DistTaskInputCollection> inputCollectionItem = new InputCollectionItem<>();
        final List<DistTaskInputCollection> distTaskInputCollections = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(distTaskDot.getIds())){
            final List<BreakdownTask> breakdownTasks = (List<BreakdownTask>) this.breakdownTaskService.listByIds(distTaskDot.getIds());
            breakdownTasks.stream().filter(task -> CommonConstant.CODE_00.equals(task.getImperpStatus())).forEach(task -> {
                final DistTaskInputCollection distTaskInputCollection = new DistTaskInputCollection();
                BeanUtils.copyProperties(task, distTaskInputCollection);
                distTaskInputCollection.setPriKey(task.getId().toString());
                distTaskInputCollection.setChangeType(distTaskDot.getChangeType());
                final BreakdownTaskExt breakdownTaskExt = this.breakdownTaskExtService.getOne(Wrappers.<BreakdownTaskExt>lambdaQuery().eq(BreakdownTaskExt::getProjectCode, distTaskInputCollection.getProjectCode())
                        .eq(BreakdownTaskExt::getTaskCode, distTaskInputCollection.getTaskCode()).eq(BreakdownTaskExt::getDeleteFlag, 0));
                if (Objects.nonNull(breakdownTaskExt)){
                    if (StringUtils.isNotEmpty(breakdownTaskExt.getIsResearchNature())){
                        distTaskInputCollection.setIsResearchNature(breakdownTaskExt.getIsResearchNature());
                    }
                    if (StringUtils.isNotEmpty(breakdownTaskExt.getIsResearchNatureRms())){
                        distTaskInputCollection.setIsResearchNatureRms(breakdownTaskExt.getIsResearchNatureRms());
                    }
                }
                distTaskInputCollections.add(distTaskInputCollection);
            });
        }
        inputCollectionItem.setItemList(distTaskInputCollections);
        final MsgHeader jmsMsgHeader = getJmsMsgHeader(soaConfig);
        distTaskInfoInputParameters.setMsgHeader(jmsMsgHeader);
        distTaskInfoInputParameters.setInputCollectionList(inputCollectionItem);
        log.info("发往soa集成平台入参：{}",JSON.toJSONString(distTaskInfoInputParameters));
        final JSONObject requestBody = new JSONObject();
        requestBody.put("InputParameters", JSONObject.toJSON(distTaskInfoInputParameters));
        requestBody.put("MSGHEADER", jmsMsgHeader);
        final String request = JSON.toJSONString(requestBody, this.filter);
        String resultMsg = "JMS开关未打开";
        if (this.soaConfig.isSoaEnable()){
            log.info("-------JMS开关打开，推送任务信息至集成平台------");
            //TODO 待验证
            resultMsg = httpPost(this.soaConfig.getSoaDistPushUrl(), MediaType.APPLICATION_JSON_UTF8, request);
        }
        return resultMsg;
    }

    private final ValueFilter filter = new ValueFilter() {
        @Override
        public Object process(final Object obj, final String s, final Object v) {
            if (v == null) {
                return "";
            }
            return v;
        }
    };

    public static String httpPost(final String url, final MediaType mediaType, final String reqBody) {

        final StringBuilder stb = new StringBuilder("");
        stb.append("请求报文：").append(reqBody)
                .append("请求路径：").append(url);
        log.info("请求报文：" + reqBody);
        log.info("请求路径：" + url);
        final RestTemplate restTemplate = new RestTemplate();

        final HttpHeaders headers = new HttpHeaders();
        headers.setContentType(mediaType);

        final HttpEntity<String> reqEntity = new HttpEntity<>(reqBody, headers);

        final ResponseEntity<String> response = restTemplate.postForEntity(url, reqEntity, String.class);
        if (response.hasBody()) {
            log.info("请求响应：" + response.getBody());
            stb.append("请求响应：").append(response.getBody());
            return stb.toString();
        }
        log.info("请求发送取消...");
        return stb.toString();
    }

筛选出已推送erp的任务，并给pri_key赋值

        //筛选出已推送erp的任务，并给pri_key赋值
        final List<DictTaskOutInfo> distFilter = dictTaskOutInfos.stream().filter(task -> CommonConstant.CODE_00.equals(task.getImperpStatus())).collect(
                Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(ele -> ele.getProjectCode() + ";" + ele.getTaskCode()))), ArrayList::new)
        );
        final List<DistTaskInputCollection> filterTaskInfo = itemList.stream().filter(item ->
                distFilter.stream().anyMatch(dist -> dist.getProjectCode().equals(item.getProjectCode()) && dist.getTaskCode().equals(item.getTaskCode()))
        ).peek(item -> {
            for (DictTaskOutInfo taskOutInfo : distFilter) {
                if (StringUtils.isEmpty(item.getPriKey()) && taskOutInfo.getProjectCode().equals(item.getProjectCode()) && taskOutInfo.getTaskCode().equals(item.getTaskCode())){
                    item.setPriKey(taskOutInfo.getId().toString());
                }
            }
        }).collect(Collectors.toList());