package com.vincent.rsf.openApi.service.phyz.impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.databind.cfg.CoercionAction;
|
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.openApi.config.PlatformProperties;
|
import com.vincent.rsf.openApi.entity.constant.PhyzMesConstant;
|
import com.vincent.rsf.openApi.entity.dto.CommonResponse;
|
import com.vincent.rsf.openApi.entity.phyz.*;
|
import com.vincent.rsf.openApi.service.phyz.MesReportService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.springframework.http.HttpEntity;
|
import org.springframework.http.HttpHeaders;
|
import org.springframework.http.HttpMethod;
|
import org.springframework.http.ResponseEntity;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.LinkedMultiValueMap;
|
import org.springframework.util.MultiValueMap;
|
import org.springframework.web.client.RestTemplate;
|
|
import javax.annotation.PostConstruct;
|
import javax.annotation.Resource;
|
import java.io.IOException;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
|
import org.springframework.http.client.ClientHttpResponse;
|
import java.util.Objects;
|
|
@Service
|
@Slf4j
|
public class MesReportServiceImpl implements MesReportService {
|
|
private static String MES_REPORT_URL;
|
|
@Resource
|
private PlatformProperties.MesApi mesApi;
|
@Resource
|
private RestTemplate restTemplate;
|
|
@PostConstruct
|
public void init() {
|
MES_REPORT_URL = mesApi.getMesUrl();
|
}
|
|
/**
|
* 获取token
|
*
|
* @return token字符串
|
*/
|
private String getToken() {
|
String mesUrl = MES_REPORT_URL + PhyzMesConstant.TOKEN;
|
try {
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/x-www-form-urlencoded");
|
|
// 准备表单数据
|
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
|
map.add("grant_type", "password");
|
map.add("username", PhyzMesConstant.TOKEN_USER);
|
map.add("password", PhyzMesConstant.TOKEN_PASSWORD);
|
map.add("client_id", "global");
|
map.add("client_secret", "cs");
|
|
HttpEntity<Object> httpEntity = new HttpEntity<>(map, headers);
|
ResponseEntity<String> exchange = restTemplate.exchange(mesUrl, HttpMethod.POST, httpEntity, String.class);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("请求失败！！");
|
}
|
|
try {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
JSONObject jsonObject = objectMapper.readValue(exchange.getBody(), JSONObject.class);
|
return jsonObject.getString("access_token");
|
} catch (JsonProcessingException e) {
|
log.error("Mes解析响应失败", e);
|
throw new CoolException("Mes解析响应失败：" + e.getMessage());
|
}
|
} catch (Exception e) {
|
log.error("Mes解析token响应失败", e);
|
return StringUtils.EMPTY;
|
}
|
}
|
|
/**
|
* 托盘信息同步
|
*
|
* @param params 托盘信息参数
|
* @return 响应结果
|
*/
|
public CommonResponse syncPalletInfo(Object params) {
|
if (Objects.isNull(params)) {
|
throw new CoolException("托盘信息参数不能为空！！");
|
}
|
|
// TODO: 参数转换
|
List<Pallet> pallets = new ArrayList<>();
|
// 将传入的 params 转换为 Pallet 对象列表
|
if (params instanceof List) {
|
for (Object obj : (List<?>) params) {
|
if (obj instanceof Map) {
|
Map<String, Object> map = (Map<String, Object>) obj;
|
Pallet pallet = new Pallet();
|
pallet.setBarCode((String) map.get("BarCode"));
|
pallet.setPalletCode((String) map.get("PalletCode"));
|
pallet.setPalletName((String) map.get("PalletName"));
|
pallet.setPalletTypeCode((String) map.get("PalletTypeCode"));
|
pallet.setPalletTypeName((String) map.get("PalletTypeName"));
|
pallet.setCreatedBy((String) map.get("CreatedBy"));
|
pallets.add(pallet);
|
} else if (obj instanceof Pallet) {
|
pallets.add((Pallet) obj);
|
}
|
}
|
}
|
|
MesReportList<Pallet> reportList = new MesReportList<>();
|
reportList.setCommand(new MesReportList.CommandData<Pallet>().setDataList(pallets));
|
|
String mesUrl = MES_REPORT_URL + PhyzMesConstant.PALLET_SYN;
|
log.info("Mes托盘信息同步： {}， 请求参数： {}", mesUrl, JSONObject.toJSONString(reportList));
|
try {
|
JSONObject jsonObject = postRequest(mesUrl, reportList, getToken());
|
boolean sendSuccess = jsonObject.getBoolean("Succeeded");
|
|
if (sendSuccess) {
|
return CommonResponse.ok();
|
} else {
|
// TODO：失败后记录重发
|
return CommonResponse.error(jsonObject.getJSONObject("Error").getString("ErrorMessage"));
|
}
|
} catch (Exception e) {
|
log.error("Mes解析托盘信息同步响应失败", e);
|
throw new CoolException("Mes解析响应失败：" + e.getMessage());
|
}
|
}
|
|
/**
|
* 接驳口信息同步（站点信息同步）
|
*
|
* @param params 站点信息参数
|
* @return 响应结果
|
*/
|
public CommonResponse syncStationInfo(Object params) {
|
if (Objects.isNull(params)) {
|
throw new CoolException("站点信息参数不能为空！！");
|
}
|
|
// TODO：参数转换
|
List<Station> stations = new ArrayList<>();
|
if (params instanceof List) {
|
for (Object obj : (List<?>) params) {
|
if (obj instanceof Map) {
|
Map<String, Object> map = (Map<String, Object>) obj;
|
Station station = new Station();
|
station.setConnPortCode((String) map.get("ConnPortCode"));
|
station.setConnPortName((String) map.get("ConnPortName"));
|
station.setWorkshopCode((String) map.get("WorkshopCode"));
|
station.setWorkshopName((String) map.get("WorkshopName"));
|
station.setProductionLineCode((String) map.get("ProductionLineCode"));
|
station.setProductionLineName((String) map.get("ProductionLineName"));
|
station.setCreatedBy((String) map.get("CreatedBy"));
|
stations.add(station);
|
} else if (obj instanceof Station) {
|
stations.add((Station) obj);
|
}
|
}
|
}
|
|
MesReportList<Station> reportList = new MesReportList<>();
|
reportList.setCommand(new MesReportList.CommandData<Station>().setDataList(stations));
|
|
String mesUrl = MES_REPORT_URL + PhyzMesConstant.STATION_SYN;
|
log.info("Mes站点信息同步： {}， 请求参数： {}", mesUrl, JSONObject.toJSONString(reportList));
|
try {
|
JSONObject jsonObject = postRequest(mesUrl, reportList, getToken());
|
boolean sendSuccess = jsonObject.getBoolean("Succeeded");
|
|
if (sendSuccess) {
|
return CommonResponse.ok();
|
} else {
|
// TODO：失败后记录重发
|
return CommonResponse.error(jsonObject.getJSONObject("Error").getString("ErrorMessage"));
|
}
|
} catch (Exception e) {
|
log.error("Mes解析站点信息同步响应失败", e);
|
throw new CoolException("Mes解析响应失败：" + e.getMessage());
|
}
|
}
|
|
/**
|
* 托盘任务回调（任务执行上报）
|
*
|
* @param params 任务执行参数
|
* @return 响应结果
|
*/
|
public CommonResponse reportTaskExecute(Object params) {
|
if (Objects.isNull(params)) {
|
throw new CoolException("任务执行参数不能为空！！");
|
}
|
|
// TODO：参数转换
|
TaskResult taskResult = new TaskResult();
|
if (params instanceof TaskResult) {
|
TaskResult task = (TaskResult) params;
|
taskResult.setTaskNo(task.getTaskNo());
|
taskResult.setStatus(task.getStatus());
|
} else if (params instanceof Map) {
|
Map<String, Object> map = (Map<String, Object>) params;
|
taskResult.setTaskNo((String) map.get("TaskNo"));
|
taskResult.setStatus((Integer) map.get("Status"));
|
}
|
|
MesReportOne<TaskResult> reportOne = new MesReportOne<>();
|
reportOne.setCommand(taskResult);
|
|
String mesUrl = MES_REPORT_URL + PhyzMesConstant.TASK_EXECUTE_REPORT;
|
log.info("Mes任务执行上报： {}， 请求参数： {}", mesUrl, JSONObject.toJSONString(reportOne));
|
try {
|
JSONObject jsonObject = postRequest(mesUrl, reportOne, getToken());
|
boolean sendSuccess = jsonObject.getBoolean("Succeeded");
|
|
if (sendSuccess) {
|
return CommonResponse.ok();
|
} else {
|
// TODO：失败后记录重发
|
return CommonResponse.error(jsonObject.getJSONObject("Error").getString("ErrorMessage"));
|
}
|
} catch (Exception e) {
|
log.error("Mes解析任务执行上报响应失败", e);
|
throw new CoolException("Mes解析响应失败：" + e.getMessage());
|
}
|
}
|
|
/**
|
* 通用HTTP POST请求方法
|
*
|
* @param url 请求URL
|
* @param params 请求参数
|
* @param token token
|
* @return 响应结果
|
*/
|
public JSONObject postRequest(String url, Object params, String token) {
|
if (StringUtils.isBlank(url)) {
|
throw new CoolException("请求URL不能为空！！");
|
}
|
if (Objects.isNull(params)) {
|
throw new CoolException("请求参数不能为空！！");
|
}
|
|
log.info("Mes POST请求： {}， 请求参数： {}", url, JSONObject.toJSONString(params));
|
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json;charset=utf-8"); //
|
headers.add("Authorization", "Bearer " + token);
|
|
HttpEntity<Object> httpEntity = new HttpEntity<>(params, headers);
|
|
try {
|
// 创建自定义的ResponseErrorHandler来处理非200状态码
|
RestTemplate customRestTemplate = new RestTemplate();
|
customRestTemplate.setRequestFactory(restTemplate.getRequestFactory());
|
|
// 设置错误处理器，不抛出异常，而是返回响应体
|
customRestTemplate.setErrorHandler(new org.springframework.web.client.DefaultResponseErrorHandler() {
|
@Override
|
public boolean hasError(ClientHttpResponse response) throws IOException {
|
// 不管状态码如何，都不视为错误
|
return false;
|
}
|
});
|
|
ResponseEntity<String> exchange = customRestTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
|
log.info("Mes POST请求响应结果： {}", exchange);
|
|
if (Objects.isNull(exchange.getBody()) || exchange.getBody().isEmpty()) {
|
throw new CoolException("请求失败！！");
|
}
|
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
return objectMapper.readValue(exchange.getBody(), JSONObject.class);
|
} catch (Exception e) { //JsonProcessingException
|
log.error("Mes解析响应失败", e);
|
throw new CoolException("Mes解析响应失败：" + e.getMessage());
|
}
|
}
|
|
}
|
