自动化立体仓库 - WCS系统
luxiaotao1123
2020-12-25 45c7066917384a3a0fea8f9cf8a0f0c03c6e81a7
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
package com.zy.common.service;
 
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Arith;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.common.model.StartupDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
/**
 * 货架核心功能
 * Created by vincent on 2020/6/11
 */
@Service
public class CommonService {
 
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkLastnoService wrkLastnoService;
    @Autowired
    private RowLastnoService rowLastnoService;
    @Autowired
    private BasCrnpService basCrnpService;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private LocMastService locMastService;
 
    /**
     * 生成工作号
     * @param wrkMk 0:入库 1 - 3000 ; 1:拣料/并板/盘点 3001 - 6000 ; 2: 出库 6001 -9000 ; 3:其他 9001 -9999
     * @return workNo(工作号)
     */
    public int getWorkNo(Integer wrkMk) {
        WrkLastno wrkLastno = wrkLastnoService.selectById(wrkMk);
        if (Cools.isEmpty(wrkLastno)) {
            throw new CoolException("数据异常,请联系管理员");
        }
 
        int workNo = wrkLastno.getWrkNo();
        int sNo = wrkLastno.getSNo();
        int eNo = wrkLastno.getENo();
        workNo = workNo>=eNo ? sNo : workNo+1;
        while (true) {
            WrkMast wrkMast = wrkMastService.selectById(workNo);
            if (null != wrkMast) {
                workNo = workNo>=eNo ? sNo : workNo+1;
            } else {
                break;
            }
        }
        // 修改序号记录
        if (workNo > 0){
            wrkLastno.setWrkNo(workNo);
            wrkLastnoService.updateById(wrkLastno);
        }
        // 检验
        if (workNo == 0) {
            throw new CoolException("生成工作号失败,请联系管理员");
        } else {
            if (wrkMastService.selectById(workNo)!=null) {
                throw new CoolException("生成工作号" + workNo + "在工作档中已存在");
            }
        }
        return workNo;
    }
 
    /**
     * 检索库位号
     * @param whsType 类型 1:双深式货架
     * @param staDescId 路径工作类型
     * @param sourceStaNo 源站
     * @param matNos 物料号集合
     * @return locNo 检索到的库位号
     */
    public StartupDto getLocNo(Integer whsType, Integer staDescId, Integer sourceStaNo, List<String> matNos) {
        StartupDto startupDto = new StartupDto();
        int workNo = getWorkNo(WorkNoType.getWorkNoType(staDescId));
        startupDto.setWorkNo(workNo);
        if (sourceStaNo < 100) {
            whsType = 1;
        } else {
            whsType = 2;
        }
        RowLastno rowLastno = rowLastnoService.selectById(whsType);
        if (Cools.isEmpty(rowLastno)) {
            throw new CoolException("数据异常,请联系管理员");
        }
        if (whsType == 1 || whsType == 2){
            int curRow = rowLastno.getCurrentRow();
            int sRow = rowLastno.getsRow();
            int eRow = rowLastno.geteRow();
 
            // 获取目标站所在货架排号
            curRow = curRow == sRow ? eRow : sRow;
            // 目标堆垛机号
            int crnNo;
            switch (whsType) {
                case 1:
                    crnNo = 1;
                    break;
                case 2:
                    crnNo = 2;
                    break;
                default:
                    throw new CoolException("检索库位 -- 检索堆垛机号失败");
            }
 
            basCrnpService.checkSiteStatus(crnNo);
            // 获取目标站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", staDescId)
                    .eq("stn_no", sourceStaNo)
                    .eq("crn_no", crnNo);
            StaDesc staDesc = staDescService.selectOne(wrapper);
            if (Cools.isEmpty(staDesc)) {
                throw new CoolException("入库路径不存在");
            }
            BasDevp staNo = basDevpService.selectById(staDesc.getCrnStn());
            int inQty = staNo.getInQty()==null?0:staNo.getInQty();
            if (staNo.getAutoing().equals("Y") && inQty<2) {
                // 查找库位
                LocMast locMast = locMastService.queryFreeLocMast(curRow);
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("没有空库位");
                }
                String locNo = locMast.getLocNo();
 
                // 更新库位排号
                rowLastno.setCurrentRow(curRow);
                rowLastnoService.updateById(rowLastno);
 
                // 返回dto
                startupDto.setCrnNo(crnNo);
                startupDto.setSourceStaNo(sourceStaNo);
                startupDto.setStaNo(staNo.getDevNo());
                startupDto.setLocNo(locNo);
            } else {
                throw new CoolException("目标站"+staDesc.getCrnStn()+"不可用");
            }
        } else {
            throw new CoolException(rowLastno.getWhsType()+"号库位排号分配规则不可用");
        }
        return startupDto;
    }
 
    public static void main(String[] args) {
        System.out.println(Arith.remainder(1, 4));
        System.out.println("0200201".substring(0, 2));
        String locNo = "0800201";
        int row = Integer.parseInt(locNo.substring(0, 2));
        double remainder = Arith.remainder(row, 4);
        int targetRow;
        if (remainder == 1) {
            // 得到当前库位的外围库位
            targetRow =  row + 1;
        } else if (remainder == 0) {
            // 得到当前库位的内围库位
            targetRow =  row - 1;
        } else {
            return;
        }
        String zerofill = zerofill(String.valueOf(targetRow), 2)+locNo.substring(2);
        System.out.println(zerofill);
    }
 
    public static String zerofill(String msg, Integer count) {
        if (msg.length() == count) {
            return msg;
        } else if (msg.length() > count) {
            return msg.substring(0, 16);
        } else {
            StringBuilder msgBuilder = new StringBuilder(msg);
            for(int i = 0; i < count - msg.length(); ++i) {
                msgBuilder.insert(0, "0");
            }
            return msgBuilder.toString();
        }
    }
 
}