自动化立体仓库 - WMS系统
zhangc
2024-12-25 aa3476e8ff45d168f0bb9376ed3a114610a65f12
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
package com.zy.asrs.service.impl;
 
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.OrderDetl;
import com.zy.asrs.mapper.OrderDetlMapper;
import com.zy.asrs.service.OrderDetlService;
import com.zy.asrs.utils.Utils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
@Slf4j
@Service("orderDetlService")
public class OrderDetlServiceImpl extends ServiceImpl<OrderDetlMapper, OrderDetl> implements OrderDetlService {
 
    @Override
    public List<OrderDetl> selectByOrderId(Long orderId) {
        return this.selectList(new EntityWrapper<OrderDetl>().eq("order_id", orderId));
    }
 
    @Override
    public Page<OrderDetl> getPakoutPage(Page<OrderDetl> page) {
        page.setRecords(baseMapper.getPakoutPage(page.getCondition()));
        //page.setTotal(baseMapper.getPakoutPageCount(page.getCondition()));
        return page;
    }
 
    @Override
    public Page<OrderDetl> getOrderDetlByDoctype(Page<OrderDetl> page) {
        page.setRecords(baseMapper.getOrderDetlByDoctype(page.getCondition()));
        page.setTotal(baseMapper.getOrderDetlByDoctypeCount(page.getCondition()));
        return page;
    }
 
    @Override
    public OrderDetl selectItem(Long orderId, String matnr, String batch, String csocode, String isoCode) {
        List<OrderDetl> orderDetls = this.baseMapper.selectItem(orderId, matnr, batch, csocode, isoCode);
        if (orderDetls.isEmpty()) {
            return null;
        } else if (orderDetls.size() > 1) {
            throw new CoolException("订单明细查询到多条记录");
        }
        return orderDetls.get(0);
    }
 
    @Override
    public OrderDetl selectItem(String orderNo, String matnr, String batch, String csocode, String isoCode) {
        List<OrderDetl> orderDetls = this.baseMapper.selectItemByOrderNo(orderNo, matnr, batch, csocode, isoCode);
        if (orderDetls.isEmpty()) {
            return null;
        } else if (orderDetls.size() > 1) {
            throw new CoolException("订单明细查询到多条记录");
        }
        return orderDetls.get(0);
    }
 
    @Override
    public OrderDetl selectItem(String orderNo, String matnr, String batch, String threeCode) {
        List<OrderDetl> orderDetls = this.baseMapper.selectItemByOrderNo2(orderNo, matnr, batch, threeCode);
        if (orderDetls.isEmpty()) {
            return null;
        } else if (orderDetls.size() > 1) {
            throw new CoolException("订单明细查询到多条记录");
        }
        return orderDetls.get(0);
    }
 
 
    @Override
    public OrderDetl selectItemNoneOfBatch(String orderNo, String matnr) {
        List<OrderDetl> orderDetls = this.baseMapper.selectItemNoneOfBatch(orderNo, matnr);
        if (orderDetls.isEmpty()) {
            return null;
        } else if (orderDetls.size() > 1) {
            throw new CoolException("订单明细查询到多条记录");
        }
        return orderDetls.get(0);
    }
 
    @Override
    public OrderDetl selectItemOfBatch(String matnr, String batch) {
        List<OrderDetl> orderDetls = this.baseMapper.selectItemOfBatch(matnr, batch);
        if (orderDetls.isEmpty()) {
            return null;
        } else if (orderDetls.size() > 1) {
            throw new CoolException("订单明细查询到多条记录");
        }
        return orderDetls.get(0);
    }
 
    @Override
    public OrderDetl findByLook(List<OrderDetl> orderDetls, Long orderId, String matnr, String batch) {
        for (OrderDetl orderDetl : orderDetls) {
            if (orderDetl.getOrderId().equals(orderId) && orderDetl.getMatnr().equals(matnr)) {
                if (Cools.eq(batch, orderDetl.getBatch())) {
                    return orderDetl;
                }
            }
        }
        return null;
    }
 
    @Override
    public boolean increaseAnfme(Long orderId, String matnr, String batch, Double qty, String csocode, String isoCode) {
        return this.baseMapper.increaseAnfme(orderId, matnr, batch, qty, csocode, isoCode) > 0;
    }
 
    @Override
    public boolean increase(Long orderId, String matnr, String batch, Double qty, String csocode, String isoCode) {
        return this.baseMapper.increase(orderId, matnr, batch, qty, csocode, isoCode) > 0;
    }
 
    @Override
    public boolean decrease(String orderNo, String matnr, String batch, Double qty, String csocode, String isoCode) {
        int decrease = this.baseMapper.decrease(orderNo, matnr, batch, qty, csocode, isoCode);
        if (decrease == 0) {
            return this.baseMapper.decrease(orderNo, matnr, null, qty, csocode, isoCode) > 0;
        } else {
            return true;
        }
    }
 
    @Override
    public boolean modifyStatus(Long orderId, Integer status) {
        return this.baseMapper.modifyStatus(orderId, status) > 0;
    }
 
    @Override
    public List<OrderDetl> selectRemainder(Long orderId) {
        return this.baseMapper.selectRemainder(orderId);
    }
 
    @Override
    public OrderDetl selectContainBatch(String batch) {
        OrderDetl orderDetl = this.selectOne(new EntityWrapper<OrderDetl>().like("batch", batch));
        return orderDetl;
//        if (!Cools.isEmpty(orderDetls)) {
//            if (orderDetls.size() > 1) {
//                log.error("{}条码同时存在多笔订单,请注意查看!", matnr);
//            } else {
//                return orderDetls.get(0);
//            }
//        }
//        return null;
    }
 
    @Override
    public OrderDetl selectByOrderNoAndMatnr(String orderNo, String matnr, String csocode, String isoseq) {
        Wrapper<OrderDetl> wrapper = new EntityWrapper<OrderDetl>().eq("order_no", orderNo).eq("matnr", matnr);
        Utils.wapperSetCondition(wrapper, "three_code", csocode);
        Utils.wapperSetCondition(wrapper, "dead_time", isoseq);
 
        return this.selectOne(wrapper);
    }
 
 
}