pqs/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/ExecutionCenter.java

package com.njcn.prepare;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.text.StrPool;
import cn.hutool.core.util.StrUtil;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.bo.BaseParam;
import com.njcn.prepare.bo.CalculatedParam;
import com.njcn.prepare.harmonic.enums.PrepareResponseEnum;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import com.yomahub.liteflow.annotation.LiteflowComponent;
import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.core.NodeComponent;
import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.flow.entity.CmpStep;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @author hongawen
 * @version 1.0.0
 * @date 2023年11月01日 10:20
 */
@Slf4j
@Api(tags = "算法执行中心")
@RestController
@RequestMapping("/executor")
@RequiredArgsConstructor
public class ExecutionCenter extends BaseController {

    private final CommTerminalGeneralClient commTerminalGeneralClient;
    private final DeptFeignClient deptFeignClient;

    @Resource
    private FlowExecutor flowExecutor;


    /***
     * 1、校验非全链执行时，tagNames节点标签集合必须为非空，否则提示---无可执行节点
     * 2、补招标识为true时，起始日期&截止日期不可为空
     * 3、算法需要的索引集合
     * @author hongawen
     * @date 2023/11/3 11:36
     * @param baseParam 执行的基础参数
     */
    private CalculatedParam judgeExecuteParam(BaseParam baseParam) {
        CalculatedParam calculatedParam = new CalculatedParam();

        if (!baseParam.isFullChain() && CollectionUtil.isEmpty(baseParam.getTagNames())) {
            throw new BusinessException(PrepareResponseEnum.NO_EXECUTOR_NODE);
        }

        if (baseParam.isRepair() && StrUtil.isAllEmpty(baseParam.getBeginTime(), baseParam.getEndTime())) {
            throw new BusinessException(PrepareResponseEnum.NO_REPAIR_DATE);
        }

        BeanUtil.copyProperties(baseParam, calculatedParam);
        return calculatedParam;
    }

    /***
     *
     * @author hongawen
     * @date 2023/11/7 14:44
     */
    private void dealResponse(CalculatedParam calculatedParam, LiteflowResponse liteflowResponse,String methodDescribe) {
        if(liteflowResponse.isSuccess()){
            log.info("日期{}，{}执行{}成功",calculatedParam.getDataDate(),methodDescribe,calculatedParam.isFullChain()?"全链":"指定节点：".concat(String.join(StrPool.COMMA,calculatedParam.getTagNames())));
        }else{
            Map<String, List<CmpStep>> executeSteps =  liteflowResponse.getExecuteSteps();
            CmpStep failStep = null;
            for (String key : executeSteps.keySet()) {
                List<CmpStep> cmpSteps = executeSteps.get(key);
                cmpSteps=cmpSteps.stream().filter(cmpStep -> !cmpStep.isSuccess()).collect(Collectors.toList());
                if(CollectionUtil.isNotEmpty(cmpSteps)){
                    failStep = cmpSteps.get(0);
                }
            }
            log.error("日期{}，{}执行{}失败，在执行{}失败，失败原因:{}"
                    ,calculatedParam.getDataDate()
                    ,methodDescribe
                    ,calculatedParam.isFullChain()?"全链":"指定节点：".concat(String.join(StrPool.COMMA,calculatedParam.getTagNames()))
                    ,failStep.getNodeId().concat(Objects.isNull(failStep.getTag()) ? "" :StrPool.DASHED.concat(failStep.getTag()))
                    ,Objects.isNull(failStep.getException()) ? null:failStep.getException().getMessage());
        }
    }


    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
    @ApiOperation("监测点算法执行链")
    @PostMapping("/measurementPointExecutor")
    public void measurementPointExecutor(@RequestBody BaseParam baseParam) {
        String methodDescribe = getMethodDescribe("measurementPointExecutor");
        //手动判断参数是否合法,
        CalculatedParam calculatedParam = judgeExecuteParam(baseParam);
        // 测点索引
        if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
            calculatedParam.setIdList(commTerminalGeneralClient.getRunMonitorIds().getData());
        }
        LiteflowResponse liteflowResponse;
        if (baseParam.isRepair()) {
            //补招时，起始日期、截止日期必填
            DateTime startDate = DateUtil.parse(baseParam.getBeginTime(), DatePattern.NORM_DATE_FORMAT);
            DateTime endDate = DateUtil.parse(baseParam.getEndTime(), DatePattern.NORM_DATE_FORMAT);
            long betweenDay = DateUtil.betweenDay(startDate, endDate, true);
            //递增日期执行算法链
            for (int i = 0; i < betweenDay; i++) {
                if (i != 0) {
                    startDate = DateUtil.offsetDay(startDate, 1);
                }
                calculatedParam.setDataDate(DateUtil.format(startDate, DatePattern.NORM_DATE_PATTERN));
                liteflowResponse = flowExecutor.execute2Resp("measurement_point", calculatedParam);
                dealResponse(calculatedParam,liteflowResponse,methodDescribe);
            }
        } else {
            //非补招
            liteflowResponse = flowExecutor.execute2Resp("measurement_point", calculatedParam);
            dealResponse(calculatedParam,liteflowResponse,methodDescribe);
        }


    }
    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
    @ApiOperation("单位监测点算法执行链")
    @PostMapping("/orgPointExecutor")
    public void orgPointExecutor(@RequestBody BaseParam baseParam) {
        String methodDescribe = getMethodDescribe("OrgPointExecutor");
        //手动判断参数是否合法,
        CalculatedParam<DeptGetChildrenMoreDTO> calculatedParam = judgeExecuteParam(baseParam);
        // 测点索引
        DeptGetLineParam deptGetLineParam = new DeptGetLineParam();

        if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
            Dept data = deptFeignClient.getRootDept().getData();
            deptGetLineParam.setDeptId(data.getId());
            calculatedParam.setIdList(commTerminalGeneralClient.deptGetLine(deptGetLineParam).getData());
        }
        LiteflowResponse liteflowResponse;
        if (baseParam.isRepair()) {
            //补招时，起始日期、截止日期必填
            DateTime startDate = DateUtil.parse(baseParam.getBeginTime(), DatePattern.NORM_DATE_FORMAT);
            DateTime endDate = DateUtil.parse(baseParam.getEndTime(), DatePattern.NORM_DATE_FORMAT);
            long betweenDay = DateUtil.betweenDay(startDate, endDate, true);
            //递增日期执行算法链
            for (int i = 0; i < betweenDay; i++) {
                if (i != 0) {
                    startDate = DateUtil.offsetDay(startDate, 1);
                }
                calculatedParam.setDataDate(DateUtil.format(startDate, DatePattern.NORM_DATE_PATTERN));
                liteflowResponse = flowExecutor.execute2Resp("org_point", calculatedParam);
                dealResponse(calculatedParam, liteflowResponse, methodDescribe);
            }
        } else {
            //非补招
            liteflowResponse = flowExecutor.execute2Resp("org_point", calculatedParam);
            dealResponse(calculatedParam, liteflowResponse, methodDescribe);
        }

    }

}