package org.jeecg.modules.iot.service.impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.apache.http.HttpResponse;
|
import org.apache.http.client.HttpClient;
|
import org.apache.http.client.methods.HttpPost;
|
import org.apache.http.entity.StringEntity;
|
import org.apache.http.impl.client.HttpClients;
|
import org.apache.http.util.EntityUtils;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.modules.iot.depository.DbConfig;
|
import org.jeecg.modules.iot.depository.MysqlDataWriter;
|
import org.jeecg.modules.iot.entity.EmptyParameter;
|
import org.jeecg.modules.iot.entity.Equipment;
|
import org.jeecg.modules.iot.entity.RealParameter;
|
import org.jeecg.modules.iot.entity.ScriptCompilation;
|
import org.jeecg.modules.iot.mapper.EmptyParameterMapper;
|
import org.jeecg.modules.iot.mapper.RealParameterMapper;
|
import org.jeecg.modules.iot.service.IEmptyParameterService;
|
import org.jeecg.modules.iot.service.IEquipmentService;
|
import org.jeecg.modules.iot.util.AESUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import javax.sql.DataSource;
|
import java.sql.*;
|
import java.util.*;
|
import java.util.Date;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Description: 虚设备参数
|
* @Author: cuikaidong
|
* @Date: 2025-1-7
|
* @Version: V1.0
|
*/
|
@Service
|
public class EmptyParameterServiceImpl extends ServiceImpl<EmptyParameterMapper, EmptyParameter> implements IEmptyParameterService {
|
|
@Resource
|
private RealParameterMapper realParameterMapper;
|
@Autowired
|
private IEquipmentService equipmentService;
|
@Autowired
|
private DataSource dataSource;
|
|
@Override
|
public List<EmptyParameter> findParameterByEquipmentIds(Set<String> ids) {
|
return new LambdaQueryChainWrapper<>(baseMapper).in(EmptyParameter::getEquipmentId, ids).list();
|
}
|
|
@Override
|
public Result<?> handleCompile(EmptyParameter emptyParameter) {
|
Map<String, String> referenceInfo = new HashMap<>();
|
// 验证脚本实设备
|
List<String> attributes = new ArrayList<>(getAttributes(emptyParameter.getScript(), "IOT_[\\p{L}\\p{N}_]+_[\\p{L}\\p{N}_]+_[\\p{L}\\p{N}_]+"));
|
if (!attributes.isEmpty()) {
|
List<RealParameter> realParameterList = realParameterMapper.findRealParameterList(attributes);
|
// 判断实设备参数数量是否相等
|
if (attributes.size() != realParameterList.size()) {
|
// 求差集
|
Set<String> difference1 = new HashSet<>(attributes);
|
// 使用 Stream API 将 name 字段转换为 Set<String>
|
Set<String> difference2 = realParameterList.stream()
|
.map(RealParameter::getAddress).collect(Collectors.toSet());
|
difference1.removeAll(difference2);
|
return Result.error(difference1 + "属性有误！！！");
|
}
|
realParameterList.forEach(r -> {
|
if (r.getSystemDataType().isEmpty()) {
|
referenceInfo.put(r.getAddress(), r.getParameterType());
|
} else {
|
referenceInfo.put(r.getAddress(), r.getSystemDataType());
|
}
|
});
|
}
|
// 验证虚设备
|
List<String> empAttributes = new ArrayList<>(getAttributes(emptyParameter.getScript(), "IOT_[\\p{L}\\p{N}_]+_[\\p{L}\\p{N}_]+"));
|
if (!empAttributes.isEmpty()) {
|
List<EmptyParameter> emptyParameterList = new ArrayList<>();
|
Set<String> difference = new HashSet<>(empAttributes);
|
if (!attributes.isEmpty()) {
|
// 求差集
|
difference.removeAll(attributes);
|
List<String> www = new ArrayList<>(difference);
|
// 查询数据库中匹配的数量
|
if (!www.isEmpty()) {
|
emptyParameterList = baseMapper.findEmptyParameterList(www);
|
}
|
} else {
|
emptyParameterList = baseMapper.findEmptyParameterList(empAttributes);
|
}
|
// 使用 HashSet 去重
|
Set<EmptyParameter> personSet = new HashSet<>(emptyParameterList);
|
// 判断虚设备参数数量是否相等
|
if (difference.size() != personSet.size()) {
|
// 求差集
|
Set<String> difference1 = new HashSet<>(difference);
|
// 使用 Stream API 将 name 字段转换为 Set<String>
|
Set<String> difference2 = personSet.stream()
|
.map(EmptyParameter::getAddress).collect(Collectors.toSet());
|
difference1.removeAll(difference2);
|
return Result.error(difference1 + "属性有误！！！");
|
}
|
personSet.forEach(p -> {
|
if (p.getSystemDataType().isEmpty()) {
|
referenceInfo.put(p.getAddress(), p.getParameterType());
|
} else {
|
referenceInfo.put(p.getAddress(), p.getSystemDataType());
|
}
|
});
|
}
|
// --------AES_CBC加密---------
|
String cbcResult = AESUtil.encryptCBC(emptyParameter.getScript(), "xhVs6DRXLfUGxw+AhtfQdpQGoa+8SA9d");
|
try {
|
ScriptCompilation scriptCompilation = new ScriptCompilation();
|
Equipment equipment = equipmentService.getById(emptyParameter.getEquipmentId());
|
scriptCompilation.setDeviceId(equipment.getEqptCode());
|
scriptCompilation.setParameterCode(cbcResult);
|
scriptCompilation.setParameterDataType(emptyParameter.getParameterType());
|
scriptCompilation.setParameterName(emptyParameter.getParameterName());
|
scriptCompilation.setReferenceinfo(referenceInfo);
|
String jsonPayload = JSONObject.toJSONString(scriptCompilation);
|
|
// 创建 HttpClient 实例
|
HttpClient httpClient = HttpClients.createDefault();
|
// 创建 HttpPost 请求实例
|
HttpPost httpPost = new HttpPost("http://localhost:3002/ScriptCompiler/ScriptCompiler");
|
// 设置请求头，指定内容类型为 JSON，编码为 UTF-8
|
httpPost.setHeader("Content-Type", "application/json; charset=UTF-8");
|
|
// 创建 StringEntity 并指定编码为 UTF-8
|
StringEntity entity = new StringEntity(jsonPayload, "UTF-8");
|
httpPost.setEntity(entity);
|
|
// 执行请求并获取响应
|
HttpResponse response = httpClient.execute(httpPost);
|
// 获取响应实体内容
|
String responseBody = EntityUtils.toString(response.getEntity(), "UTF-8");
|
boolean isContain = responseBody.contains("编译成功");
|
if (isContain) {
|
return Result.ok(responseBody);
|
} else {
|
// 输出响应内容
|
return Result.error(responseBody);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return Result.error("编译失败");
|
}
|
|
@Override
|
public Result<?> preserveScript(EmptyParameter emptyParameter) {
|
Map<String, String> referenceInfo = new HashMap<>();
|
// 验证脚本实设备
|
List<String> attributes = new ArrayList<>(getAttributes(emptyParameter.getScript(), "IOT_[\\p{L}\\p{N}_]+_[\\p{L}\\p{N}_]+_[\\p{L}\\p{N}_]+"));
|
if (!attributes.isEmpty()) {
|
List<RealParameter> realParameterList = realParameterMapper.findRealParameterList(attributes);
|
realParameterList.forEach(r -> {
|
if (r.getSystemDataType().isEmpty()) {
|
referenceInfo.put(r.getAddress(), r.getParameterType());
|
} else {
|
referenceInfo.put(r.getAddress(), r.getSystemDataType());
|
}
|
});
|
}
|
// 验证虚设备
|
List<String> empAttributes = new ArrayList<>(getAttributes(emptyParameter.getScript(), "IOT_[\\p{L}\\p{N}_]+_[\\p{L}\\p{N}_]+"));
|
if (!empAttributes.isEmpty()) {
|
List<EmptyParameter> emptyParameterList = new ArrayList<>();
|
Set<String> difference = new HashSet<>(empAttributes);
|
if (!attributes.isEmpty()) {
|
// 求差集
|
difference.removeAll(attributes);
|
List<String> www = new ArrayList<>(difference);
|
// 查询数据库中匹配的数量
|
if (!www.isEmpty()) {
|
emptyParameterList = baseMapper.findEmptyParameterList(www);
|
}
|
} else {
|
emptyParameterList = baseMapper.findEmptyParameterList(empAttributes);
|
}
|
// 使用 HashSet 去重
|
Set<EmptyParameter> personSet = new HashSet<>(emptyParameterList);
|
personSet.forEach(p -> {
|
if (p.getSystemDataType().isEmpty()) {
|
referenceInfo.put(p.getAddress(), p.getParameterType());
|
} else {
|
referenceInfo.put(p.getAddress(), p.getSystemDataType());
|
}
|
});
|
}
|
// --------AES_CBC加密---------
|
String cbcResult = AESUtil.encryptCBC(emptyParameter.getScript(), "xhVs6DRXLfUGxw+AhtfQdpQGoa+8SA9d");
|
try {
|
ScriptCompilation scriptCompilation = new ScriptCompilation();
|
Equipment equipment = equipmentService.getById(emptyParameter.getEquipmentId());
|
scriptCompilation.setDeviceId(equipment.getEqptCode());
|
scriptCompilation.setParameterCode(cbcResult);
|
scriptCompilation.setParameterDataType(emptyParameter.getParameterType());
|
scriptCompilation.setParameterName(emptyParameter.getParameterName());
|
scriptCompilation.setReferenceinfo(referenceInfo);
|
String jsonPayload = JSONObject.toJSONString(scriptCompilation);
|
|
// 创建 HttpClient 实例
|
HttpClient httpClient = HttpClients.createDefault();
|
// 创建 HttpPost 请求实例
|
HttpPost httpPost = new HttpPost("http://localhost:3002/ScriptCompiler/ScriptSave");
|
// 设置请求头，指定内容类型为 JSON，编码为 UTF-8
|
httpPost.setHeader("Content-Type", "application/json; charset=UTF-8");
|
|
// 创建 StringEntity 并指定编码为 UTF-8
|
StringEntity entity = new StringEntity(jsonPayload, "UTF-8");
|
httpPost.setEntity(entity);
|
|
// 执行请求并获取响应
|
HttpResponse response = httpClient.execute(httpPost);
|
// 获取响应实体内容
|
String responseBody = EntityUtils.toString(response.getEntity(), "UTF-8");
|
boolean isContain = responseBody.contains("保存成功");
|
// 将 JSON 字符串转换为 JSONObject
|
cn.hutool.json.JSONObject jsonObject = new cn.hutool.json.JSONObject(responseBody);
|
// 访问 JSON 对象的属性
|
String message = jsonObject.getStr("Message");
|
if (isContain) {
|
// 保存脚本标记列表
|
StringBuilder scriptTagList = new StringBuilder();
|
for (String key : referenceInfo.keySet()) {
|
if (scriptTagList.toString().equals("")) {
|
scriptTagList = new StringBuilder(key);
|
} else {
|
scriptTagList.append("|").append(key);
|
}
|
}
|
// 保存属性
|
emptyParameter.setScriptTagList(scriptTagList.toString());
|
// 保存脚本
|
emptyParameter.setScriptContent(emptyParameter.getScript());
|
baseMapper.updateById(emptyParameter);
|
return Result.ok(message);
|
} else {
|
// 输出响应内容
|
return Result.error(message);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return Result.error("编译失败");
|
}
|
|
@Override
|
public Integer findEmptyParameterCode(String equipmentId) {
|
List<EmptyParameter> list = new LambdaQueryChainWrapper<>(baseMapper)
|
.eq(EmptyParameter::getEquipmentId, equipmentId)
|
.orderByDesc(EmptyParameter::getParameterCode)
|
.list();
|
if (list.size() == 0) {
|
return 1;
|
}
|
return list.get(0).getParameterCode() + 1;
|
}
|
|
@Override
|
public Boolean findEmptyParameterByName(EmptyParameter emptyParameter) {
|
List<EmptyParameter> realParameters = new LambdaQueryChainWrapper<>(baseMapper)
|
.eq(EmptyParameter::getEquipmentId, emptyParameter.getEquipmentId())
|
.eq(EmptyParameter::getParameterName, emptyParameter.getParameterName())
|
.list();
|
return realParameters.size() > 0;
|
}
|
|
@Override
|
public void createEmptyEmptyField(Date deployDate, String serverId) {
|
List<EmptyParameter> emptyParameterList = baseMapper.findEmptyParameterListByTime(deployDate, serverId);
|
Map<String, List<EmptyParameter>> emptyParameterListMap = emptyParameterList.stream()
|
.collect(Collectors.groupingBy(EmptyParameter::getEqptCode));
|
emptyParameterListMap.forEach((eqptCode, parameterList) -> {
|
Equipment equipment = equipmentService.findEquipmentByCode(eqptCode);
|
List<String> columnDefinitions = new ArrayList<>();
|
Set<String> columnNames = new HashSet<>();
|
// 遍历当前设备下的所有参数
|
parameterList.forEach(param -> {
|
columnDefinitions.add("NVARCHAR(100) DEFAULT ''");
|
columnNames.add(param.getParameterName());
|
});
|
addSqlserverColumns(equipment.getControlSystem() + '_' + eqptCode, new ArrayList<>(columnDefinitions),
|
new ArrayList<>(columnNames));
|
});
|
}
|
|
/**
|
* // 批量导入字段（SQL Server 版本）
|
*
|
* @param tableName
|
* @param columnDefinitions
|
* @param columnNames
|
*/
|
public void addSqlserverColumns(String tableName, List<String> columnDefinitions, List<String> columnNames) {
|
if (columnDefinitions.size() != columnNames.size()) {
|
throw new IllegalArgumentException("字段定义和字段名的数量必须一致");
|
}
|
|
// 转义表名中的方括号，防止SQL注入
|
tableName = tableName.replace("[", "[[").replace("]", "]]");
|
|
StringBuilder sqlBuilder = new StringBuilder();
|
sqlBuilder.append("ALTER TABLE").append("[")
|
.append(tableName).append("] ADD ");
|
|
boolean hasNewColumns = false;
|
for (int i = 0; i < columnDefinitions.size(); i++) {
|
String columnName = columnNames.get(i);
|
if (sqlServeBatchIsColumnExists(tableName, columnName)) {
|
System.out.println("字段已存在，无需添加: " + columnName);
|
continue;
|
}
|
|
String columnDefinition = columnDefinitions.get(i);
|
if (hasNewColumns) {
|
sqlBuilder.append(", ");
|
}
|
sqlBuilder.append("[").append(columnName.replace("[", "[[").replace("]", "]]")).append("] ")
|
.append(columnDefinition);
|
hasNewColumns = true;
|
}
|
|
String sql = sqlBuilder.toString();
|
if (!hasNewColumns) {
|
System.out.println("没有需要添加的新字段");
|
return;
|
}
|
|
try (Connection conn = dataSource.getConnection();
|
Statement stmt = conn.createStatement()) {
|
System.out.println("执行SQL: " + sql); // 调试用
|
stmt.executeUpdate(sql);
|
System.out.println("字段批量添加成功");
|
} catch (SQLException e) {
|
System.err.println("批量添加字段失败: " + sql);
|
e.printStackTrace();
|
}
|
}
|
|
/**
|
* 验证字段是否存在（SQL Server 版本）
|
*/
|
private boolean sqlServeBatchIsColumnExists(String tableName, String columnName) {
|
// 自动转义表名（处理方括号和特殊字符）
|
String quotedTable = "[" + tableName.replace("]", "]]") + "]";
|
|
String sql = "SELECT COUNT(*) FROM sys.columns " +
|
"WHERE object_id = OBJECT_ID(?) AND name = ?";
|
|
try (Connection conn = dataSource.getConnection();
|
PreparedStatement stmt = conn.prepareStatement(sql)) {
|
// 设置第一个参数：转义后的表名
|
stmt.setString(1, quotedTable);
|
// 设置第二个参数：字段名
|
stmt.setString(2, columnName);
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
if (rs.next()) {
|
return rs.getInt(1) > 0;
|
}
|
}
|
} catch (SQLException e) {
|
// log.error("检查字段 {} 在表 {} 中是否存在时出错", columnName, tableName, e);
|
return false;
|
}
|
return false;
|
}
|
|
|
/**
|
* 根据表达式查询脚本中包含的属性
|
*
|
* @param script 脚本
|
* @param regex 表达式
|
* @return 属性
|
*/
|
Set<String> getAttributes(String script, String regex) {
|
Set<String> scriptList = new HashSet<>();
|
// 编译正则表达式
|
Pattern pattern = Pattern.compile(regex);
|
// 创建 Matcher 对象
|
Matcher matcher = pattern.matcher(script);
|
// 查找所有匹配的子字符串
|
while (matcher.find()) {
|
// 获取当前匹配到的内容
|
scriptList.add(matcher.group());
|
}
|
return scriptList;
|
}
|
}
|
