package com.vincent.rsf.openApi.service.phyz.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
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.app.OpenApiOrder;
|
import com.vincent.rsf.openApi.entity.app.OpenApiOrderItem;
|
import com.vincent.rsf.openApi.entity.app.OpenApiOrderItemMap;
|
import com.vincent.rsf.openApi.entity.app.OpenApiOrderReportEvent;
|
import com.vincent.rsf.openApi.entity.constant.WmsConstant;
|
import com.vincent.rsf.openApi.entity.dto.CommonResponse;
|
import com.vincent.rsf.openApi.entity.phyz.*;
|
import com.vincent.rsf.openApi.entity.params.ReportDataParam;
|
import com.vincent.rsf.openApi.entity.params.ReportParams;
|
import com.vincent.rsf.openApi.mapper.OpenApiOrderItemMapMapper;
|
import com.vincent.rsf.openApi.mapper.OpenApiOrderItemMapper;
|
import com.vincent.rsf.openApi.mapper.OpenApiOrderMapper;
|
import com.vincent.rsf.openApi.mapper.OpenApiOrderReportEventMapper;
|
import com.vincent.rsf.openApi.service.WmsErpService;
|
import com.vincent.rsf.openApi.service.phyz.ErpReportService;
|
import com.vincent.rsf.openApi.utils.ParamsMapUtils;
|
import com.vincent.rsf.openApi.utils.SslUtils;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.http.client.methods.HttpPost;
|
import org.apache.http.entity.StringEntity;
|
import org.apache.http.impl.client.CloseableHttpClient;
|
import org.apache.http.impl.client.HttpClients;
|
import org.apache.http.util.EntityUtils;
|
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
|
import org.apache.http.client.config.RequestConfig;
|
import org.springframework.http.HttpEntity;
|
import org.springframework.http.HttpHeaders;
|
import org.springframework.http.HttpMethod;
|
import org.springframework.http.ResponseEntity;
|
import org.springframework.http.client.ClientHttpResponse;
|
import org.springframework.stereotype.Service;
|
import org.springframework.web.client.RestTemplate;
|
|
import jakarta.annotation.PostConstruct;
|
import jakarta.annotation.Resource;
|
import javax.net.ssl.SSLContext;
|
import javax.net.ssl.TrustManager;
|
import javax.net.ssl.X509TrustManager;
|
import java.lang.reflect.Field;
|
import java.security.cert.X509Certificate;
|
import java.io.IOException;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.security.MessageDigest;
|
import java.security.NoSuchAlgorithmException;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
public class ErpReportServiceImpl implements ErpReportService {
|
|
private static String ERP_REPORT_URL;
|
|
private CloseableHttpClient httpClient;
|
|
@Resource
|
private PlatformProperties.ErpApi erpApi;
|
@Resource
|
private PlatformProperties.WmsApi wmsApi;
|
@Resource
|
private WmsErpService wmsErpService;
|
@Resource
|
private RestTemplate restTemplate;
|
@Resource
|
private OpenApiOrderMapper openApiOrderMapper;
|
@Resource
|
private OpenApiOrderItemMapper openApiOrderItemMapper;
|
@Resource
|
private OpenApiOrderItemMapMapper openApiOrderItemMapMapper;
|
@Resource
|
private OpenApiOrderReportEventMapper openApiOrderReportEventMapper;
|
|
private static final BigDecimal ZERO = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
|
|
|
@PostConstruct
|
public void init() {
|
ERP_REPORT_URL = erpApi.getErpUrl();
|
}
|
|
@Override
|
public String syncMaterial(List<Material> materialList){
|
if (materialList.isEmpty()) {
|
throw new CoolException("参数不能为空！！");
|
}
|
/**WMS基础配置链接*/
|
String wmsUrl = wmsApi.getHost() + ":" + wmsApi.getPort() + WmsConstant.SYNC_MATNRS;
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
// Material -> BaseMatParms 字段一一对应后再下发
|
List<Map<String, Object>> baseMatParamsList = materialToBaseMatParams(materialList);
|
HttpEntity httpEntity2 = new HttpEntity<>(baseMatParamsList, headers);//cs
|
// sync/warehouse
|
ResponseEntity<String> exchange = restTemplate.exchange(wmsUrl, HttpMethod.POST, httpEntity2, String.class);//cs
|
log.info("同步物料信息返回结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("查询失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
// JSONObject object = JSONObject.parseObject(JSONObject.toJSONString(result.getData()));
|
return "200";
|
} else {
|
return result.getMsg();
|
// throw new CoolException("查询失败！！");
|
}
|
} catch (JsonProcessingException e) {
|
return e.getMessage();
|
// throw new CoolException(e.getMessage());
|
}
|
}
|
}
|
|
/**
|
* Material 字段映射为 server 端 BaseMatParms 字段
|
*/
|
private List<Map<String, Object>> materialToBaseMatParams(List<Material> materialList) {
|
List<Map<String, Object>> mappedList = new ArrayList<>();
|
for (Material material : materialList) {
|
if (Objects.isNull(material)) {
|
continue;
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("maktx", material.getMakTx());
|
map.put("matnr", material.getMatNr());
|
map.put("groupName", material.getGroupName());
|
map.put("model", material.getModel());
|
map.put("weight", material.getWeight() == null ? null : material.getWeight().toString());
|
map.put("color", material.getColor());
|
map.put("size", material.getSize());
|
map.put("spec", material.getSpec());
|
map.put("describle", material.getDescribe());
|
map.put("unit", material.getUnit());
|
map.put("operateType", material.getOperateType());
|
mappedList.add(map);
|
}
|
return mappedList;
|
}
|
|
@Override
|
public String syncWareHouse(List<Warehouse> warehouseList){
|
if (warehouseList.isEmpty()) {
|
throw new CoolException("参数不能为空！！");
|
}
|
/**WMS基础配置链接*/
|
String wmsUrl = wmsApi.getHost() + ":" + wmsApi.getPort() + WmsConstant.SYNC_WAREHOUSE;
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
// Warehouse -> WarehouseParams 字段一一对应后再下发
|
List<Map<String, Object>> warehouseParamsList = warehouseToWarehouseParams(warehouseList);
|
HttpEntity httpEntity2 = new HttpEntity<>(warehouseParamsList, headers);//cs
|
// sync/warehouse
|
ResponseEntity<String> exchange = restTemplate.exchange(wmsUrl, HttpMethod.POST, httpEntity2, String.class);//cs
|
log.info("同步仓库信息返回结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("查询失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
// JSONObject object = JSONObject.parseObject(JSONObject.toJSONString(result.getData()));
|
return "200";
|
} else {
|
return result.getMsg();
|
// throw new CoolException("查询失败！！");
|
}
|
} catch (JsonProcessingException e) {
|
return e.getMessage();
|
// throw new CoolException(e.getMessage());
|
}
|
}
|
}
|
@Override
|
public String syncCustomer(List<Customer> customerList){
|
if (customerList.isEmpty()) {
|
throw new CoolException("参数不能为空！！");
|
}
|
/**WMS基础配置链接*/
|
String wmsUrl = wmsApi.getHost() + ":" + wmsApi.getPort() + WmsConstant.SYNC_COMPANIES;
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
// Customer -> CompaniesParam 字段一一对应后再下发
|
List<Map<String, Object>> companiesParamsList = customerToCompaniesParams(customerList);
|
HttpEntity httpEntity2 = new HttpEntity<>(companiesParamsList, headers);//cs
|
ResponseEntity<String> exchange = restTemplate.exchange(wmsUrl, HttpMethod.POST, httpEntity2, String.class);//cs
|
log.info("同步客户信息返回结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("查询失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
return "200";
|
} else {
|
return result.getMsg();
|
}
|
} catch (JsonProcessingException e) {
|
return e.getMessage();
|
}
|
}
|
}
|
|
@Override
|
public String syncSupplier(List<Supplier> supplierList){
|
if (supplierList.isEmpty()) {
|
throw new CoolException("参数不能为空！！");
|
}
|
/**WMS基础配置链接*/
|
String wmsUrl = wmsApi.getHost() + ":" + wmsApi.getPort() + WmsConstant.SYNC_COMPANIES;
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
// Supplier -> supplierParams 字段一一对应后再下发
|
List<Map<String, Object>> supplierParamsList = customerToSupplierParams(supplierList);
|
HttpEntity httpEntity2 = new HttpEntity<>(supplierParamsList, headers);//cs
|
ResponseEntity<String> exchange = restTemplate.exchange(wmsUrl, HttpMethod.POST, httpEntity2, String.class);//cs
|
log.info("同步客户信息返回结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("查询失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
return "200";
|
} else {
|
return result.getMsg();
|
}
|
} catch (JsonProcessingException e) {
|
return e.getMessage();
|
}
|
}
|
}
|
|
/**
|
* Warehouse 字段映射为 server 端 WarehouseParams 字段
|
*/
|
private List<Map<String, Object>> warehouseToWarehouseParams(List<Warehouse> warehouseList) {
|
List<Map<String, Object>> mappedList = new ArrayList<>();
|
for (Warehouse warehouse : warehouseList) {
|
if (Objects.isNull(warehouse)) {
|
continue;
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", warehouse.getWareHouseName());
|
map.put("code", warehouse.getWareHouseId());
|
map.put("factory", warehouse.getUseOrgName());
|
map.put("factoryId", warehouse.getUseOrgId());
|
map.put("address", warehouse.getAddress());
|
map.put("type", null);
|
map.put("longitude", null);
|
map.put("latitude", null);
|
map.put("operateType", warehouse.getOperateType());
|
mappedList.add(map);
|
}
|
return mappedList;
|
}
|
|
/**
|
* Customer 字段映射为 server 端 CompaniesParam 字段
|
*/
|
private List<Map<String, Object>> customerToCompaniesParams(List<Customer> customerList) {
|
List<Map<String, Object>> mappedList = new ArrayList<>();
|
int rowNum = 0;
|
for (Customer customer : customerList) {
|
rowNum++;
|
if (Objects.isNull(customer)) {
|
continue;
|
}
|
if (StringUtils.isBlank(customer.getCustomerId())) {
|
throw new CoolException("客户同步失败：第" + rowNum + "行客户编码为空");
|
}
|
if (StringUtils.isBlank(customer.getCustomerName())) {
|
throw new CoolException("客户同步失败：第" + rowNum + "行客户名称为空");
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", customer.getCustomerName());
|
map.put("nameEn", null);
|
map.put("breifCode", customer.getCustomerNickName());
|
// server 端类型转换使用中文描述
|
map.put("type", "客户");
|
map.put("contact", customer.getContact());
|
map.put("tel", customer.getTelephone());
|
map.put("email", customer.getEmail());
|
map.put("pcode", null);
|
map.put("city", customer.getCustomerGroup());
|
map.put("province", null);
|
map.put("address", customer.getAddress());
|
map.put("code", customer.getCustomerId());
|
map.put("operateType", customer.getOperateType());
|
mappedList.add(map);
|
}
|
return mappedList;
|
}
|
|
/**
|
* Customer 字段映射为 server 端 CompaniesParam 字段
|
*/
|
private List<Map<String, Object>> customerToSupplierParams(List<Supplier> supplierList) {
|
List<Map<String, Object>> mappedList = new ArrayList<>();
|
for (Supplier supplier : supplierList) {
|
if (Objects.isNull(supplier)) {
|
continue;
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", supplier.getSupplierName());
|
map.put("nameEn", null);
|
map.put("breifCode", supplier.getSupplierName());
|
// server 端类型转换使用中文描述
|
map.put("type", supplier.getType());
|
map.put("contact", supplier.getContact());
|
map.put("tel", supplier.getTelephone());
|
map.put("email", supplier.getEmail());
|
map.put("pcode", null);
|
map.put("city", supplier.getSupplierGroup());
|
map.put("province", null);
|
map.put("address", supplier.getAddress());
|
map.put("code", supplier.getSupplierId());
|
map.put("operateType", supplier.getOperateType());
|
mappedList.add(map);
|
}
|
return mappedList;
|
}
|
|
@Override
|
public String addOrderToServer(Order order) {
|
if (Objects.isNull(order.getOrderNo()) || order.getOrderNo().isEmpty()) {
|
throw new CoolException("订单号不能为空！！");
|
}
|
/**WMS基础配置链接*/
|
String wmsUrl = wmsApi.getHost() + ":" + wmsApi.getPort() + WmsConstant.MODIFY_ORDER_DETLS;
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json");
|
headers.add("api-version", "v2.0");
|
|
List<Map<String, Object>> maps = new ArrayList<>();
|
Map<String, Object> mapParams = new HashMap<>();
|
// mapParams.put("orderNo", params.getOrderNo());
|
// mapParams.put("anfme", params.getAnfme());
|
// mapParams.put("type", params.getType());
|
// mapParams.put("wkType", params.getWkType());
|
// mapParams.put("exceStatus", params.getExceStatus());
|
// mapParams.put("orderItems", params.getOrderItems());
|
// maps.add(mapParams);
|
|
JSONObject params = JSONObject.parseObject(JSON.toJSONString(order));
|
JSONObject mappedData = ParamsMapUtils.apiMaps("erp", "orderId", params);
|
mappedData.put("updateBy", "erp");
|
mapParams = objectToMap(mappedData);
|
maps.add(mapParams);
|
log.info("修改订单信息及状态： {}， 请求参数： {}", wmsUrl, JSONArray.toJSONString(maps));
|
HttpEntity<List<Map<String, Object>>> httpEntity = new HttpEntity<>(maps, headers);
|
ArrayList<Order> orders = new ArrayList<>();
|
orders.add(order);
|
HttpEntity httpEntity2 = new HttpEntity<>(orders, headers);//cs
|
// asnOrder/items/save
|
ResponseEntity<String> exchange = restTemplate.exchange(wmsUrl, HttpMethod.POST, httpEntity2, String.class);//cs
|
log.info("订单修改返回结果： {}", exchange);
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("查询失败！！");
|
} else {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
try {
|
CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
|
if (result.getCode() == 200) {
|
// JSONObject object = JSONObject.parseObject(JSONObject.toJSONString(result.getData()));
|
return "200";
|
} else {
|
return result.getMsg();
|
// throw new CoolException("查询失败！！");
|
}
|
} catch (JsonProcessingException e) {
|
return e.getMessage();
|
// throw new CoolException(e.getMessage());
|
}
|
}
|
|
|
// ErpOpParams erpOpParams = new ErpOpParams();
|
// erpOpParams.set
|
//
|
// wmsErpService.updateOrderDetl(ErpOpParams params);
|
|
// CommonResponse updateOrderDetl()
|
//
|
// asnOrderService.saveOrderAndItems(params, getLoginUserId());
|
}
|
|
@Override
|
public String addOrderToServerNew(Order order) {
|
if (Objects.isNull(order) || StringUtils.isBlank(order.getOrderNo())) {
|
throw new CoolException("订单号不能为空！！");
|
}
|
if (Objects.isNull(order.getOrderItems()) || order.getOrderItems().isEmpty()) {
|
throw new CoolException("订单明细不能为空！！");
|
}
|
|
OpenApiOrder persistedOrder = saveOpenApiOrder(order);
|
List<OpenApiOrderItem> persistedItems = saveOpenApiOrderItems(persistedOrder, order.getOrderItems());
|
saveOpenApiOrderItemMappings(persistedOrder, persistedItems);
|
|
Order mergedOrder = buildMergedOrder(order);
|
String dispatchResult = addOrderToServer(mergedOrder);
|
if (!"200".equals(dispatchResult)) {
|
return dispatchResult;
|
}
|
return "200";
|
}
|
|
@Override
|
public CommonResponse reportOrderNew(Object params) {
|
if (Objects.isNull(params)) {
|
throw new CoolException("参数不能为空！！");
|
}
|
JSONObject root = JSONObject.parseObject(JSON.toJSONString(params));
|
|
String eventId = pickString(root, "eventId", "EventId");
|
String taskNo = pickString(root, "taskNo", "TaskNo");
|
String reportNo = pickString(root, "reportNo", "ReportNo");
|
if (StringUtils.isBlank(eventId) && StringUtils.isBlank(taskNo) && StringUtils.isBlank(reportNo)) {
|
throw new CoolException("幂等键不能为空（eventId/taskNo/reportNo）");
|
}
|
|
if (existsReportEvent(eventId, taskNo, reportNo)) {
|
return CommonResponse.ok("重复回传已忽略");
|
}
|
OpenApiOrderReportEvent reportEvent = saveReportEvent(eventId, taskNo, reportNo, pickString(root, "orderNo", "WMSNO"), root.toJSONString());
|
|
JSONArray dataArray = pickArray(root, "Data", "data");
|
if (Objects.isNull(dataArray) || dataArray.isEmpty()) {
|
return CommonResponse.error("回传明细为空");
|
}
|
|
int allocateCount = 0;
|
int erpReportCount = 0;
|
List<String> errors = new ArrayList<>();
|
|
for (int i = 0; i < dataArray.size(); i++) {
|
JSONObject row = dataArray.getJSONObject(i);
|
String orderNo = pickString(row, "WMSNO", "wmsNo", "orderNo", "OrderNo");
|
String matnrCode = pickString(row, "ItemCode", "itemCode", "matNr", "MatNr");
|
String batch = pickString(row, "Batch", "batch", "GoodsNO", "goodsNo");
|
BigDecimal doneQty = pickDecimal(row, "qty", "doneQty", "InQty", "OutQty");
|
if (StringUtils.isBlank(orderNo) || StringUtils.isBlank(matnrCode) || doneQty.compareTo(ZERO) <= 0) {
|
errors.add("第" + (i + 1) + "行缺少必要字段（WMSNO/ItemCode/数量）");
|
continue;
|
}
|
doneQty = doneQty.setScale(2, RoundingMode.HALF_UP);
|
|
try {
|
int singleAllocated = allocateMergedDoneQty(orderNo, matnrCode, batch, doneQty);
|
allocateCount += singleAllocated;
|
erpReportCount += reportReadyLinesToErp(orderNo);
|
refreshOrderFinishStatus(orderNo);
|
} catch (Exception e) {
|
log.error("处理回传失败，orderNo={}, matnr={}, batch={}", orderNo, matnrCode, batch, e);
|
errors.add("第" + (i + 1) + "行处理失败：" + e.getMessage());
|
}
|
}
|
|
if (!errors.isEmpty()) {
|
reportEvent.setStatus(2);
|
openApiOrderReportEventMapper.updateById(reportEvent);
|
return CommonResponse.error("处理完成，但存在异常：" + String.join(" | ", errors));
|
}
|
reportEvent.setStatus(1);
|
openApiOrderReportEventMapper.updateById(reportEvent);
|
|
Map<String, Object> result = new HashMap<>();
|
result.put("allocatedCount", allocateCount);
|
result.put("erpReportCount", erpReportCount);
|
return CommonResponse.ok(result);
|
}
|
|
private OpenApiOrder saveOpenApiOrder(Order order) {
|
OpenApiOrder existing = openApiOrderMapper.selectOne(new LambdaQueryWrapper<OpenApiOrder>()
|
.eq(OpenApiOrder::getCode, order.getOrderNo())
|
.last("limit 1"));
|
|
BigDecimal totalQty = sumOrderItemQty(order.getOrderItems());
|
Date businessTime = toDate(order.getBusinessTime());
|
OpenApiOrder target = Objects.isNull(existing) ? new OpenApiOrder() : existing;
|
target.setCode(order.getOrderNo())
|
.setType(order.getType())
|
.setWkType(order.getWkType())
|
.setAnfme(totalQty)
|
.setQty(ZERO)
|
.setWorkQty(ZERO)
|
.setExceStatus(0)
|
.setStatus(1)
|
.setBusinessTime(businessTime)
|
.setOrderInternalCode(order.getOrderInternalCode())
|
.setStationId(order.getStationId())
|
.setStockDirect(order.getStockDirect())
|
.setCustomerId(order.getCustomerId())
|
.setCustomerName(order.getCustomerName())
|
.setSupplierId(order.getSupplierId())
|
.setSupplierName(order.getSupplierName())
|
.setStockOrgId(order.getStockOrgId())
|
.setStockOrgName(order.getStockOrgName())
|
.setPurchaseOrgId(order.getPurchaseOrgId())
|
.setPurchaseOrgName(order.getPurchaseOrgName())
|
.setPurchaseUserId(order.getPurchaseUserId())
|
.setPurchaseUserName(order.getPurchaseUserName())
|
.setPrdOrgId(order.getPrdOrgId())
|
.setPrdOrgName(order.getPrdOrgName())
|
.setSaleOrgId(order.getSaleOrgId())
|
.setSaleOrgName(order.getSaleOrgName())
|
.setSaleUserId(order.getSaleUserId())
|
.setSaleUserName(order.getSaleUserName());
|
|
if (Objects.isNull(existing)) {
|
openApiOrderMapper.insert(target);
|
} else {
|
openApiOrderMapper.updateById(target);
|
openApiOrderItemMapper.delete(new LambdaQueryWrapper<OpenApiOrderItem>().eq(OpenApiOrderItem::getOrderId, target.getId()));
|
openApiOrderItemMapMapper.delete(new LambdaQueryWrapper<OpenApiOrderItemMap>().eq(OpenApiOrderItemMap::getOrderId, target.getId()));
|
}
|
return target;
|
}
|
|
private List<OpenApiOrderItem> saveOpenApiOrderItems(OpenApiOrder order, List<OrderItem> orderItems) {
|
List<OpenApiOrderItem> saved = new ArrayList<>();
|
for (OrderItem src : orderItems) {
|
OpenApiOrderItem target = new OpenApiOrderItem()
|
.setOrderId(order.getId())
|
.setOrderCode(order.getCode())
|
.setPlatItemId(src.getLineId())
|
.setPlatWorkCode(src.getPlanNo())
|
.setMatnrCode(src.getMatNr())
|
.setMaktx(src.getMakTx())
|
.setModel(src.getModel())
|
.setSpec(src.getSpec())
|
.setAnfme(toDecimal(src.getAnfme()))
|
.setStockUnit(src.getUnit())
|
.setWorkQty(ZERO)
|
.setQty(ZERO)
|
.setBatch(src.getBatch())
|
.setMemo(src.getMemo())
|
.setTargetWarehouseId(src.getTargetWarehouseId())
|
.setSourceWarehouseId(src.getSourceWarehouseId())
|
.setOwnerId(src.getOwnerId())
|
.setBaseUnit(src.getBaseUnit())
|
.setUseOrgId(src.getUseOrgId())
|
.setUseOrgName(src.getUseOrgName())
|
.setErpClsId(src.getErpClsId())
|
.setPriceUnitId(src.getPriceUnitId())
|
.setInStockType(src.getInStockType())
|
.setOwnerTypeId(src.getOwnerTypeId())
|
.setOwnerName(src.getOwnerName())
|
.setKeeperTypeId(src.getKeeperTypeId())
|
.setKeeperId(src.getKeeperId())
|
.setKeeperName(src.getKeeperName())
|
.setStatus(1)
|
.setDeleted(0);
|
openApiOrderItemMapper.insert(target);
|
saved.add(target);
|
}
|
return saved;
|
}
|
|
private void saveOpenApiOrderItemMappings(OpenApiOrder order, List<OpenApiOrderItem> items) {
|
Map<String, List<OpenApiOrderItem>> grouped = items.stream().collect(Collectors.groupingBy(i -> mergeKey(i.getMatnrCode(), i.getBatch())));
|
for (List<OpenApiOrderItem> sameGroupItems : grouped.values()) {
|
sameGroupItems.sort(Comparator.comparing(OpenApiOrderItem::getId));
|
for (int i = 0; i < sameGroupItems.size(); i++) {
|
OpenApiOrderItem item = sameGroupItems.get(i);
|
OpenApiOrderItemMap map = new OpenApiOrderItemMap()
|
.setOrderId(order.getId())
|
.setOrderCode(order.getCode())
|
.setSourceItemId(item.getId())
|
.setSourceLineId(item.getPlatItemId())
|
.setMergeMatnrCode(defaultString(item.getMatnrCode()))
|
.setMergeBatch(defaultString(item.getBatch()))
|
.setSeqNo(i + 1)
|
.setSourceQty(defaultQty(item.getAnfme()))
|
.setAllocatedQty(ZERO)
|
.setReportedQty(ZERO)
|
.setStatus(1)
|
.setDeleted(0);
|
openApiOrderItemMapMapper.insert(map);
|
}
|
}
|
}
|
|
private Order buildMergedOrder(Order source) {
|
Order merged = new Order()
|
.setOrderNo(source.getOrderNo())
|
.setOrderInternalCode(source.getOrderInternalCode())
|
.setWkType(source.getWkType())
|
.setCreateTime(source.getCreateTime())
|
.setBusinessTime(source.getBusinessTime())
|
.setStockDirect(source.getStockDirect())
|
.setStationId(source.getStationId())
|
.setCustomerId(source.getCustomerId())
|
.setCustomerName(source.getCustomerName())
|
.setSupplierId(source.getSupplierId())
|
.setSupplierName(source.getSupplierName())
|
.setStockOrgId(source.getStockOrgId())
|
.setStockOrgName(source.getStockOrgName())
|
.setPurchaseOrgId(source.getPurchaseOrgId())
|
.setPurchaseOrgName(source.getPurchaseOrgName())
|
.setPurchaseUserId(source.getPurchaseUserId())
|
.setPurchaseUserName(source.getPurchaseUserName())
|
.setPrdOrgId(source.getPrdOrgId())
|
.setPrdOrgName(source.getPrdOrgName())
|
.setSaleOrgId(source.getSaleOrgId())
|
.setSaleOrgName(source.getSaleOrgName())
|
.setSaleUserId(source.getSaleUserId())
|
.setSaleUserName(source.getSaleUserName());
|
merged.setType(source.getType());
|
Map<String, List<OrderItem>> grouped = source.getOrderItems().stream().collect(Collectors.groupingBy(i -> mergeKey(i.getMatNr(), i.getBatch())));
|
List<OrderItem> mergedItems = new ArrayList<>();
|
int idx = 1;
|
for (List<OrderItem> groupItems : grouped.values()) {
|
OrderItem first = groupItems.get(0);
|
BigDecimal qty = groupItems.stream()
|
.map(i -> toDecimal(i.getAnfme()))
|
.reduce(ZERO, BigDecimal::add)
|
.setScale(2, RoundingMode.HALF_UP);
|
OrderItem mergedItem = new OrderItem()
|
.setLineId("M" + idx++)
|
.setPlanNo(first.getPlanNo())
|
.setMatNr(first.getMatNr())
|
.setMakTx(first.getMakTx())
|
.setModel(first.getModel())
|
.setAnfme(qty.doubleValue())
|
.setBatch(first.getBatch())
|
.setUnit(first.getUnit())
|
.setBaseUnit(first.getBaseUnit())
|
.setPriceUnitId(first.getPriceUnitId())
|
.setPalletId(first.getPalletId())
|
.setTargetWarehouseId(first.getTargetWarehouseId())
|
.setSourceWarehouseId(first.getSourceWarehouseId())
|
.setInStockType(first.getInStockType())
|
.setOwnerTypeId(first.getOwnerTypeId())
|
.setOwnerId(first.getOwnerId())
|
.setOwnerName(first.getOwnerName())
|
.setKeeperTypeId(first.getKeeperTypeId())
|
.setKeeperId(first.getKeeperId())
|
.setKeeperName(first.getKeeperName())
|
.setMemo(first.getMemo())
|
.setUseOrgId(first.getUseOrgId())
|
.setUseOrgName(first.getUseOrgName())
|
.setErpClsId(first.getErpClsId());
|
mergedItem.setSpec(first.getSpec());
|
mergedItems.add(mergedItem);
|
}
|
merged.setOrderItems(mergedItems);
|
return merged;
|
}
|
|
private boolean existsReportEvent(String eventId, String taskNo, String reportNo) {
|
return openApiOrderReportEventMapper.selectCount(new LambdaQueryWrapper<OpenApiOrderReportEvent>()
|
.eq(OpenApiOrderReportEvent::getEventId, defaultString(eventId))
|
.eq(OpenApiOrderReportEvent::getTaskNo, defaultString(taskNo))
|
.eq(OpenApiOrderReportEvent::getReportNo, defaultString(reportNo))
|
.eq(OpenApiOrderReportEvent::getStatus, 1)) > 0;
|
}
|
|
private OpenApiOrderReportEvent saveReportEvent(String eventId, String taskNo, String reportNo, String orderCode, String payload) {
|
OpenApiOrderReportEvent event = new OpenApiOrderReportEvent()
|
.setEventId(defaultString(eventId))
|
.setTaskNo(defaultString(taskNo))
|
.setReportNo(defaultString(reportNo))
|
.setOrderCode(orderCode)
|
.setPayload(payload)
|
.setStatus(0);
|
openApiOrderReportEventMapper.insert(event);
|
return event;
|
}
|
|
private int allocateMergedDoneQty(String orderNo, String matnrCode, String batch, BigDecimal mergedDoneQty) {
|
OpenApiOrder order = openApiOrderMapper.selectOne(new LambdaQueryWrapper<OpenApiOrder>()
|
.eq(OpenApiOrder::getCode, orderNo)
|
.last("limit 1"));
|
if (Objects.isNull(order)) {
|
throw new CoolException("未找到订单：" + orderNo);
|
}
|
|
LambdaQueryWrapper<OpenApiOrderItemMap> queryWrapper = new LambdaQueryWrapper<OpenApiOrderItemMap>()
|
.eq(OpenApiOrderItemMap::getOrderId, order.getId())
|
.eq(OpenApiOrderItemMap::getMergeMatnrCode, defaultString(matnrCode))
|
.orderByAsc(OpenApiOrderItemMap::getSeqNo)
|
.orderByAsc(OpenApiOrderItemMap::getId);
|
if (StringUtils.isNotBlank(batch)) {
|
queryWrapper.eq(OpenApiOrderItemMap::getMergeBatch, batch);
|
}
|
List<OpenApiOrderItemMap> mappingRows = openApiOrderItemMapMapper.selectList(queryWrapper);
|
if (mappingRows.isEmpty()) {
|
throw new CoolException("未找到映射关系，订单：" + orderNo + "，物料：" + matnrCode);
|
}
|
|
BigDecimal remaining = mergedDoneQty;
|
int allocateRows = 0;
|
for (OpenApiOrderItemMap row : mappingRows) {
|
if (remaining.compareTo(ZERO) <= 0) {
|
break;
|
}
|
BigDecimal sourceQty = defaultQty(row.getSourceQty());
|
BigDecimal allocatedQty = defaultQty(row.getAllocatedQty());
|
BigDecimal canAllocate = sourceQty.subtract(allocatedQty);
|
if (canAllocate.compareTo(ZERO) <= 0) {
|
continue;
|
}
|
BigDecimal toAllocate = remaining.min(canAllocate).setScale(2, RoundingMode.HALF_UP);
|
if (toAllocate.compareTo(ZERO) <= 0) {
|
continue;
|
}
|
|
row.setAllocatedQty(allocatedQty.add(toAllocate).setScale(2, RoundingMode.HALF_UP));
|
openApiOrderItemMapMapper.updateById(row);
|
openApiOrderItemMapper.update(null, new LambdaUpdateWrapper<OpenApiOrderItem>()
|
.eq(OpenApiOrderItem::getId, row.getSourceItemId())
|
.setSql("qty = IFNULL(qty,0) + " + toAllocate));
|
remaining = remaining.subtract(toAllocate).setScale(2, RoundingMode.HALF_UP);
|
allocateRows++;
|
}
|
if (remaining.compareTo(ZERO) > 0) {
|
log.warn("回传数量超过未分配数量，orderNo={}, matnr={}, batch={}, overflow={}", orderNo, matnrCode, batch, remaining);
|
}
|
return allocateRows;
|
}
|
|
private int reportReadyLinesToErp(String orderNo) {
|
OpenApiOrder order = openApiOrderMapper.selectOne(new LambdaQueryWrapper<OpenApiOrder>()
|
.eq(OpenApiOrder::getCode, orderNo)
|
.last("limit 1"));
|
if (Objects.isNull(order)) {
|
return 0;
|
}
|
|
List<OpenApiOrderItemMap> mappings = openApiOrderItemMapMapper.selectList(new LambdaQueryWrapper<OpenApiOrderItemMap>()
|
.eq(OpenApiOrderItemMap::getOrderId, order.getId())
|
.orderByAsc(OpenApiOrderItemMap::getSeqNo)
|
.orderByAsc(OpenApiOrderItemMap::getId));
|
int successCount = 0;
|
|
for (OpenApiOrderItemMap mapping : mappings) {
|
BigDecimal allocatedQty = defaultQty(mapping.getAllocatedQty());
|
BigDecimal reportedQty = defaultQty(mapping.getReportedQty());
|
BigDecimal delta = allocatedQty.subtract(reportedQty).setScale(2, RoundingMode.HALF_UP);
|
if (delta.compareTo(ZERO) <= 0) {
|
continue;
|
}
|
|
OpenApiOrderItem item = openApiOrderItemMapper.selectById(mapping.getSourceItemId());
|
if (Objects.isNull(item)) {
|
continue;
|
}
|
|
ReportParams params = buildLineReportParams(order, item, delta);
|
CommonResponse erpResp = wmsErpService.reportOrders(params);
|
if (Objects.nonNull(erpResp) && Objects.equals(erpResp.getCode(), 200)) {
|
mapping.setReportedQty(reportedQty.add(delta).setScale(2, RoundingMode.HALF_UP));
|
openApiOrderItemMapMapper.updateById(mapping);
|
successCount++;
|
} else {
|
String msg = Objects.isNull(erpResp) ? "ERP响应为空" : erpResp.getMsg();
|
log.warn("ERP行上报失败，orderNo={}, itemId={}, msg={}", orderNo, item.getId(), msg);
|
}
|
}
|
return successCount;
|
}
|
|
private ReportParams buildLineReportParams(OpenApiOrder order, OpenApiOrderItem item, BigDecimal deltaQty) {
|
ReportDataParam dataParam = new ReportDataParam()
|
.setWMSNO(order.getCode())
|
.setPONO(order.getPoCode())
|
.setOrderNO(item.getPlatWorkCode())
|
.setGoodsNO(item.getBatch())
|
.setItemCode(item.getMatnrCode())
|
.setEditUser("open-api")
|
.setEditDate(new Date())
|
.setMemoDtl("lineId=" + defaultString(item.getPlatItemId()));
|
|
if ("in".equalsIgnoreCase(order.getType())) {
|
dataParam.setInQty(deltaQty.doubleValue());
|
} else {
|
dataParam.setOutQty(deltaQty.doubleValue());
|
}
|
|
return new ReportParams().setOrderType(order.getType()).setAction("Update").setData(Collections.singletonList(dataParam));
|
}
|
|
private void refreshOrderFinishStatus(String orderNo) {
|
OpenApiOrder order = openApiOrderMapper.selectOne(new LambdaQueryWrapper<OpenApiOrder>()
|
.eq(OpenApiOrder::getCode, orderNo)
|
.last("limit 1"));
|
if (Objects.isNull(order)) {
|
return;
|
}
|
List<OpenApiOrderItem> items = openApiOrderItemMapper.selectList(new LambdaQueryWrapper<OpenApiOrderItem>()
|
.eq(OpenApiOrderItem::getOrderId, order.getId()));
|
BigDecimal totalPlan = items.stream().map(i -> defaultQty(i.getAnfme())).reduce(ZERO, BigDecimal::add);
|
BigDecimal totalDone = items.stream().map(i -> defaultQty(i.getQty())).reduce(ZERO, BigDecimal::add);
|
|
int exceStatus = 0;
|
if (totalDone.compareTo(ZERO) > 0 && totalDone.compareTo(totalPlan) < 0) {
|
exceStatus = 1;
|
} else if (totalDone.compareTo(totalPlan) >= 0 && totalPlan.compareTo(ZERO) > 0) {
|
exceStatus = 2;
|
}
|
|
order.setQty(totalDone.setScale(2, RoundingMode.HALF_UP))
|
.setWorkQty(totalDone.setScale(2, RoundingMode.HALF_UP))
|
.setExceStatus(exceStatus);
|
openApiOrderMapper.updateById(order);
|
}
|
|
private BigDecimal sumOrderItemQty(List<OrderItem> orderItems) {
|
return orderItems.stream()
|
.filter(Objects::nonNull)
|
.map(i -> toDecimal(i.getAnfme()))
|
.reduce(ZERO, BigDecimal::add)
|
.setScale(2, RoundingMode.HALF_UP);
|
}
|
|
private BigDecimal toDecimal(Double value) {
|
if (Objects.isNull(value)) {
|
return ZERO;
|
}
|
return BigDecimal.valueOf(value).setScale(2, RoundingMode.HALF_UP);
|
}
|
|
private BigDecimal defaultQty(BigDecimal value) {
|
return Objects.isNull(value) ? ZERO : value.setScale(2, RoundingMode.HALF_UP);
|
}
|
|
private Date toDate(Long timestampSeconds) {
|
if (Objects.isNull(timestampSeconds) || timestampSeconds <= 0L) {
|
return null;
|
}
|
return new Date(timestampSeconds * 1000);
|
}
|
|
private String mergeKey(String matnr, String batch) {
|
return defaultString(matnr) + "@@" + defaultString(batch);
|
}
|
|
private String defaultString(String value) {
|
return StringUtils.trimToEmpty(value);
|
}
|
|
private String pickString(JSONObject object, String... candidates) {
|
if (Objects.isNull(object) || Objects.isNull(candidates)) {
|
return "";
|
}
|
for (String key : candidates) {
|
Object value = object.get(key);
|
if (Objects.nonNull(value) && StringUtils.isNotBlank(String.valueOf(value))) {
|
return String.valueOf(value).trim();
|
}
|
}
|
return "";
|
}
|
|
private JSONArray pickArray(JSONObject object, String... candidates) {
|
if (Objects.isNull(object) || Objects.isNull(candidates)) {
|
return new JSONArray();
|
}
|
for (String key : candidates) {
|
Object value = object.get(key);
|
if (value instanceof JSONArray) {
|
return (JSONArray) value;
|
}
|
if (value instanceof List) {
|
return JSONArray.parseArray(JSON.toJSONString(value));
|
}
|
if (value instanceof String && ((String) value).trim().startsWith("[")) {
|
return JSONArray.parseArray((String) value);
|
}
|
}
|
return new JSONArray();
|
}
|
|
private BigDecimal pickDecimal(JSONObject object, String... candidates) {
|
if (Objects.isNull(object) || Objects.isNull(candidates)) {
|
return ZERO;
|
}
|
for (String key : candidates) {
|
Object value = object.get(key);
|
if (Objects.isNull(value)) {
|
continue;
|
}
|
try {
|
return new BigDecimal(String.valueOf(value)).abs().setScale(2, RoundingMode.HALF_UP);
|
} catch (Exception ignore) {
|
// ignore invalid value
|
}
|
}
|
return ZERO;
|
}
|
|
public static Map<String, Object> objectToMap(Object obj) {
|
Map<String, Object> map = new HashMap<>();
|
Field[] fields = obj.getClass().getDeclaredFields();
|
for (Field field : fields) {
|
field.setAccessible(true); // 设置私有字段也可以访问
|
try {
|
map.put(field.getName(), field.get(obj));
|
} catch (IllegalAccessException e) {
|
e.printStackTrace();
|
}
|
}
|
return map;
|
}
|
|
|
|
/**
|
* 入/出库任务完成上报
|
*
|
* @param params
|
* @return
|
*/
|
public CommonResponse reportInOrOutBound(Object params) {
|
if (Objects.isNull(params)) {
|
throw new CoolException("入/出库任务信息参数不能为空！！");
|
}
|
|
// TODO：参数转换
|
ErpReportParams erpReportParams = new ErpReportParams();
|
if (params instanceof ErpReportParams) {
|
erpReportParams = (ErpReportParams) params;
|
} else if (params instanceof java.util.Map) {
|
java.util.Map<String, Object> paramMap = (java.util.Map<String, Object>) params;
|
|
// 设置基本属性
|
erpReportParams.setFDate((String) paramMap.get("FDate"));
|
erpReportParams.setF_OHDL_BillnoType((String) paramMap.get("F_OHDL_BillnoType"));
|
erpReportParams.setFStockOrgId(paramMap.get("FStockOrgId"));
|
erpReportParams.setFPrdOrgId(paramMap.get("FPrdOrgId"));
|
erpReportParams.setF_OHDL_ProPlan((String) paramMap.get("F_OHDL_ProPlan"));
|
|
// 处理FEntity列表
|
Object fEntityObj = paramMap.get("FEntity");
|
if (fEntityObj instanceof java.util.List) {
|
java.util.List<?> fEntityList = (java.util.List<?>) fEntityObj;
|
java.util.List<ErpReportParams.FEntityItem> entityItems = new java.util.ArrayList<>();
|
|
for (Object item : fEntityList) {
|
if (item instanceof java.util.Map) {
|
java.util.Map<String, Object> itemMap = (java.util.Map<String, Object>) item;
|
ErpReportParams.FEntityItem entityItem = new ErpReportParams.FEntityItem();
|
|
// 使用反射设置属性值
|
try {
|
// 使用反射直接访问字段并设置值
|
java.lang.reflect.Field field;
|
|
field = entityItem.getClass().getDeclaredField("FMaterialId");
|
field.setAccessible(true);
|
field.set(entityItem, itemMap.get("FMaterialId"));
|
|
field = entityItem.getClass().getDeclaredField("FUnitID");
|
field.setAccessible(true);
|
field.set(entityItem, itemMap.get("FUnitID"));
|
|
// 处理数值类型
|
Object fAppQty = itemMap.get("FAppQty");
|
if (fAppQty instanceof Number) {
|
field = entityItem.getClass().getDeclaredField("FAppQty");
|
field.setAccessible(true);
|
field.set(entityItem, ((Number) fAppQty).doubleValue());
|
} else if (fAppQty != null) {
|
field = entityItem.getClass().getDeclaredField("FAppQty");
|
field.setAccessible(true);
|
field.set(entityItem, Double.parseDouble(fAppQty.toString()));
|
}
|
|
Object fActualQty = itemMap.get("FActualQty");
|
if (fActualQty instanceof Number) {
|
field = entityItem.getClass().getDeclaredField("FActualQty");
|
field.setAccessible(true);
|
field.set(entityItem, ((Number) fActualQty).doubleValue());
|
} else if (fActualQty != null) {
|
field = entityItem.getClass().getDeclaredField("FActualQty");
|
field.setAccessible(true);
|
field.set(entityItem, Double.parseDouble(fActualQty.toString()));
|
}
|
|
field = entityItem.getClass().getDeclaredField("FStockId");
|
field.setAccessible(true);
|
field.set(entityItem, itemMap.get("FStockId"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_BworkShop");
|
field.setAccessible(true);
|
field.set(entityItem, itemMap.get("F_OHDL_BworkShop"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_Pallet");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_Pallet"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_ConPoint");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_ConPoint"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_PlanNo");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_PlanNo"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_MONo");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_MONo"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_MOId");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_MOId"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_MOLine");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_MOLine"));
|
|
field = entityItem.getClass().getDeclaredField("F_OHDL_MOLineId");
|
field.setAccessible(true);
|
field.set(entityItem, (String) itemMap.get("F_OHDL_MOLineId"));
|
} catch (Exception e) {
|
log.error("设置FEntityItem属性时发生错误: " + e.getMessage());
|
throw new CoolException("设置FEntityItem属性失败: " + e.getMessage());
|
}
|
|
entityItems.add(entityItem);
|
} else if (item instanceof ErpReportParams.FEntityItem) {
|
entityItems.add((ErpReportParams.FEntityItem) item);
|
}
|
}
|
erpReportParams.setFEntity(entityItems);
|
}
|
} else {
|
throw new CoolException("无法处理的参数类型: " + params.getClass().getName());
|
}
|
|
JSONObject model = new JSONObject();
|
model.put("Model", erpReportParams);
|
JSONObject data = new JSONObject();
|
data.put("data", model);
|
data.put("formid", "ke3d5adc0bbe64eceafd5891400adf40e");
|
|
try {
|
JSONObject loginResult = loginBySign();
|
if (loginResult.getInteger("LoginResultType") == 1) {
|
String erpUrl = ERP_REPORT_URL + "/Kingdee.BOS.WebApi.ServicesStub.DynamicFormService.Save.common.kdsvc";
|
log.info("Erp入/出库任务完成上报： {}， 请求参数： {}", erpUrl, JSONObject.toJSONString(data));
|
|
String result2 = httpPostExample(erpUrl, data.toJSONString());
|
JSONObject jsonObject = JSONObject.parseObject(result2);
|
log.info("Erp入/出库任务完成上报返回" + jsonObject.toJSONString());
|
boolean sendSuccess = jsonObject.getJSONObject("Result").getJSONObject("ResponseStatus").getBoolean("IsSuccess");
|
|
// TODO:转换后返回
|
if (sendSuccess) {
|
return CommonResponse.ok();
|
} else {
|
JSONArray errors = jsonObject.getJSONObject("Result").getJSONObject("ResponseStatus").getJSONArray("Errors");
|
String errorMsg = "";
|
for (int i = 0; i < errors.size(); i++) {
|
errorMsg += errors.getJSONObject(i).getString("Message") + " ";
|
}
|
return CommonResponse.error(errorMsg);
|
}
|
}
|
} catch (Exception e) {
|
log.error("loginBySign", e);
|
}
|
|
|
// try {
|
// JSONObject jsonObject = postRequest(erpUrl, data, true);
|
// log.info(jsonObject.toJSONString());
|
// boolean sendSuccess = jsonObject.getJSONObject("Result").getJSONObject("ResponseStatus").getBoolean("IsSuccess");
|
//
|
// // TODO:转换后返回
|
// if (sendSuccess) {
|
// return CommonResponse.ok();
|
// } else {
|
// JSONArray errors = jsonObject.getJSONObject("Result").getJSONObject("ResponseStatus").getJSONArray("Errors");
|
// String errorMsg = "";
|
// for (int i = 0; i < errors.size(); i++) {
|
// errorMsg += errors.getJSONObject(i).getString("Message") + " ";
|
// }
|
// return CommonResponse.error(errorMsg);
|
// }
|
// } catch (Exception e) {
|
// log.error("Erp入/出库任务上报响应失败", e);
|
// throw new CoolException("Erp解析响应失败：" + e.getMessage());
|
// }
|
|
return null;
|
}
|
|
|
// 其他入/出库主动上报
|
|
|
// 盘点结果上报
|
|
|
// region 登录
|
/**
|
* 登录，登录参数依次为账套ID、用户名、应用ID、时间戳、签名信息、语言ID
|
*
|
* @throws UnsupportedEncodingException
|
* @throws NoSuchAlgorithmException
|
*/
|
public JSONObject loginBySign() throws UnsupportedEncodingException, NoSuchAlgorithmException {
|
String url = ERP_REPORT_URL + "/Kingdee.BOS.WebApi.ServicesStub.AuthService.LoginBySign.common.kdsvc";
|
JSONObject params = new JSONObject();
|
params.put("parameters", loginParams());
|
String result = httpPostExample(url, params.toJSONString());
|
return JSONObject.parseObject(result);
|
}
|
|
/**
|
* 登录参数整理
|
*
|
* @return
|
* @throws UnsupportedEncodingException
|
* @throws NoSuchAlgorithmException
|
*/
|
private Object[] loginParams() throws UnsupportedEncodingException, NoSuchAlgorithmException {
|
//时间戳
|
long timestamp = System.currentTimeMillis() / 1000;
|
//数据中心ID
|
String dbId = "69368c1051a322";
|
//用户名称
|
String userName = "楼坚伟";
|
//第三方系统应用Id
|
String appId = "330678_w2eBwdkp0oCW2XxuW16D4w/NRhTaTPKp";
|
//第三方系统应用秘钥
|
String appSecret = "31c9e5da6472456193e0c8a7dd2160d9";
|
//将账套ID、用户名、应用ID、应用秘钥、时间戳 放到数组里面
|
String[] arr = new String[] { dbId, userName, appId, appSecret, String.valueOf(timestamp) };
|
//生成签名信息
|
String sign = getSha256(arr);
|
|
return new Object[] { dbId, userName, appId, String.valueOf(timestamp), sign, 2052};
|
}
|
|
public static String getSha256(String[] input) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchAlgorithmException {
|
Arrays.sort(input);
|
//SHA1加密的话改成MessageDigest.getInstance("SHA-1");
|
MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
|
for (String str : input) {
|
sha256.update(str.getBytes("UTF-8"));
|
}
|
byte[] hashBytes = sha256.digest();
|
StringBuilder hashString = new StringBuilder();
|
for (byte b : hashBytes) {
|
String hex = Integer.toHexString(0xff & b);
|
if (hex.length() == 1) {
|
hashString.append('0');
|
}
|
hashString.append(hex);
|
}
|
return hashString.toString();
|
}
|
// endregion
|
|
/**
|
* 通用HTTP POST请求方法
|
*
|
* @param url 请求URL
|
* @param params 请求参数
|
* @return 响应结果
|
*/
|
public JSONObject postRequest(String url, Object params) {
|
if (StringUtils.isBlank(url)) {
|
throw new CoolException("请求URL不能为空！！");
|
}
|
if (Objects.isNull(params)) {
|
throw new CoolException("请求参数不能为空！！");
|
}
|
|
log.info("Erp POST请求： {}， 请求参数： {}", url, JSONObject.toJSONString(params));
|
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json;charset=utf-8");
|
|
HttpEntity<Object> httpEntity = new HttpEntity<>(params, headers);
|
|
// 创建支持忽略SSL证书验证的RestTemplate
|
RestTemplate sslRestTemplate = SslUtils.createIgnoreSSLRestTemplate();
|
|
// 设置错误处理器，不抛出异常，而是返回响应体
|
sslRestTemplate.setErrorHandler(new org.springframework.web.client.DefaultResponseErrorHandler() {
|
@Override
|
public boolean hasError(ClientHttpResponse response) throws IOException {
|
// 不管状态码如何，都不视为错误
|
return false;
|
}
|
});
|
|
ResponseEntity<String> exchange = sslRestTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
|
log.info("Erp POST请求响应结果： {}", exchange);
|
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("请求失败！！");
|
}
|
|
try {
|
ObjectMapper objectMapper = new ObjectMapper();
|
objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
|
return objectMapper.readValue(exchange.getBody(), JSONObject.class);
|
} catch (JsonProcessingException e) {
|
log.error("Erp解析响应失败", e);
|
throw new CoolException("Erp解析响应失败：" + e.getMessage());
|
}
|
}
|
|
|
|
/**
|
* HTTP POST请求示例 - 支持HTTPS
|
*
|
* @param url 请求URL
|
* @param params 请求参数
|
* @return 响应结果
|
*/
|
public String httpPostExample(String url, String params) {
|
if (httpClient == null) {
|
httpClient = createHttpsClient();
|
}
|
HttpPost httpPost = new HttpPost(url);
|
try {
|
StringEntity entity = new StringEntity(params, "UTF-8");
|
httpPost.setEntity(entity);
|
httpPost.setHeader("Content-type", "application/json;charset=utf-8");
|
httpPost.setHeader("Accept", "application/json");
|
return EntityUtils.toString(httpClient.execute(httpPost).getEntity());
|
} catch (Exception e) {
|
log.error("HTTP POST请求失败: {}", e.getMessage(), e);
|
throw new CoolException("HTTP POST请求失败: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 使用RestTemplate的HTTPS POST请求示例
|
*
|
* @param url 请求URL
|
* @param params 请求参数
|
* @return 响应结果
|
*/
|
public String httpsPostWithRestTemplate(String url, String params) {
|
try {
|
log.info("HTTPS POST请求： {}， 请求参数： {}", url, params);
|
|
HttpHeaders headers = new HttpHeaders();
|
headers.add("Content-Type", "application/json;charset=utf-8");
|
headers.add("Accept", "application/json");
|
|
HttpEntity<String> httpEntity = new HttpEntity<>(params, headers);
|
|
// 使用项目中已有的SSL工具类创建忽略SSL证书验证的RestTemplate
|
RestTemplate sslRestTemplate = SslUtils.createIgnoreSSLRestTemplate();
|
|
// 设置错误处理器，不抛出异常，而是返回响应体
|
sslRestTemplate.setErrorHandler(new org.springframework.web.client.DefaultResponseErrorHandler() {
|
@Override
|
public boolean hasError(ClientHttpResponse response) throws IOException {
|
// 不管状态码如何，都不视为错误
|
return false;
|
}
|
});
|
|
ResponseEntity<String> exchange = sslRestTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
|
log.info("HTTPS POST请求响应结果： {}", exchange);
|
|
if (Objects.isNull(exchange.getBody())) {
|
throw new CoolException("请求失败！！");
|
}
|
|
return exchange.getBody();
|
} catch (Exception e) {
|
log.error("HTTPS POST请求失败: {}", e.getMessage(), e);
|
throw new CoolException("HTTPS POST请求失败: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 创建支持HTTPS的HttpClient
|
*
|
* @return CloseableHttpClient实例
|
*/
|
private CloseableHttpClient createHttpsClient() {
|
try {
|
// 创建信任所有证书的TrustManager
|
TrustManager[] trustAllCerts = new TrustManager[] {
|
new X509TrustManager() {
|
public X509Certificate[] getAcceptedIssuers() { return null; }
|
public void checkClientTrusted(X509Certificate[] certs, String authType) { }
|
public void checkServerTrusted(X509Certificate[] certs, String authType) { }
|
}
|
};
|
|
// 初始化SSLContext
|
SSLContext sslContext = SSLContext.getInstance("TLS");
|
sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
|
|
// 创建SSL连接管理器
|
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
|
sslContext,
|
(hostname, session) -> true // 允许所有主机名
|
);
|
|
// 创建HttpClientBuilder并设置SSL配置
|
RequestConfig config = RequestConfig.custom()
|
.setConnectTimeout(30000) // 连接超时时间
|
.setSocketTimeout(60000) // 读取超时时间
|
.build();
|
|
return HttpClients.custom()
|
.setSSLSocketFactory(sslsf)
|
.setDefaultRequestConfig(config)
|
.build();
|
} catch (Exception e) {
|
log.error("创建HTTPS客户端失败: {}", e.getMessage(), e);
|
return HttpClients.createDefault(); // 回退到默认客户端
|
}
|
}
|
|
// /**
|
// * 示例：如何使用HTTPS POST方法
|
// *
|
// * @param url 目标URL
|
// * @param jsonData JSON数据
|
// * @return 响应结果
|
// */
|
// public String exampleUsage(String url, String jsonData) {
|
// log.info("开始调用HTTPS POST请求示例");
|
//
|
// try {
|
// // 方法1: 使用Apache HttpClient
|
// String result1 = httpPostExample(url, jsonData);
|
// log.info("使用HttpClient的POST请求结果: {}", result1);
|
//
|
// // 方法2: 使用RestTemplate
|
// String result2 = httpsPostWithRestTemplate(url, jsonData);
|
// log.info("使用RestTemplate的POST请求结果: {}", result2);
|
//
|
// // 根据实际需要选择返回结果
|
// return result1;
|
// } catch (Exception e) {
|
// log.error("HTTPS POST请求示例执行失败: {}", e.getMessage(), e);
|
// throw e;
|
// }
|
// }
|
|
}
|
