严智鑫
2025-11-13 945bc394f40d8af1072a53da9a94f24207124e6d
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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
package com.northglass.service.missingpiece;
 
import java.util.ArrayList;
import java.util.List;
 
import javax.servlet.http.HttpServletRequest;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
 
import com.northglass.constants.StateConstants.LoadMachineTaskState;
import com.northglass.constants.StateConstants.ShelfRankState;
import com.northglass.entity.LoadMachineRack;
import com.northglass.entity.LoadMachineTask;
import com.northglass.entity.OptPattern;
import com.northglass.entity.RawPackage;
import com.northglass.repository.LoadMachineDao;
import com.northglass.repository.LoadMachineRackDao;
import com.northglass.repository.LoadMachineTaskDao;
 
@Component
@Transactional
public class MisssingManageService {
    private static final Logger LOGGER = LoggerFactory.getLogger(MisssingManageService.class);
 
    @Autowired
    LoadMachineRackDao loadMachineRackDao;
    
    @Autowired
    LoadMachineTaskDao loadMachineTaskDao;
    
    @Autowired
    LoadMachineDao loadMachineDao;
    
    /**
     * 拼接工位信息(含有缺片信息)
     * @return
     */
    public String MissingMessage(long loadMachineId){
        //根据上片机获取所有的上片位对象
        List<LoadMachineRack> loadMachineRacks = loadMachineRackDao.findLoadMachineRacksByLoadMachineId(loadMachineId);
        
        StringBuffer loadMachineRankHtml = new StringBuffer();
        
        //定义标志(当两个工位同时缺片时,只显示一号位缺片按钮)
        boolean flag = true;
        
        for(LoadMachineRack loadMachineRack:loadMachineRacks){
            //将number显示成1和2
            String rackid = loadMachineRack.getNumber();
            
            //获取该工位上的message
            String message = loadMachineRack.getMessage();
            if(message!=null && !"".equals(message)){
                //缺片信息不为空,拼接缺片按钮
                loadMachineRankHtml.append("<tr>");
                loadMachineRankHtml.append("<td width='20%'>").append("No.").append(rackid).append("</td>");
                loadMachineRankHtml.append("<td width='60%'>").append("&nbsp").append("MESSAGE:").append(message).append("</td>").append("&nbsp;&nbsp");    
                if(flag && (rackid.equals("101") || rackid.equals("103"))){
                    loadMachineRankHtml.append("<td align='left'>").append("<input type='button' value='LACK' style='color: red;' onclick='checkMissing("+loadMachineRack.getNumber()+")'/>").append("</td>");
                }
                loadMachineRankHtml.append("</tr>");
                
                flag = false;
                
            }else{
                //信息为空,不缺片
                //拿到当前工位上的原片信息
                RawPackage rawPackage = loadMachineRack.getRawPackage();
                String state = loadMachineRack.getState();
                if(rawPackage!=null && state.equals(ShelfRankState.IN_WORKING) && rawPackage.getLeftPieces()>0){
                    loadMachineRankHtml.append("<tr>");
                    loadMachineRankHtml.append("<td width='20%'>").append("No.").append(rackid).append("</td>");
                    loadMachineRankHtml.append("<td width='60%'>").append("&nbsp").append("SIZE:");
                    loadMachineRankHtml.append(rawPackage.getWidth()).append("*").append(rawPackage.getHeight()).append("*");
                    loadMachineRankHtml.append(rawPackage.getThickness()).append("&nbsp").append("COLOR:").append(rawPackage.getColor());
                    loadMachineRankHtml.append("</tr>");
                }else{
                    loadMachineRankHtml.append("<tr>");
                    loadMachineRankHtml.append("<td width='20%'>").append("No.").append(rackid).append("</td>");
                    loadMachineRankHtml.append("<td width='80%'>").append("&nbsp").append("</td>");
                    loadMachineRankHtml.append("</tr>");
                }
                
                flag = true;
            }
            
        }
        return loadMachineRankHtml.toString();
    
    }
    
    /**
     * 处理缺片操作
     * @return
     */
    @Transactional
    public String dealMissing(HttpServletRequest request){
        //获取当前点击缺片的工位号
        String loadMachineRackId = request.getParameter("loadMachineRackId");
        //统计当前共标记了多少片
        int i = 0;
        if(loadMachineRackId.equals("101") || loadMachineRackId.equals("102")){
            //1号上片机上正在工作的原片
            LoadMachineTask workingGlass = loadMachineTaskDao.findWorkingGlass((long) 1);
            //当前要标记的原片的patternId
            Long optId = workingGlass.getOptPattern().getId();
            //找到当前原片同属于一个pattern下的原片,将未完成的全部标记为缺片(切割机一次跳过一个pattern)
            Long glassId = workingGlass.getId();
            //定义一个标志用于结束非同一个opt下的原片循环
            boolean flag = true;
            
            while(flag){
                //找到下一个id的原片
                LoadMachineTask nextGlass = loadMachineTaskDao.findOne(glassId+1);
                //将1号上片机的正在工作的原片设置为缺片
                workingGlass.setState(LoadMachineTaskState.LACK_PIECE);
                //把当前pattern的状态设置为缺片
                workingGlass.getOptPattern().setState(LoadMachineTaskState.LACK_PIECE);
                
                loadMachineTaskDao.save(workingGlass);
                i++;
                if(nextGlass!=null){
                    Long nextGlassOptId = nextGlass.getOptPattern().getId();
                    String loadNumber = nextGlass.getLoadMachine().getNumber();
                    //看是否是同一个opt且属于同一条产线下的
                    if(nextGlassOptId==optId && loadNumber.equals(loadMachineDao.findOne((long) 1).getNumber())){
                        //如果是,设置缺片状态
                        nextGlass.setState(LoadMachineTaskState.LACK_PIECE);
                        loadMachineTaskDao.save(nextGlass);
                        glassId++;
                        i++;
                    }else{
                        //不是同一个产线同一个opt下的原片,结束循环
                        flag = false;
                    }
                }else{
                    //没有下一个原片,结束循环
                    flag = false;
                }
                
            }
            
            //处理成功
            //将当前message信息缺片信息重组
            LoadMachineRack loadMachineRack = loadMachineRackDao.findLoadMachineRacksByRankNumber(loadMachineRackId);
            //清空当前缺片信息,由监听类重新设置缺片信息
            loadMachineRack.setMessage(null);;
            
            return "missingmanage/dealMissingSuccess";
        }
        
        if(loadMachineRackId.equals("103") || loadMachineRackId.equals("104")){
            //2号上片机正在工作的原片
            LoadMachineTask workingGlass = loadMachineTaskDao.findWorkingGlass((long) 2);
            //当前要标记的原片的patternId
            Long optId = workingGlass.getOptPattern().getId();
            //找到当前原片同属于一个pattern下的原片,将未完成的全部标记为缺片(切割机一次跳过一个pattern)
            Long glassId = workingGlass.getId();
            //定义一个标志用于结束非同一个opt下的原片循环
            boolean flag = true;
            while(flag){
                //找到下一个id的原片
                LoadMachineTask nextGlass = loadMachineTaskDao.findOne(glassId+1);
                //将2号上片机的正在工作的原片设置为缺片
                workingGlass.setState(LoadMachineTaskState.LACK_PIECE);
                //把当前pattern的状态设置为缺片
                workingGlass.getOptPattern().setState(LoadMachineTaskState.LACK_PIECE);
                
                loadMachineTaskDao.save(workingGlass);
                
                if(nextGlass!=null){
                    Long nextGlassOptId = nextGlass.getOptPattern().getId();
                    String loadNumber = nextGlass.getLoadMachine().getNumber();
                    //看是否是同一个opt且属于同一条产线下的
                    if(nextGlassOptId==optId && loadNumber.equals(loadMachineDao.findOne((long) 2).getNumber())){
                        //如果是设置缺片状态
                        nextGlass.setState(LoadMachineTaskState.LACK_PIECE);
                        loadMachineTaskDao.save(nextGlass);
                        glassId++;
                    }else{
                        //不是同一个产线同一个opt下的原片,结束循环
                        flag = false;
                    }
                }else{
                    //没有下一个原片,结束循环
                    flag = false;
                }
                
            }
            //将当前message信息缺片信息重组
            LoadMachineRack loadMachineRack = loadMachineRackDao.findLoadMachineRacksByRankNumber(loadMachineRackId);
            //清空缺片信息,由监听类重新设置缺片信息
            loadMachineRack.setMessage(null);
            //处理成功
            return "missingmanage/dealMissingSuccess2";
        }
        
        //处理失败
        if(loadMachineRackId.equals("101") || loadMachineRackId.equals("102")){
            //1号线的失败页面
            return "missingmanage/dealMissingFail";
        }
        //2号线的失败页面
        return "missingmanage/dealMissingFail2";
        
    }
    
    /**
     * 整理缺片信息
     * @return
     */
    public List<RawPackage> countLackPiece(long loadMachineId){
        List<LoadMachineTask> lackPiece = loadMachineTaskDao.findLackPiece(loadMachineId);//拿到所有状态为缺片的对象
        //创建一个集合用来放统计整理的原片对象
        List<RawPackage> raws = new ArrayList<RawPackage>();
        
        if(!lackPiece.isEmpty()){
            //缺片不为空
            aa:for(int i=0;i<lackPiece.size();i++){
                LoadMachineTask loadMachineTask = lackPiece.get(i);
                OptPattern optPattern = loadMachineTask.getOptPattern();
                String glassId = optPattern.getGlassId();
                double width = optPattern.getWidth();
                double height = optPattern.getHeight();
                double thickness = optPattern.getGlassThickness();
                String color = optPattern.getColor();
                int piece = 1;
                if(raws.isEmpty()){
                    //第一次进入
                    RawPackage ra = new RawPackage(glassId,piece, width, height, thickness, color);
                    raws.add(ra);
                }else{
                    //不为空
                    for(int j=0;j<raws.size();j++){
                        RawPackage rawPackage2 = raws.get(j);
                        double width2 = rawPackage2.getWidth();
                        double height2 = rawPackage2.getHeight();
                        double thickness2 = rawPackage2.getThickness();
                        String color2 = rawPackage2.getColor();
                        if(width==width2 && height==height2 && thickness==thickness2 && color.equals(color2)){
                            //相同规格将片数加一起
                            rawPackage2.setPieces(rawPackage2.getPieces()+piece);
                            continue aa;//后面的没有必要比较,不可能会出现一样的
                        }else{
                            //不相同,寻找下一个看是否相同
                            continue;
                        }
                    }
                    //都不相同,创建新的对象放入集合
                    RawPackage ra = new RawPackage(glassId, piece, width, height, thickness, color);
                    raws.add(ra);
                }
            }
        }
        
        return raws;
        
    }
    
}