lsh#

1

14 小时以前 d11eff090fb94927fa98a594b6c7ab4d3f04f3cd

 rsf-server/src/main/java/com/vincent/rsf/server/manager/schedules/TaskSchedules.java

@@ -11,10 +11,12 @@
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.common.SpringUtils;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.config.RemotesInfoProperties;
import com.vincent.rsf.server.api.entity.CommonResponse;
import com.vincent.rsf.server.api.entity.constant.RcsConstant;
import com.vincent.rsf.server.api.entity.params.MissionTaskIssueParam;
import com.vincent.rsf.server.api.entity.params.TaskItemParam;
import com.vincent.rsf.server.api.entity.params.WcsTaskParams;
import com.vincent.rsf.server.api.utils.LocUtils;
@@ -28,10 +30,7 @@
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.entity.*;
import com.vincent.rsf.server.system.service.ConfigService;
import com.vincent.rsf.server.system.service.impl.FlowInstanceServiceImpl;
import com.vincent.rsf.server.system.service.impl.FlowStepInstanceServiceImpl;
import com.vincent.rsf.server.system.service.impl.TaskInstanceNodeServiceImpl;
import com.vincent.rsf.server.system.service.impl.TaskInstanceServiceImpl;
import com.vincent.rsf.server.system.service.impl.*;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import com.vincent.rsf.server.system.utils.SystemAuthUtils;
import lombok.extern.slf4j.Slf4j;
@@ -96,6 +95,8 @@
    @Autowired
    private RemotesInfoProperties.RcsApi rcsApi;
    @Autowired
    private RemotesInfoProperties.WmsOpenApi wmsOpenApi;
    @Autowired
    private BasStationService basStationService;
    @Autowired
    private FlowStepInstanceServiceImpl flowStepInstanceService;
@@ -105,6 +106,12 @@
    private TaskInstanceNodeServiceImpl taskInstanceNodeService;
    @Autowired
    private TaskInstanceServiceImpl taskInstanceService;
    @Autowired
    private SubsystemFlowTemplateServiceImpl subsystemFlowTemplateService;
    @Autowired
    private FlowStepTemplateServiceImpl flowStepTemplateService;
    @Autowired
    private WarehouseAreasService warehouseAreasService;


    /**
@@ -112,110 +119,262 @@
     */
    @Scheduled(cron = "0/2 * * * * ?  ")
    @Transactional(rollbackFor = Exception.class)
    public void missionTaskEXECUTE() {
        List<String> typeList = Arrays.asList(
                MissionStepType.MISSION_STEP_TYPE_REQUEST.type,
                MissionStepType.MISSION_STEP_TYPE_UNBIND.type,
                MissionStepType.MISSION_STEP_TYPE_BIND.type,
                MissionStepType.MISSION_STEP_TYPE_OBTAIN.type,
                MissionStepType.MISSION_STEP_TYPE_NO_EXECUTE.type);
        List<FlowStepInstance> flowStepInstanceList = flowStepInstanceService.list(new LambdaQueryWrapper<FlowStepInstance>()
                .eq(FlowStepInstance::getStatus, 1).in(FlowStepInstance::getStepType,typeList));
        for (FlowStepInstance flowStepInstance : flowStepInstanceList) {
            FlowInstance flowInstance = flowInstanceService.getById(flowStepInstance.getFlowInstanceId());
            if (Cools.isEmpty(flowInstance)) { continue;}
            TaskInstanceNode taskInstanceNode = taskInstanceNodeService.getById(flowInstance.getNodeInstanceId());
            if (Cools.isEmpty(taskInstanceNode)) { continue;}
            TaskInstance taskInstance = taskInstanceService.getById(flowInstance.getTaskId());
            if (Cools.isEmpty(taskInstance)) { continue;}
            Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, taskInstance.getTaskNo()));
            if (Cools.isEmpty(task)) { continue;}
            if (!task.getTaskStatus().equals(flowStepInstance.getWmsNowTaskStatus())) {
                log.error("任务号："+task.getTaskCode()+"的任务状态与执行档案任务状态："+flowStepInstance.getWmsNowTaskStatus()+"不一致！！！");
                continue;
            }

            if (flowStepInstance.getStepType().equals(MissionStepType.MISSION_STEP_TYPE_NO_EXECUTE.type)) {
                /**基础配置链接*/
                log.info("任务越过， 请求参数： {}", JSONObject.toJSONString(flowStepInstance));
                try {
                    task.setTaskStatus(flowStepInstance.getWmsNextTaskStatus());
                    flowStepInstance.setStatus((short)3);

                    flowStepInstanceService.updateById(flowStepInstance);
                    taskService.updateById(task);

                    if (flowStepInstance.getWmsNextTaskStatus() != 9999) {
                        FlowStepInstance nextFlowStepInstance = flowStepInstanceService.getOne(new LambdaQueryWrapper<FlowStepInstance>()
                                .eq(FlowStepInstance::getFlowInstanceId, flowStepInstance.getFlowInstanceId())
                                .eq(FlowStepInstance::getFlowInstanceNo, flowStepInstance.getFlowInstanceNo())
                                .eq(FlowStepInstance::getStepOrder, flowStepInstance.getStepOrder() + 1)
                                .eq(FlowStepInstance::getWmsNowTaskStatus, flowStepInstance.getWmsNextTaskStatus()));
                        nextFlowStepInstance.setStatus((short)1);

                        flowStepInstanceService.updateById(nextFlowStepInstance);
                    }
                } catch (Exception e) {
                    throw new CoolException(e.getMessage());
    public synchronized void missionTaskEXECUTE() {
        try{
            List<FlowStepInstance> flowStepInstanceList = flowStepInstanceService.list(new LambdaQueryWrapper<FlowStepInstance>()
                    .eq(FlowStepInstance::getStatus, 1).in(FlowStepInstance::getStepType,MissionStepType.getTaskISSUE()));
            for (FlowStepInstance flowStepInstance : flowStepInstanceList) {
                FlowInstance flowInstance = flowInstanceService.getById(flowStepInstance.getFlowInstanceId());
                if (Cools.isEmpty(flowInstance)) { continue;}
                List<FlowStepInstance> flowStepInstances = flowStepInstanceService.list(new LambdaQueryWrapper<FlowStepInstance>()
                        .eq(FlowStepInstance::getFlowInstanceId, flowInstance.getId()).eq(FlowStepInstance::getStatus, (short) 0));
                flowInstance.setStatus(flowStepInstances.isEmpty()? (short) 2:(short) 1);
                TaskInstanceNode taskInstanceNode = taskInstanceNodeService.getById(flowInstance.getNodeInstanceId());
                if (Cools.isEmpty(taskInstanceNode)) { continue;}
                taskInstanceNode.setStatus(flowInstance.getStatus());
                TaskInstance taskInstance = taskInstanceService.getById(flowInstance.getTaskId());
                if (Cools.isEmpty(taskInstance)) { continue;}
                Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, taskInstance.getTaskNo()));
                if (Cools.isEmpty(task)) { continue;}
                if (!task.getTaskStatus().equals(flowStepInstance.getWmsNowTaskStatus())) {
                    log.error("任务号："+task.getTaskCode()+"的任务状态与执行档案任务状态："+flowStepInstance.getWmsNowTaskStatus()+"不一致！！！");
                    continue;
                }
            } else {
                /**任务下发接口*/
                String pubTakUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.MISSION_TRANSFER_STATION;

                /**基础配置链接*/
                log.info("任务下发，请求地址： {}， 请求参数： {}", pubTakUrl, JSONObject.toJSONString(""));
                HttpHeaders headers = new HttpHeaders();
                headers.add("Content-Type", "application/json");
                headers.add("api-version", "v2.0");
                HttpEntity httpEntity = new HttpEntity(flowStepInstance, headers);
                ResponseEntity<String> exchange = restTemplate.exchange(pubTakUrl, HttpMethod.POST, httpEntity, String.class);
                log.info("任务下发后，响应结果： {}", exchange);
                if (Objects.isNull(exchange.getBody())) {
                    throw new CoolException("任务下发失败！！，返回参数为空！！！");
                } else {
                if (flowStepInstance.getStepType().equals(MissionStepType.MISSION_STEP_TYPE_NO_EXECUTE.type)) {
                    /**基础配置链接*/
                    log.info("任务越过， 请求参数： {}", JSONObject.toJSONString(flowStepInstance));
                    try {
                        ObjectMapper objectMapper = new ObjectMapper();
                        objectMapper.coercionConfigDefaults()
                                .setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                        CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                        if (result.getCode() == 200) {
                            task.setTaskStatus(flowStepInstance.getWmsNextTaskStatus());
                            flowStepInstance.setStatus((short)3);
                        task.setTaskStatus(flowStepInstance.getWmsNextTaskStatus());
                        flowStepInstance.setStatus((short)3);

                            if (flowStepInstance.getStepType().equals(MissionStepType.MISSION_STEP_TYPE_OBTAIN.type)) {
                                //获取数据解析
                                //录入
                        flowStepInstanceService.updateById(flowStepInstance);
                        taskService.updateById(task);

                        if (flowStepInstance.getWmsNextTaskStatus() != 9999) {
                            FlowStepInstance nextFlowStepInstance = flowStepInstanceService.getOne(new LambdaQueryWrapper<FlowStepInstance>()
                                    .eq(FlowStepInstance::getStatus, (short)0)
                                    .eq(FlowStepInstance::getTaskNo, flowStepInstance.getTaskNo())
                                    .eq(FlowStepInstance::getStepOrder, flowStepInstance.getStepOrder() + 1)
                                    .eq(FlowStepInstance::getWmsNowTaskStatus, flowStepInstance.getWmsNextTaskStatus()));
                            if (Cools.isEmpty(nextFlowStepInstance)) {
                                throw new CoolException("任务号"+task.getTaskCode()+"任务步骤丢失！！！");
                            }
                            nextFlowStepInstance.setStatus((short)1);

                            flowStepInstanceService.updateById(flowStepInstance);
                            taskService.updateById(task);
                            flowStepInstanceService.updateById(nextFlowStepInstance);
                        } else {
                            taskInstance.setStatus((short)2);
                            taskInstanceService.updateById(taskInstance);
                        }
                        flowInstanceService.updateById(flowInstance);
                        taskInstanceNodeService.updateById(taskInstanceNode);
                    } catch (Exception e) {
                        throw new CoolException(e.getMessage());
                    }
                } else {
                    SubsystemFlowTemplate subsystemFlowTemplate = subsystemFlowTemplateService.getById(flowInstance.getFlowTemplateId());
                    FlowStepTemplate flowStepTemplate = flowStepTemplateService.getById(flowStepInstance.getStepTemplateId());

                            if (flowStepInstance.getWmsNextTaskStatus() != 9999) {
                                FlowStepInstance nextFlowStepInstance = flowStepInstanceService.getOne(new LambdaQueryWrapper<FlowStepInstance>()
                                        .eq(FlowStepInstance::getFlowInstanceId, flowStepInstance.getFlowInstanceId())
                                        .eq(FlowStepInstance::getFlowInstanceNo, flowStepInstance.getFlowInstanceNo())
                                        .eq(FlowStepInstance::getStepOrder, flowStepInstance.getStepOrder() + 1)
                                        .eq(FlowStepInstance::getWmsNowTaskStatus, flowStepInstance.getWmsNextTaskStatus()));
                                nextFlowStepInstance.setStatus((short)1);
                    MissionTaskIssueParam missionTaskIssueParam = new MissionTaskIssueParam(flowStepInstance,subsystemFlowTemplate,flowStepTemplate);

                                flowStepInstanceService.updateById(nextFlowStepInstance);
                    missionTaskIssueParam.setType(RcsTaskType.getTypeDesc(task.getTaskType()));
                    boolean souSign = taskInstance.getSourceCode().matches("\\d+");
                    if (souSign){
                        WarehouseAreas warehouseAreas = warehouseAreasService.getById(Long.parseLong(taskInstance.getSourceCode()));
                        if (Cools.isEmpty(warehouseAreas)){
                            BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, taskInstance.getSourceCode()));
                            if (Cools.isEmpty(basStation)){
                                basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                                        .apply("station_alias != '[]'")  // 不是空数组
                                        .apply("JSON_CONTAINS(station_alias, '\"{0}\"') = 1", taskInstance.getSourceCode())
                                        .eq(BasStation::getDeleted, 0)  // 通常需要加上未删除条件
                                        .last("LIMIT 1"));
                            }
                            if (Cools.isEmpty(basStation)){
                                flowStepInstance.setRetryTimes(flowStepInstance.getRetryTimes() + 1);
                                if (flowStepInstance.getRetryTimes()>5){
                                    flowStepInstance.setStatus((short)4);
                                    flowStepInstanceService.updateById(flowStepInstance);
                                    log.error("任务下发失败,源点未查询到，重试次数大于等于五次，标记为失败！！！");
                                } else {
                                    flowStepInstanceService.updateById(flowStepInstance);
                                    log.error("任务下发失败,源点未查询到目标点未查询到，等待重试....");
                                }
                                return;
                            } else {
                                missionTaskIssueParam.setSourceCode(basStation.getStationName());
                            }
                        } else {
                            missionTaskIssueParam.setSourceCode(taskInstance.getSourceCode());
                        }
                    } else {
                        BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, taskInstance.getSourceCode()));
                        if (Cools.isEmpty(basStation)){
                            basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                                    .apply("station_alias != '[]'")  // 不是空数组
                                    .apply("JSON_CONTAINS(station_alias, '\"{0}\"') = 1", taskInstance.getSourceCode())
                                    .eq(BasStation::getDeleted, 0)  // 通常需要加上未删除条件
                                    .last("LIMIT 1"));                            }
                        if (Cools.isEmpty(basStation)){
                            flowStepInstance.setRetryTimes(flowStepInstance.getRetryTimes() + 1);
                            if (flowStepInstance.getRetryTimes()>5){
                                flowStepInstance.setStatus((short)4);
                                flowStepInstanceService.updateById(flowStepInstance);
                                log.error("任务下发失败，重试次数大于等于五次，标记为失败！！！");
                                log.error("任务下发失败,源点未查询到，重试次数大于等于五次，标记为失败！！！");
                            } else {
                                flowStepInstanceService.updateById(flowStepInstance);
                                log.error("任务下发失败，等待重试....");
                                log.error("任务下发失败,源点未查询到目标点未查询到，等待重试....");
                            }
                            return;
                        } else {
                            missionTaskIssueParam.setSourceCode(basStation.getStationName());
                        }
                    } catch (JsonProcessingException e) {
                        throw new CoolException(e.getMessage());
                    }
                    boolean endSign = taskInstance.getTargetCode().matches("\\d+");
                    if (endSign){
                        WarehouseAreas warehouseAreas = warehouseAreasService.getById(Long.parseLong(taskInstance.getTargetCode()));
                        if (Cools.isEmpty(warehouseAreas)){
                            BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, taskInstance.getTargetCode()));
                            if (Cools.isEmpty(basStation)){
                                basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                                        .apply("station_alias != '[]'")  // 不是空数组
                                        .apply("JSON_CONTAINS(station_alias, '\"{0}\"') = 1", taskInstance.getTargetCode())
                                        .eq(BasStation::getDeleted, 0)  // 通常需要加上未删除条件
                                        .last("LIMIT 1"));                                }
                            if (Cools.isEmpty(basStation)){
                                flowStepInstance.setRetryTimes(flowStepInstance.getRetryTimes() + 1);
                                if (flowStepInstance.getRetryTimes()>5){
                                    flowStepInstance.setStatus((short)4);
                                    flowStepInstanceService.updateById(flowStepInstance);
                                    log.error("任务下发失败,目标点未查询到，重试次数大于等于五次，标记为失败！！！");
                                } else {
                                    flowStepInstanceService.updateById(flowStepInstance);
                                    log.error("任务下发失败,目标点未查询到，等待重试....");
                                }
                                return;
                            } else {
                                missionTaskIssueParam.setTargetCode(basStation.getStationName());
                            }

                        } else {
                            missionTaskIssueParam.setTargetCode(taskInstance.getTargetCode());
                        }
                    } else {
                        BasStation basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, taskInstance.getTargetCode()));
                        if (Cools.isEmpty(basStation)){
                            basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                                    .apply("station_alias != '[]'")  // 不是空数组
                                    .apply("JSON_CONTAINS(station_alias, '\"{0}\"') = 1", taskInstance.getTargetCode())
                                    .eq(BasStation::getDeleted, 0)  // 通常需要加上未删除条件
                                    .last("LIMIT 1"));                                  }
                        if (Cools.isEmpty(basStation)){
                            flowStepInstance.setRetryTimes(flowStepInstance.getRetryTimes() + 1);
                            if (flowStepInstance.getRetryTimes()>5){
                                flowStepInstance.setStatus((short)4);
                                flowStepInstanceService.updateById(flowStepInstance);
                                log.error("任务下发失败,目标点未查询到，重试次数大于等于五次，标记为失败！！！");
                            } else {
                                flowStepInstanceService.updateById(flowStepInstance);
                                log.error("任务下发失败,目标点未查询到，等待重试....");
                            }
                            return;
                        } else {
                            missionTaskIssueParam.setTargetCode(basStation.getStationName());
                        }
                    }
                    missionTaskIssueParam.setTaskPri(task.getSort());
                    missionTaskIssueParam.setBarcode(task.getBarcode());
                    missionTaskIssueParam.setTaskNo(task.getTaskCode());
                    if (missionTaskIssueParam.getType().equals(RcsTaskType.RCS_TASK_TYPE_ENUM_IN.type) && endSign){
                        missionTaskIssueParam.setLocNo(task.getTargLoc());
                        missionTaskIssueParam.setSourcestaNo(missionTaskIssueParam.getSourcestaNo());
                    } else if (missionTaskIssueParam.getType().equals(RcsTaskType.RCS_TASK_TYPE_ENUM_OUT.type) && souSign){
                        missionTaskIssueParam.setSourcelocNo(task.getOrgLoc());
                        missionTaskIssueParam.setStaNo(missionTaskIssueParam.getTargetCode());
                    } else if (missionTaskIssueParam.getType().equals(RcsTaskType.RCS_TASK_TYPE_ENUM_TRANSFER.type) && souSign && endSign){
                        missionTaskIssueParam.setSourcelocNo(task.getOrgLoc());
                        missionTaskIssueParam.setLocNo(task.getTargLoc());
                    } else if (missionTaskIssueParam.getType().equals(RcsTaskType.RCS_TASK_TYPE_ENUM_TRANSFER.type) && souSign && !endSign){
                        missionTaskIssueParam.setType(RcsTaskType.RCS_TASK_TYPE_ENUM_TRANSFER.type);
                        missionTaskIssueParam.setSourcelocNo(task.getOrgLoc());
                        missionTaskIssueParam.setStaNo(missionTaskIssueParam.getTargetCode());
                    }  else if (missionTaskIssueParam.getType().equals(RcsTaskType.RCS_TASK_TYPE_ENUM_TRANSFER.type) && !souSign && endSign){
                        missionTaskIssueParam.setType(RcsTaskType.RCS_TASK_TYPE_ENUM_IN.type);
                        missionTaskIssueParam.setSourcestaNo(missionTaskIssueParam.getSourcestaNo());
                        missionTaskIssueParam.setLocNo(task.getTargLoc());
                    } else if (missionTaskIssueParam.getType().equals(RcsTaskType.RCS_TASK_TYPE_ENUM_STA.type) || (!souSign && !endSign)){
                        missionTaskIssueParam.setType(RcsTaskType.RCS_TASK_TYPE_ENUM_STA.type);
                        missionTaskIssueParam.setSourcestaNo(missionTaskIssueParam.getSourcestaNo());
                        missionTaskIssueParam.setStaNo(missionTaskIssueParam.getTargetCode());
                    }

                    /**任务下发接口*/
                    String pubTakUrl = wmsOpenApi.getHost() + ":" + wmsOpenApi.getPort() + RcsConstant.MISSION_TRANSFER_STATION;

                    /**基础配置链接*/
                    log.info("任务下发，请求地址： {}， 请求参数： {}", pubTakUrl, JSONObject.toJSONString(flowStepInstance));
                    HttpHeaders headers = new HttpHeaders();
                    headers.add("Content-Type", "application/json");
                    headers.add("api-version", "v2.0");
                    HttpEntity httpEntity = new HttpEntity(missionTaskIssueParam, headers);
                    ResponseEntity<String> exchange = restTemplate.exchange(pubTakUrl, HttpMethod.POST, httpEntity, String.class);
                    log.info("任务下发后，响应结果： {}", exchange);
                    if (Objects.isNull(exchange.getBody())) {
                        throw new CoolException("任务下发失败！！，返回参数为空！！！");
                    } else {
                        try {
                            ObjectMapper objectMapper = new ObjectMapper();
                            objectMapper.coercionConfigDefaults()
                                    .setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                            CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                            if (result.getCode() == 200) {
                                task.setTaskStatus(flowStepInstance.getWmsNextTaskStatus());
                                flowStepInstance.setStatus((short)3);

                                if (flowStepInstance.getStepType().equals(MissionStepType.MISSION_STEP_TYPE_OBTAIN.type)) {
                                    //获取数据解析
                                    //录入
                                }

                                flowStepInstanceService.updateById(flowStepInstance);
                                taskService.updateById(task);

                                if (flowStepInstance.getWmsNextTaskStatus() != 9999) {
                                    FlowStepInstance nextFlowStepInstance = flowStepInstanceService.getOne(new LambdaQueryWrapper<FlowStepInstance>()
                                            .eq(FlowStepInstance::getStatus, (short)0)
                                            .eq(FlowStepInstance::getTaskNo, flowStepInstance.getTaskNo())
                                            .eq(FlowStepInstance::getStepOrder, flowStepInstance.getStepOrder() + 1)
                                            .eq(FlowStepInstance::getWmsNowTaskStatus, flowStepInstance.getWmsNextTaskStatus()));
                                    if (Cools.isEmpty(nextFlowStepInstance)) {
                                        throw new CoolException("任务号"+task.getTaskCode()+"任务步骤丢失！！！");
                                    }
                                    nextFlowStepInstance.setStatus((short)1);

                                    flowStepInstanceService.updateById(nextFlowStepInstance);
                                } else {
                                    taskInstance.setStatus((short)2);
                                    taskInstanceService.updateById(taskInstance);
                                }
                            } else {
                                flowStepInstance.setRetryTimes(flowStepInstance.getRetryTimes() + 1);
                                if (flowStepInstance.getRetryTimes()>5){
                                    flowStepInstance.setStatus((short)4);
                                    flowStepInstanceService.updateById(flowStepInstance);
                                    log.error("任务下发失败，重试次数大于等于五次，标记为失败！！！");
                                } else {
                                    flowStepInstanceService.updateById(flowStepInstance);
                                    log.error("任务下发失败，等待重试....");
                                }
                            }
                        } catch (JsonProcessingException e) {
                            throw new CoolException(e.getMessage());
                        }
                    }
                }
            }
        } catch (Exception e) {
            throw new CoolException(e.getMessage());
        }
    }

@@ -232,12 +391,57 @@
        completeInStock();
        complateOutStock();
        completeStock9999();
        completeStock10000();
    }


    public void completeStock9999() throws Exception {
        try{
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskStatus, TaskStsType.MISSION_TRANSFER.id).select(Task::getId));
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskStatus, TaskStsType.MISSION_TRANSFER.id));
            if (tasks.isEmpty()) {
                return;
            }
            for (Task task : tasks) {
                /**任务下发接口*/
                String pubTakUrl = wmsOpenApi.getHost() + ":" + wmsOpenApi.getPort() + RcsConstant.REPORT_TASKS;

                /**基础配置链接*/
                log.info("任务上报，请求地址： {}， 请求参数： {}", pubTakUrl, JSONObject.toJSONString(""));
                HttpHeaders headers = new HttpHeaders();
                headers.add("Content-Type", "application/json");
                headers.add("api-version", "v2.0");
                HttpEntity httpEntity = new HttpEntity(task, headers);
                ResponseEntity<String> exchange = restTemplate.exchange(pubTakUrl, HttpMethod.POST, httpEntity, String.class);
                log.info("任务上报，响应结果： {}", exchange);
                if (Objects.isNull(exchange.getBody())) {
                    throw new CoolException("任务上报失败！！，返回参数为空！！！");
                } else {
                    try {
                        ObjectMapper objectMapper = new ObjectMapper();
                        objectMapper.coercionConfigDefaults()
                                .setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                        CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                        if (result.getCode() == 200) {
                            task.setTaskStatus( TaskStsType.MISSION_TRANSFER_END.id);
                            taskService.updateById(task);
                        }
                    } catch (JsonProcessingException e) {
                        throw new CoolException(e.getMessage());
                    }
                }
            }
//            List<Long> longSet = tasks.stream().map(Task::getId).collect(Collectors.toList());
//            List<Task> vaildTasks = taskService.list(new LambdaQueryWrapper<Task>().in(Task::getId, longSet));
//            taskService.complateInTask(vaildTasks);
        } catch (Exception e) {
            log.error(e.getMessage());
        }
    }


    public void completeStock10000() throws Exception {
        try{
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskStatus, TaskStsType.MISSION_TRANSFER_END.id));
            if (tasks.isEmpty()) {
                return;
            }
@@ -771,6 +975,10 @@
        tasks.forEach(task -> {
            TaskLog taskLog = new TaskLog();
            BeanUtils.copyProperties(task, taskLog);
            taskLog.setOrgLoc(task.getOrgLoc())
                    .setTargLoc(task.getTargLoc())
                    .setTargSite(task.getTargSite())
                    .setOrgSite(task.getOrgSite());
            taskLog.setTaskId(task.getId())
                    .setId(null);
            if (!taskLogService.save(taskLog)) {