feat(adm-diagram): 系统图相关接口实现

adm-business/adm-diagram/src/main/java/com/persagy/adm/diagram/core/impl/DataStrategyImpl.java

@@ -0,0 +1,268 @@
+package com.persagy.adm.diagram.core.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.StrUtil;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.persagy.adm.diagram.client.RwdClient;
+import com.persagy.adm.diagram.core.DataStrategy;
+import com.persagy.adm.diagram.core.model.Diagram;
+import com.persagy.adm.diagram.core.model.legend.Legend;
+import com.persagy.adm.diagram.core.model.template.DiagramTemplate;
+import com.persagy.adm.diagram.dao.DiagramMapper;
+import com.persagy.adm.diagram.dao.DiagramTypeMapper;
+import com.persagy.adm.diagram.dao.LegendMapper;
+import com.persagy.adm.diagram.dao.TemplateMapper;
+import com.persagy.adm.diagram.entity.*;
+import com.persagy.adm.diagram.util.ServiceUtil;
+import com.persagy.dmp.basic.model.QueryCriteria;
+import com.persagy.dmp.basic.model.QueryOperator;
+import com.persagy.dmp.basic.utils.JsonNodeUtils;
+import com.persagy.dmp.digital.client.DigitalObjectFacade;
+import com.persagy.dmp.digital.client.DigitalRelationFacade;
+import com.persagy.dmp.digital.entity.ObjectRelation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.cloud.client.discovery.DiscoveryClient;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.stream.Collectors;
+
+
+@Service("dataStrategyImpl")
+public class DataStrategyImpl implements DataStrategy {
+    @Autowired
+    private RwdClient rwdClient;
+    @Autowired
+    private ModelAdapter modelAdapter;
+    @Autowired
+    private ObjectMapper objectMapper;
+    @Autowired
+    private DiagramTypeMapper diagramTypeMapper;
+    @Autowired
+    private TemplateMapper templateMapper;
+    @Autowired
+    private LegendMapper legendMapper;
+    @Autowired
+    private DiagramMapper diagramMapper;
+    @Autowired
+    private DiscoveryClient discoveryClient;
+    @Autowired
+    @Qualifier("customThreadPool")
+    private ThreadPoolExecutor executor;
+
+    @Override
+    public List<DiagramType> getDiagramTypes() {
+        return diagramTypeMapper.getDiagramTypes();
+    }
+
+    @Override
+    public List<DiagramTemplate> getTemplates() {
+        List<TemplateEntity> templates = templateMapper.getTemplates();
+        if (CollectionUtil.isNotEmpty(templates)) {
+            return templates.stream().map(templateEntity ->
+                    modelAdapter.toTemplate(templateEntity)).collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<DiagramTemplate> getTemplates(String diagramType) {
+        List<TemplateEntity> templates = templateMapper.getTemplatesByType(diagramType);
+        if (CollectionUtil.isNotEmpty(templates)) {
+            return templates.stream().map(templateEntity ->
+                    modelAdapter.toTemplate(templateEntity)).collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public DiagramTemplate saveTemplate(DiagramTemplate template) {
+        TemplateEntity templateEntity = modelAdapter.toTemplateEntity(template);
+        templateMapper.saveTemplate(templateEntity);
+        return template;
+    }
+
+    @Override
+    public boolean deleteTemplate(String templateId) {
+        templateMapper.deleteByTemplateId(templateId);
+        return true;
+    }
+
+    @Override
+    public DiagramTemplate getTemplate(String templateId) {
+        TemplateEntity templateEntity = templateMapper.selectByTemplateId(templateId);
+        //TODO 没有数据返回一个空对象
+        return templateEntity != null ? modelAdapter.toTemplate(templateEntity) : new DiagramTemplate();
+    }
+
+    @Override
+    public List<Legend> getLegends(String systemCode) {
+        //TODO 这个systemCode 对应的是bt_system字段？
+        List<LegendEntity> legends = legendMapper.getLegends(systemCode);
+        if (CollectionUtil.isNotEmpty(legends)) {
+            return legends.stream().map(legendEntity ->
+                    modelAdapter.toLegend(legendEntity)).collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public Legend saveLegend(Legend legend, String systemCode) {
+        legend.setSystem(systemCode);
+        legendMapper.saveLegend(modelAdapter.toLegendEntity(legend));
+        return legend;
+    }
+
+    @Override
+    public boolean deleteLegend(String legendId, String systemCode) {
+        return legendMapper.deleteLegend(legendId, systemCode);
+    }
+
+    @Override
+    public Legend getLegend(String legendId, String systemCode) {
+        LegendEntity legendEntity = legendMapper.getLegend(legendId, systemCode);
+        //TODO 没有数据返回一个空对象
+        return legendEntity == null ? new Legend() : modelAdapter.toLegend(legendEntity);
+    }
+
+    @Override
+    public List<Legend> getLegendsForEquipment(String equipmentType) {
+        String systemCode = Optional.of(equipmentType).map(s -> s.substring(0, 4)).orElse(StrUtil.EMPTY);
+        return getLegends(systemCode);
+    }
+
+    @Override
+    public List<Diagram> getDiagrams(String projectId, String systemId, String groupCode) {
+        List<DiagramEntity> diagrams = diagramMapper.getDiagrams(null, projectId, systemId, groupCode);
+        if (CollectionUtil.isNotEmpty(diagrams)) {
+            return diagrams.stream().map(diagramEntity ->
+                    modelAdapter.toDiagram(diagramEntity)).collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<Diagram> getDiagrams(String diagramType, String projectId, String systemId, String groupCode) {
+        List<DiagramEntity> diagrams = diagramMapper.getDiagrams(diagramType,
+                projectId, systemId, groupCode);
+        if (CollectionUtil.isNotEmpty(diagrams)) {
+            return diagrams.stream().map(diagramEntity ->
+                    modelAdapter.toDiagram(diagramEntity)).collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public Diagram saveDiagram(Diagram diagram) {
+        DiagramEntity diagramEntity = modelAdapter.toDiagramEntity(diagram);
+        diagramMapper.saveDiagram(diagramEntity);
+        return diagram;
+    }
+
+    @Override
+    public boolean deleteDiagram(String diagramId) {
+        return diagramMapper.deleteByDiagramId(diagramId);
+    }
+
+    @Override
+    public Diagram getDiagram(String diagramId) {
+        DiagramEntity diagramEntity = diagramMapper.getDiagram(diagramId);
+        //TODO 没有数据返回一个空对象
+        return diagramEntity == null ? new Diagram() : modelAdapter.toDiagram(diagramEntity);
+    }
+
+    @Override
+    public List<ObjectNode> loadObjectsByType(List<String> equipmentTypes, String projectId,
+                                              String systemId, String groupCode) {
+        //TODO 是否需要校验 equipmentTypes 、objectIds
+        QueryCriteria criteria = ServiceUtil.getQueryCriteria(objectMapper, "equipment");
+        ArrayNode types = criteria.getCriteria().putArray("classCode");
+        Optional.ofNullable(equipmentTypes).ifPresent(stringList ->
+                stringList.forEach(types::add));
+
+        if (StrUtil.isNotBlank(systemId)) {
+            ObjectNode on = JsonNodeFactory.instance.objectNode();
+            on.put(ObjectRelation.REL_CODE_HUM, "Sy2Eq");
+            on.put(ObjectRelation.OBJ_FROM_HUM, systemId);
+            criteria.getCriteria().set(QueryOperator.RELATION_TO.getIndex(), on);
+        }
+
+        return DigitalObjectFacade.query(groupCode, projectId, null, null, criteria);
+    }
+
+    @Override
+    public List<ObjectNode> loadRelationsByType(List<String[]> relationTypes, List<String> objectIds,
+                                                String projectId, String groupCode) {
+        //TODO 是否需要校验 relationTypes 、objectIds
+        //查询到的所有关系
+        List<ObjectRelation> allRelations = queryRelationsByObjIds(projectId, groupCode, objectIds);
+        Set<String> collect = allRelations.stream().map(ObjectRelation::getRelCode).collect(Collectors.toSet());
+        //所有关系类型
+        Set<String> types = new HashSet<>();
+        Optional.ofNullable(relationTypes).ifPresent(relations ->
+                relations.forEach(strings -> types.addAll(Arrays.asList(strings))));
+        Set<String> typeSet = types.stream().filter(Objects::nonNull).collect(Collectors.toSet());
+        //最终符合结果的关系
+        if (CollectionUtil.isNotEmpty(typeSet)) {
+            List<ObjectRelation> res = allRelations.stream().filter(objectRelation ->
+                    typeSet.contains(objectRelation.getRelCode())).collect(Collectors.toList());
+            //转换并返回
+            return JsonNodeUtils.toListNode(res, null, null);
+        }
+        return JsonNodeUtils.toListNode(allRelations, null, null);
+    }
+
+    private List<ObjectRelation> queryRelationsByObjIds(String projectId, String groupCode, List<String> objectIds) {
+        List<ObjectRelation> resultList = new ArrayList<>();
+        //obj_from
+        CompletableFuture<List<ObjectRelation>> fromFuture = CompletableFuture.supplyAsync(() -> {
+            QueryCriteria criteria = ServiceUtil.getQueryCriteria(objectMapper);
+            ArrayNode objFrom = criteria.getCriteria().putArray("objFrom");
+            Optional.ofNullable(objectIds).ifPresent(strings -> strings.forEach(objFrom::add));
+            return DigitalRelationFacade.query(groupCode, projectId, null, null, criteria);
+        }, executor);
+        //obj_to
+        CompletableFuture<List<ObjectRelation>> toFuture = CompletableFuture.supplyAsync(() -> {
+            QueryCriteria criteria = ServiceUtil.getQueryCriteria(objectMapper);
+            ArrayNode objTo = criteria.getCriteria().putArray("objTo");
+            Optional.ofNullable(objectIds).ifPresent(strings -> strings.forEach(objTo::add));
+            return DigitalRelationFacade.query(groupCode, projectId, null, null, criteria);
+        }, executor);
+
+        CompletableFuture.allOf(fromFuture, toFuture).join();
+
+        try {
+            resultList.addAll(fromFuture.get());
+            resultList.addAll(toFuture.get());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return resultList.stream().distinct().filter(Objects::nonNull).collect(Collectors.toList());
+    }
+
+    @Override
+    public List<ObjectNode> loadObjectsById(List<String> objectIds, String projectId, String groupCode) {
+        //TODO 是否需要校验 objectIds
+        QueryCriteria criteria = ServiceUtil.getQueryCriteria(objectMapper, "equipment");
+        ArrayNode arr = criteria.getCriteria().putArray("id");
+        Optional.ofNullable(objectIds).ifPresent(ids -> ids.forEach(arr::add));
+        return DigitalObjectFacade.query(groupCode, projectId, null, null, criteria);
+    }
+
+    @Override
+    public List<ObjectNode> loadRelationsById(List<String> relationIds, String projectId, String groupCode) {
+        //TODO 是否需要校验 relationIds
+        QueryCriteria criteria = ServiceUtil.getQueryCriteria(objectMapper);
+        ArrayNode nodes = criteria.getCriteria().putArray("id");
+        Optional.ofNullable(relationIds).ifPresent(ids -> ids.forEach(nodes::add));
+
+        List<ObjectRelation> result = DigitalRelationFacade.query(groupCode, projectId, null, null, criteria);
+        return JsonNodeUtils.toListNode(result, null, null);
+    }
+}