package cn.iocoder.yudao.module.iot.service.thingmodel;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.convert.Convert;
|
import cn.hutool.core.date.DatePattern;
|
import cn.hutool.core.date.LocalDateTimeUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.hutool.extra.spring.SpringUtil;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils;
|
import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
|
import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
|
import cn.iocoder.yudao.framework.tenant.core.aop.TenantIgnore;
|
import cn.iocoder.yudao.module.iot.controller.admin.thingmodel.vo.IotThingModelListReqVO;
|
import cn.iocoder.yudao.module.iot.controller.admin.thingmodel.vo.IotThingModelPageReqVO;
|
import cn.iocoder.yudao.module.iot.controller.admin.thingmodel.vo.IotThingModelSaveReqVO;
|
import cn.iocoder.yudao.module.iot.convert.thingmodel.IotThingModelConvert;
|
import cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO;
|
import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.IotThingModelDO;
|
import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.model.dataType.ThingModelBoolOrEnumDataSpecs;
|
import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.model.dataType.ThingModelDataSpecs;
|
import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.model.dataType.ThingModelDateOrTextDataSpecs;
|
import cn.iocoder.yudao.module.iot.dal.mysql.thingmodel.IotThingModelMapper;
|
import cn.iocoder.yudao.module.iot.dal.redis.RedisKeyConstants;
|
import cn.iocoder.yudao.module.iot.enums.product.IotProductStatusEnum;
|
import cn.iocoder.yudao.module.iot.enums.thingmodel.IotDataSpecsDataTypeEnum;
|
import cn.iocoder.yudao.module.iot.framework.tdengine.core.TDengineTableField;
|
import cn.iocoder.yudao.module.iot.service.device.IotDeviceModbusPointService;
|
import cn.iocoder.yudao.module.iot.service.product.IotProductService;
|
import jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.cache.annotation.CacheEvict;
|
import org.springframework.cache.annotation.Cacheable;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.math.BigDecimal;
|
import java.nio.charset.StandardCharsets;
|
import java.time.Instant;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.OffsetDateTime;
|
import java.time.ZonedDateTime;
|
import java.util.Collection;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Set;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
|
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.*;
|
|
/**
|
* IoT 产品物模型 Service 实现类
|
*
|
* @author 芋道源码
|
*/
|
@Service
|
@Validated
|
@Slf4j
|
public class IotThingModelServiceImpl implements IotThingModelService {
|
|
@Resource
|
private IotThingModelMapper thingModelMapper;
|
|
@Resource
|
@Lazy // 延迟加载，解决循环依赖
|
private IotProductService productService;
|
@Resource
|
@Lazy // 延迟加载，解决循环依赖
|
private IotDeviceModbusPointService deviceModbusPointService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createThingModel(IotThingModelSaveReqVO createReqVO) {
|
// 1.1 校验功能标识符在同一产品下是否唯一
|
validateIdentifierUnique(null, createReqVO.getProductId(), createReqVO.getIdentifier());
|
// 1.2 功能名称在同一产品下是否唯一
|
validateNameUnique(createReqVO.getProductId(), createReqVO.getName());
|
// 1.3 校验产品状态，发布状态下，不允许新增功能
|
validateProductStatus(createReqVO.getProductId());
|
|
// 2. 插入数据库
|
IotThingModelDO thingModel = IotThingModelConvert.INSTANCE.convert(createReqVO);
|
thingModelMapper.insert(thingModel);
|
|
// 3. 删除缓存
|
deleteThingModelListCache(createReqVO.getProductId());
|
return thingModel.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateThingModel(IotThingModelSaveReqVO updateReqVO) {
|
// 1.1 校验功能是否存在
|
validateProductThingModelMapperExists(updateReqVO.getId());
|
// 1.2 校验功能标识符是否唯一
|
validateIdentifierUnique(updateReqVO.getId(), updateReqVO.getProductId(), updateReqVO.getIdentifier());
|
// 1.3 校验产品状态，发布状态下，不允许操作功能
|
validateProductStatus(updateReqVO.getProductId());
|
|
// 2. 更新数据库
|
IotThingModelDO thingModel = IotThingModelConvert.INSTANCE.convert(updateReqVO);
|
thingModelMapper.updateById(thingModel);
|
|
// 3. 同步更新 Modbus 点位的冗余字段（identifier、name）
|
deviceModbusPointService.updateDeviceModbusPointByThingModel(
|
updateReqVO.getId(), updateReqVO.getIdentifier(), updateReqVO.getName());
|
|
// 4. 删除缓存
|
deleteThingModelListCache(updateReqVO.getProductId());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteThingModel(Long id) {
|
// 1.1 校验功能是否存在
|
IotThingModelDO thingModel = thingModelMapper.selectById(id);
|
if (thingModel == null) {
|
throw exception(THING_MODEL_NOT_EXISTS);
|
}
|
// 1.2 校验产品状态，发布状态下，不允许操作功能
|
validateProductStatus(thingModel.getProductId());
|
|
// 2. 删除功能
|
thingModelMapper.deleteById(id);
|
|
// 3. 删除缓存
|
deleteThingModelListCache(thingModel.getProductId());
|
}
|
|
@Override
|
public IotThingModelDO getThingModel(Long id) {
|
return thingModelMapper.selectById(id);
|
}
|
|
@Override
|
public List<IotThingModelDO> getThingModelListByProductId(Long productId) {
|
return thingModelMapper.selectListByProductId(productId);
|
}
|
|
@Override
|
public List<IotThingModelDO> getThingModelListByProductIdAndIdentifiers(Long productId, Collection<String> identifiers) {
|
return thingModelMapper.selectListByProductIdAndIdentifiers(productId, identifiers);
|
}
|
|
@Override
|
public List<IotThingModelDO> getThingModelListByProductIdAndType(Long productId, Integer type) {
|
return thingModelMapper.selectListByProductIdAndType(productId, type);
|
}
|
|
@Override
|
@Cacheable(value = RedisKeyConstants.THING_MODEL_LIST, key = "#productId")
|
@TenantIgnore // 忽略租户信息
|
public List<IotThingModelDO> getThingModelListByProductIdFromCache(Long productId) {
|
return thingModelMapper.selectListByProductId(productId);
|
}
|
|
@Override
|
public PageResult<IotThingModelDO> getProductThingModelPage(IotThingModelPageReqVO pageReqVO) {
|
return thingModelMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public List<IotThingModelDO> getThingModelList(IotThingModelListReqVO reqVO) {
|
return thingModelMapper.selectList(reqVO);
|
}
|
|
@Override
|
public void validateThingModelListExists(Long productId, Set<String> identifiers) {
|
if (CollUtil.isEmpty(identifiers)) {
|
return;
|
}
|
List<IotThingModelDO> thingModels = thingModelMapper.selectListByProductIdAndIdentifiers(
|
productId, identifiers);
|
Set<String> foundIdentifiers = convertSet(thingModels, IotThingModelDO::getIdentifier);
|
for (String identifier : identifiers) {
|
if (!foundIdentifiers.contains(identifier)) {
|
throw exception(THING_MODEL_NOT_EXISTS);
|
}
|
}
|
}
|
|
@Override
|
public Object convertThingModelPropertyValue(IotThingModelDO thingModel, Object value) {
|
if (thingModel == null || thingModel.getProperty() == null || value == null) {
|
return null;
|
}
|
String dataType = thingModel.getProperty().getDataType();
|
if (ObjectUtils.equalsAny(dataType,
|
IotDataSpecsDataTypeEnum.STRUCT.getDataType(), IotDataSpecsDataTypeEnum.ARRAY.getDataType())) {
|
// 特殊：STRUCT 和 ARRAY 类型，在 TDengine 里，没有对应数据类型，只能通过 JSON 来存储
|
return convertToVarchar(JsonUtils.toJsonString(value), TDengineTableField.LENGTH_VARCHAR);
|
}
|
if (IotDataSpecsDataTypeEnum.INT.getDataType().equals(dataType)) {
|
return convertToInt(value);
|
}
|
if (IotDataSpecsDataTypeEnum.FLOAT.getDataType().equals(dataType)) {
|
return convertToFloat(value);
|
}
|
if (IotDataSpecsDataTypeEnum.DOUBLE.getDataType().equals(dataType)) {
|
return convertToDouble(value);
|
}
|
if (IotDataSpecsDataTypeEnum.ENUM.getDataType().equals(dataType)) {
|
return convertEnumToTinyInt(thingModel, value);
|
}
|
if (IotDataSpecsDataTypeEnum.BOOL.getDataType().equals(dataType)) {
|
return convertBoolToTinyInt(value);
|
}
|
if (IotDataSpecsDataTypeEnum.TEXT.getDataType().equals(dataType)) {
|
return convertToVarchar(Convert.toStr(value), getTextLength(thingModel));
|
}
|
if (IotDataSpecsDataTypeEnum.DATE.getDataType().equals(dataType)) {
|
return convertToTimestamp(value);
|
}
|
return null;
|
}
|
|
private Integer getTextLength(IotThingModelDO thingModel) {
|
ThingModelDataSpecs dataSpecs = thingModel.getProperty().getDataSpecs();
|
if (!(dataSpecs instanceof ThingModelDateOrTextDataSpecs)) {
|
return null;
|
}
|
return ((ThingModelDateOrTextDataSpecs) dataSpecs).getLength();
|
}
|
|
private String convertToVarchar(String value, Integer length) {
|
if (value == null) {
|
return null;
|
}
|
if (length != null && value.getBytes(StandardCharsets.UTF_8).length > length) {
|
return null;
|
}
|
return value;
|
}
|
|
private Integer convertToInt(Object value) {
|
BigDecimal decimal = convertToBigDecimal(value);
|
if (decimal == null) {
|
return null;
|
}
|
try {
|
return decimal.intValueExact();
|
} catch (ArithmeticException e) {
|
return null;
|
}
|
}
|
|
private Float convertToFloat(Object value) {
|
BigDecimal decimal = convertToBigDecimal(value);
|
if (decimal == null) {
|
return null;
|
}
|
float result = decimal.floatValue();
|
return Float.isFinite(result) ? result : null;
|
}
|
|
private Double convertToDouble(Object value) {
|
BigDecimal decimal = convertToBigDecimal(value);
|
if (decimal == null) {
|
return null;
|
}
|
double result = decimal.doubleValue();
|
return Double.isFinite(result) ? result : null;
|
}
|
|
private BigDecimal convertToBigDecimal(Object value) {
|
if (value instanceof Boolean) {
|
return null;
|
}
|
String text = Convert.toStr(value);
|
if (StrUtil.isBlank(text)) {
|
return null;
|
}
|
try {
|
return new BigDecimal(text);
|
} catch (NumberFormatException e) {
|
return null;
|
}
|
}
|
|
private Byte convertEnumToTinyInt(IotThingModelDO thingModel, Object value) {
|
Integer intValue = convertToInt(value);
|
if (intValue == null && value instanceof CharSequence) {
|
intValue = getEnumValueByName(thingModel, value.toString());
|
}
|
if (intValue == null || !isTinyInt(intValue)) {
|
return null;
|
}
|
if (CollUtil.isNotEmpty(thingModel.getProperty().getDataSpecsList())
|
&& getEnumDataSpecsByValue(thingModel, intValue) == null) {
|
return null;
|
}
|
return intValue.byteValue();
|
}
|
|
private Integer getEnumValueByName(IotThingModelDO thingModel, String name) {
|
ThingModelBoolOrEnumDataSpecs dataSpecs = getEnumDataSpecsByName(thingModel, name);
|
return dataSpecs != null ? dataSpecs.getValue() : null;
|
}
|
|
private ThingModelBoolOrEnumDataSpecs getEnumDataSpecsByName(IotThingModelDO thingModel, String name) {
|
if (CollUtil.isEmpty(thingModel.getProperty().getDataSpecsList())) {
|
return null;
|
}
|
for (ThingModelDataSpecs dataSpecs : thingModel.getProperty().getDataSpecsList()) {
|
if (!(dataSpecs instanceof ThingModelBoolOrEnumDataSpecs)) {
|
continue;
|
}
|
ThingModelBoolOrEnumDataSpecs enumDataSpecs = (ThingModelBoolOrEnumDataSpecs) dataSpecs;
|
if (StrUtil.equals(enumDataSpecs.getName(), name)) {
|
return enumDataSpecs;
|
}
|
}
|
return null;
|
}
|
|
private ThingModelBoolOrEnumDataSpecs getEnumDataSpecsByValue(IotThingModelDO thingModel, Integer value) {
|
if (CollUtil.isEmpty(thingModel.getProperty().getDataSpecsList())) {
|
return null;
|
}
|
for (ThingModelDataSpecs dataSpecs : thingModel.getProperty().getDataSpecsList()) {
|
if (!(dataSpecs instanceof ThingModelBoolOrEnumDataSpecs)) {
|
continue;
|
}
|
ThingModelBoolOrEnumDataSpecs enumDataSpecs = (ThingModelBoolOrEnumDataSpecs) dataSpecs;
|
if (Objects.equals(enumDataSpecs.getValue(), value)) {
|
return enumDataSpecs;
|
}
|
}
|
return null;
|
}
|
|
private Byte convertBoolToTinyInt(Object value) {
|
if (value instanceof Boolean) {
|
return (Boolean) value ? (byte) 1 : (byte) 0;
|
}
|
if (value instanceof CharSequence) {
|
String text = StrUtil.trim(value.toString());
|
if (StrUtil.equalsIgnoreCase(text, "true")) {
|
return (byte) 1;
|
}
|
if (StrUtil.equalsIgnoreCase(text, "false")) {
|
return (byte) 0;
|
}
|
}
|
Integer intValue = convertToInt(value);
|
if (intValue == null || (intValue != 0 && intValue != 1)) {
|
return null;
|
}
|
return intValue.byteValue();
|
}
|
|
private boolean isTinyInt(Integer value) {
|
return value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE;
|
}
|
|
private Long convertToTimestamp(Object value) {
|
if (value instanceof LocalDateTime) {
|
return LocalDateTimeUtil.toEpochMilli((LocalDateTime) value);
|
}
|
if (value instanceof LocalDate) {
|
return LocalDateTimeUtil.toEpochMilli(((LocalDate) value).atStartOfDay());
|
}
|
if (value instanceof Instant) {
|
return ((Instant) value).toEpochMilli();
|
}
|
if (value instanceof OffsetDateTime) {
|
return ((OffsetDateTime) value).toInstant().toEpochMilli();
|
}
|
if (value instanceof ZonedDateTime) {
|
return ((ZonedDateTime) value).toInstant().toEpochMilli();
|
}
|
if (value instanceof Date) {
|
return ((Date) value).getTime();
|
}
|
Long timestamp = convertToLong(value);
|
if (timestamp != null) {
|
return timestamp;
|
}
|
if (!(value instanceof CharSequence)) {
|
return null;
|
}
|
String text = StrUtil.trim(value.toString());
|
if (StrUtil.isBlank(text)) {
|
return null;
|
}
|
try {
|
return OffsetDateTime.parse(text).toInstant().toEpochMilli();
|
} catch (Exception ignored) {
|
// 尝试本地时间格式，例如 yyyy-MM-dd HH:mm:ss
|
}
|
try {
|
return LocalDateTimeUtil.toEpochMilli(LocalDateTimeUtil.parse(text, DatePattern.NORM_DATETIME_PATTERN));
|
} catch (Exception ignored) {
|
// 尝试其它 Hutool 支持的本地时间格式
|
}
|
try {
|
return LocalDateTimeUtil.toEpochMilli(LocalDateTimeUtils.parse(text));
|
} catch (Exception ignored) {
|
return null;
|
}
|
}
|
|
private Long convertToLong(Object value) {
|
BigDecimal decimal = convertToBigDecimal(value);
|
if (decimal == null) {
|
return null;
|
}
|
try {
|
return decimal.longValueExact();
|
} catch (ArithmeticException e) {
|
return null;
|
}
|
}
|
|
private void validateProductThingModelMapperExists(Long id) {
|
if (thingModelMapper.selectById(id) == null) {
|
throw exception(THING_MODEL_NOT_EXISTS);
|
}
|
}
|
|
private void validateIdentifierUnique(Long id, Long productId, String identifier) {
|
// 1. 情况一：创建时校验
|
if (id == null) {
|
// 1.1 系统保留字段，不能用于标识符定义
|
if (StrUtil.equalsAny(identifier, "set", "get", "post", "property", "event", "time", "value")) {
|
throw exception(THING_MODEL_IDENTIFIER_INVALID);
|
}
|
// 1.2 校验唯一
|
IotThingModelDO thingModel = thingModelMapper.selectByProductIdAndIdentifier(productId, identifier);
|
if (thingModel != null) {
|
throw exception(THING_MODEL_IDENTIFIER_EXISTS);
|
}
|
return;
|
}
|
|
// 2. 情况二：更新时校验
|
IotThingModelDO thingModel = thingModelMapper.selectByProductIdAndIdentifier(productId, identifier);
|
if (thingModel != null && ObjectUtil.notEqual(thingModel.getId(), id)) {
|
throw exception(THING_MODEL_IDENTIFIER_EXISTS);
|
}
|
}
|
|
private void validateProductStatus(Long createReqVO) {
|
IotProductDO product = productService.validateProductExists(createReqVO);
|
if (Objects.equals(product.getStatus(), IotProductStatusEnum.PUBLISHED.getStatus())) {
|
throw exception(PRODUCT_STATUS_NOT_ALLOW_THING_MODEL);
|
}
|
}
|
|
private void validateNameUnique(Long productId, String name) {
|
IotThingModelDO thingModel = thingModelMapper.selectByProductIdAndName(productId, name);
|
if (thingModel != null) {
|
throw exception(THING_MODEL_NAME_EXISTS);
|
}
|
}
|
|
private void deleteThingModelListCache(Long productId) {
|
// 保证 Spring AOP 触发
|
getSelf().deleteThingModelListCache0(productId);
|
}
|
|
@CacheEvict(value = RedisKeyConstants.THING_MODEL_LIST, key = "#productId")
|
@TenantIgnore // 忽略租户信息
|
public void deleteThingModelListCache0(Long productId) {
|
}
|
|
private IotThingModelServiceImpl getSelf() {
|
return SpringUtil.getBean(getClass());
|
}
|
|
}
|
