no message

skyouc

2025-08-15 e8cbdfacdc15ce8e0faa1f4effc1154479b6ed31

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
package com.zy.asrs.wms.asrs.service.impl; 
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 
import com.zy.asrs.framework.exception.CoolException; 
import com.zy.asrs.wms.asrs.entity.*; 
import com.zy.asrs.wms.asrs.entity.enums.OrderSettleType; 
import com.zy.asrs.wms.asrs.entity.enums.OrderType; 
import com.zy.asrs.wms.asrs.mapper.WaitPakinMapper; 
import com.zy.asrs.wms.asrs.service.*; 
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import org.springframework.transaction.annotation.Transactional; 
 
import java.util.Date; 
import java.util.List; 
 
@Service("waitPakinService") 
public class WaitPakinServiceImpl extends ServiceImpl<WaitPakinMapper, WaitPakin> implements WaitPakinService { 
 
    @Autowired 
    private OrderService orderService; 
    @Autowired 
    private OrderDetlService orderDetlService; 
    @Autowired 
    private LocService locService; 
    @Autowired 
    private TaskService taskService; 
    @Autowired 
    private WaitPakinRuleService waitPakinRuleService; 
    @Autowired 
    private WaitPakinService waitPakinService; 
 
    @Override 
    public List<WaitPakin> getByOrderDetlId(Long orderDetlId) { 
        return this.list(new LambdaQueryWrapper<WaitPakin>().eq(WaitPakin::getDetlId, orderDetlId)); 
    } 
 
    @Override 
    @Transactional(rollbackFor = Exception.class) 
    public boolean comb(WaitPakin waitPakin, Long inType) { 
        //组托规则校验 
        waitPakinRuleService.rule(waitPakin); 
 
        if (waitPakin.getAnfme() <= 0) { 
            throw new CoolException("组托数量错误"); 
        } 
 
        List<Loc> locList = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getBarcode, waitPakin.getBarcode())); 
        if (!locList.isEmpty()) { 
            throw new CoolException("托盘已在库"); 
        } 
 
        List<Task> taskList = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, waitPakin.getBarcode())); 
        if (!taskList.isEmpty()) { 
            throw new CoolException("托盘正在入库中"); 
        } 
 
        OrderDetl orderDetl = orderDetlService.getById(waitPakin.getDetlId()); 
        if (orderDetl == null) { 
            throw new CoolException("订单明细不存在"); 
        } 
 
        if (inType.equals(OrderType.PK_IN_ORDER.id)) { 
            Double sCount = Math.round((orderDetl.getAnfme() - orderDetl.getWaitQty()) * 1000) / 1000.0; 
            if (waitPakin.getAnfme().compareTo(sCount) > 0) { 
                throw new CoolException("组托数量超过剩余可用数量"); 
            } 
        } else { 
//        Double count = orderDetl.getAnfme() - orderDetl.getQty() - orderDetl.getWorkQty() - orderDetl.getWaitQty(); 
            Double count = Math.round((orderDetl.getAnfme() - orderDetl.getWorkQty() - orderDetl.getQty()) * 1000) / 1000.0; 
            if (waitPakin.getAnfme().compareTo(count) > 0) { 
                throw new CoolException("组托数量超过剩余可用数量"); 
            } 
        } 
 
 
        //查询是否存在相同明细和托盘码的组托通知档 
        WaitPakin waitPakin1 = this.getOne(new LambdaQueryWrapper<WaitPakin>() 
                .eq(WaitPakin::getBarcode, waitPakin.getBarcode()) 
                .eq(WaitPakin::getDetlId, waitPakin.getDetlId())); 
 
        if (waitPakin1 == null) { 
            //不存在组托通知档，创建 
            waitPakin.setMatnr(orderDetl.getMat$().getMatnr()); 
            waitPakin.setBatch(orderDetl.getBatch()); 
            if (!this.save(waitPakin)) { 
                throw new CoolException("添加失败"); 
            } 
        }else { 
            Double total = waitPakin1.getAnfme() + waitPakin.getAnfme(); 
            //存在组托通知档，更新 
            waitPakin1.setAnfme(total); 
            waitPakin1.setUpdateTime(new Date()); 
            if (!this.updateById(waitPakin1)) { 
                throw new CoolException("添加失败"); 
            } 
        } 
 
        //获取订单 
        Order order = orderService.getById(orderDetl.getOrderId()); 
        if(order == null){ 
            throw new CoolException("订单不存在"); 
        } 
 
        //如果是平库入库单，修改订单明细执行数量 
        if (inType.equals(OrderType.PK_IN_ORDER.id)) { 
            Double workQty = Math.round((orderDetl.getWorkQty() + waitPakin.getAnfme()) * 1000) / 1000.0; 
            orderDetl.setWorkQty(workQty); 
            orderDetlService.updateById(orderDetl); 
        } 
 
        if (orderDetl.getWaitQty().compareTo(orderDetl.getAnfme()) >= 0) { 
            orderDetl.setSorted(0); 
        } else if (orderDetl.getWaitQty().compareTo(0.0) > 0) { 
            orderDetl.setSorted(55); 
        } else { 
            orderDetl.setSorted(49); 
        } 
        orderDetlService.updateById(orderDetl); 
 
        //更新订单状态 
        if (order.getOrderSettle().equals(OrderSettleType.INIT.val())) { 
            order.setOrderSettle(OrderSettleType.WAIT.val()); 
            order.setUpdateTime(new Date()); 
            if (!orderService.updateById(order)) { 
                throw new CoolException("订单数据更新失败"); 
            } 
        } 
        return true; 
    } 
}