鞍钢鲅鱼圈能源管控系统后端代码
潘志宝
2 天以前 f571adc905374a61bf004072ae2ce8915a49b741
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
package com.iailab.module.ansteel.job.task;
 
import com.iailab.framework.common.util.date.DateUtils;
import com.iailab.module.ansteel.coking.entity.CokingProcessConfEntity;
import com.iailab.module.ansteel.coking.entity.CokingProcessMainEntity;
import com.iailab.module.ansteel.coking.service.CokingProcessConfService;
import com.iailab.module.ansteel.coking.service.CokingProcessMainService;
import com.iailab.module.ansteel.common.enums.ProcessConfDataTypeEnum;
import com.iailab.module.ansteel.common.enums.ProcessIndDataTypeEnum;
import com.iailab.module.data.api.ind.IndItemApi;
import com.iailab.module.data.api.ind.dto.ApiIndItemValueDTO;
import com.iailab.module.data.api.point.DataPointApi;
import org.apache.commons.lang3.ObjectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
 
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
 
/**
 * @author HouZhongjian
 * @Description
 * @createTime 2025年04月12日
 */
@Component("runCokingMainDayTask")
public class RunCokingMainDayTask implements ITask {
 
    private Logger logger = LoggerFactory.getLogger(getClass());
 
    @Resource
    private CokingProcessConfService cokingProcessConfService;
 
    @Resource
    private CokingProcessMainService cokingProcessMainService;
 
    @Resource
    private DataPointApi dataPointApi;
 
    @Resource
    private IndItemApi indItemApi;
 
    @Override
    public void run(String params) {
        logger.info("RunCokingMainDayTask,参数为:{}", params);
        try {
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.MILLISECOND, 0);
            calendar.set(Calendar.SECOND, 0);
            calendar.add(Calendar.DAY_OF_YEAR, -1);
            String clock = DateUtils.format(calendar.getTime(), DateUtils.FORMAT_YEAR_MONTH_DAY);
            CokingProcessConfEntity queryParams = new CokingProcessConfEntity();
            queryParams.setIndType("main");
            List<CokingProcessConfEntity> list = cokingProcessConfService.list(queryParams);
            if (CollectionUtils.isEmpty(list)) {
                logger.info("ConfLis is Empty");
                return;
            }
            // 先建立ext1到sort的映射关系
            Map<String, Integer> ext1ToSort = list.stream()
                    .collect(Collectors.toMap(
                            CokingProcessConfEntity::getExt1,
                            CokingProcessConfEntity::getSort,
                            (oldValue, newValue) -> oldValue));
 
            // 然后按这个关系排序分组
            Map<String, List<CokingProcessConfEntity>> groupMap = list.stream()
                    .sorted(Comparator.comparing(CokingProcessConfEntity::getSort))
                    .collect(Collectors.collectingAndThen(
                            Collectors.groupingBy(CokingProcessConfEntity::getExt1),
                            map -> map.entrySet().stream()
                                    .sorted(Comparator.comparingInt(
                                            e -> ext1ToSort.get(e.getKey())))  // 按ext1对应的sort值排序
                                    .collect(Collectors.toMap(
                                            Map.Entry::getKey,
                                            Map.Entry::getValue,
                                            (a, b) -> a,
                                            LinkedHashMap::new))));
 
            logger.info("清理旧数据");
            cokingProcessMainService.deleteByClock(clock);
 
            //计数器
            AtomicReference<Integer> counter = new AtomicReference<>(1);
            groupMap.forEach((group, confList) -> {
                CokingProcessMainEntity cokingProcessMainEntity = new CokingProcessMainEntity();
                cokingProcessMainEntity.setInfoType("0");
                cokingProcessMainEntity.setSort(counter.getAndSet(counter.get() + 1));
                cokingProcessMainEntity.setCategory("day");
                CokingProcessConfEntity cokingProcessConfEntity = confList.get(0);
                cokingProcessMainEntity.setIndName(cokingProcessConfEntity.getExt3());
                cokingProcessMainEntity.setClock(clock);
                confList.forEach(conf -> {
                    String value = "";
                    switch (ProcessConfDataTypeEnum.getEumByCode(conf.getDataType())) {
                        case DATAPOINT:
                            List<String> points = new ArrayList<>();
                            points.add(conf.getPointNo());
                            Map<String, Object> pointsRealValue = dataPointApi.queryPointsRealValue(points);
                            value = pointsRealValue.get(conf.getPointNo()).toString();
                            break;
                        case IND:
                            List<ApiIndItemValueDTO> indValues = indItemApi.queryIndItemDefaultValue(conf.getPointNo());
                            if (!CollectionUtils.isEmpty(indValues)) {
                                value = indValues.get(indValues.size() - 1).getDataValue().toString();
                            }
                            break;
                        default:
                            break;
                    }
                    //保存数据
                    if(ObjectUtils.isNotEmpty(value)) {
                        if(conf.getExt2().equals(ProcessIndDataTypeEnum.LSPJ.getCode())) {
                            cokingProcessMainEntity.setAvgValue(value.toString());
                        } else if(conf.getExt2().equals(ProcessIndDataTypeEnum.LLZ.getCode())) {
                            cokingProcessMainEntity.setTheoryValue(value.toString());
                        } else if(conf.getExt2().equals(ProcessIndDataTypeEnum.SJZ.getCode())) {
                            cokingProcessMainEntity.setActualValue(value.toString());
                        } else if(conf.getExt2().equals(ProcessIndDataTypeEnum.JZZ.getCode())) {
                            cokingProcessMainEntity.setStandValue(value.toString());
                        } else if(conf.getExt2().equals(ProcessIndDataTypeEnum.SSSJ.getCode())) {
                            cokingProcessMainEntity.setRealValue(value.toString());
                        }
                    }
                });
                cokingProcessMainService.save(cokingProcessMainEntity);
            });
 
        } catch (Exception ex) {
            logger.error("RunCokingMainDayTask运行异常");
            ex.printStackTrace();
        }
        logger.info("RunCokingMainDayTask运行完成");
 
    }
}