bluejay
2025-04-12 a40d3116690c0584e933b2f76ea2951e528c297d
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
package com.aps.core.service.impl;
 
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
 
import com.aps.common.core.utils.uuid.IdUtils;
import com.aps.common.core.web.domain.AjaxResult;
import com.aps.core.domain.ApsResourceDateStat;
import com.aps.core.mapper.ApsResourceGroupMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.aps.core.mapper.ApsPartRouteStatMapper;
import com.aps.core.domain.ApsPartRouteStat;
import com.aps.core.service.IApsPartRouteStatService;
 
import static java.util.stream.Collectors.groupingBy;
 
/**
 * 零件统计表Service业务层处理
 * 
 * @author zhl
 * @date 2025-04-11
 */
@Service
public class ApsPartRouteStatServiceImpl implements IApsPartRouteStatService 
{
    @Autowired
    private ApsPartRouteStatMapper apsPartRouteStatMapper;
    @Autowired
    private ApsResourceGroupMapper resourceGroupMapper;
 
    /**
     * 查询零件统计表
     * 
     * @param id 零件统计表主键
     * @return 零件统计表
     */
    @Override
    public ApsPartRouteStat selectApsPartRouteStatById(String id)
    {
        return apsPartRouteStatMapper.selectApsPartRouteStatById(id);
    }
 
    /**
     * 查询零件统计表列表
     * 
     * @param apsPartRouteStat 零件统计表
     * @return 零件统计表
     */
    @Override
    public List<ApsPartRouteStat> selectApsPartRouteStatList(ApsPartRouteStat apsPartRouteStat)
    {
        return apsPartRouteStatMapper.selectApsPartRouteStatList(apsPartRouteStat);
    }
 
    /**
     * 新增零件统计表
     * 
     * @param apsPartRouteStat 零件统计表
     * @return 结果
     */
    @Override
    public int insertApsPartRouteStat(ApsPartRouteStat apsPartRouteStat)
    {
        return apsPartRouteStatMapper.insertApsPartRouteStat(apsPartRouteStat);
    }
 
    /**
     * 修改零件统计表
     * 
     * @param apsPartRouteStat 零件统计表
     * @return 结果
     */
    @Override
    public int updateApsPartRouteStat(ApsPartRouteStat apsPartRouteStat)
    {
        return apsPartRouteStatMapper.updateApsPartRouteStat(apsPartRouteStat);
    }
 
    /**
     * 批量删除零件统计表
     * 
     * @param ids 需要删除的零件统计表主键
     * @return 结果
     */
    @Override
    public int deleteApsPartRouteStatByIds(String[] ids)
    {
        return apsPartRouteStatMapper.deleteApsPartRouteStatByIds(ids);
    }
 
    /**
     * 删除零件统计表信息
     * 
     * @param id 零件统计表主键
     * @return 结果
     */
    @Override
    public int deleteApsPartRouteStatById(String id)
    {
        return apsPartRouteStatMapper.deleteApsPartRouteStatById(id);
    }
 
 
 
 
    /**
     * 查询零件工序并更新计划开工日期
     * */
    @Override
    public void updatePartRoutPlanDate() {
        List<ApsPartRouteStat> tempList = apsPartRouteStatMapper.selectPartRoutStat();
        /*对tempList 按照 workOrderNo 进行分组*/
        Map<String, List<ApsPartRouteStat>> groupByWorkOrderNo = tempList.stream().collect(groupingBy(ApsPartRouteStat::getWorkOrderNo));
        /*本次计算批次号*/
        String batchNum = IdUtils.fastSimpleUUID();
        for (Map.Entry<String, List<ApsPartRouteStat>> entry : groupByWorkOrderNo.entrySet()) {
            /*取出每个零件工单的工艺路线信息*/
            List<ApsPartRouteStat> apsPartRouteStatList = entry.getValue();
            /*按照工序号进行排序*/
            apsPartRouteStatList.sort((a, b)->a.getRoadProcessNumber().compareTo(b.getRoadProcessNumber()));
            /*临时保存 上一道工序的工序总工时*/
            ApsPartRouteStat last=null;
            for (int i = 0; i <apsPartRouteStatList.size(); i++) {
                ApsPartRouteStat stat = apsPartRouteStatList.get(i);
                /*判断当前工序 当前工序只有一条*/
                if (stat.getCurrentProcessNumber().equals(stat.getRoadProcessNumber())) {
                    /* 对 stat.getProcessPlanStartDay() 和当前日期 进行对比,只对比到日,不用管十分秒*/
                    if (stat.getProcessPlanStartDay().toLocalDate().isBefore(LocalDateTime.now().toLocalDate())) {
                        stat.setProcessPlanStartDay(LocalDateTime.now());
                    }
                }
                /*未开工工序的计划开工日=上一道工序的计划开工日+上一道工序的工序总工时。*/
                if (stat.getCurrentProcessNumber().compareTo(stat.getRoadProcessNumber()) < 0) {
                    if (last != null) {
                        stat.setProcessPlanStartDay(last.getProcessPlanStartDay().plusHours(last.getProcessTotalTime()));
                    }
                }
                /*保存上一步计算的 开工日*/
                last = stat;
                stat.setId(IdUtils.fastUUID().toString());
                stat.setBatchNumber(batchNum);
                apsPartRouteStatMapper.insertApsPartRouteStat(stat);
            }
        }
        apsPartRouteStatMapper.deleteLastBatch(batchNum);
    }
    /** 查询资源日历表
     */
    @Override
    public AjaxResult selectResourceDateStat() {
        /*查出所有统计的数据*/
        AjaxResult result = new AjaxResult(200, "生成成功");
        List<ApsResourceDateStat> list = apsPartRouteStatMapper.selectResourceDateStat();
        if (!list.isEmpty()) {
            /*求出计划的最大时间,没有 设置为当前时间+15天*/
            ApsResourceDateStat apsResourceDateStat = list.stream().max(Comparator.comparing(ApsResourceDateStat::getPlanDay)).orElse(null);
            LocalDate maxPlanDay = LocalDate.now().plus(15, ChronoUnit.DAYS);
            if (apsResourceDateStat != null) {
                maxPlanDay = apsResourceDateStat.getPlanDay();
            }
            /*组织出日期表头*/
            List<String> planDays = new ArrayList<>();
            LocalDate startDay = LocalDate.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            while (!startDay.isAfter(maxPlanDay)) {
                planDays.add(startDay.format(formatter));
                startDay = startDay.plus(1, ChronoUnit.DAYS);
            }
            /*组织出列头数据*/
            List<String> resourceNames =list.stream().map(ApsResourceDateStat::getResourceName).distinct().toList();
            /*准备资源组信息*/
            List<Map<String, List<ApsResourceDateStat>>> targetList = new ArrayList<>();
            resourceNames.forEach(resourceName -> {
                        /*根据日期表头的顺序,组织出每个日期下的统计项目*/
                Map<String, List<ApsResourceDateStat>> maps = new HashMap<>(Map.of());
                List<ApsResourceDateStat> currentDaysResouces=new ArrayList<>();
                for (String planDay : planDays) {
                    /*查找当前计划日期下的所有资源组的数据*/
                    Optional<ApsResourceDateStat> first = list.stream()
                            .filter(item ->
                                    item.getPlanDay().equals(LocalDate.parse(planDay, formatter))
                                 && item.getResourceGroupName().equals(resourceName)
                            ).collect(Collectors.toList()).stream().findFirst();
                    if(first.isPresent()){
                        currentDaysResouces.add(first.get());
                    }
                    else {
                        ApsResourceDateStat empty = new ApsResourceDateStat();
                        empty.setPlanDay(LocalDate.parse(planDay, formatter));
                        empty.setDesignTimes(0);
                        empty.setRequireTimes(0);
                        empty.setResourceName(resourceName);
                        empty.setResourceGroupName(resourceName);
                        empty.setCapacityLoad(BigDecimal.ZERO);
                        currentDaysResouces.add(empty);
                    }
                };
                maps.put(resourceName, currentDaysResouces);
                targetList.add(maps);
            });
            result.put("planTitle", planDays);
            result.put("planTable", targetList);
        }
        return result;
    }
 
}