hongjli
2025-05-22 e4efff6637f4d598a7efdfca8b62fbb4c3286b02
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
package com.aps.job.service.impl;
 
import cn.hutool.core.collection.ListUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.aps.common.core.utils.StringUtils;
import com.aps.common.security.utils.SecurityUtils;
import com.aps.job.domain.ApsWeldSeamStandardJob;
import com.aps.job.mapper.ApsWeldSeamStandardMapper;
import com.aps.job.mapper.ApsWeldSeamStandardJobMapper;
import com.aps.job.service.IApsWeldSeamStandardJobService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;
 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
 
/**
 * 焊缝标准Job Service业务层处理
 * 
 * @author user
 * @date 2023-11-05
 */
@Slf4j
@Service
public class ApsWeldSeamStandardJobServiceImpl implements IApsWeldSeamStandardJobService 
{
    @Autowired
    private ApsWeldSeamStandardJobMapper apsWeldSeamStandardJobMapper;
    
    @Autowired
    private ApsWeldSeamStandardMapper apsWeldSeamStandardMapper;
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Value("${pipingIntegrationplatform.apsWeldSeamStandard}")
    private String apsWeldSeamStandardUrl;
 
    /**
     * 查询焊缝标准列表
     * 
     * @param apsWeldSeamStandardJob 焊缝标准
     * @return 焊缝标准集合
     */
    @Override
    public List<ApsWeldSeamStandardJob> selectApsWeldSeamStandardJobList(ApsWeldSeamStandardJob apsWeldSeamStandardJob)
    {
        return apsWeldSeamStandardJobMapper.selectApsWeldSeamStandardJobList(apsWeldSeamStandardJob);
    }
 
    /**
     * 删除所有焊缝标准Job数据
     * 
     * @return 结果
     */
    @Override
    public int deleteAllApsWeldSeamStandardJob()
    {
        return apsWeldSeamStandardJobMapper.deleteAllApsWeldSeamStandardJob();
    }
    
    /**
     * 批量新增焊缝标准Job
     * 
     * @param list 焊缝标准Job列表
     * @return 结果
     */
    @Override
    public int batchInsertApsWeldSeamStandardJob(List<ApsWeldSeamStandardJob> list)
    {
        return apsWeldSeamStandardJobMapper.batchInsertApsWeldSeamStandardJob(list);
    }
    
    /**
     * 同步物料标准焊缝数据
     * 
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean syncWeldSeamStandardData()
    {
        try {
            // 使用POST方法调用接口
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            
            // 准备请求参数 - 传递工厂代码字符串数组,设置为空数组
            String[] plantCodeArray = new String[0];
            
            // 直接使用字符串数组作为请求体
            HttpEntity<String[]> requestEntity = new HttpEntity<>(plantCodeArray, headers);
            
            ResponseEntity<String> responseEntity = restTemplate.postForEntity(apsWeldSeamStandardUrl, requestEntity, String.class);
            if (!responseEntity.getStatusCode().is2xxSuccessful()) {
                log.error("获取物料标准焊缝数据失败");
                return false;
            }
            
            String responseBody = responseEntity.getBody();
            if (StringUtils.isEmpty(responseBody)) {
                return false;
            }
            
            JSONObject responseJson = JSON.parseObject(responseBody);
            
            // 检查返回码
            if (responseJson.getIntValue("code") != 0) {
                return false;
            }
            
            // 获取接口返回的数据
            JSONArray weldSeamList = responseJson.getJSONArray("ok");
            if (weldSeamList == null || weldSeamList.isEmpty()) {
                return false;
            }
            
            // 解析数据并转换为实体对象
            List<ApsWeldSeamStandardJob> jobList = new ArrayList<>();
            AtomicLong idCounter = new AtomicLong(System.currentTimeMillis()); // 使用当前时间戳作为起始ID
            
            for (int i = 0; i < weldSeamList.size(); i++) {
                JSONObject item = weldSeamList.getJSONObject(i);
                
                // 使用正确的字段名称 plantCode
                String plantCode = item.getString("plantCode");
                
                // 获取UHP和LOD数量
                BigDecimal uhpCount = null;
                BigDecimal lodCount = null;
                
                try {
                    uhpCount = item.getBigDecimal("uhpCount");
                } catch (Exception e) {
                    // 忽略异常
                }
                
                try {
                    lodCount = item.getBigDecimal("lodCount");
                } catch (Exception e) {
                    // 忽略异常
                }
                
                // 判断数据是否完整
                if (StringUtils.isEmpty(plantCode)) {
                    continue;
                }
                
                ApsWeldSeamStandardJob job = new ApsWeldSeamStandardJob();
                // 为id赋值,使用自增长整型
                job.setId(idCounter.incrementAndGet());
                job.setItemCode(plantCode);  // 映射关系: plantCode -> itemCode
                job.setHupQty(uhpCount);     // 映射关系: uhpCount -> hupQty
                job.setLodQty(lodCount);     // 映射关系: lodCount -> lodQty
                job.setDelFlag(0);
                // 不再设置createBy和createTime
                jobList.add(job);
            }
            
            if (jobList.isEmpty()) {
                return false;
            }
            
            // 清空旧数据
            deleteAllApsWeldSeamStandardJob();
            
            // 批量插入新数据
            List<List<ApsWeldSeamStandardJob>> dataGroupInterface = ListUtil.split(jobList, 1000);
            for (List<ApsWeldSeamStandardJob> data : dataGroupInterface) {
                batchInsertApsWeldSeamStandardJob(data);
            }
 
            // 同步数据到业务表
            List<List<ApsWeldSeamStandardJob>> dataGroup = ListUtil.split(jobList, 1000);
            for (List<ApsWeldSeamStandardJob> data : dataGroup) {
                syncToBizTable(data);
            }
            return true;
        } catch (Exception e) {
            log.error("同步物料标准焊缝数据异常", e);
            throw e;
        }
    }
    
    /**
     * 同步数据到业务表
     * 
     * @param jobList 焊缝标准Job数据列表
     */
    private void syncToBizTable(List<ApsWeldSeamStandardJob> jobList) {
        try {
            // 删除业务表数据(全量覆盖)
            apsWeldSeamStandardMapper.deleteAllApsWeldSeamStandard();
            
            if (jobList == null || jobList.isEmpty()) {
                return;
            }
            
            // 批量插入数据到业务表
            apsWeldSeamStandardMapper.batchInsertApsWeldSeamStandard(jobList);
        } catch (Exception e) {
            log.error("同步物料标准焊缝数据到业务表异常", e);
            throw e;
        }
    }