package com.product.integration.service;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.google.common.collect.Lists;
|
import com.google.common.collect.Maps;
|
import com.google.common.collect.Sets;
|
import com.product.admin.service.PublicService;
|
import com.product.common.lang.ExceptionUtils;
|
import com.product.common.lang.StringUtils;
|
import com.product.core.cache.DataPoolCacheImpl;
|
import com.product.core.config.Global;
|
import com.product.core.dao.BaseDao;
|
import com.product.core.entity.DataTableEntity;
|
import com.product.core.entity.FieldSetEntity;
|
import com.product.core.entity.RequestParameterEntity;
|
import com.product.core.exception.BaseException;
|
import com.product.core.spring.context.SpringMVCContextHolder;
|
import com.product.core.util.ReflectUtil;
|
import com.product.file.service.FileManagerService;
|
import com.product.integration.config.CmnConst;
|
import com.product.integration.config.IntegrationCode;
|
import com.product.integration.service.idel.IInterfaceIntegrationService;
|
import com.product.util.BaseUtil;
|
import com.product.util.SystemParamReplace;
|
import com.product.util.http.HttpRequestUtil;
|
import okhttp3.MultipartBody;
|
import okhttp3.RequestBody;
|
import org.apache.commons.io.FileUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.util.*;
|
|
/**
|
* 实现功能：
|
*
|
* @author 作者[夜丶光]
|
* @version 1.0.00 2025-12-01 11:15
|
*/
|
@Service
|
public class InterfaceIntegrationService implements IInterfaceIntegrationService {
|
@Autowired
|
private BaseDao baseDao;
|
@Autowired
|
private PublicService publicService;
|
@Autowired
|
private FileManagerService fileManagerService;
|
|
/**
|
* 查询数据
|
* @param fse
|
* @return
|
*/
|
public FieldSetEntity find(FieldSetEntity fse) {
|
FieldSetEntity integrationFse = baseDao.getFieldSetEntity(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION, fse.getUUID(), true);
|
DataTableEntity responseInfoDte = integrationFse.getSubDataTable(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO);
|
Map<String, String> acceptKayMap = Maps.newHashMap();
|
acceptKayMap.put("uuid", "front_uuid");
|
JSONArray arr = BaseUtil.dataTableToTreeData(responseInfoDte, CmnConst.TRICODE, 3, acceptKayMap, null, null);
|
integrationFse.removeSubData(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO);
|
integrationFse.setValue(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO, arr.toString());
|
return integrationFse;
|
}
|
|
/**
|
* 保存
|
* @param fse
|
* @return
|
*/
|
@Override
|
public String save(FieldSetEntity fse) {
|
String responseInfo = fse.getString(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO);
|
|
// 清理响应结构子表
|
String uuid = fse.getUUID();
|
if (!StringUtils.isEmpty(uuid)) {
|
baseDao.delete(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO, String.format("%s=?", CmnConst.PARENT_UUID), new Object[]{uuid});
|
}
|
|
DataTableEntity responseInfoDte = dealResponseInfo(responseInfo);
|
fse.addSubDataTable(responseInfoDte);
|
uuid = publicService.saveFieldSetEntity(fse);
|
|
// 验证定时任务是否创建，若是未创建，那么创建定时任务
|
generateTimedTask(fse);
|
|
return uuid;
|
}
|
/**
|
* 处理响应数据结构
|
* @param responseInfo 响应树结构子表信息
|
* @return
|
*/
|
private DataTableEntity dealResponseInfo(String responseInfo) {
|
DataTableEntity responseInfoDte = new DataTableEntity();
|
try {
|
if (!StringUtils.isEmpty(responseInfo)) {
|
saveDealResponseInfoPart(responseInfoDte, JSONArray.parseArray(responseInfo), "");
|
}
|
} catch (Exception e) {
|
SpringMVCContextHolder.getSystemLogger().error(IntegrationCode.INTERFACE_INTEGRATION_SAVE_DEAL_RESPONSE_INFO_FAIL);
|
}
|
return responseInfoDte;
|
}
|
/**
|
* 保存-处理响应数据结构-循环方法
|
* @param responseInfoDte 存储容器，响应子表数据dte
|
* @param responseInfoArr 响应子表数据待处理数组
|
* @param parentCode 父编码
|
*/
|
private void saveDealResponseInfoPart(DataTableEntity responseInfoDte, JSONArray responseInfoArr, String parentCode) {
|
for (int i = 0; i < responseInfoArr.size(); i++) {
|
JSONObject responseInfoObj = responseInfoArr.getJSONObject(i);
|
FieldSetEntity fse = new FieldSetEntity(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO);
|
List<String> passList = Arrays.asList("promptName", "children", "front_uuid");
|
List<String> fieldList = Arrays.asList("name", "type", "db_info", "unique_sign");
|
String code = String.format("%s%0" + 3 + "d", parentCode, i + 1);
|
responseInfoObj.forEach((key, value) -> {
|
if (!passList.contains(key)) {
|
fse.setValue(key, value);
|
}
|
});
|
fieldList.forEach(fieldName -> {
|
if (StringUtils.isEmpty(fse.getString(fieldName))) {
|
fse.setValue(fieldName, "");
|
}
|
});
|
fse.setValue(CmnConst.TRICODE, code);
|
responseInfoDte.addFieldSetEntity(fse);
|
saveDealResponseInfoPart(responseInfoDte, responseInfoObj.getJSONArray(CmnConst.CHILDREN), code);
|
}
|
}
|
|
/**
|
* 验证定时任务是否创建，若是未创建，那么创建定时任务
|
* @param fse
|
*/
|
public void generateTimedTask(FieldSetEntity fse) {
|
String invokeTarget = String.format("interfaceIntegrationService.timedTaskTrigger('%s')", fse.getUUID());
|
FieldSetEntity timedTaskFse = baseDao.getFieldSetEntityByFilter(CmnConst.PRODUCT_SYS_TIMED_TASK, String.format("%s=?", CmnConst.INVOKE_TARGET), new Object[]{invokeTarget}, false);
|
if (FieldSetEntity.isEmpty(timedTaskFse)) {
|
timedTaskFse = new FieldSetEntity(CmnConst.PRODUCT_SYS_TIMED_TASK);
|
timedTaskFse.setValue(CmnConst.JOB_GROUP, "system");
|
timedTaskFse.setValue(CmnConst.MISFIRE_POLICY, "3");
|
timedTaskFse.setValue(CmnConst.CONCURRENT, 0);
|
timedTaskFse.setValue(CmnConst.INVOKE_TARGET, invokeTarget);
|
BaseUtil.createCreatorAndCreationTime(timedTaskFse);
|
} else {
|
BaseUtil.updatedRegeneratorAndUpdateTime(SpringMVCContextHolder.getCurrentUser(), timedTaskFse);
|
}
|
timedTaskFse.setValue(CmnConst.JOB_NAME, String.format("接口集成-%s", fse.getString(CmnConst.NAME)));
|
timedTaskFse.setValue(CmnConst.CRON_EXPRESSION, fse.getString(CmnConst.FREQUENCY));
|
timedTaskFse.setValue(CmnConst.IS_CONCEAL, 0);
|
timedTaskFse.setValue(CmnConst.STATUS, 1);
|
baseDao.saveFieldSetEntity(timedTaskFse);
|
|
}
|
|
/**
|
* 定时任务触发方法
|
* @param uuid 接口集成uuid
|
*/
|
public void timedTaskTrigger(String uuid) {
|
String code = "";
|
String message = "";
|
StringBuilder content = new StringBuilder(128);
|
String errorInfo = null;
|
try {
|
// 数据准备
|
FieldSetEntity paramFse = baseDao.getFieldSetEntity(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION, uuid, true);
|
DataTableEntity requestParamDte = paramFse.getSubDataTable(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_REQUEST_PARAM);
|
DataTableEntity requestHederDte = paramFse.getSubDataTable(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_REQUEST_HEADER);
|
String requestType = paramFse.getString(CmnConst.REQUEST_TYPE);
|
String url = paramFse.getString(CmnConst.ADDRESS);
|
MultipartBody.Builder builder = new MultipartBody.Builder().setType(okhttp3.MultipartBody.FORM);
|
// 请求头信息
|
Map<String, String> headerMap = Maps.newHashMap();
|
if (!DataTableEntity.isEmpty(requestHederDte)) {
|
for (int i = 0; i < requestHederDte.getRows(); i++) {
|
FieldSetEntity fse = requestHederDte.getFieldSetEntity(i);
|
headerMap.put(fse.getString(CmnConst.NAME), dealValue(fse.getString(CmnConst.VALUE)));
|
}
|
}
|
// 添加请求参数信息
|
Map<String, String> paramMap = Maps.newHashMap();
|
if (!DataTableEntity.isEmpty(requestParamDte)) {
|
for (int i = 0; i < requestParamDte.getRows(); i++) {
|
FieldSetEntity fse = requestParamDte.getFieldSetEntity(i);
|
paramMap.put(fse.getString(CmnConst.NAME), dealValue(fse.getString(CmnConst.VALUE)));
|
}
|
}
|
|
// 请求参数方法自定义处理
|
String customRequestParamInfo = paramFse.getString(CmnConst.REQUEST_PARAM_CUSTOM_METHOD);
|
if (!StringUtils.isEmpty(customRequestParamInfo)) {
|
String[] customMethodInfoArr = customRequestParamInfo.split("\\.");
|
String beanName = customMethodInfoArr[0];
|
String methodName = customMethodInfoArr[1];
|
ReflectUtil.invoke(beanName, methodName, new Object[]{headerMap, paramMap});
|
content.append(String.format("%s 执行自定义方法[%s]补充处理请求参数\n", BaseUtil.getCurTimeWithMill(), customRequestParamInfo));
|
}
|
|
// 发起请求
|
Object requestResult;
|
try {
|
if ("post".equals(requestType)) {
|
paramMap.forEach(builder::addFormDataPart);
|
RequestBody requestBody = builder.build();
|
requestResult = HttpRequestUtil.request(url, "POST", "multipart/form-data", requestBody, JSONObject.class, headerMap);
|
} else {
|
StringBuilder urlParamPart = new StringBuilder(128);
|
paramMap.forEach((name, value) -> {
|
if (urlParamPart.length() > 0) {
|
urlParamPart.append("&");
|
} else {
|
urlParamPart.append("?");
|
}
|
urlParamPart.append(name).append("=").append(value);
|
});
|
requestResult = HttpRequestUtil.request(url + urlParamPart, "GET", "application/json", null, JSONObject.class, headerMap);
|
}
|
System.out.println(requestResult);
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new BaseException(IntegrationCode.INTERFACE_INTEGRATION_REQUEST_DATA_FAIL);
|
}
|
|
// 数据处理
|
String customResponseInfo = paramFse.getString(CmnConst.RESPONSE_CUSTOM_METHOD);
|
if (!StringUtils.isEmpty(customResponseInfo)) {
|
// 自定义方法处理
|
String[] customMethodInfoArr = customResponseInfo.split("\\.");
|
String beanName = customMethodInfoArr[0];
|
String methodName = customMethodInfoArr[1];
|
ReflectUtil.invoke(beanName, methodName, new Object[]{paramFse, requestResult});
|
content.append(String.format("%s 执行自定义数据处理方法[%s]\n", BaseUtil.getCurTimeWithMill(), customResponseInfo));
|
} else {
|
// 默认方法处理
|
FieldSetEntity clientFse = baseDao.getFieldSetEntityByFilter("product_sys_clients", "1=1", new Object[]{}, false);
|
String clientUUID = clientFse.getUUID();
|
|
String coverSign = paramFse.getString(CmnConst.IS_COVER);
|
DataTableEntity responseInfoDte = paramFse.getSubDataTable(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_RESPONSE_INFO);
|
if (DataTableEntity.isEmpty(responseInfoDte)) {
|
content.append(String.format("%s 响应结构配置信息为空\n", BaseUtil.getCurTimeWithMill()));
|
return;
|
}
|
Map<String, String> keyMap = Maps.newHashMap();
|
for (Object key : responseInfoDte.getFieldSetEntity(0).getFields()) {
|
keyMap.put(key.toString(), String.format("[%s]", key));
|
}
|
JSONObject structureObj = BaseUtil.dataTableToTreeDataObj(responseInfoDte, CmnConst.NAME, CmnConst.TRICODE, 3, keyMap, null, null);
|
if (structureObj.isEmpty()) {
|
return;
|
}
|
JSONObject resultObj = (JSONObject) requestResult;
|
JSONObject dealtDataObj = dealResult(resultObj, structureObj);
|
for (Map.Entry<String, Object> entry : dealtDataObj.entrySet()) {
|
String key = entry.getKey();
|
Object value = entry.getValue();
|
if (CmnConst.CODE.equals(key)) {
|
code = value != null ? value.toString() : null;
|
} else if (CmnConst.MESSAGE.equals(key)) {
|
message = value != null ? value.toString() : null;
|
} else {
|
// 表处理
|
JSONObject tableObj = (JSONObject) value;
|
Set<String> uniqueFieldSet = (Set<String>) tableObj.get(CmnConst.UNIQUE_SIGN);
|
DataTableEntity waitDealDte = (DataTableEntity) tableObj.get(CmnConst.TABLE);
|
// 优先处理文件内容，需要根据表结构信息进行处理
|
dealFile(waitDealDte, clientUUID);
|
String tableName = waitDealDte.getTableName().toString();
|
if (uniqueFieldSet == null || uniqueFieldSet.isEmpty()) {
|
if ("1".equals(coverSign)) {
|
// 覆盖
|
baseDao.executeUpdate(String.format("TRUNCATE TABLE %s", tableName));
|
content.append(String.format("%s 开始-处理[%s]表-无标识且覆盖\n", BaseUtil.getCurTimeWithMill(), tableName));
|
content.append(String.format("%s 清理[%s]表\n", BaseUtil.getCurTimeWithMill(), tableName));
|
} else {
|
content.append(String.format("%s 开始-处理[%s]表-无标识不覆盖\n", BaseUtil.getCurTimeWithMill(), tableName));
|
}
|
BaseUtil.generateTime(waitDealDte);
|
baseDao.add(waitDealDte);
|
} else {
|
StringBuilder filter = new StringBuilder(128);
|
List<String> paramList = Lists.newArrayList();
|
for (int i = 0; i < waitDealDte.getRows(); i++) {
|
FieldSetEntity waitDealFse = waitDealDte.getFieldSetEntity(i);
|
if (filter.length() > 0) {
|
filter.append("\nOR ");
|
}
|
StringBuilder singleFilter = new StringBuilder(128);
|
for (String uniqueField : uniqueFieldSet) {
|
if (singleFilter.length() > 0) {
|
singleFilter.append(" AND ");
|
}
|
singleFilter.append(uniqueField).append("=?");
|
paramList.add(waitDealFse.getString(uniqueField));
|
}
|
filter.append("(").append(singleFilter).append(")");
|
}
|
if ("1".equals(coverSign)) {
|
// 覆盖
|
content.append(String.format("%s 开始-处理[%s]表-无标识且覆盖\n", BaseUtil.getCurTimeWithMill(), tableName));
|
baseDao.executeUpdate(String.format("DELETE FROM %s WHERE %s", tableName, filter), paramList.toArray());
|
content.append(String.format("%s 根据唯一标识字段[%s]进行清理\n", BaseUtil.getCurTimeWithMill(), BaseUtil.collection2String(uniqueFieldSet)));
|
baseDao.add(waitDealDte);
|
} else {
|
// 不覆盖
|
content.append(String.format("%s 开始-处理[%s]表-无标识不覆盖\n", BaseUtil.getCurTimeWithMill(), tableName));
|
DataTableEntity waitUpdateDte = baseDao.listTable(tableName, filter.toString(), paramList.toArray());
|
int waitAddCount = 0;
|
Map<JSONObject, FieldSetEntity> waitUpdateMap = Maps.newHashMap();
|
for (int i = 0; i < waitUpdateDte.getRows(); i++) {
|
FieldSetEntity waitUpdateFse = waitUpdateDte.getFieldSetEntity(i);
|
JSONObject keyObj = extractFseAimField2Obj(waitUpdateFse, uniqueFieldSet);
|
waitUpdateMap.put(keyObj, waitUpdateFse);
|
}
|
for (int i = 0; i < waitDealDte.getRows(); i++) {
|
FieldSetEntity waitDealFse = waitDealDte.getFieldSetEntity(i);
|
JSONObject keyObj = extractFseAimField2Obj(waitDealFse, uniqueFieldSet);
|
FieldSetEntity waitUpdateFse = waitUpdateMap.get(keyObj);
|
if (waitUpdateFse != null) {
|
waitUpdateFse.getValues().forEach((fieldNameObj, fieldValue) -> {
|
String fieldName = fieldNameObj.toString();
|
if (StringUtils.isEmpty(waitDealFse.getString(fieldName))) {
|
waitDealFse.setValue(fieldName, fieldValue);
|
}
|
});
|
waitDealFse.setValue(CmnConst.UPDATED_UTC_DATETIME, new Date());
|
} else {
|
waitAddCount++;
|
}
|
}
|
baseDao.update(waitDealDte);
|
content.append(String.format("%s 根据[%s]表唯一标识字段[%s]进行更新\n", BaseUtil.getCurTimeWithMill(), tableName, BaseUtil.collection2String(uniqueFieldSet)));
|
content.append(String.format("%s 更新[%s]条数据\n", BaseUtil.getCurTimeWithMill(), waitUpdateDte.getRows()));
|
content.append(String.format("%s 新增[%s]条数据\n", BaseUtil.getCurTimeWithMill(), waitAddCount));
|
}
|
}
|
content.append(String.format("%s 完成-执行默认方法处理数据-操作[%s]数据，共[%s]条\n", BaseUtil.getCurTimeWithMill(), tableName, waitDealDte.getRows()));
|
}
|
}
|
code = dealtDataObj.getString(CmnConst.CODE);
|
message = dealtDataObj.getString(CmnConst.MESSAGE);
|
}
|
|
// 完成后方法调用
|
String customAfterSaveInfo = paramFse.getString(CmnConst.AFTER_SAVE_CUSTOM_METHOD);
|
if (!StringUtils.isEmpty(customAfterSaveInfo)) {
|
String[] customMethodInfoArr = customAfterSaveInfo.split("\\.");
|
String beanName = customMethodInfoArr[0];
|
String methodName = customMethodInfoArr[1];
|
ReflectUtil.invoke(beanName, methodName, new Object[]{requestResult});
|
content.append(String.format("%s 执行自定义保存后方法[%s]\n", BaseUtil.getCurTimeWithMill(), customAfterSaveInfo));
|
}
|
} catch (BaseException e) {
|
errorInfo = ExceptionUtils.getStackTraceAsString(e);
|
|
e.printStackTrace();
|
throw new BaseException(e);
|
} catch (Exception e) {
|
errorInfo = ExceptionUtils.getStackTraceAsString(e);
|
|
e.printStackTrace();
|
throw new BaseException(IntegrationCode.INTERFACE_INTEGRATION_REQUEST_DEAL_DATA_FAIL);
|
} finally {
|
// 日志记录
|
recordLog(uuid, code, message, content.toString(), errorInfo);
|
}
|
}
|
|
/**
|
* 优先处理文件内容，需要根据表结构信息进行处理
|
* @param waitDealDte
|
* @param clientUUID
|
* @throws IOException
|
*/
|
private void dealFile(DataTableEntity waitDealDte, String clientUUID) throws IOException {
|
String tableName = waitDealDte.getTableName().toString();
|
DataTableEntity tableDte = DataPoolCacheImpl.getInstance().getCacheData("所有表信息", new String[]{tableName});
|
if (DataTableEntity.isEmpty(tableDte)) {
|
throw new BaseException(IntegrationCode.GET_SYSTEM_CACHE_TABLE_STRUCTURE_FAIL.getValue(), IntegrationCode.GET_SYSTEM_CACHE_TABLE_STRUCTURE_FAIL.getText() + ":" + tableName);
|
}
|
FieldSetEntity tableFse = tableDte.getFieldSetEntity(0);
|
DataTableEntity fieldDte = DataPoolCacheImpl.getInstance().getCacheData("所有字段信息并按表分组", new String[]{tableFse.getUUID()});
|
if (DataTableEntity.isEmpty(fieldDte)) {
|
throw new BaseException(IntegrationCode.GET_SYSTEM_CACHE_FIELD_INFO_FAIL.getValue(), IntegrationCode.GET_SYSTEM_CACHE_FIELD_INFO_FAIL.getText() + ":" + tableName);
|
}
|
Map<String, FieldSetEntity> fieldMap = BaseUtil.dte2Map(fieldDte, CmnConst.FIELD_NAME);
|
List<String> fileTypeList = Arrays.asList("file", "file-image", "blob-attachment");
|
for (int i = 0; i < waitDealDte.getRows(); i++) {
|
FieldSetEntity waitDealFse = waitDealDte.getFieldSetEntity(i);
|
for (Map.Entry<Object, Object> entry : waitDealFse.getValues().entrySet()) {
|
String fieldName = entry.getKey().toString();
|
String value = entry.getValue().toString();
|
FieldSetEntity fieldFse = fieldMap.get(fieldName);
|
if (fieldFse != null && fileTypeList.contains(fieldFse.getString(CmnConst.FIELD_TYPE))) {
|
// 文件处理
|
String fileName = waitDealFse.getString(String.format("~%s~", fieldName));
|
String attachmentUUID = saveFile(tableName, fieldName, fileName, value, clientUUID);
|
waitDealFse.setValue(fieldName, attachmentUUID);
|
}
|
}
|
}
|
}
|
|
/**
|
* 保存文件返回uuid
|
* @param tableName 表名
|
* @param fieldName 字段名
|
* @param fileName 文件名
|
* @param base64Content 文件流字符串
|
* @param clientUUID 客户uuid，通常是默认顶级
|
* @return
|
* @throws IOException
|
*/
|
private String saveFile(String tableName, String fieldName, String fileName, String base64Content, String clientUUID) throws IOException {
|
String outPath = Global.getSystemConfig("upload.file.path", "") + File.separator + BaseUtil.getCurDateTime("yyyy/MM/dd") + File.separator + UUID.randomUUID() + "_" + fileName;
|
byte[] fileBytes = Base64.getDecoder().decode(base64Content);
|
FileUtils.writeByteArrayToFile(new File(outPath), fileBytes);
|
|
RequestParameterEntity requestParameterEntity = new RequestParameterEntity();
|
Map<String, File> fileMap = new HashMap<>();
|
fileMap.put(fileName, new File(outPath));
|
requestParameterEntity.setFiles(fileMap);
|
FieldSetEntity fseAttachment = new FieldSetEntity();
|
fseAttachment.setTableName(tableName);
|
fseAttachment.setValue("~field_name~", fieldName);
|
fseAttachment.setValue(UUID.randomUUID().toString(), fileName);
|
fseAttachment.setValue("client_uuid", clientUUID);
|
requestParameterEntity.setFormData(fseAttachment);
|
FieldSetEntity resultFse = fileManagerService.uploadFile(requestParameterEntity);
|
|
return resultFse.getString(fieldName);
|
}
|
|
/**
|
* 提取fse中指定字段信息转化为JSONObject
|
* @param fse 待处理数据
|
* @param acceptCollection 接收字段的集合
|
* @return
|
*/
|
private JSONObject extractFseAimField2Obj(FieldSetEntity fse, Collection<String> acceptCollection) {
|
JSONObject resultObj = new JSONObject();
|
acceptCollection.forEach(fieldName -> resultObj.put(fieldName, fse.getString(fieldName)));
|
return resultObj;
|
}
|
|
/**
|
* 处理值，若是含有系统参数，那么替换，若是不含，则直接返回
|
* @param value
|
* @return
|
*/
|
private String dealValue(String value) {
|
if (value.contains("{")) {
|
return SystemParamReplace.systemParamsReplace(value);
|
} else {
|
return value;
|
}
|
}
|
|
/**
|
* 处理结果信息-默认方法
|
* @param resultObj 结果内容obj
|
* @param structureObj 结构信息arr
|
* @return
|
*/
|
private JSONObject dealResult(JSONObject resultObj, JSONObject structureObj) {
|
JSONObject infoObj = new JSONObject();
|
dealResultPart(infoObj, resultObj, structureObj, "");
|
return infoObj;
|
}
|
private void dealResultPart(JSONObject infoObj, JSONObject resultObj, JSONObject structureObj, String curTableName) {
|
if (structureObj == null || resultObj.isEmpty()) {
|
return;
|
}
|
FieldSetEntity fse = null;
|
if (!StringUtils.isEmpty(curTableName)) {
|
fse = new FieldSetEntity(curTableName);
|
DataTableEntity dte = (DataTableEntity) infoObj.getJSONObject(curTableName).get(CmnConst.TABLE);
|
dte.addFieldSetEntity(fse);
|
}
|
for (Map.Entry<String, Object> entry : resultObj.entrySet()) {
|
String resultKey = entry.getKey();
|
Object resultValue = entry.getValue();
|
JSONObject singleStructureObj = structureObj.getJSONObject(resultKey);
|
if (singleStructureObj == null || singleStructureObj.isEmpty()) {
|
if (fse != null) {
|
fse.setValue(resultKey, resultValue);
|
}
|
} else {
|
String dealtCodeField = String.format("[%s]", CmnConst.CODE);
|
String dealtMessageField = String.format("[%s]", CmnConst.MESSAGE);
|
String dealtTypeField = String.format("[%s]", CmnConst.TYPE);
|
String dealtDBInfoField = String.format("[%s]", CmnConst.DB_INFO);
|
if ("1".equals(singleStructureObj.getString(dealtTypeField)) && StringUtils.isEmpty(infoObj.getString(dealtCodeField))) {
|
// 状态码
|
infoObj.put(CmnConst.CODE, resultValue);
|
} else if ("2".equals(singleStructureObj.getString(dealtTypeField)) && StringUtils.isEmpty(infoObj.getString(dealtMessageField))) {
|
// 消息内容
|
infoObj.put(CmnConst.MESSAGE, resultValue);
|
} else if ("3".equals(singleStructureObj.getString(dealtTypeField))) {
|
// 表
|
JSONObject tableInfoObj = new JSONObject();
|
curTableName = singleStructureObj.getString(dealtDBInfoField);
|
infoObj.put(curTableName, tableInfoObj);
|
DataTableEntity dte = new DataTableEntity();
|
tableInfoObj.put(CmnConst.TABLE, dte);
|
Set<String> uniqueSignSet = Sets.newHashSet();
|
tableInfoObj.put(CmnConst.UNIQUE_SIGN, uniqueSignSet);
|
} else if ("4".equals(singleStructureObj.getString(dealtTypeField))) {
|
// 字段
|
if (fse != null) {
|
fse.setValue(singleStructureObj.getString(dealtDBInfoField), resultValue);
|
}
|
String dealtUniqueSignField = String.format("[%s]", CmnConst.UNIQUE_SIGN);
|
if ("1".equals(singleStructureObj.getString(dealtUniqueSignField))) {
|
Set<String> uniqueSignSet = (Set<String>) infoObj.getJSONObject(curTableName).get(CmnConst.UNIQUE_SIGN);
|
uniqueSignSet.add(singleStructureObj.getString(dealtDBInfoField));
|
}
|
}
|
}
|
if (resultValue instanceof JSONArray) {
|
JSONArray arr = (JSONArray) resultValue;
|
for (int i = 0; i < arr.size(); i++) {
|
dealResultPart(infoObj, arr.getJSONObject(i), singleStructureObj, curTableName);
|
}
|
} else if (resultValue instanceof JSONObject) {
|
if (singleStructureObj != null) {
|
dealResultPart(infoObj, (JSONObject) resultValue, singleStructureObj, curTableName);
|
}
|
}
|
}
|
JSONObject tableInfoObj = resultObj.getJSONObject(curTableName);
|
if (tableInfoObj != null) {
|
((DataTableEntity) tableInfoObj.get(curTableName)).addFieldSetEntity(fse);
|
}
|
}
|
|
/**
|
* 日志记录
|
* @param configUUID 配置uuid
|
* @param code 状态码
|
* @param message 返回消息内容
|
* @param content 执行明细内容
|
*/
|
private void recordLog(String configUUID, String code, String message, String content) {
|
recordLog(configUUID, code, message, content, null);
|
}
|
|
/**
|
* 日志记录
|
* @param configUUID 配置uuid
|
* @param code 状态码
|
* @param message 返回消息内容
|
* @param content 执行明细内容
|
* @param errorInfo 错误信息
|
*/
|
private void recordLog(String configUUID, String code, String message, String content, String errorInfo) {
|
FieldSetEntity logFse = new FieldSetEntity(CmnConst.PRODUCT_SYS_INTERFACE_INTEGRATION_LOG);
|
logFse.setValue(CmnConst.CREATED_UTC_DATETIME, new Date());
|
logFse.setValue(CmnConst.CONFIG_UUID, configUUID);
|
logFse.setValue(CmnConst.CODE, code);
|
logFse.setValue(CmnConst.MESSAGE, message);
|
if (!StringUtils.isEmpty(errorInfo)) {
|
content = BaseUtil.getCurTimeWithMill() + " 执行失败\n" + content;
|
} else {
|
content = BaseUtil.getCurTimeWithMill() + " 执行成功\n" + content;
|
}
|
logFse.setValue(CmnConst.CONTENT, content);
|
logFse.setValue(CmnConst.ERROR_INFO, errorInfo);
|
baseDao.saveFieldSetEntity(logFse);
|
}
|
}
|
