skyouc
2024-12-21 c635d78b479510ebe2556a420948effcd30a0731
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package com.zy.asrs.wms.apis.wcs.services.Impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.zy.asrs.framework.common.R;
import com.zy.asrs.wms.apis.wcs.entity.domain.EssTaskStatus;
import com.zy.asrs.wms.apis.wcs.entity.request.*;
import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;
import com.zy.asrs.wms.apis.wcs.services.WcsApiService;
import com.zy.asrs.wms.asrs.entity.Task;
import com.zy.asrs.wms.asrs.entity.WaitPakin;
import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
import com.zy.asrs.wms.asrs.service.TaskService;
import com.zy.asrs.wms.asrs.service.WaitPakinService;
import com.zy.asrs.wms.asrs.service.WorkService;
import io.jsonwebtoken.lang.Collections;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
@Service
public class WcsApiServiceImpl implements WcsApiService {
 
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private WorkService workService;
    @Autowired
    private TaskService taskService;
 
    @Override
    public CommonReponse publishTaskOfCarry() {
        //获取组拖通知档中,状态为正常,组托状态为待入库且未删除的WaitPakins
        List<WaitPakin> list = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>()
                .eq(WaitPakin::getStatus, 1)
                .eq(WaitPakin::getIoStatus, 0)
                .eq(WaitPakin::getDeleted, 0));
        if (!list.isEmpty()) {
            return publishTaskOfCarry(list);
        }
        return new CommonReponse();
    }
 
    /**
     * 下发料箱(容器)滚动至扫码区
     * //TODO 已费弃
     *
     * @param pakins
     * @return
     */
    @Override
    public CommonReponse publishTaskOfCarry(List<WaitPakin> pakins) {
        PublishTasksParam tasksParam = new PublishTasksParam();
        tasksParam.setTaskType("carry");
        List<TaskParam> tasks = new ArrayList<>();
        Map<String, List<WaitPakin>> barcodes = pakins.stream().collect(Collectors.groupingBy(WaitPakin::getBarcode));
        /**
         * 当前问题:
         * //TODO 1. 目前任务下发接口沟通下来,是需要目标位置的,这里我们只是刚组拖完成,并不是通知流动,没有目标位置
         * //TODO 2. 文档上的搬运任务下发指的都是多任务,多容器搬运,而不是我们需要物料信息同步功能
         * //TODO 3. 流程走不通暂时先跳过,确认是否需要WMS触发料箱滚动至扫码区
         * */
        barcodes.keySet().forEach(actionKey -> {
            List<TaskDescribe> taskDescribes = new ArrayList<>();
            barcodes.get(actionKey).forEach(action -> {
                TaskDescribe taskDescribe = new TaskDescribe();
                taskDescribe.setContainerCode(action.getBarcode());
                taskDescribes.add(taskDescribe);
            });
        });
 
        if (!pakins.isEmpty()) {
            pakins.forEach(waitPakin -> {
 
            });
        }
        tasksParam.setTasks(tasks);
 
        return null;
    }
 
 
    /**
     * 容器到达接收
     * 根据ESS返回的容器编码修改任务档中的输送线起始位置节点,及任务档执行状态
     * @param arrivedParam
     * @return
     */
    @Override
    @Transactional
    public R containerArrivedNotify(ContainerArrivedParam arrivedParam) {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));
        if (!Collections.isEmpty(tasks)) {
            return R.error("任务不存在!!");
//            throw new CoolException("任务不存在!!");
        }
 
        //DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点,及任务档容器到达状态
        taskService.update(new LambdaUpdateWrapper<Task>()
                .set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)
                .set(Task::getOriginLoc, arrivedParam.getSlotCode())
                .eq(Task::getBarcode, arrivedParam.getContainerCode()));
 
        return R.success("success");
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean receiveTaskStatus(TasksStatusCallbackParam callbackParam) {
        TaskStsType taskStsType = TaskStsType.WCS_CONTAINER_RECEIVE;
 
       if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
           taskStsType = TaskStsType.WCS_TOTE_LOAD;
        } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
           taskStsType = TaskStsType.WCS_TOTE_UNLOAD;
        } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中,任务完成是哪个事件,目前暂定task事件
           taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;
       }
 
        return taskService.update(new LambdaUpdateWrapper<Task>()
                .set(Task::getRobotCode, callbackParam.getRobotCode())
                .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
                .set(Task::getTaskSts, taskStsType.id)
                .set(Task::getExcudeStatus, callbackParam.getStatus())
                .set(Task::getTaskDesc, callbackParam.getMessage())
                .eq(Task::getBarcode, callbackParam.getContainerCode())
                .eq(Task::getTaskNo, callbackParam.getTaskCode()));
    }
 
 
}