物联网之产品类型业务逻辑 、引用模板
@Service
@Slf4j
public class IotProductService {
@Autowired
private LoginService loginService;
@Autowired
private ObjectModelDao objectModelDao;
@Autowired
private ProductsDao productsDao;
@Autowired
private SystemConfigDao systemConfigDao;
@Autowired
private CategoryDao categoryDao;
@Autowired
private ObjectPropertiesDao objectPropertiesDao;
@Autowired
private ObjectServicesDao objectServicesDao;
@Autowired
private ObjectEventsDao objectEventsDao;
@Autowired
private ObjectEventsParamsDao objectEventsParamsDao;
@Autowired
private ObjectServicesParamsDao objectServicesParamsDao;
@Autowired
private ProductPropertiesDao productPropertiesDao;
@Autowired
private ProductServicesDao productServicesDao;
@Autowired
private ProductEventsDao productEventsDao;
@Autowired
private ProductEventsParamsDao productEventsParamsDao;
@Autowired
private ProductServicesParamsDao productServicesParamsDao;
@Autowired
private EmployeeDao employeeDao;
@Autowired
private ProductInnerIdentifierDao innerIdentifierDao;
@Autowired
private ProductsService productsService;
private final String SERVICE_METHOD_PREFIX = "thing.service.property.";
private final String AUTH_TYPE = "product_auth_mode";
private final String LINK_TYPE = "product_link_mode";
private final String EVENT_METHOD_PROPERTY = "thing.event.property.post";
/**
* 默认功能事件的标识符
*/
private final String POST = "property";
@Autowired
private SystemConfig systemConfig;
/**
* 根据id查询
*/
public ProductsEntity getById(Long id) {
return productsDao.selectById(id);
}
/* public boolean checkExistByProductNameAndCategoryId(String productName, Long categoryId) {
QueryWrapper<ProductsEntity> qw = new QueryWrapper<>();
qw.eq("category_id", categoryId);
qw.eq("name", productName);
qw.eq("product_status", 1);
Integer integer = productsDao.selectCount(qw);
return integer > 0;
}*/
/**
* 分页查询 默认按添加时间降序排列
* <p>
* TODO 选择发布状态，可以看到所有人发布的；选择草稿状态，只能看到自己创建的
* 优化缓存产品类型信息
*
*/
public ResponseDTO<PageResultDTO<ProductsVO>> queryByPage(ProductsQueryDTO queryDTO) {
Page<?> page = IotPageUtil.convert2QueryPage(queryDTO);
if (page.getOrders() == null || page.getOrders().isEmpty()) {
List<OrderItem> list = new ArrayList<OrderItem>();
OrderItem item = new OrderItem();
item.setAsc(false);
item.setColumn("update_time");
list.add(item);
page.setOrders(list);
}
IPage<ProductsVO> pageVOs = productsDao.queryByPage(page, queryDTO);
List<ProductsVO> records = pageVOs.getRecords();
records.forEach(r -> {
Long categoryId = r.getCategoryId();
r.setCategoryName(systemConfig.id2CategoryMap.get(categoryId));
});
pageVOs.setRecords(records);
PageResultDTO<ProductsVO> pageResultDTO = IotPageUtil.convert2PageResult(pageVOs);
return ResponseDTO.succData(pageResultDTO);
}
@Transactional(rollbackFor = Exception.class)
public ResponseDTO<Long> add(ProductsAddDTO addDTO, String userNo) {
ProductsEntity productsEntity = IotBeanUtil.copy(addDTO, ProductsEntity.class);
productsEntity.setAuthType(convertListToString(addDTO.getAuthType()));
productsEntity.setLinkType(convertListToString(addDTO.getLinkType()));
// 新增产品类型 草稿状态
productsEntity
.setProductStatus(ProductRefEnum.ProductStatusType.DRAFT.getCode())
.setProductRefNum(1);
// 当前前端请求参数未传noteType
productsEntity.setNodeType(addDTO.getNodeType() == null ? NodeTypeEnum.NodeType.DIRECT_CONNECTED_DEVICE.code : addDTO.getNodeType());
// TODO 调试阶段注释此逻辑。获取当前用户并赋值给entity的creator_id
// RequestTokenBO requestUser = IotRequestTokenUtil.getRequestUser();
//
// LoginDetailVO session = loginService.getSession(requestUser);
// Long id = session.getId();
// String number = session.getPhone();
// entity.setCreatorId(id);
QueryWrapper<EmployeeEntity> qw = new QueryWrapper<>(new EmployeeEntity());
qw.eq("login_name", userNo);
EmployeeEntity employeeEntity = employeeDao.selectOne(qw);
//String loginName = employeeEntity.getLoginName();
if (employeeEntity != null) {
productsEntity.setCreatorId(employeeEntity.getId());
}
Long categoryId = productsEntity.getCategoryId();
productsEntity.setCategoryName(systemConfig.id2CategoryMap.get(categoryId));
productsEntity.setCreatorName(userNo);
productsDao.insert(productsEntity);
long productId = productsEntity.getId();
createDefaultFunction4Product(productId);
return ResponseDTO.succData(productId);
}
private void createDefaultFunction4Product(long productId) {
// 创建默认的set、get服务，post事件
String get = "get";
String set = "set";
ProductServicesEntity identifierGetEntity = createProductServicesEntity4Identifier(productId, get, 1);
ProductServicesEntity identifierSetEntity = createProductServicesEntity4Identifier(productId, set, 2);
productServicesDao.insertBatch(new ArrayList<>(Arrays.asList(identifierGetEntity, identifierSetEntity)));
// 自动生成get的set参数
ProductServicesParamsEntity setServiceParam = createProductServicesParamsEntity4Set(identifierSetEntity.getId());
ProductServicesParamsEntity getServiceParam = createProductServicesParamsEntity4Get(identifierGetEntity.getId());
productServicesParamsDao.insertBatch(new ArrayList<>(Arrays.asList(setServiceParam, getServiceParam)));
ProductEventsEntity eventsEntity = new ProductEventsEntity();
eventsEntity.setCustom(ProductRefEnum.FunctionType.DEFAULT.getCode())
.setIdentifier(POST)
.setDescription("属性上报")
.setOriginalRequired(0)
.setProductId(productId)
.setLevel(0) // 设计文档 默认等级为0
.setMethod(EVENT_METHOD_PROPERTY)
.setName(POST)
.setType(0)
.setUpdateRequired(0);
productEventsDao.insert(eventsEntity);
// 插入get、post、set 信息到 t_product_inner_identifier 开始
ProductInnerIdentifierEntity getEntity = new ProductInnerIdentifierEntity()
.setProductId(productId).setIdentifier("get").setRef(1).setCustom(2);
ProductInnerIdentifierEntity setEntity = new ProductInnerIdentifierEntity()
.setProductId(productId).setIdentifier("set").setRef(2).setCustom(2);
ProductInnerIdentifierEntity postEntity = new ProductInnerIdentifierEntity()
.setProductId(productId).setIdentifier("property").setRef(3).setCustom(2);
List<ProductInnerIdentifierEntity> list = new ArrayList<>(3);
list.add(getEntity);
list.add(postEntity);
list.add(setEntity);
innerIdentifierDao.insertBatch4WithRefIdentifier(list);
// 插入get、post、set 信息到 t_product_inner_identifier 完毕
}
private ProductServicesParamsEntity createProductServicesParamsEntity4Set(long setServiceId) {
ProductServicesParamsEntity getServiceParam = new ProductServicesParamsEntity();
getServiceParam.setRef(1);
getServiceParam.setCustom(2);
getServiceParam.setType(ServiceParamTypeEnum.ParamType.OUT_PARAM.getCode());
getServiceParam.setIdentifier("set_results");
getServiceParam.setName("请求参数");
getServiceParam.setRefId(setServiceId);
getServiceParam.setDescription("设置失败的属性ref列表");
getServiceParam.setDataType(7); // 数组嵌套
/**
* "dataType": {
* "type": "array",
* "specs": {
* "size": "5",
* "item": {
* "dataType": {
* "type": "text",
* "specs": {
* "rule": "",
* "length": 0
* }* }
* }
* }* }
*/
JSONObject specs = new JSONObject();
specs.put("size", 0); // 创建产品时，get 的输出参数列表默认大小为0
JSONObject item = new JSONObject();
JSONObject dataType = new JSONObject();
dataType.put("type", 3);
JSONObject innerSpecs = new JSONObject();
innerSpecs.put("rule", "");
innerSpecs.put("length", 64);
dataType.put("specs", innerSpecs);
item.put("dataType", dataType);
specs.put("item", item);
getServiceParam.setSpecs(specs.toJSONString());
return getServiceParam;
}
private ProductServicesParamsEntity createProductServicesParamsEntity4Get(long getServiceId) {
ProductServicesParamsEntity setServiceParam = new ProductServicesParamsEntity();
setServiceParam.setRef(2);
setServiceParam.setCustom(2);
setServiceParam.setType(ServiceParamTypeEnum.ParamType.IN_PARAM.getCode());
setServiceParam.setIdentifier("get_params");
setServiceParam.setName("返回值");
setServiceParam.setRefId(getServiceId);
setServiceParam.setDescription("获取属性(默认生成)");
setServiceParam.setDataType(7); // 数组嵌套
/**
* "dataType": {
* "type": "array",
* "specs": {
* "size": "5",
* "item": {
* "dataType": {
* "type": "text",
* "specs": {
* "rule": "",
* "length": 0
* }* }
* }
* }* }
*/
JSONObject specs = new JSONObject();
specs.put("size", 0); // 创建产品时，get 的输出参数列表默认大小为0
JSONObject item = new JSONObject();
JSONObject dataType = new JSONObject();
dataType.put("type", 3);
JSONObject innerSpecs = new JSONObject();
innerSpecs.put("rule", "");
innerSpecs.put("length", 64);
dataType.put("specs", innerSpecs);
item.put("dataType", dataType);
specs.put("item", item);
setServiceParam.setSpecs(specs.toJSONString());
return setServiceParam;
}
private ProductServicesEntity createProductServicesEntity4Identifier(long productId, String identifier, Integer ref) {
String method;
ProductServicesEntity servicesEntity = new ProductServicesEntity();
method = SERVICE_METHOD_PREFIX + identifier;
servicesEntity.setMethod(method)
.setCustom(ProductRefEnum.FunctionType.DEFAULT.getCode()) // custom 1：自定义
.setDescription("set".equals(identifier) ? "设置属性(默认生成)" : "获取属性(默认生成)")
.setName(identifier)
.setProductId(productId)
.setOriginalRequired(0)
.setUpdateRequired(0)
.setIdentifier(identifier)
.setSystemCall(0); // 确认方法默认情况暂按异步处理 0：async（异步），1：sync（同步）
return servicesEntity;
}
/**
* 将数组转为字符串,update时，控制器层已校验数组是否空
*
* @param stringList
* @return
*/
private String convertListToString(List<String> stringList) {
if (CollectionUtils.isEmpty(stringList)) {
return "";
}
String str = stringList.toString();
return str.substring(1, str.length() - 1);
}
/**
* 编辑
*/
@Transactional(rollbackFor = Exception.class)
public ResponseDTO<String> update(ProductsUpdateDTO updateDTO) {
ProductsEntity entity = IotBeanUtil.copy(updateDTO, ProductsEntity.class);
entity.setAuthType(convertListToString(updateDTO.getAuthType()));
entity.setLinkType(convertListToString(updateDTO.getLinkType()));
entity.setUpdateTime(new Date());
int ret = productsDao.updateByIdAndStatus(entity);
return ret > 0 ? ResponseDTO.succ() : ResponseDTO.failInvalidParamWithMsg("产品类型已发布");
}
@Transactional(rollbackFor = Exception.class)
public ResponseDTO<String> deleteByIds(List<Long> idList) {
/*
List<ProductsEntity> productsEntities = productsDao.listByIds(idList);
if (CollectionUtils.isEmpty(productsEntities)) {
return ResponseDTO.failInvalidParamWithMsg("参数异常!");
}
ProductsEntity productsEntity = productsEntities.get(0);
String name = productsEntity.getName();
ProductsEntity existed = productsDao.selectOneByNameAndDeletedIsTrue(name);
String innerType = productsEntity.getInnerType();
ProductsEntity existedInner = productsDao.selectOneByInnerTypeAndDeletedIsTrue(innerType);
if (existedInner != null) {
// 第一次删除保留数据，若开多个界面，一个删除之后，其他页面再删除，则删除数据！
productsDao.deleteById4NotLogic(idList.get(0));
return ResponseDTO.failInvalidParam();
}
if (existed != null && ((existed.getObjectId() == null && productsEntity.getObjectId() == null) ||
(existed.getObjectId() == productsEntity.getObjectId()))) {
// 第一次删除保留数据，若开多个界面，一个删除之后，其他页面再删除，则删除数据！
productsDao.deleteById4NotLogic(idList.get(0));
return ResponseDTO.failInvalidParam();
}*/
int affected = productsDao.deleteBatch(idList);
if (affected < 1) {
log.error("产品类型已发布或者不存在, productId = {}", idList.get(0));
return ResponseDTO.failInvalidParamWithMsg("产品类型已发布或者不存在");
}
return ResponseDTO.succ();
}
@Transactional(rollbackFor = Exception.class)
public ResponseDTO<Integer> releaseByIds(List<Long> idList) {
int ret = productsDao.releaseByIds(idList);
if (ret < 1) {
return ResponseDTO.failInvalidParam();
}
long productId = idList.get(0);
// 统一更新默认服务get(输入参数)、set(输出参数) 数据规格的size
int count = productPropertiesDao.countByProductId(productId);
QueryWrapper<ProductServicesEntity> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("product_id", productId);
queryWrapper.in("identifier", new ArrayList<>(Arrays.asList("get", "set")));
List<ProductServicesEntity> services = productServicesDao.selectList(queryWrapper);
Map<String, Long> collect = services.stream().collect(Collectors.toMap(ProductServicesEntity::getIdentifier, ProductServicesEntity::getId));
QueryWrapper<ProductServicesParamsEntity> paramsEntityQueryWrapper4Get = new QueryWrapper<>();
paramsEntityQueryWrapper4Get.eq("ref_id", collect.get("get"));
paramsEntityQueryWrapper4Get.eq("identifier", "get_params");
ProductServicesParamsEntity productServicesParamsEntity4Get = productServicesParamsDao.selectOne(paramsEntityQueryWrapper4Get);
QueryWrapper<ProductServicesParamsEntity> paramsEntityQueryWrapper4Set = new QueryWrapper<>();
paramsEntityQueryWrapper4Set.eq("ref_id", collect.get("set"));
paramsEntityQueryWrapper4Set.eq("identifier", "set_results");
ProductServicesParamsEntity productServicesParamsEntity4Set = productServicesParamsDao.selectOne(paramsEntityQueryWrapper4Set);
if (null == productServicesParamsEntity4Get || productServicesParamsEntity4Set == null) {
log.error("脏数据，默认服务参数列表不能为空！productId = {}", productId);
throw new IotBusinessException("默认服务参数列表不能为空！");
}
String specsGet = productServicesParamsEntity4Get.getSpecs();
JSONObject getJson = (JSONObject) JSONObject.parse(specsGet);
getJson.put("size", count);
productServicesParamsEntity4Get.setSpecs(getJson.toJSONString());
String specs4Set = productServicesParamsEntity4Set.getSpecs();
JSONObject setJson = (JSONObject) JSONObject.parse(specs4Set);
setJson.put("size", count);
productServicesParamsEntity4Set.setSpecs(setJson.toJSONString());
ArrayList<ProductServicesParamsEntity> productServicesParamsEntities = new ArrayList<>(Arrays.asList(productServicesParamsEntity4Get, productServicesParamsEntity4Set));
log.info("默认服务更新size： {}", productServicesParamsEntities);
productServicesParamsDao.updateBatch(productServicesParamsEntities);
return ResponseDTO.succData(ret);
}
public ProductsDetailVO getProductDetailsById(Long id) {
ProductsEntity entity = productsDao.selectById(id);
if (null == entity) {
return null;
}
SystemConfigEntity authTypeConfig;
SystemConfigEntity linkTypeConfig;
ConcurrentHashMap<String, SystemConfigEntity> authAndLinkModeEntityMap = systemConfig.authAndLinkModeEntityMap;
if (authAndLinkModeEntityMap.containsKey(AUTH_TYPE)) {
authTypeConfig = authAndLinkModeEntityMap.get(AUTH_TYPE);
} else {
authTypeConfig = systemConfigDao.getByConfigKey(AUTH_TYPE);
}
if (authAndLinkModeEntityMap.containsKey(LINK_TYPE)) {
linkTypeConfig = authAndLinkModeEntityMap.get(LINK_TYPE);
} else {
linkTypeConfig = systemConfigDao.getByConfigKey(LINK_TYPE);
}
String authType = authTypeConfig.getConfigValue();
String linkType = linkTypeConfig.getConfigValue();
List<ConfigName2ValueVO> authRet = JSONObject.parseArray(authType, ConfigName2ValueVO.class);
List<ConfigName2ValueVO> linkRet = JSONObject.parseArray(linkType, ConfigName2ValueVO.class);
String entityAuth = entity.getAuthType();
String entityLink = entity.getLinkType();
System.err.println("entityAuth: " + entityAuth + "\n entityLink: " + entityLink);
List<String> auths = new ArrayList<>(Arrays.asList(StringUtils.split(entityAuth, ";")));
List<String> links = new ArrayList<>(Arrays.asList(StringUtils.split(entityLink, ";")));
List<SystemConfigKey2ValueDTO> authKey2ValueDTOs = new ArrayList<>(auths.size());
List<SystemConfigKey2ValueDTO> linkKey2ValueDTOs = new ArrayList<>(links.size());
JSONArray authArray = new JSONArray();
JSONArray linkArray = new JSONArray();
for (ConfigName2ValueVO configName2ValueVO : authRet) {
if (auths.contains(configName2ValueVO.getValue())) {
SystemConfigKey2ValueDTO object = new SystemConfigKey2ValueDTO();
object.setKey(configName2ValueVO.getValue()).setValue(configName2ValueVO.getName());
authKey2ValueDTOs.add(object);
authArray.add(object);
}
}
for (ConfigName2ValueVO configName2ValueVO : linkRet) {
if (links.contains(configName2ValueVO.getValue())) {
SystemConfigKey2ValueDTO object = new SystemConfigKey2ValueDTO();
object.setKey(configName2ValueVO.getValue()).setValue(configName2ValueVO.getName());
linkKey2ValueDTOs.add(object);
linkArray.add(object);
}
}
CategoryEntity categoryEntity = categoryDao.selectById(entity.getCategoryId());
ProductsDetailVO vo = new ProductsDetailVO();
System.err.println("AuthArray: " + authArray.toJSONString());
vo.setAuthType(authArray.toJSONString())
.setLinkType(linkArray.toJSONString())
.setId(entity.getId())
.setCategoryId(entity.getCategoryId())
.setCreatorName(entity.getCreatorName())
.setName(entity.getName())
.setDescription(entity.getDescription())
.setInnerType(entity.getInnerType())
.setProductRefNum(entity.getProductRefNum())
.setNodeType(Objects.requireNonNull(NodeTypeEnum.NodeType.parse(entity.getNodeType())).msg)
.setCategoryName(categoryEntity.getName());
System.out.println("ret: " + authRet);
return vo;
}
public ProductObjectRefInfoVO getObjectRefInfoByProductId(Long productId) {
ProductObjectRefInfoVO ret = new ProductObjectRefInfoVO();
ProductsEntity productsEntity = productsDao.selectById(productId);
Long categoryId = productsEntity.getCategoryId();
CategoryEntity categoryEntity = categoryDao.selectById(categoryId);
String categoryName = categoryEntity.getName();
ret.setCategoryName(categoryName);
// TODO 查询产品类型相关数据填充result
Long objectId = productsEntity.getObjectId();
if (objectId == null) {
ret.setRefObjectEvents(new ArrayList<>(0)).setRefObjectServices(new ArrayList<>(0))
.setRefObjectProperties(new ArrayList<>(0));
return ret;
}
ret.setObjectId(objectId);
ObjectModelEntity objectModelEntity = objectModelDao.selectById(objectId);
// 获取产品类型引用的功能定义列表
List<ProductPropertiesVO> propertiesVOS = productPropertiesDao.listByProductIdAndCustom(productId, 0);
List<ProductEventsVO> eventsVOS = productEventsDao.listByProductIdAndCustom(productId, 0);
List<ProductServicesVO> servicesVOS = productServicesDao.listByProductIdAndCustom(productId, 0);
// 获取产品类型引用的功能定义列表标识符集合
List<String> propertyIdentifiers = propertiesVOS.stream().map(ProductPropertiesVO::getIdentifier).collect(Collectors.toList());
List<String> serviceIdentifiers = servicesVOS.stream().map(ProductServicesVO::getIdentifier).collect(Collectors.toList());
List<String> eventIdentifiers = eventsVOS.stream().map(ProductEventsVO::getIdentifier).collect(Collectors.toList());
// 到这儿其实已经够判断了 下面的逻辑完全多余 前端可根据当前产品类型的objectId 和 identifier的集合就可以筛选出已经引用的功能定义
// 物模板属性
List<ObjectPropertiesVO> objectPropertiesVOS = new ArrayList<>(propertyIdentifiers.size());
if (CollectionUtils.isNotEmpty(propertyIdentifiers)) {
System.err.println("属性====产品类型引用物模板identifier集合： " + propertyIdentifiers);
objectPropertiesVOS = objectPropertiesDao.listByObjectIdAndIdentifiersIn(objectId, propertyIdentifiers);
List<ProductObjectFunctionRefVO> properties = objectPropertiesVOS
.stream()
.map(a -> new ProductObjectFunctionRefVO(a.getId(), a.getIdentifier()))
.collect(Collectors.toList());
ret.setRefObjectProperties(properties);
}
// 物模板事件
List<ObjectEventsVO> objectEventsVOS = new ArrayList<>(eventIdentifiers.size());
if (CollectionUtils.isNotEmpty(eventIdentifiers)) {
System.err.println("事件====产品类型引用物模板identifier集合： " + eventIdentifiers);
objectEventsVOS = objectEventsDao.listByObjectIdAndIdentifiersIn(objectId, eventIdentifiers);
List<ProductObjectFunctionRefVO> events= objectEventsVOS.stream().map(a -> new ProductObjectFunctionRefVO(a.getId(), a.getIdentifier())).collect(Collectors.toList());
ret.setRefObjectEvents(events);
}
// 物模板服务
List<ObjectServicesVO> objectServiceVOS = new ArrayList<>(serviceIdentifiers.size());
if (CollectionUtils.isNotEmpty(serviceIdentifiers)) {
System.err.println("服务====产品类型引用物模板identifier集合： " + serviceIdentifiers);
objectServiceVOS = objectServicesDao.listByObjectIdAndIdentifiersIn(objectId, serviceIdentifiers);
List<ProductObjectFunctionRefVO> services = objectServiceVOS
.stream()
.map(a -> new ProductObjectFunctionRefVO(a.getId(), a.getIdentifier()))
.collect(Collectors.toList());
ret.setRefObjectServices(services);
}
ret.setObjectModelName(objectModelEntity.getName());
return ret;
}
@Transactional(rollbackFor = Exception.class)
public ResponseDTO<String> addObjectFunctions(ProductsSaveFunctionsDTO saveFunctionsDTO) {
Long productId = saveFunctionsDTO.getId();
Long objectId = saveFunctionsDTO.getObjectId();
ObjectModelEntity objectModel = null;
if (objectId != null) {
objectModel = objectModelDao.selectById(objectId);
}
// 操作编辑或者添加物模板时，没有选择物模板,将产品之前的引用信息置空
if (objectModel == null) {
return deleteAllRefObjectFunctions(productId);
}
// 编辑时查询产品类型是否存在
ProductsEntity products = productsDao.selectById(productId);
List<Long> objectPropertiesIdsRequest = saveFunctionsDTO.getPropertiesIdList();
List<Long> objectServicesIdsRequest = saveFunctionsDTO.getServicesIdList();
List<Long> objectEventsIdsRequest = saveFunctionsDTO.getEventsIdsList();
if (products == null) {
return ResponseDTO.failInvalidParamWithMsg("请你不要乱搞接口，操作可以操作的产品类型去！");
}
// 不论如何，直接删除所有引用的功能定义
deleteAllRefObjectFunctions(productId);
// 请求的去掉交集 批量insert 去掉模板中的 set、get、post
List<ObjectServicesVO> objectServicesVOS = objectServicesDao.listByObjectIdAndIdentifiersIn(objectId, new ArrayList<>(Arrays.asList("get", "set")));
List<ObjectEventsVO> postEventVO = objectEventsDao.listByObjectIdAndIdentifiersIn(objectId, new ArrayList<>(Arrays.asList("property")));
objectEventsIdsRequest.removeAll(postEventVO.stream().map(ObjectEventsVO::getId).collect(Collectors.toSet()));
objectServicesIdsRequest.removeAll(objectServicesVOS.stream().map(ObjectServicesVO::getId).collect(Collectors.toSet()));
// 添加模板功能定义 perf 声明和数据准备合并
List<ObjectPropertiesEntity> objectPropertiesEntities = new ArrayList<>();
List<ObjectServicesEntity> objectServicesEntities = new ArrayList<>();
List<ObjectEventsEntity> objectEventsEntities = new ArrayList<>();
List<ObjectServicesParamsEntity> servicesParamsEntities = new ArrayList<>();
List<ObjectEventsParamsEntity> eventsParamsEntities = new ArrayList<>();
log.error("\n===>Debug#物模型模板一致 跳出数据处理 objectEventsIdsRequest = {} \n objectServicesIdsRequest = {} \n objectPropertiesIdsRequest = {}", objectEventsIdsRequest, objectServicesIdsRequest, objectPropertiesIdsRequest);
objectPropertiesEntities = prepareObjectPropertiesEntities(objectPropertiesIdsRequest, objectPropertiesEntities);
ObjectServicesOrEventsAndParamsDTO temp =
prepareObjectServicesOrEventAndParams(objectServicesIdsRequest, objectEventsIdsRequest);
objectEventsEntities = temp.getObjectEventsEntities();
eventsParamsEntities = temp.getEventsParamsEntities();
objectServicesEntities = temp.getObjectServicesEntities();
servicesParamsEntities = temp.getServicesParamsEntities();
/**
* 批量插入标识符到中间记录表 开始
*/
int maxRef = innerIdentifierDao.selectMaxRefByProductIdOrderByRef(productId);
List<ProductInnerIdentifierEntity> identifiers4Properties = prepareProductIdentifiersWithProperties(objectPropertiesEntities, productId, maxRef);
maxRef = maxRef + identifiers4Properties.size();
List<ProductInnerIdentifierEntity> identifier4Services = prepareProductIdentifiersWithServices(objectServicesEntities, productId, maxRef);
maxRef = maxRef + identifier4Services.size();
List<ProductInnerIdentifierEntity> identifier4Events = prepareProductIdentifiersWithEvents(objectEventsEntities, productId, maxRef);
identifiers4Properties.addAll(identifier4Services);
identifiers4Properties.addAll(identifier4Events);
List<ProductPropertiesEntity> productPropertiesEntities = createProductPropertiesEntities(objectPropertiesEntities, productId);
// 产品类型——》新增服务
List<ProductServicesEntity> productServicesEntities = createProductServicesEntities(objectServicesEntities, productId);
List<ProductEventsEntity> productEventsEntities = createProductEventsEntities(objectEventsEntities, productId);
// TODO mapper.xml
innerIdentifierDao.deleteAllByProductIdAndCustom(productId, 0);
if (CollectionUtils.isNotEmpty(identifiers4Properties)) {
innerIdentifierDao.insertBatch4WithRefIdentifier(identifiers4Properties);
}
if (CollectionUtils.isNotEmpty(productPropertiesEntities)) {
log.info("===>debug,模板引入属性数据 properties = {}", productPropertiesEntities);
int count = productPropertiesDao.insertBatch(productPropertiesEntities);
log.info("===>debug,模板引入属性数据成功，共{}个", count);
// 生成对应的服务、事件
createProductFunctionParamRecord(productPropertiesEntities, productId);
}
List<String> serviceIdentifiers = new ArrayList<>(productServicesEntities.size());
Map<String, Long> serviceIdentifier2IdMap = new HashMap<>(productServicesEntities.size());
if (CollectionUtils.isNotEmpty(productServicesEntities)) {
productServicesDao.insertBatch(productServicesEntities);
serviceIdentifier2IdMap = prepareServiceIdentifier2IdMap(productId, productServicesEntities);
}
List<String> eventIdentifiers = new ArrayList<>(productEventsEntities.size());
Map<String, Long> eventIdentifier2IdMap = new HashMap<>(productEventsEntities.size());
if (CollectionUtils.isNotEmpty(productEventsEntities)) {
productEventsDao.insertBatch(productEventsEntities);
eventIdentifier2IdMap = getEventIdentifier2IdMap(productId, productEventsEntities);
}
List<ProductEventsParamsEntity> productEventsParamsEntities = new ArrayList<>();
List<Long> serviceParamRefIds = servicesParamsEntities
.stream()
.map(ObjectServicesParamsEntity::getRefId)
.collect(Collectors.toList());
Map<Long, String> id2IdentifiersMap = new HashMap<>();
if (CollectionUtils.isNotEmpty(serviceParamRefIds)) {
id2IdentifiersMap = objectServicesDao
.selectBatchIds(serviceParamRefIds)
.stream()
.collect(Collectors.toMap(ObjectServicesEntity::getId, ObjectServicesEntity::getIdentifier));
}
List<ProductServicesParamsEntity> productsServicesParamsEntities = prepareProductServiceParam(servicesParamsEntities, serviceIdentifier2IdMap, id2IdentifiersMap);
log.info("模板引入，服务参数列表：{}", productsServicesParamsEntities);
List<Long> eventParamRefIds = eventsParamsEntities.stream().map(ObjectEventsParamsEntity::getRefId).collect(Collectors.toList());
Map<Long, String> id2EventIdentifiersMap = new HashMap<>();
if (CollectionUtils.isNotEmpty(eventParamRefIds)) {
id2EventIdentifiersMap = objectEventsDao.selectBatchIds(eventParamRefIds).stream().collect(Collectors.toMap(ObjectEventsEntity::getId, ObjectEventsEntity::getIdentifier));
}
productEventsParamsEntities = prepareProductEventParamEntities(eventsParamsEntities, eventIdentifier2IdMap, id2EventIdentifiersMap);
log.info("模板引入，事件参数列表：{}", productEventsParamsEntities);
// b、将模板的参数插入参数表
if (CollectionUtils.isNotEmpty(productsServicesParamsEntities)) {
productServicesParamsDao.insertBatch(productsServicesParamsEntities);
}
if (CollectionUtils.isNotEmpty(productEventsParamsEntities)) {
productEventsParamsDao.insertBatch(productEventsParamsEntities);
}
// 更新产品类型信息
ProductsEntity productsEntity = new ProductsEntity();
productsEntity.setId(productId);
productsEntity.setObjectId(objectId);
productsEntity.setObjectCategoryId(objectModel.getCategoryId());
productsDao.updateById(productsEntity);
/**
* 批量插入标识符到中间记录表 结束
*/
return ResponseDTO.succ();
}
private List<ProductEventsParamsEntity> prepareProductEventParamEntities(List<ObjectEventsParamsEntity> eventsParamsEntities, Map<String, Long> eventIdentifier2IdMap, Map<Long, String> id2EventIdentifiersMap) {
List<ProductEventsParamsEntity> productEventsParamsEntities = new ArrayList<>();
for (ObjectEventsParamsEntity event : eventsParamsEntities) {
ProductEventsParamsEntity entity = new ProductEventsParamsEntity();
String identifier = id2EventIdentifiersMap.get(event.getRefId());
Long refId = eventIdentifier2IdMap.get(identifier);
entity.setRefId(refId)
.setDataType(event.getDataType())
.setDescription(event.getDescription())
.setIdentifier(event.getIdentifier())
.setSpecs(event.getSpecs())
.setRef(event.getRef())
.setCustom(ProductRefEnum.FunctionType.MODEL_REF.getCode()) // 模板引入，非自定义
.setName(event.getName());
productEventsParamsEntities.add(entity);
}
return productEventsParamsEntities;
}
private ObjectServicesOrEventsAndParamsDTO prepareObjectServicesOrEventAndParams(List<Long> objectServicesIdsRequest, List<Long> objectEventsIdsRequest) {
ObjectServicesOrEventsAndParamsDTO ret = new ObjectServicesOrEventsAndParamsDTO();
List<ObjectServicesEntity> objectServicesEntities = new ArrayList<>();
List<ObjectEventsEntity> objectEventsEntities = new ArrayList<>();
List<ObjectServicesParamsEntity> servicesParamsEntities = new ArrayList<>();
List<ObjectEventsParamsEntity> eventsParamsEntities = new ArrayList<>();
if (!CollectionUtils.isEmpty(objectServicesIdsRequest)) {
// 此次请求添加的物模板功能：服务及服务对应的参数
objectServicesEntities = objectServicesDao.selectBatchIds(objectServicesIdsRequest);
List<ObjectServicesParamsVO> servicesParamsVOS = objectServicesParamsDao.listByRefIds(objectServicesIdsRequest);
servicesParamsVOS.forEach(spv -> {
ObjectServicesParamsEntity entity = new ObjectServicesParamsEntity();
log.info("debug#addFunctions,模板服务参数: {}", spv);
BeanUtils.copyProperties(spv, entity);
servicesParamsEntities.add(entity);
});
}
if (!CollectionUtils.isEmpty(objectEventsIdsRequest)) {
objectEventsEntities = objectEventsDao.selectBatchIds(objectEventsIdsRequest);
List<ObjectEventsParamsVO> eventsParamsVOS = objectEventsParamsDao.listByRefIds(objectEventsIdsRequest);
eventsParamsVOS.forEach(epv -> {
ObjectEventsParamsEntity entity = new ObjectEventsParamsEntity();
BeanUtils.copyProperties(epv, entity);
log.info("debug#addFunctions,模板事件参数: " + epv);
eventsParamsEntities.add(entity);
});
}
ret.setServicesParamsEntities(servicesParamsEntities);
ret.setObjectServicesEntities(objectServicesEntities);
ret.setObjectEventsEntities(objectEventsEntities);
ret.setEventsParamsEntities(eventsParamsEntities);
return ret;
}
private List<ObjectPropertiesEntity> prepareObjectPropertiesEntities(List<Long> objectPropertiesIdsRequest, List<ObjectPropertiesEntity> objectPropertiesEntities) {
if (!CollectionUtils.isEmpty(objectPropertiesIdsRequest)) {
// 此次请求添加的物模板功能：属性
objectPropertiesEntities = objectPropertiesDao.selectBatchIds(objectPropertiesIdsRequest);
log.error("\n===>Debug#查询数据库返回objectPropertiesEntities {}", objectPropertiesEntities);
}
return objectPropertiesEntities;
}
private List<ProductServicesParamsEntity> prepareProductServiceParam(List<ObjectServicesParamsEntity> servicesParamsEntities, Map<String, Long> serviceIdentifier2IdMap, Map<Long, String> id2IdentifiersMap) {
List<ProductServicesParamsEntity> productsServicesParamsEntities = new ArrayList<>();
for (ObjectServicesParamsEntity service : servicesParamsEntities) {
ProductServicesParamsEntity entity = new ProductServicesParamsEntity();
entity.setRefId(serviceIdentifier2IdMap.get(id2IdentifiersMap.get(service.getRefId())))
.setType(service.getType())
.setDataType(service.getDataType())
.setDescription(service.getDescription())
.setIdentifier(service.getIdentifier())
.setSpecs(service.getSpecs())
.setCustom(ProductRefEnum.FunctionType.MODEL_REF.getCode())// 模板引入，非自定义
.setRef(service.getRef()) // 直接使用模板的ref
.setName(service.getName());
productsServicesParamsEntities.add(entity);
}
return productsServicesParamsEntities;
}
private Map<String, Long> getEventIdentifier2IdMap(Long productId, List<ProductEventsEntity> productEventsEntities) {
List<String> eventIdentifiers;
Map<String, Long> eventIdentifier2IdMap;
eventIdentifiers = productEventsEntities
.stream()
.map(ProductEventsEntity::getIdentifier)
.collect(Collectors.toList());
List<ProductEventsVO> eventsVOS = productEventsDao.listByProductIdAndIdentifiersIn(productId, eventIdentifiers);
eventIdentifier2IdMap = eventsVOS
.stream()
.collect(Collectors.toMap(ProductEventsVO::getIdentifier, ProductEventsVO::getId));
return eventIdentifier2IdMap;
}
private Map<String, Long> prepareServiceIdentifier2IdMap(Long productId, List<ProductServicesEntity> productServicesEntities) {
List<String> serviceIdentifiers;
Map<String, Long> serviceIdentifier2IdMap;
serviceIdentifiers = productServicesEntities
.stream()
.map(ProductServicesEntity::getIdentifier)
.collect(Collectors.toList());
List<ProductServicesVO> servicesVOS = productServicesDao.listByProductIdAndIdentifiersIn(productId, serviceIdentifiers);
serviceIdentifier2IdMap = servicesVOS
.stream()
.collect(Collectors.toMap(ProductServicesVO::getIdentifier, ProductServicesVO::getId));
return serviceIdentifier2IdMap;
}
void deleteProductServiceParamByRefIdAndIdentifier(String identifier, long refId) {
QueryWrapper<ProductServicesParamsEntity> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(ProductRefEnum.DefaultIdentifierType.IDENTIFIER.getValue(), identifier)
.eq(ProductRefEnum.DefaultIdentifierType.TYPE.getValue(),
ProductRefEnum.DefaultIdentifierType.GET.getValue().equals(identifier) ? 0 : 1)
.eq(ProductRefEnum.DefaultIdentifierType.REF_ID.getValue(), refId);
productServicesParamsDao.delete(queryWrapper);
}
void deleteProductEventParamByRefId(long refId) {
QueryWrapper<ProductEventsParamsEntity> queryWrapperPost = new QueryWrapper<>();
queryWrapperPost.eq(ProductRefEnum.DefaultIdentifierType.IDENTIFIER.getValue(),
ProductRefEnum.DefaultIdentifierType.POST.getValue())
.eq(ProductRefEnum.DefaultIdentifierType.REF_ID.getValue(), refId);
productEventsParamsDao.delete(queryWrapperPost);
}
@Transactional(rollbackFor = Exception.class)
public ResponseDTO<String> deleteAllRefObjectFunctions(Long productId) {
// 获取产品类型的所有模板引入的属性功能定义
List<ProductPropertiesEntity> productPropertiesEntities = productPropertiesDao.selectAllRefPropertiesByProductIdAndCustomIsFalse(productId);
List<String> identifiers = productPropertiesEntities.stream()
.map(ProductPropertiesEntity::getIdentifier)
.collect(Collectors.toList());
// 获取对应set、get、post 功能定义id
QueryWrapper<ProductServicesEntity> queryMapperSet = new QueryWrapper<>();
queryMapperSet.eq("product_id", productId);
queryMapperSet.eq("identifier", "set");
ProductServicesEntity setService = productServicesDao.selectOne(queryMapperSet);
QueryWrapper<ProductServicesEntity> queryMapperGet = new QueryWrapper<>();
queryMapperGet.eq("product_id", productId);
queryMapperGet.eq("identifier", "get");
ProductServicesEntity getService = productServicesDao.selectOne(queryMapperGet);
QueryWrapper<ProductEventsEntity> queryMapperPost = new QueryWrapper<>();
queryMapperPost.eq("product_id", productId);
queryMapperPost.eq("identifier", "property");
ProductEventsEntity postEvent = productEventsDao.selectOne(queryMapperPost);
if (setService == null || getService == null || postEvent == null) {
throw new IotBusinessException("数据异常，默认功能定义不存在！");
}
long getId = getService.getId();
long setId = setService.getId();
long postId = postEvent.getId();
// 统一删除模板引入的参数 get set post
if (CollectionUtils.isNotEmpty(identifiers)) {
productServicesParamsDao.deleteByRefIdAndIdentifiersIn(getId, identifiers);
productServicesParamsDao.deleteByRefIdAndIdentifiersIn(setId, identifiers);
productEventsParamsDao.deleteByRefIdAndIdentifiersIn(postId, identidentifiers);
}
log.info("\n===>Debug#deleteAllRefObjectFunctions postId = {}, getId = {}, setId = {}, identifiers = {}", postId, getId, setId, identifiers);
productPropertiesDao.deleteAllRefObjectByProductId(productId);
List<ProductEventsEntity> productEventsEntities = productEventsDao.selectAllByProductIdAndCustomIsFalse(productId);
List<ProductServicesEntity> productServicesEntities = productServicesDao.selectAllByProductIdAndCustomIsFalse(productId);
// 清空服务、事件参数表
if (CollectionUtils.isNotEmpty(productServicesEntities)) {
List<Long> serviceParamsDel = productServicesEntities
.stream()
.map(ProductServicesEntity::getId)
.collect(Collectors.toList());
productServicesParamsDao.deleteByRefIds4ObjectRef(serviceParamsDel);
}
if (CollectionUtils.isNotEmpty(productEventsEntities)) {
List<Long> eventParamsDel = productEventsEntities
.stream()
.map(ProductEventsEntity::getId)
.collect(Collectors.toList());
productEventsParamsDao.deleteByRefIds(eventParamsDel);
}
// 清空产品类型的所有服务、事件功能定义
productPropertiesDao.deleteAllRefObjectByProductId(productId);
productEventsDao.deleteAllRefObjectByProductId(productId);
productServicesDao.deleteAllRefObjectByProductId(productId);
// 清空产品类型的中间表中的identifier记录
innerIdentifierDao.deleteAllByProductIdAndCustom(productId, 0);
// 将产品类型的模板信息清除
ProductsEntity productsEntity = new ProductsEntity();
productsEntity.setId(productId);
int ret = productsDao.updateProductObjectRefNullById(productsEntity);
if (ret < 1) {
log.error("并发过高，产品类型更新错误: {}", productId);
throw new IotBusinessException("产品类型更新错误!");
}
return ResponseDTO.succ();
}
private List<ProductEventsEntity> createProductEventsEntities(List<ObjectEventsEntity> objectEventsEntities, long productId) {
List<ProductEventsEntity> productEventsEntities = new ArrayList<>();
for (ObjectEventsEntity e : objectEventsEntities) {
ProductEventsEntity productEventsEntity = new ProductEventsEntity();
System.err.println("level: " + e.getLevel());
productEventsEntity
.setCustom(0)
.setDescription(e.getDescription())
.setIdentifier(e.getIdentifier())
.setName(e.getName())
.setRefId(e.getId())
.setType(e.getType())
.setLevel(e.getLevel() == null ? 0 : e.getLevel())
.setMethod(e.getMethod())
.setProductId(productId);
if (e.getRequired() == 1) {
productEventsEntity.setOriginalRequired(1).setUpdateRequired(1);
} else {
productEventsEntity.setOriginalRequired(0).setUpdateRequired(0);
}
log.info("=====>Debug#saveFunctions, productEventsEntity: " + productEventsEntity.getLevel());
productEventsEntities.add(productEventsEntity);
}
return productEventsEntities;
}
private List<ProductServicesEntity> createProductServicesEntities(List<ObjectServicesEntity> objectServicesEntities, long productId) {
List<ProductServicesEntity> productServicesEntities = new ArrayList<>();
for (ObjectServicesEntity s : objectServicesEntities) {
ProductServicesEntity productServicesEntity = new ProductServicesEntity();
productServicesEntity
.setCustom(0)
.setProductId(productId);
BeanUtils.copyProperties(s, productServicesEntity);
if (s.getRequired() == 1) {
productServicesEntity.setOriginalRequired(1).setUpdateRequired(1);
} else {
productServicesEntity.setOriginalRequired(0).setUpdateRequired(0);
}
productServicesEntities.add(productServicesEntity);
}
return productServicesEntities;
}
private List<ProductPropertiesEntity> createProductPropertiesEntities(List<ObjectPropertiesEntity> objectPropertiesEntities, Long productId) {List<ProductPropertiesEntity> productPropertiesEntities = new ArrayList<>();
for (ObjectPropertiesEntity p : objectPropertiesEntities) {
log.error("\n===>Debug#createProductPropertiesEntities {}", p);
ProductPropertiesEntity propertiesEntity = new ProductPropertiesEntity();
propertiesEntity.
.setProductId(productId)
.setUpdateRequired(0)
.setCustom(ProductRefEnum.FunctionType.MODEL_REF.getCode());
if (p.getRequired() == 1) {
BeanUtils.copyProperties(s, propertiesEntity);
} else {
propertiesEntity.setUpdateRequired(p.getRequired());
}
productPropertiesEntities.add(propertiesEntity);
}
return productPropertiesEntities;
}
@Transactional
public void createProductFunctionParamRecord(List<ProductPropertiesEntity> list, Long productId) {
List<ProductInnerIdentifierEntity> identifiers = innerIdentifierDao.selectByProductIdAndCustom(productId, 0);
Map<String, Integer> productIdAndIdentifier2RefMap = identifiers.stream().collect(Collectors.toMap(a -> a.getProductId() + a.getIdentifier(), ProductInnerIdentifierEntity::getRef));
long getServiceId = getProductServiceId(ProductRefEnum.DefaultIdentifierType.GET.getValue(), productId);
long postEventId = getProductEventId(productId);
long setServiceId = getProductServiceId(ProductRefEnum.DefaultIdentifierType.SET.getValue(), productId);
log.info("getServiceId = {}, setServiceId = {}", getServiceId, setServiceId);
List<ProductServicesParamsEntity> servicesParamsEntities = new ArrayList<>();
List<ProductEventsParamsEntity> eventsParamsEntities = new ArrayList<>();
for (ProductPropertiesEntity p : list) {
String access = p.getAccess();
ProductServicesParamsEntity getServiceParam = new ProductServicesParamsEntity().setCustom(0);
ProductServicesParamsEntity setServiceParam = new ProductServicesParamsEntity().setCustom(0);
ProductEventsParamsEntity postEventParam = new ProductEventsParamsEntity().setCustom(0);
String key = productId + p.getIdentifier();
switch (access) {
case "rwp": // 读、写服务参数加上报事件参数
getServiceParam.setDataType
.setRefId(getServiceId)
.setRef(productIdAndIdentifier2RefMap.get(key))
.setType(ServiceParamTypeEnum.ParamType.OUT_PARAM.getCode());
// 输入参数记录
setServiceParam.
.setRefId(setServiceId).setRef(productIdAndIdentifier2RefMap.get(key))
.setType(ServiceParamTypeEnum.ParamType.IN_PARAM.getCode());
servicesParamsEntities.add(getServiceParam);
servicesParamsEntities.add(setServiceParam);
postEventParam.
.setRefId(postEventId)
.setRef(productIdAndIdentifier2RefMap.get(key));
eventsParamsEntities.add(postEventParam);
break;
}
}
if(!CollectionUtils.isEmpty(servicesParamsEntities)){
log.info("引用模板，批量插入服务参数 type=1，services ={}",servicesParamsEntities.stream().filter(a->a.getType()==1).collect(Collectors.toList()));log.info("引用模板，批量插入服务参数 type=0，services = {}",servicesParamsEntities.stream().filter(a->a.getType()==0).collect(Collectors.toList()));productServicesParamsDao.insertBatch(servicesParamsEntities);
}
if(CollectionUtils.isNotEmpty(eventsParamsEntities)){
log.info("引用模板，批量插入事件参数 = {}",eventsParamsEntities);
productEventsParamsDao.insertBatch(eventsParamsEntities);
}
}
private List<ProductInnerIdentifierEntity> prepareProductIdentifiersWithEvents(List<ObjectEventsEntity> events, Long productId, int maxRef) {
List<ProductInnerIdentifierEntity> identifierEntities = new ArrayList<>(events.size());
for (ObjectEventsEntity p : events) {
maxRef++;
ProductInnerIdentifierEntity tmp = new ProductInnerIdentifierEntity();
tmp.setProductId(productId)
.setIdentifier(p.getIdentifier())
.setCustom(ProductRefEnum.FunctionType.MODEL_REF.getCode()); // 模板引入
tmp.setRef(maxRef);
identifierEntities.add(tmp);
}
return identifierEntities;
}
private Long getProductEventId(long productId) {
String identifierPost = "property"; // 默认生成的post对应的identifier为property
QueryWrapper<ProductEventsEntity> queryEventsWrapper = new QueryWrapper<>();
queryEventsWrapper.eq("identifier", identifierPost);
queryEventsWrapper.eq("product_id", productId);
ProductEventsEntity eventsEntity = productEventsDao.selectOne(queryEventsWrapper);
if (null == eventsEntity) { // 创建产品类型时，自动创建空的set、get服务,post事件，对应的identifier为property
throw new RuntimeException("引用物模板，产品类型id = " + productId + ", post(property) 事件查询异常，请联系管理员！");
}
return eventsEntity.getId();
}
private List<ProductInnerIdentifierEntity> prepareProductIdentifiersWithEvents(List<ObjectEventsEntity> events, Long productId, int maxRef) {
List<ProductInnerIdentifierEntity> identifierEntities = new ArrayList<>(events.size());
for (ObjectEventsEntity p : events) {
maxRef++;
ProductInnerIdentifierEntity tmp = new ProductInnerIdentifierEntity();
tmp.setProductId(productId)
.setIdentifier(p.getIdentifier())
.setCustom(ProductRefEnum.FunctionType.MODEL_REF.getCode()); // 模板引入
tmp.setRef(maxRef);
identifierEntities.add(tmp);
}
return identifierEntities;
}
private List<Long> getRetain(List<Long> source1, List<Long> source2) {
CollectionUtils.removeAll(source1, source2);
return source1;
}
private List<Long> getIntersection(List<Long> source1, List<Long> source2) {
List<Long> ids = new ArrayList<>();
if (CollectionUtils.isEmpty(source1) || CollectionUtils.isEmpty(source2)) {
return ids;
}
for (int i = 0; i < source1.size(); i++) {
Long eventId = source1.get(i);
for (int j = 0; j < source2.size(); j++) {
if (eventId.longValue() == source2.get(j).longValue()) {
ids.add(eventId);
}
}
}
return ids;
}
private List<ProductInnerIdentifierEntity> prepareProductIdentifiersWithProperties(List<ObjectPropertiesEntity> propertiesEntities, Long productId, int maxRef) {
List<ProductInnerIdentifierEntity> identifierEntities = new ArrayList<>(propertiesEntities.size());
for (ObjectPropertiesEntity p : propertiesEntities) {
maxRef++;
ProductInnerIdentifierEntity tmp = new ProductInnerIdentifierEntity();
tmp.setProductId(productId)
.setIdentifier(p.getIdentifier())
.setCustom(ProductRefEnum.FunctionType.MODEL_REF.getCode()); // 模板引入
tmp.setRef(maxRef);
identifierEntities.add(tmp);
}
log.info("模板引入：createProductIdentifiersWithProperties#identifierEntities = {}", identifierEntities);
return identifierEntities;
}
1562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
