wms-serve-mule/src/main/java/com/wms/controller/TaskDealController.java

package com.wms.controller;

import com.alibaba.fastjson2.JSON;
import com.wms.constants.enums.*;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.table.Location;
import com.wms.entity.app.wcs.WmsReceiveTaskResultEntity;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import com.wms.service.LocationService;
import com.wms.service.StockService;
import com.wms.service.TaskService;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import java.util.Collections;
import java.util.List;
import java.util.Objects;

/**
 * 这个类处理任务反馈信息
 */
@Controller
@CrossOrigin
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
@RequestMapping(value = "/wms/taskDeal")
public class TaskDealController extends BaseController {
    private final TaskService taskService;
    private final HttpServletRequest servletRequest;
    private final TaskController taskController;
    private final StockService stockService;
    private final LocationService locationService;

    /**
     * 更改任务状态
     *
     * @param request 请求参数
     * @return 结果
     */
    @PostMapping("/changeTaskStatus")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String changeTaskStatus(@RequestBody Task request) {
        logger.info("用户请求更改任务状态，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
        logger.info("请求详细：{}", JSON.toJSONString(request));
        ResponseEntity response = new ResponseEntity();
        try {
            if (request.getTaskStatus() == null) {
                logger.error("请选择任务状态");
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("请选择任务状态");
                return JSON.toJSONString(response);
            }
            // 更改后的任务状态
            int taskStatusRequest = request.getTaskStatus();
            int wcsTaskStatusAfter = 0;
            // 查询任务
            Task taskQuery = new Task();
            taskQuery.setTaskId(request.getTaskId());
            List<Task> tasks = taskService.selTasks(taskQuery);
            if (tasks.size() == 0) {
                logger.error("当前任务不存在");
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("当前任务不存在");
                return JSON.toJSONString(response);
            }
            Task currentTask = tasks.get(0);
            String newDestination = "";
            if (Objects.equals(currentTask.getTaskType(), TaskType.IN.getCode()) && StringUtils.isNotEmpty(request.getDestination()) && !Objects.equals(request.getDestination(), currentTask.getDestination())) {// 入库任务库位变更
                if (taskStatusRequest != 0) {
                    logger.error("更改库位必须重置任务");
                    response.setCode(ResponseCode.ERROR.getCode());
                    response.setMessage("更改库位必须重置任务");
                    return JSON.toJSONString(response);
                }
                newDestination = request.getDestination();
            }
            if (currentTask.getTaskId().startsWith("HK") && taskStatusRequest == 1) {
                logger.error("回库任务不允许取消");
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("回库任务不允许取消");
                return JSON.toJSONString(response);
            }
            String taskGroupId = currentTask.getTaskGroup();
            if (taskStatusRequest == 0) {// 重置任务
                logger.info("任务重置");
                // 将当前taskGroup的所有任务都设置为新建状态
                Task taskQuery2 = new Task();
                taskQuery2.setTaskGroup(taskGroupId);
                List<Task> tasks2 = taskService.selTasks(taskQuery2);
                for (Task task2 : tasks2) {
                    if (StringUtils.isNotEmpty(newDestination)) {
                        task2.setDestination(newDestination);
                    }
                    task2.setTaskStatus(WmsTaskStatus.NEW.getCode());
                    task2.setUserName(request.getUserName());
                    taskService.executeTask(task2);
                }
                // 如果更新了任务，那么该库位信息也要变更
                if (Objects.equals(currentTask.getTaskType(), TaskType.IN.getCode()) && StringUtils.isNotEmpty(newDestination)) {
                    Location newLocationQuery = new Location(newDestination);
                    List<Location> newLocations = locationService.selLocations(newLocationQuery);
                    for (Location newLocation : newLocations) {
                        newLocation.setVehicleId(currentTask.getVehicleNo());
                        newLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
                        locationService.modifyLocation(newLocation);
                        break;
                    }
                }
                // WCS取消任务
            } else if (taskStatusRequest == 1) {// 取消任务
                logger.info("任务取消");
                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
                sendToWmsRequest.setTaskId(taskGroupId);
                sendToWmsRequest.setTaskStatus(WcsTaskStatus.CANCEL.getCode());
                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
                sendToWmsRequest.setDestination(currentTask.getDestination());
                taskController.receiveTaskResult(sendToWmsRequest);
                wcsTaskStatusAfter = 999;
            } else if (taskStatusRequest == 2) {// 完成任务
                logger.info("任务完成");
                WmsReceiveTaskResultEntity sendToWmsRequest = new WmsReceiveTaskResultEntity();
                sendToWmsRequest.setTaskId(taskGroupId);
                sendToWmsRequest.setTaskStatus(WcsTaskStatus.FINISH.getCode());
                sendToWmsRequest.setVehicleNo(currentTask.getVehicleNo());
                sendToWmsRequest.setDestination(currentTask.getDestination());
                taskController.receiveTaskResult(sendToWmsRequest);
                wcsTaskStatusAfter = 3;
            }
            // 向WCS反馈
            WmsReceiveTaskResultEntity sendToWcsRequest = new WmsReceiveTaskResultEntity();
            sendToWcsRequest.setTaskId(taskGroupId);
            sendToWcsRequest.setTaskStatus(wcsTaskStatusAfter);
            if (StringUtils.isNotEmpty(newDestination)) {
                sendToWcsRequest.setDestination(newDestination);
            }
            ResponseEntity response1;
//            for (int i = 0; i < 5; i++) {
//                response1 = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CHANGE_TASK.getValue(), JSON.toJSONString(sendToWcsRequest)), ResponseEntity.class);
//                logger.info("向WCS反馈任务状态变更");
//                if (response1 == null || response1.getCode() != 0) {
//                    logger.error("向WCS反馈任务状态变更失败");
//                    response.setCode(ResponseCode.ERROR.getCode());
//                    response.setMessage("向WCS反馈任务状态变更失败");
//                    return JSON.toJSONString(response);
//                }
//                if (Objects.equals(response1.getCode(), 0)) {// 发送成功，则不再发送；不成功，一共尝试发送5次
//                    break;
//                }
//            }
            logger.info("更新任务状态成功");
            response.setCode(ResponseCode.OK.getCode());
            response.setMessage("更新任务状态成功");
            return JSON.toJSONString(response);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("发生异常{}", e.getMessage());
            response.setCode(ResponseCode.ERROR.getCode());
            response.setMessage("发生异常" + e.getMessage());
            return JSON.toJSONString(response);
        }
    }

    /**
     * 更改任务状态
     *
     * @param request 请求参数
     * @return 结果
     */
    @PostMapping("/updateTaskStatus")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String updateTaskStatus(@RequestBody Task request) {
        logger.info("用户请求更改任务状态，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
        logger.info("请求详细：{}", JSON.toJSONString(request));
        logger.info("更新任务状态成功");
        ResponseEntity response = new ResponseEntity();
        if (StringUtils.isEmpty(request.getTaskId())) {
            response.setCode(ResponseCode.OK.getCode());
        }
        Task task = new Task();
        task.setTaskId(request.getTaskId());
        task.setTaskStatus(request.getTaskStatus());
        int i = taskService.executeTask(task);
        if(i <= 0){
            logger.info("任务id{},无此任务",request.getTaskId());
            response.setCode(ResponseCode.ERROR.getCode());
            response.setMessage("无此任务");
        }
        response.setCode(ResponseCode.OK.getCode());
        response.setMessage("更新任务状态成功");
        return JSON.toJSONString(response);

    }

    /**
     * 删除kate清单数据
     *
     * @param request 请求参数
     * @return 结果
     */
    @PostMapping("/deleteAllKateTasks")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String deleteAllKateTasks(@RequestBody Task request) {
        logger.info("用户请求删除配料任务清单，包括配件、合件、紧急件，用户名：{}，ip地址：{}", request.getUserName(), HttpUtils.getIpAddr(servletRequest));
        ResponseEntity response = new ResponseEntity();
        try {
            // 有任务正在执行时不允许删除清单
            Task taskQuery = new Task();
            taskQuery.setTaskType(TaskType.OUT.getCode());
            List<Task> tasks = taskService.selTasks(taskQuery);
            if (tasks.size() > 0) {
                for (Task task : tasks) {
                    if (StringUtils.isNotEmpty(task.getKateTaskId())) {// 卡特任务未做完
                        logger.error("卡特任务未做完，不允许删除");
                        response.setCode(ResponseCode.ERROR.getCode());
                        response.setMessage("卡特任务未做完，不允许删除");
                        return JSON.toJSONString(response);
                    }
                }
            }
            stockService.resetStock(new Stock());
            logger.info("删除任务清单成功");
            response.setCode(ResponseCode.OK.getCode());
            response.setMessage("删除任务清单成功");
            return JSON.toJSONString(response);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("发生异常{}", e.getMessage());
            response.setCode(ResponseCode.ERROR.getCode());
            response.setMessage("发生异常" + e.getMessage());
            return JSON.toJSONString(response);
        }
    }
}