TOSCA Consolidation Data handling - Refactoring

Create new Interface, Base and Implementation classes for Consolidation Data Handlers

Change-Id: I9638a7b57321aca00b458b244b278807a99b25f2
Issue-ID: SDC-1330
Signed-off-by: eleonorali <eleonoral@amdocs.com>
Signed-off-by: vempo <vitaliy.emporopulo@amdocs.com>

8 files changed, 1463 insertions, 923 deletions

diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ComputeConsolidationDataHandler.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ComputeConsolidationDataHandler.java
new file mode 100644
index 0000000000..cc27dd9806
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ComputeConsolidationDataHandler.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
+
+import java.util.Objects;
+import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
+import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
+import org.openecomp.sdc.heat.datatypes.model.Resource;
+import org.openecomp.sdc.tosca.services.DataModelUtil;
+import org.openecomp.sdc.tosca.services.ToscaUtil;
+import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
+import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
+import org.openecomp.sdc.translator.services.heattotosca.NameExtractor;
+
+public class ComputeConsolidationDataHandler implements ConsolidationDataHandler {
+
+    private final ComputeConsolidationData computeConsolidationData;
+
+    ComputeConsolidationDataHandler(ComputeConsolidationData computeConsolidationData) {
+        this.computeConsolidationData = computeConsolidationData;
+    }
+
+    @Override
+    public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
+                                     RequirementAssignment requirementAssignment) {
+
+        String translatedSourceNodeId = translateTo.getTranslatedId();
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, translatedSourceNodeId);
+        String nodeType = computeNodeTemplate.getType();
+
+        EntityConsolidationData entityConsolidationData =
+                getComputeTemplateConsolidationData(translateTo, nodeType, translatedSourceNodeId);
+
+        if (Objects.nonNull(entityConsolidationData)) {
+            entityConsolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
+        }
+    }
+
+    @Override
+    public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
+                                    String dependentNodeTemplateId, String targetResourceId, String requirementId,
+                                    RequirementAssignment requirementAssignment) {
+
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, dependentNodeTemplateId);
+        String nodeType = getNodeType(nodeTemplate, translateTo, targetResourceId, dependentNodeTemplateId);
+        EntityConsolidationData entityConsolidationData =
+                getComputeTemplateConsolidationData(translateTo, nodeType, dependentNodeTemplateId);
+
+        if (Objects.nonNull(entityConsolidationData)) {
+            entityConsolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment);
+        }
+    }
+
+    @Override
+    public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
+            HeatOrchestrationTemplate heatOrchestrationTemplate, String paramName, String contrailSharedResourceId,
+            String sharedTranslatedResourceId) {
+
+        NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, sharedTranslatedResourceId);
+        EntityConsolidationData entityConsolidationData =
+                getComputeTemplateConsolidationData(serviceTemplate, nodeTemplate.getType(),
+                        sharedTranslatedResourceId);
+
+        if (Objects.nonNull(entityConsolidationData)) {
+            entityConsolidationData.removeParamNameFromAttrFuncList(paramName);
+        }
+    }
+
+    private ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
+            TranslateTo translateTo, String computeNodeType, String computeNodeTemplateId) {
+
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        return getComputeTemplateConsolidationData(serviceTemplate, computeNodeType, computeNodeTemplateId);
+    }
+
+    private ComputeTemplateConsolidationData getComputeTemplateConsolidationData(ServiceTemplate serviceTemplate,
+            String computeNodeType, String computeNodeTemplateId) {
+
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+
+        FileComputeConsolidationData fileComputeConsolidationData =
+                computeConsolidationData.getFileComputeConsolidationData(serviceTemplateFileName);
+        if (fileComputeConsolidationData == null) {
+            fileComputeConsolidationData = new FileComputeConsolidationData();
+            computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
+                    fileComputeConsolidationData);
+        }
+
+        TypeComputeConsolidationData typeComputeConsolidationData =
+                fileComputeConsolidationData.getTypeComputeConsolidationData(computeNodeType);
+        if (typeComputeConsolidationData == null) {
+            typeComputeConsolidationData = new TypeComputeConsolidationData();
+            fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType, typeComputeConsolidationData);
+        }
+
+        ComputeTemplateConsolidationData computeTemplateConsolidationData =
+                typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
+        if (computeTemplateConsolidationData == null) {
+            computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
+            computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
+            typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
+                    computeTemplateConsolidationData);
+        }
+
+        return computeTemplateConsolidationData;
+    }
+
+    private String getNodeType(NodeTemplate computeNodeTemplate, TranslateTo translateTo, String targetResourceId,
+            String nodeTemplateId) {
+
+        if (Objects.isNull(computeNodeTemplate)) {
+            Resource targetResource = translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
+            NameExtractor nodeTypeNameExtractor = TranslationContext.getNameExtractorImpl(targetResource.getType());
+            return nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate()
+                                    .getResources().get(nodeTemplateId), nodeTemplateId, nodeTemplateId);
+        }
+
+        return computeNodeTemplate.getType();
+    }
+}
\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationData.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationData.java
index 20cc3be3cd..c46e7450e5 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationData.java
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationData.java
@@ -1,81 +1,139 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
 
-/**
- * The type Consolidation data.
- */
+import java.util.Optional;
+import org.openecomp.sdc.translator.services.heattotosca.ConsolidationEntityType;
+
 public class ConsolidationData {
 
-  //Compute consolidation data
-  private ComputeConsolidationData computeConsolidationData;
-
-  //Port Consolidation data
-  private PortConsolidationData portConsolidationData;
-
-  //Nested Consolidation data
-  private NestedConsolidationData nestedConsolidationData;
-
-
-  /**
-   * Instantiates a new Consolidation data.
-   */
-  public ConsolidationData() {
-    computeConsolidationData = new ComputeConsolidationData();
-    portConsolidationData = new PortConsolidationData();
-    nestedConsolidationData = new NestedConsolidationData();
-  }
-
-  /**
-   * Gets compute consolidation data.
-   *
-   * @return the compute consolidation data
-   */
-  public ComputeConsolidationData getComputeConsolidationData() {
-    return computeConsolidationData;
-  }
-
-  /**
-   * Sets compute consolidation data.
-   *
-   * @param computeConsolidationData the compute consolidation data
-   */
-  public void setComputeConsolidationData(ComputeConsolidationData computeConsolidationData) {
-    this.computeConsolidationData = computeConsolidationData;
-  }
-
-  /**
-   * Gets port consolidation data.
-   *
-   * @return the port consolidation data
-   */
-  public PortConsolidationData getPortConsolidationData() {
-    return portConsolidationData;
-  }
-
-  /**
-   * Sets port consolidation data.
-   *
-   * @param portConsolidationData the port consolidation data
-   */
-  public void setPortConsolidationData(
-      PortConsolidationData portConsolidationData) {
-    this.portConsolidationData = portConsolidationData;
-  }
-
-  /**
-   * Gets nested consolidation data.
-   *
-   * @return the nested consolidation data
-   */
-  public NestedConsolidationData getNestedConsolidationData() {
-    return nestedConsolidationData;
-  }
-
-  /**
-   * Sets nested consolidation data.
-   *
-   * @param nestedConsolidationData the nested consolidation data
-   */
-  public void setNestedConsolidationData(NestedConsolidationData nestedConsolidationData) {
-    this.nestedConsolidationData = nestedConsolidationData;
-  }
+    private ComputeConsolidationData computeConsolidationData;
+    private final ComputeConsolidationDataHandler computeConsolidationDataHandler;
+
+    private PortConsolidationData portConsolidationData;
+    private final PortConsolidationDataHandler portConsolidationDataHandler;
+    private final SubInterfaceConsolidationDataHandler subInterfaceConsolidationDataHandler;
+
+    private NestedConsolidationData nestedConsolidationData;
+    private final NestedConsolidationDataHandler nestedConsolidationDataHandler;
+
+    public ConsolidationData() {
+
+        computeConsolidationData = new ComputeConsolidationData();
+        computeConsolidationDataHandler = new ComputeConsolidationDataHandler(computeConsolidationData);
+
+        portConsolidationData = new PortConsolidationData();
+        portConsolidationDataHandler = new PortConsolidationDataHandler(portConsolidationData);
+        subInterfaceConsolidationDataHandler = new SubInterfaceConsolidationDataHandler(portConsolidationData);
+
+        nestedConsolidationData = new NestedConsolidationData();
+        nestedConsolidationDataHandler = new NestedConsolidationDataHandler(nestedConsolidationData);
+
+    }
+
+    /**
+     * Get Consolidation data handler by entity type.
+     *
+     * @return If there is no consolidation handler for a type, return an empty {@link Optional}.
+     */
+    public Optional<ConsolidationDataHandler> getConsolidationDataHandler(ConsolidationEntityType type) {
+
+        switch (type) {
+            case COMPUTE:
+                return Optional.of(getComputeConsolidationDataHelper());
+            case PORT:
+                return Optional.of(getPortConsolidationDataHandler());
+            case SUB_INTERFACE:
+                return Optional.of(getSubInterfaceConsolidationDataHandler());
+            case NESTED:
+            case VFC_NESTED:
+                return Optional.of(getNestedConsolidationDataHandler());
+            default:
+                return Optional.empty();
+        }
+    }
+
+    public ComputeConsolidationDataHandler getComputeConsolidationDataHelper() {
+        return computeConsolidationDataHandler;
+    }
+
+    public PortConsolidationDataHandler getPortConsolidationDataHandler() {
+        return portConsolidationDataHandler;
+    }
+
+    public NestedConsolidationDataHandler getNestedConsolidationDataHandler() {
+        return nestedConsolidationDataHandler;
+    }
+
+    public SubInterfaceConsolidationDataHandler getSubInterfaceConsolidationDataHandler() {
+        return subInterfaceConsolidationDataHandler;
+    }
+
+    /**
+     * Gets compute consolidation data.
+     *
+     * @return the compute consolidation data
+     */
+    public ComputeConsolidationData getComputeConsolidationData() {
+        return computeConsolidationData;
+    }
+
+    /**
+     * Sets compute consolidation data.
+     *
+     * @param computeConsolidationData the compute consolidation data
+     */
+    public void setComputeConsolidationData(ComputeConsolidationData computeConsolidationData) {
+        this.computeConsolidationData = computeConsolidationData;
+    }
+
+    /**
+     * Gets port consolidation data.
+     *
+     * @return the port consolidation data
+     */
+    public PortConsolidationData getPortConsolidationData() {
+        return portConsolidationData;
+    }
+
+    /**
+     * Sets port consolidation data.
+     *
+     * @param portConsolidationData the port consolidation data
+     */
+    public void setPortConsolidationData(PortConsolidationData portConsolidationData) {
+        this.portConsolidationData = portConsolidationData;
+    }
+
+    /**
+     * Gets nested consolidation data.
+     *
+     * @return the nested consolidation data
+     */
+    public NestedConsolidationData getNestedConsolidationData() {
+        return nestedConsolidationData;
+    }
+
+    /**
+     * Sets nested consolidation data.
+     *
+     * @param nestedConsolidationData the nested consolidation data
+     */
+    public void setNestedConsolidationData(NestedConsolidationData nestedConsolidationData) {
+        this.nestedConsolidationData = nestedConsolidationData;
+    }
 }
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationDataHandler.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationDataHandler.java
new file mode 100644
index 0000000000..bbd26342b1
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ConsolidationDataHandler.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
+
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
+import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
+import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
+
+public interface ConsolidationDataHandler {
+
+    /**
+     * Add node connected out from current consolidation entity.
+     *
+     * @param nodeTemplateId        the node template id of target node - node connected out from current node
+     * @param requirementId         the requirement id of requirement assignment
+     * @param requirementAssignment the requirement assignment data connected to target node
+     */
+    void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId,
+                                     String requirementId, RequirementAssignment requirementAssignment);
+
+    /**
+     * Add source node connected in to target node consolidation entity.
+     *
+     * @param sourceNodeTemplateId  the node template id of source node connected to consolidation entity
+     * @param targetNodeTemplateId  the node template id of consolidation entity node
+     * @param targetResourceId      the resource id of consolidation entity node
+     * @param requirementId         the requirement id of source node
+     * @param requirementAssignment the requirement assignment data of source node
+     */
+    void addNodesConnectedIn(TranslateTo translateTo,  String sourceNodeTemplateId,
+                                    String targetNodeTemplateId,
+                                    String targetResourceId, String requirementId,
+                                    RequirementAssignment requirementAssignment);
+
+    void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
+                                                HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                String paramName, String contrailSharedResourceId,
+                                                String sharedTranslatedResourceId);
+}
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/EntityConsolidationData.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/EntityConsolidationData.java
index 0b4b454adf..06b1a58718 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/EntityConsolidationData.java
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/EntityConsolidationData.java
@@ -1,245 +1,275 @@
-package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
 
 /**
  * The type Entity consolidation data.
  */
 public class EntityConsolidationData {
 
-  private String nodeTemplateId;
-
-  //groups that point to this entity node template
-  private List<String> groupIds;
-
-  // key - node template id which has connection to this entity
-  // value - List of Requirement assignment data which connect to this entity
-  private Map<String, List<RequirementAssignmentData>> nodesConnectedIn;
-
-  // key - node template id which connected from this entity
-  // List of Requirement assignment data which connect to the key node template id
-  private Map<String, List<RequirementAssignmentData>> nodesConnectedOut;
-
-  //key - node template id which include get attribute function from this entity
-  //key - node template id which include get attribute function from this entity
-  //value - List of getAttr data
-  private Map<String, List<GetAttrFuncData>> nodesGetAttrIn;
-
-  //key - node template id which is pointed by this entity using get attribute function
-  //value - List of getAttr data
-  private Map<String, List<GetAttrFuncData>> nodesGetAttrOut;
-
-  //List of getAttr data
-  private List<GetAttrFuncData> outputParametersGetAttrIn;
-
-  /**
-   * Gets node template id.
-   *
-   * @return the node template id
-   */
-  public String getNodeTemplateId() {
-    return nodeTemplateId;
-  }
-
-  /**
-   * Sets node template id.
-   *
-   * @param nodeTemplateId the node template id
-   */
-  public void setNodeTemplateId(String nodeTemplateId) {
-    this.nodeTemplateId = nodeTemplateId;
-  }
-
-  /**
-   * Gets group ids point to me.
-   *
-   * @return the group ids point to me
-   */
-  public List<String> getGroupIds() {
-    return groupIds;
-  }
-
-  /**
-   * Sets group ids point to me.
-   *
-   * @param groupIds the group ids point to me
-   */
-  public void setGroupIds(List<String> groupIds) {
-    this.groupIds = groupIds;
-  }
-
-
-  /**
-   * Sets node connected to me.
-   *
-   * @param nodesConnectedIn the node connected to me
-   */
-  public void setNodesConnectedIn(Map<String, List<RequirementAssignmentData>> nodesConnectedIn) {
-    this.nodesConnectedIn = nodesConnectedIn;
-  }
-
-  /**
-   * Add nodeConnectedIn.
-   *
-   * @param nodeTemplateId        the node template id which has connection to me
-   * @param requirementId         the requirement id
-   * @param requirementAssignment the requirement assignment
-   */
-  public void addNodesConnectedIn(String nodeTemplateId, String requirementId,
+    private String nodeTemplateId;
+
+    //groups that point to this entity node template
+    private List<String> groupIds;
+
+    // key - node template id which has connection to this entity
+    // value - List of Requirement assignment data which connect to this entity
+    private Map<String, List<RequirementAssignmentData>> nodesConnectedIn;
+
+    // key - node template id which connected from this entity
+    // List of Requirement assignment data which connect to the key node template id
+    private Map<String, List<RequirementAssignmentData>> nodesConnectedOut;
+
+    //key - node template id which include get attribute function from this entity
+    //key - node template id which include get attribute function from this entity
+    //value - List of getAttr data
+    private Map<String, List<GetAttrFuncData>> nodesGetAttrIn;
+
+    //key - node template id which is pointed by this entity using get attribute function
+    //value - List of getAttr data
+    private Map<String, List<GetAttrFuncData>> nodesGetAttrOut;
+
+    //List of getAttr data
+    private List<GetAttrFuncData> outputParametersGetAttrIn;
+
+    /**
+    * Gets node template id.
+    *
+    * @return the node template id
+    */
+    public String getNodeTemplateId() {
+        return nodeTemplateId;
+    }
+
+    /**
+    * Sets node template id.
+    *
+    * @param nodeTemplateId the node template id
+    */
+    public void setNodeTemplateId(String nodeTemplateId) {
+        this.nodeTemplateId = nodeTemplateId;
+    }
+
+    /**
+    * Gets group ids point to me.
+    *
+    * @return the group ids point to me
+    */
+    public List<String> getGroupIds() {
+        return groupIds;
+    }
+
+    /**
+    * Sets group ids point to me.
+    *
+    * @param groupIds the group ids point to me
+    */
+    public void setGroupIds(List<String> groupIds) {
+        this.groupIds = groupIds;
+    }
+
+
+    /**
+    * Sets node connected to me.
+    *
+    * @param nodesConnectedIn the node connected to me
+    */
+    public void setNodesConnectedIn(Map<String, List<RequirementAssignmentData>> nodesConnectedIn) {
+        this.nodesConnectedIn = nodesConnectedIn;
+    }
+
+    /**
+    * Add nodeConnectedIn.
+    *
+    * @param nodeTemplateId        the node template id which has connection to me
+    * @param requirementId         the requirement id
+    * @param requirementAssignment the requirement assignment
+    */
+    public void addNodesConnectedIn(String nodeTemplateId, String requirementId,
                                   RequirementAssignment requirementAssignment) {
-    if (this.nodesConnectedIn == null) {
-      this.nodesConnectedIn = new HashMap<>();
-    }
-    this.nodesConnectedIn.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
-    this.nodesConnectedIn.get(nodeTemplateId).add(new RequirementAssignmentData(requirementId,
-        requirementAssignment));
-  }
-
-  /**
-   * Gets node connected to me.
-   *
-   * @return the node connected to me
-   */
-  public Map<String, List<RequirementAssignmentData>> getNodesConnectedIn() {
-    return nodesConnectedIn;
-  }
-
-
-  /**
-   * Gets node connected from me.
-   *
-   * @return the node connected from me
-   */
-  public Map<String, List<RequirementAssignmentData>> getNodesConnectedOut() {
-    return nodesConnectedOut;
-  }
-
-  /**
-   * Sets node connected from me.
-   *
-   * @param nodesConnectedOut the node connected from me
-   */
-  public void setNodesConnectedOut(
-      Map<String, List<RequirementAssignmentData>> nodesConnectedOut) {
-    this.nodesConnectedOut = nodesConnectedOut;
-  }
-
-  /**
-   * Add nodeConnectedOut.
-   *
-   * @param nodeTemplateId        the node template id which is connected from me
-   * @param requirementId         the requirement id
-   * @param requirementAssignment the requirement assignment
-   */
-  public void addNodesConnectedOut(String nodeTemplateId, String requirementId,
-                                   RequirementAssignment
-                                       requirementAssignment) {
-    if (this.nodesConnectedOut == null) {
-      this.nodesConnectedOut = new HashMap<>();
-    }
-    this.nodesConnectedOut.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
-    this.nodesConnectedOut.get(nodeTemplateId).add(new RequirementAssignmentData(requirementId,
-        requirementAssignment));
-  }
-
-  /**
-   * Gets nodes get attr in.
-   *
-   * @return the get attr in
-   */
-  public Map<String, List<GetAttrFuncData>> getNodesGetAttrIn() {
-    return nodesGetAttrIn;
-  }
-
-  /**
-   * Sets nodes get attr in.
-   *
-   * @param nodesGetAttrIn the get attr in
-   */
-  public void setNodesGetAttrIn(
-      Map<String, List<GetAttrFuncData>> nodesGetAttrIn) {
-    this.nodesGetAttrIn = nodesGetAttrIn;
-  }
-
-  /**
-   * Add nodes get attr in data.
-   *
-   * @param nodeTemplateId  the node template id
-   * @param getAttrFuncData get attr data
-   */
-  public void addNodesGetAttrIn(String nodeTemplateId, GetAttrFuncData getAttrFuncData) {
-    if (nodesGetAttrIn == null) {
-      nodesGetAttrIn = new HashMap<>();
-    }
-    this.nodesGetAttrIn.putIfAbsent(nodeTemplateId, new ArrayList<>());
-    this.nodesGetAttrIn.get(nodeTemplateId).add(getAttrFuncData);
-  }
-
-  /**
-   * Gets output parameters get attr from me.
-   *
-   * @return the get attr from me
-   */
-  public List<GetAttrFuncData> getOutputParametersGetAttrIn() {
-    return outputParametersGetAttrIn;
-  }
-
-  /**
-   * Sets output parameters get attr from me.
-   *
-   * @param outputParametersGetAttrIn the output parameters get attr from me
-   */
-  public void setOutputParametersGetAttrIn(List<GetAttrFuncData> outputParametersGetAttrIn) {
-    this.outputParametersGetAttrIn = outputParametersGetAttrIn;
-  }
-
-  /**
-   * Add output parameters get attr data.
-   *
-   * @param getAttrFuncData get attr data
-   */
-  public void addOutputParamGetAttrIn(GetAttrFuncData getAttrFuncData) {
-    if (outputParametersGetAttrIn == null) {
-      outputParametersGetAttrIn = new ArrayList<>();
-    }
-    this.outputParametersGetAttrIn.add(getAttrFuncData);
-  }
-
-  /**
-   * Gets nodes get attr out.
-   *
-   * @return the get attr out
-   */
-  public Map<String, List<GetAttrFuncData>> getNodesGetAttrOut() {
-    return nodesGetAttrOut;
-  }
-
-  /**
-   * Sets nodes get attr out.
-   *
-   * @param nodesGetAttrOut the get attr out
-   */
-  public void setNodesGetAttrOut(
-      Map<String, List<GetAttrFuncData>> nodesGetAttrOut) {
-    this.nodesGetAttrOut = nodesGetAttrOut;
-  }
-
-  /**
-   * Add nodes get attr out data.
-   *
-   * @param nodeTemplateId  the node template id
-   * @param getAttrFuncData get attr data
-   */
-  public void addNodesGetAttrOut(String nodeTemplateId, GetAttrFuncData getAttrFuncData) {
-    if (nodesGetAttrOut == null) {
-      nodesGetAttrOut = new HashMap<>();
-    }
-    this.nodesGetAttrOut.putIfAbsent(nodeTemplateId, new ArrayList<>());
-    this.nodesGetAttrOut.get(nodeTemplateId).add(getAttrFuncData);
-  }
+
+        if (this.nodesConnectedIn == null) {
+            this.nodesConnectedIn = new HashMap<>();
+        }
+
+        this.nodesConnectedIn.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
+        this.nodesConnectedIn.get(nodeTemplateId).add(
+                new RequirementAssignmentData(requirementId, requirementAssignment));
+    }
+
+    /**
+    * Gets node connected to me.
+    *
+    * @return the node connected to me
+    */
+    public Map<String, List<RequirementAssignmentData>> getNodesConnectedIn() {
+        return nodesConnectedIn;
+    }
+
+
+    /**
+    * Gets node connected from me.
+    *
+    * @return the node connected from me
+    */
+    public Map<String, List<RequirementAssignmentData>> getNodesConnectedOut() {
+        return nodesConnectedOut;
+    }
+
+    /**
+    * Sets node connected from me.
+    *
+    * @param nodesConnectedOut the node connected from me
+    */
+    public void setNodesConnectedOut(Map<String, List<RequirementAssignmentData>> nodesConnectedOut) {
+        this.nodesConnectedOut = nodesConnectedOut;
+    }
+
+    /**
+    * Add nodeConnectedOut.
+    *
+    * @param nodeTemplateId        the node template id which is connected from me
+    * @param requirementId         the requirement id
+    * @param requirementAssignment the requirement assignment
+    */
+    public void addNodesConnectedOut(String nodeTemplateId, String requirementId,
+                                   RequirementAssignment requirementAssignment) {
+
+        if (this.nodesConnectedOut == null) {
+            this.nodesConnectedOut = new HashMap<>();
+        }
+
+        this.nodesConnectedOut.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
+        this.nodesConnectedOut.get(nodeTemplateId).add(
+                new RequirementAssignmentData(requirementId, requirementAssignment));
+    }
+
+    /**
+    * Gets nodes get attr in.
+    *
+    * @return the get attr in
+    */
+    public Map<String, List<GetAttrFuncData>> getNodesGetAttrIn() {
+        return nodesGetAttrIn;
+    }
+
+    /**
+    * Sets nodes get attr in.
+    *
+    * @param nodesGetAttrIn the get attr in
+    */
+    public void setNodesGetAttrIn(Map<String, List<GetAttrFuncData>> nodesGetAttrIn) {
+        this.nodesGetAttrIn = nodesGetAttrIn;
+    }
+
+    /**
+    * Add nodes get attr in data.
+    *
+    * @param nodeTemplateId  the node template id
+    * @param getAttrFuncData get attr data
+    */
+    public void addNodesGetAttrIn(String nodeTemplateId, GetAttrFuncData getAttrFuncData) {
+
+        if (nodesGetAttrIn == null) {
+            nodesGetAttrIn = new HashMap<>();
+        }
+
+        this.nodesGetAttrIn.putIfAbsent(nodeTemplateId, new ArrayList<>());
+        this.nodesGetAttrIn.get(nodeTemplateId).add(getAttrFuncData);
+    }
+
+    /**
+    * Gets output parameters get attr from me.
+    *
+    * @return the get attr from me
+    */
+    public List<GetAttrFuncData> getOutputParametersGetAttrIn() {
+        return outputParametersGetAttrIn;
+    }
+
+    /**
+    * Sets output parameters get attr from me.
+    *
+    * @param outputParametersGetAttrIn the output parameters get attr from me
+    */
+    public void setOutputParametersGetAttrIn(List<GetAttrFuncData> outputParametersGetAttrIn) {
+        this.outputParametersGetAttrIn = outputParametersGetAttrIn;
+    }
+
+    /**
+    * Add output parameters get attr data.
+    *
+    * @param getAttrFuncData get attr data
+    */
+    public void addOutputParamGetAttrIn(GetAttrFuncData getAttrFuncData) {
+
+        if (outputParametersGetAttrIn == null) {
+            outputParametersGetAttrIn = new ArrayList<>();
+        }
+
+        this.outputParametersGetAttrIn.add(getAttrFuncData);
+    }
+
+    /**
+    * Gets nodes get attr out.
+    *
+    * @return the get attr out
+    */
+    public Map<String, List<GetAttrFuncData>> getNodesGetAttrOut() {
+        return nodesGetAttrOut;
+    }
+
+    /**
+    * Sets nodes get attr out.
+    *
+    * @param nodesGetAttrOut the get attr out
+    */
+    public void setNodesGetAttrOut(Map<String, List<GetAttrFuncData>> nodesGetAttrOut) {
+        this.nodesGetAttrOut = nodesGetAttrOut;
+    }
+
+    /**
+    * Add nodes get attr out data.
+    *
+    * @param nodeTemplateId  the node template id
+    * @param getAttrFuncData get attr data
+    */
+    public void addNodesGetAttrOut(String nodeTemplateId, GetAttrFuncData getAttrFuncData) {
+
+        if (nodesGetAttrOut == null) {
+            nodesGetAttrOut = new HashMap<>();
+        }
+
+        this.nodesGetAttrOut.putIfAbsent(nodeTemplateId, new ArrayList<>());
+        this.nodesGetAttrOut.get(nodeTemplateId).add(getAttrFuncData);
+    }
+
+    public void removeParamNameFromAttrFuncList(String paramName) {
+
+        if (outputParametersGetAttrIn == null) {
+            return;
+        }
+
+        outputParametersGetAttrIn.removeIf(outputParameters -> paramName.equals(outputParameters.getFieldName()));
+    }
 }
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/NestedConsolidationDataHandler.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/NestedConsolidationDataHandler.java
new file mode 100644
index 0000000000..f7c877074d
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/NestedConsolidationDataHandler.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
+
+import java.util.Objects;
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
+import org.openecomp.core.utilities.file.FileUtils;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
+import org.openecomp.sdc.tosca.services.ToscaUtil;
+import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
+import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
+import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
+
+public class NestedConsolidationDataHandler implements ConsolidationDataHandler {
+
+    private final NestedConsolidationData nestedConsolidationData;
+
+    public NestedConsolidationDataHandler(NestedConsolidationData nestedConsolidationData) {
+        this.nestedConsolidationData = nestedConsolidationData;
+    }
+
+    @Override
+    public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
+                                            RequirementAssignment requirementAssignment) {
+        EntityConsolidationData entityConsolidationData =
+                getNestedTemplateConsolidationData(translateTo, translateTo.getHeatFileName(),
+                        translateTo.getTranslatedId());
+
+        if (Objects.nonNull(entityConsolidationData)) {
+            entityConsolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
+        }
+    }
+
+    @Override
+    public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
+                                           String dependentNodeTemplateId, String targetResourceId,
+                                           String requirementId, RequirementAssignment requirementAssignment) {
+
+        EntityConsolidationData entityConsolidationData =
+                getNestedTemplateConsolidationData(translateTo, translateTo.getHeatFileName(), dependentNodeTemplateId);
+
+        if (Objects.nonNull(entityConsolidationData)) {
+            entityConsolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment);
+        }
+
+    }
+
+    @Override
+    public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
+                                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                       String paramName,
+                                                       String contrailSharedResourceId,
+                                                       String sharedTranslatedResourceId) {
+
+        throw new UnsupportedOperationException(
+                "API removeParamNameFromAttrFuncList not supported for NestedConsolidationDataHandler");
+
+    }
+
+    private NestedTemplateConsolidationData getNestedTemplateConsolidationData(TranslateTo translateTo,
+                                                                                      String nestedHeatFileName,
+                                                                                      String nestedNodeTemplateId) {
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        TranslationContext context = translateTo.getContext();
+        return getNestedTemplateConsolidationData(serviceTemplate, context, nestedHeatFileName, nestedNodeTemplateId);
+    }
+
+    private NestedTemplateConsolidationData getNestedTemplateConsolidationData(
+                                ServiceTemplate serviceTemplate,  TranslationContext context,
+                                String nestedHeatFileName, String nestedNodeTemplateId) {
+
+
+        if (isNestedResourceIdOccursInDifferentNestedFiles(context, nestedHeatFileName,
+                nestedNodeTemplateId)) {
+            throw new CoreException(new
+                                            DuplicateResourceIdsInDifferentFilesErrorBuilder(
+                                                    nestedNodeTemplateId).build());
+        }
+
+        if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
+                nestedNodeTemplateId, nestedHeatFileName, context)) {
+            return null;
+        }
+
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+        FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData
+                                               .getFileNestedConsolidationData(serviceTemplateFileName);
+
+        if (fileNestedConsolidationData == null) {
+            fileNestedConsolidationData = new FileNestedConsolidationData();
+            nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
+                    fileNestedConsolidationData);
+        }
+
+        NestedTemplateConsolidationData nestedTemplateConsolidationData =
+                fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
+        if (nestedTemplateConsolidationData == null) {
+            nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
+            nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
+            fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
+                    nestedTemplateConsolidationData);
+        }
+
+        return nestedTemplateConsolidationData;
+    }
+
+    private boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String nestedNodeTemplateId,
+                                                                                     String nestedHeatFileName,
+                                                                                     TranslationContext context) {
+
+        return context.isServiceTemplateWithoutNodeTemplatesSection(
+                FileUtils.getFileWithoutExtention(nestedHeatFileName))
+                       || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
+    }
+
+    private boolean isNestedResourceIdOccursInDifferentNestedFiles(TranslationContext context,
+                                                                          String nestedHeatFileName,
+                                                                          String nestedNodeTemplateId) {
+        return Objects.nonNull(nestedHeatFileName) && context.getAllTranslatedResourceIdsFromDiffNestedFiles(
+                nestedHeatFileName).contains(nestedNodeTemplateId);
+    }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortConsolidationDataHandler.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortConsolidationDataHandler.java
new file mode 100644
index 0000000000..2da1f7e0fa
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortConsolidationDataHandler.java
@@ -0,0 +1,98 @@
+package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
+
+import java.util.Optional;
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
+import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
+import org.openecomp.sdc.heat.datatypes.model.Resource;
+import org.openecomp.sdc.tosca.services.ToscaUtil;
+import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
+import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
+
+public class PortConsolidationDataHandler implements ConsolidationDataHandler {
+
+    private final PortConsolidationData portConsolidationData;
+
+    public PortConsolidationDataHandler(PortConsolidationData portConsolidationData) {
+        this.portConsolidationData = portConsolidationData;
+    }
+
+    @Override
+    public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
+            RequirementAssignment requirementAssignment) {
+
+        EntityConsolidationData entityConsolidationData =
+                getPortTemplateConsolidationData(translateTo, translateTo.getResourceId(),
+                        translateTo.getResource().getType(), translateTo.getTranslatedId());
+
+        entityConsolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
+
+    }
+
+    @Override
+    public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
+            String dependentNodeTemplateId, String targetResourceId, String requirementId,
+            RequirementAssignment requirementAssignment) {
+
+        EntityConsolidationData entityConsolidationData =
+                getPortTemplateConsolidationData(translateTo, translateTo.getResourceId(),
+                        translateTo.getResource().getType(), dependentNodeTemplateId);
+
+        entityConsolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment);
+
+    }
+
+    @Override
+    public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
+            HeatOrchestrationTemplate heatOrchestrationTemplate, String paramName, String contrailSharedResourceId,
+            String sharedTranslatedResourceId) {
+
+        Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
+        EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(serviceTemplate,
+                contrailSharedResourceId, resource.getType(), sharedTranslatedResourceId);
+        entityConsolidationData.removeParamNameFromAttrFuncList(paramName);
+
+    }
+
+    private PortTemplateConsolidationData getPortTemplateConsolidationData(TranslateTo translateTo,
+            String portResourceId, String portResourceType, String portNodeTemplateId) {
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        return getPortTemplateConsolidationData(serviceTemplate, portResourceId, portResourceType, portNodeTemplateId);
+    }
+
+    private PortTemplateConsolidationData getPortTemplateConsolidationData(ServiceTemplate serviceTemplate,
+            String portResourceId, String portResourceType, String portNodeTemplateId) {
+
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+        FilePortConsolidationData filePortConsolidationData = portConsolidationData
+                .getFilePortConsolidationData(serviceTemplateFileName);
+
+        if (filePortConsolidationData == null) {
+            filePortConsolidationData = new FilePortConsolidationData();
+            portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
+                    filePortConsolidationData);
+        }
+
+        PortTemplateConsolidationData portTemplateConsolidationData =
+                filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
+        if (portTemplateConsolidationData == null) {
+            portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId,
+                    portResourceId, portResourceType);
+            filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId,
+                    portTemplateConsolidationData);
+        }
+
+        return portTemplateConsolidationData;
+    }
+
+    private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId,
+                                                                                      String portResourceId,
+                                                                                      String portResourceType) {
+        PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData();
+        portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
+        Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId,
+                portResourceType);
+        portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole);
+        return portTemplateConsolidationData;
+    }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceConsolidationDataHandler.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceConsolidationDataHandler.java
new file mode 100644
index 0000000000..ddc770bac7
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceConsolidationDataHandler.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
+
+import java.util.Objects;
+import java.util.Optional;
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
+import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
+import org.openecomp.sdc.heat.datatypes.model.Resource;
+import org.openecomp.sdc.tosca.services.ToscaUtil;
+import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
+import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
+import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
+
+public class SubInterfaceConsolidationDataHandler implements ConsolidationDataHandler {
+
+    private final PortConsolidationData portConsolidationData;
+
+    SubInterfaceConsolidationDataHandler(PortConsolidationData portConsolidationData) {
+        this.portConsolidationData = portConsolidationData;
+    }
+
+    @Override
+    public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
+                                            RequirementAssignment requirementAssignment) {
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        if (Objects.nonNull(
+                serviceTemplate.getTopology_template().getNode_templates().get(translateTo.getTranslatedId()))) {
+            Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
+                    getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
+
+            subInterfaceTemplateConsolidationData.ifPresent(
+                    consolidationData -> consolidationData.addNodesConnectedOut(nodeTemplateId,
+                            requirementId, requirementAssignment));
+
+        }
+    }
+
+    @Override
+    public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
+                                           String dependentNodeTemplateId, String targetResourceId,
+                                           String requirementId, RequirementAssignment requirementAssignment) {
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        TranslationContext translationContext = translateTo.getContext();
+        Resource targetResource = translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
+        TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate,
+                                                            translateTo.getHeatOrchestrationTemplate(), targetResource,
+                                                            targetResourceId, null, translationContext);
+        Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
+                getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
+
+        subInterfaceTemplateConsolidationData.ifPresent(
+                consolidationData -> consolidationData.addNodesConnectedIn(sourceNodeTemplateId,
+                        requirementId, requirementAssignment));
+
+    }
+
+    @Override
+    public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
+                                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                       String paramName,
+                                                       String contrailSharedResourceId,
+                                                       String sharedTranslatedResourceId) {
+
+
+        throw new UnsupportedOperationException(
+                "API removeParamNameFromAttrFuncList not supported for SubInterfaceConsolidationDataHandler");
+
+    }
+
+    private Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
+            TranslateTo subInterfaceTo, String subInterfaceNodeTemplateId) {
+
+        Optional<String> parentPortNodeTemplateId =
+                HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
+        return parentPortNodeTemplateId.map(s -> getSubInterfaceTemplateConsolidationData(subInterfaceTo, s,
+                subInterfaceNodeTemplateId));
+
+    }
+
+    private SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(TranslateTo subInterfaceTo,
+            String parentPortNodeTemplateId, String subInterfaceNodeTemplateId) {
+
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
+        FilePortConsolidationData filePortConsolidationData =
+                portConsolidationData.getFilePortConsolidationData(serviceTemplateFileName);
+
+        if (filePortConsolidationData == null) {
+            filePortConsolidationData = new FilePortConsolidationData();
+            portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
+                    filePortConsolidationData);
+        }
+
+        PortTemplateConsolidationData portTemplateConsolidationData =
+                filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
+        if (portTemplateConsolidationData == null) {
+            portTemplateConsolidationData = new PortTemplateConsolidationData();
+            portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
+            filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
+                    portTemplateConsolidationData);
+        }
+
+        return portTemplateConsolidationData.getSubInterfaceResourceTemplateConsolidationData(
+                subInterfaceTo.getResource(), subInterfaceNodeTemplateId, parentPortNodeTemplateId);
+    }
+
+}
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java
index 34fccc05fe..be282082ff 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java
@@ -16,24 +16,28 @@
 
 package org.openecomp.sdc.translator.services.heattotosca;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 import org.apache.commons.collections4.MapUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
 import org.openecomp.sdc.heat.datatypes.model.Resource;
-import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
-import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
-import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
-import org.openecomp.sdc.tosca.services.DataModelUtil;
 import org.openecomp.sdc.tosca.services.ToscaUtil;
 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
+import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationDataHandler;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
@@ -43,694 +47,592 @@ import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolida
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
-import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
 import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-
 
 /**
  * Utility class for consolidation data collection helper methods.
  */
 public class ConsolidationDataUtil {
 
-  private static final String UNDERSCORE = "_";
-  private static final String DIGIT_REGEX = "\\d+";
-
-  private ConsolidationDataUtil() {
-  }
-
-  /**
-   * Gets compute template consolidation data.
-   *
-   * @param context               the translation context
-   * @param serviceTemplate       the service template
-   * @param computeNodeType       the compute node type
-   * @param computeNodeTemplateId the compute node template id
-   * @return the compute template consolidation data
-   */
-  public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
-      TranslationContext context,
-      ServiceTemplate serviceTemplate,
-      String computeNodeType,
-      String computeNodeTemplateId) {
-
-    ConsolidationData consolidationData = context.getConsolidationData();
-    String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
-
-    ComputeConsolidationData computeConsolidationData = consolidationData
-        .getComputeConsolidationData();
-
-    FileComputeConsolidationData fileComputeConsolidationData = computeConsolidationData
-        .getFileComputeConsolidationData(serviceTemplateFileName);
-
-    if (fileComputeConsolidationData == null) {
-      fileComputeConsolidationData = new FileComputeConsolidationData();
-      computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
-          fileComputeConsolidationData);
-    }
+    private static final String UNDERSCORE = "_";
+    private static final String DIGIT_REGEX = "\\d+";
 
-    TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData
-        .getTypeComputeConsolidationData(computeNodeType);
-    if (typeComputeConsolidationData == null) {
-      typeComputeConsolidationData = new TypeComputeConsolidationData();
-      fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType,
-          typeComputeConsolidationData);
+    private ConsolidationDataUtil() {
+        // prevent instantiation of utility class
     }
 
-    ComputeTemplateConsolidationData computeTemplateConsolidationData =
-        typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
-    if (computeTemplateConsolidationData == null) {
-      computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
-      computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
-      typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
-          computeTemplateConsolidationData);
+    /**
+     * Gets compute template consolidation data.
+     *
+     * @param context               the translation context
+     * @param serviceTemplate       the service template
+     * @param computeNodeType       the compute node type
+     * @param computeNodeTemplateId the compute node template id
+     * @return the compute template consolidation data
+     */
+    public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData(TranslationContext context,
+            ServiceTemplate serviceTemplate, String computeNodeType, String computeNodeTemplateId) {
+
+        ConsolidationData consolidationData = context.getConsolidationData();
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+
+        ComputeConsolidationData computeConsolidationData = consolidationData.getComputeConsolidationData();
+
+        FileComputeConsolidationData fileComputeConsolidationData =
+                computeConsolidationData.getFileComputeConsolidationData(serviceTemplateFileName);
+
+        if (fileComputeConsolidationData == null) {
+            fileComputeConsolidationData = new FileComputeConsolidationData();
+            computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
+                    fileComputeConsolidationData);
+        }
+
+        TypeComputeConsolidationData typeComputeConsolidationData =
+                fileComputeConsolidationData.getTypeComputeConsolidationData(computeNodeType);
+        if (typeComputeConsolidationData == null) {
+            typeComputeConsolidationData = new TypeComputeConsolidationData();
+            fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType,
+                    typeComputeConsolidationData);
+        }
+
+        ComputeTemplateConsolidationData computeTemplateConsolidationData =
+                typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
+        if (computeTemplateConsolidationData == null) {
+            computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
+            computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
+            typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
+                    computeTemplateConsolidationData);
+        }
+
+        return computeTemplateConsolidationData;
     }
 
-    return computeTemplateConsolidationData;
-  }
-
 
-  /**
-   * Gets port template consolidation data.
-   *
-   * @param context            the context
-   * @param serviceTemplate    the service template
-   * @param portNodeTemplateId the port node template id
-   * @return the port template consolidation data
-   */
-  public static PortTemplateConsolidationData getPortTemplateConsolidationData(TranslationContext context,
-                                                                               ServiceTemplate serviceTemplate,
-                                                                               String portResourceId,
-                                                                               String portResourceType,
-                                                                               String portNodeTemplateId) {
+    /**
+     * Gets port template consolidation data.
+     *
+     * @param context            the context
+     * @param serviceTemplate    the service template
+     * @param portNodeTemplateId the port node template id
+     * @return the port template consolidation data
+     */
+    public static PortTemplateConsolidationData getPortTemplateConsolidationData(TranslationContext context,
+                                                                                        ServiceTemplate serviceTemplate,
+                                                                                        String portResourceId,
+                                                                                        String portResourceType,
+                                                                                        String portNodeTemplateId) {
+
+        ConsolidationData consolidationData = context.getConsolidationData();
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+
+        PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
+
+        FilePortConsolidationData filePortConsolidationData =
+                portConsolidationData.getFilePortConsolidationData(serviceTemplateFileName);
+
+        if (filePortConsolidationData == null) {
+            filePortConsolidationData = new FilePortConsolidationData();
+            portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
+                    filePortConsolidationData);
+        }
+
+        PortTemplateConsolidationData portTemplateConsolidationData =
+                filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
+        if (portTemplateConsolidationData == null) {
+            portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId,
+                    portResourceId, portResourceType);
+            filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId,
+                    portTemplateConsolidationData);
+        }
+
+        return portTemplateConsolidationData;
+    }
 
-    ConsolidationData consolidationData = context.getConsolidationData();
-    String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+    private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId,
+                                                                                             String portResourceId,
+                                                                                             String portResourceType) {
+        PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData();
+        portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
+        Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId,
+                portResourceType);
+        portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole);
+        return portTemplateConsolidationData;
+    }
 
-    PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 
-    FilePortConsolidationData filePortConsolidationData = portConsolidationData
-        .getFilePortConsolidationData(serviceTemplateFileName);
+    public static Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
+            TranslateTo subInterfaceTo, String subInterfaceNodeTemplateId) {
 
-    if (filePortConsolidationData == null) {
-      filePortConsolidationData = new FilePortConsolidationData();
-      portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
-          filePortConsolidationData);
+        Optional<String> parentPortNodeTemplateId =
+                HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
+        if (parentPortNodeTemplateId.isPresent()) {
+            return Optional.ofNullable(getSubInterfaceTemplateConsolidationData(subInterfaceTo,
+                    parentPortNodeTemplateId.get(), subInterfaceNodeTemplateId));
+        }
+        return Optional.empty();
     }
 
-    PortTemplateConsolidationData portTemplateConsolidationData =
-        filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
-    if (portTemplateConsolidationData == null) {
-      portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId,
-          portResourceId, portResourceType);
-      filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
-    }
+    private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(
+            TranslateTo subInterfaceTo, String parentPortNodeTemplateId, String subInterfaceNodeTemplateId) {
 
-    return portTemplateConsolidationData;
-  }
-
-  private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId,
-                                                                             String portResourceId,
-                                                                             String portResourceType) {
-    PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData();
-    portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
-    Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId,
-        portResourceType);
-    portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole);
-    return portTemplateConsolidationData;
-  }
-
-  public static Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
-      TranslateTo subInterfaceTo,
-      String subInterfaceNodeTemplateId) {
-    Optional<String> parentPortNodeTemplateId =
-        HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
-    if (parentPortNodeTemplateId.isPresent()) {
-      return Optional.ofNullable(getSubInterfaceTemplateConsolidationData(subInterfaceTo,
-         parentPortNodeTemplateId.get(), subInterfaceNodeTemplateId));
-    }
-    return Optional.empty();
-  }
+        ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData();
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
 
-  private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(
-      TranslateTo subInterfaceTo,
-      String parentPortNodeTemplateId,
-      String subInterfaceNodeTemplateId) {
+        PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 
-    ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData();
-    String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
+        FilePortConsolidationData filePortConsolidationData =
+                portConsolidationData.getFilePortConsolidationData(serviceTemplateFileName);
 
-    PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
+        if (filePortConsolidationData == null) {
+            filePortConsolidationData = new FilePortConsolidationData();
+            portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
+                    filePortConsolidationData);
+        }
 
-    FilePortConsolidationData filePortConsolidationData = portConsolidationData
-        .getFilePortConsolidationData(serviceTemplateFileName);
+        PortTemplateConsolidationData portTemplateConsolidationData =
+                filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
+        if (portTemplateConsolidationData == null) {
+            portTemplateConsolidationData = new PortTemplateConsolidationData();
+            portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
+            filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
+                    portTemplateConsolidationData);
+        }
 
-    if (filePortConsolidationData == null) {
-      filePortConsolidationData = new FilePortConsolidationData();
-      portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
-          filePortConsolidationData);
+        return portTemplateConsolidationData.getSubInterfaceResourceTemplateConsolidationData(
+                subInterfaceTo.getResource(), subInterfaceNodeTemplateId, parentPortNodeTemplateId);
     }
 
-    PortTemplateConsolidationData portTemplateConsolidationData =
-        filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
-    if (portTemplateConsolidationData == null) {
-      portTemplateConsolidationData = new PortTemplateConsolidationData();
-      portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
-      filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
-          portTemplateConsolidationData);
+    /**
+     * Gets nested template consolidation data.
+     *
+     * @param context              the context
+     * @param serviceTemplate      the service template
+     * @param nestedNodeTemplateId the nested node template id  @return the nested template
+     *                             consolidation data
+     */
+    public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(TranslationContext context,
+            ServiceTemplate serviceTemplate, String nestedHeatFileName, String nestedNodeTemplateId) {
+
+        if (isNestedResourceIdOccursInDifferentNestedFiles(context, nestedHeatFileName,
+                nestedNodeTemplateId)) {
+            throw new CoreException(new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
+        }
+
+        if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
+                nestedNodeTemplateId, nestedHeatFileName, context)) {
+            return null;
+        }
+
+        ConsolidationData consolidationData = context.getConsolidationData();
+        String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+
+        NestedConsolidationData nestedConsolidationData = consolidationData
+                                                                  .getNestedConsolidationData();
+
+        FileNestedConsolidationData fileNestedConsolidationData =
+                nestedConsolidationData.getFileNestedConsolidationData(serviceTemplateFileName);
+
+        if (fileNestedConsolidationData == null) {
+            fileNestedConsolidationData = new FileNestedConsolidationData();
+            nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
+                    fileNestedConsolidationData);
+        }
+
+        NestedTemplateConsolidationData nestedTemplateConsolidationData =
+                fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
+        if (nestedTemplateConsolidationData == null) {
+            nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
+            nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
+            fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
+                    nestedTemplateConsolidationData);
+        }
+
+        return nestedTemplateConsolidationData;
     }
 
-    return portTemplateConsolidationData.getSubInterfaceResourceTemplateConsolidationData(subInterfaceTo.getResource(),
-        subInterfaceNodeTemplateId, parentPortNodeTemplateId);
-  }
-
-  /**
-   * Gets nested template consolidation data.
-   *
-   * @param context              the context
-   * @param serviceTemplate      the service template
-   * @param nestedNodeTemplateId the nested node template id  @return the nested template
-   *                             consolidation data
-   */
-  public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(
-      TranslationContext context,
-      ServiceTemplate serviceTemplate,
-      String nestedHeatFileName, String nestedNodeTemplateId) {
-
-    if (isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
-        nestedNodeTemplateId)) {
-      throw new CoreException(
-          new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
-    }
+    public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
+                                                                                            nestedNodeTemplateId,
+                                                                                           String nestedHeatFileName,
+                                                                                           TranslationContext context) {
 
-    if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
-        nestedNodeTemplateId, nestedHeatFileName, context)) {
-      return null;
+        return context.isServiceTemplateWithoutNodeTemplatesSection(
+                FileUtils.getFileWithoutExtention(nestedHeatFileName))
+                       || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
     }
 
-    ConsolidationData consolidationData = context.getConsolidationData();
-    String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
-
-    NestedConsolidationData nestedConsolidationData = consolidationData
-        .getNestedConsolidationData();
-
-    FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData
-        .getFileNestedConsolidationData(serviceTemplateFileName);
+    private static boolean isNestedResourceIdOccursInDifferentNestedFiles(TranslationContext context,
+                                                                                  String nestedHeatFileName,
+                                                                                  String nestedNodeTemplateId) {
+        return Objects.nonNull(nestedHeatFileName)
+                       && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
+                                 .contains(nestedNodeTemplateId);
+    }
 
-    if (fileNestedConsolidationData == null) {
-      fileNestedConsolidationData = new FileNestedConsolidationData();
-      nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
-          fileNestedConsolidationData);
+    /**
+     * Update group id information in consolidation data.
+     *
+     * @param entityConsolidationData Entity consolidation data (Port/Compute)
+     * @param translatedGroupId       Group id of which compute node is a part
+     */
+    public static void updateGroupIdInConsolidationData(EntityConsolidationData
+                                                                entityConsolidationData,
+                                                               String translatedGroupId) {
+        if (entityConsolidationData.getGroupIds() == null) {
+            entityConsolidationData.setGroupIds(new ArrayList<>());
+        }
+        entityConsolidationData.getGroupIds().add(translatedGroupId);
     }
 
-    NestedTemplateConsolidationData nestedTemplateConsolidationData =
-        fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
-    if (nestedTemplateConsolidationData == null) {
-      nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
-      nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
-      fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
-          nestedTemplateConsolidationData);
+    /**
+     * Update volume information in consolidation data.
+     *
+     * @param translateTo           {@link TranslateTo} object
+     * @param computeType           Local type of the compute node
+     * @param computeNodeTemplateId Node template id of the compute node
+     * @param requirementAssignment RequirementAssignment object
+     */
+    public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
+                                                                    String computeType,
+                                                                    String computeNodeTemplateId,
+                                                                    String requirementId,
+                                                                    RequirementAssignment
+                                                                            requirementAssignment) {
+        TranslationContext translationContext = translateTo.getContext();
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        ComputeTemplateConsolidationData computeTemplateConsolidationData =
+                getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
+                        computeNodeTemplateId);
+        computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
     }
 
-    return nestedTemplateConsolidationData;
-  }
 
-  public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
-                                                                                      nestedNodeTemplateId,
-                                                                                  String nestedHeatFileName,
-                                                                                  TranslationContext context) {
-
-    return context.isServiceTemplateWithoutNodeTemplatesSection(
-        FileUtils.getFileWithoutExtention(nestedHeatFileName))
-        || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
-  }
-
-  private static boolean isNestedResourceIdOccuresInDifferentNestedFiles(TranslationContext context,
-                                                                         String nestedHeatFileName,
-                                                                         String nestedNodeTemplateId) {
-    return Objects.nonNull(nestedHeatFileName)
-        && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
-        .contains(nestedNodeTemplateId);
-  }
-
-  /**
-   * Update group id information in consolidation data.
-   *
-   * @param entityConsolidationData Entity consolidation data (Port/Compute)
-   * @param translatedGroupId       Group id of which compute node is a part
-   */
-  public static void updateGroupIdInConsolidationData(EntityConsolidationData
-                                                          entityConsolidationData,
-                                                      String translatedGroupId) {
-    if (entityConsolidationData.getGroupIds() == null) {
-      entityConsolidationData.setGroupIds(new ArrayList<>());
+    /**
+     * Update port in consolidation data.
+     *
+     * @param translateTo        the translate to
+     * @param computeNodeType    the compute node type
+     * @param portResourceId     the port resource id
+     * @param portNodeTemplateId the port node template id
+     */
+    public static void updatePortInConsolidationData(TranslateTo translateTo,
+                                                            String computeNodeType,
+                                                            String portResourceId,
+                                                            String portResourceType,
+                                                            String portNodeTemplateId) {
+        TranslationContext translationContext = translateTo.getContext();
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        ComputeTemplateConsolidationData computeTemplateConsolidationData =
+                getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeNodeType,
+                        translateTo.getTranslatedId());
+        computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId);
+        // create port in consolidation data
+        getPortTemplateConsolidationData(translationContext, serviceTemplate, portResourceId,
+                portResourceType, portNodeTemplateId);
     }
-    entityConsolidationData.getGroupIds().add(translatedGroupId);
-  }
-
-  /**
-   * Update volume information in consolidation data.
-   *
-   * @param translateTo           {@link TranslateTo} object
-   * @param computeType           Local type of the compute node
-   * @param computeNodeTemplateId Node template id of the compute node
-   * @param requirementAssignment RequirementAssignment object
-   */
-  public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
-                                                           String computeType,
-                                                           String computeNodeTemplateId,
-                                                           String requirementId,
-                                                           RequirementAssignment
-                                                               requirementAssignment) {
-    TranslationContext translationContext = translateTo.getContext();
-    ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
-    ComputeTemplateConsolidationData computeTemplateConsolidationData =
-        getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
-            computeNodeTemplateId);
-    computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
-  }
-
-
-  /**
-   * Update port in consolidation data.
-   *
-   * @param translateTo        the translate to
-   * @param computeNodeType    the compute node type
-   * @param portResourceId     the port resource id
-   * @param portNodeTemplateId the port node template id
-   */
-  public static void updatePortInConsolidationData(TranslateTo translateTo,
-                                                   String computeNodeType,
-                                                   String portResourceId,
-                                                   String portResourceType,
-                                                   String portNodeTemplateId) {
-    TranslationContext translationContext = translateTo.getContext();
-    ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
-    ComputeTemplateConsolidationData computeTemplateConsolidationData =
-        getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeNodeType,
-            translateTo.getTranslatedId());
-    computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId);
-    // create port in consolidation data
-    getPortTemplateConsolidationData(translationContext, serviceTemplate, portResourceId,
-        portResourceType, portNodeTemplateId);
-  }
-
-  /**
-   * Update nodes connected in and out for Depends on and connectivity in consolidation data.
-   *
-   * @param translateTo           the translate to
-   * @param targetResourceId      the target resource id
-   * @param nodeTemplateId        the source node template id
-   * @param requirementAssignment the requirement assignment
-   */
-  public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
-                                              Resource targetResource, Resource sourceResource,
-                                              String nodeTemplateId, String requirementId,
-                                              RequirementAssignment requirementAssignment) {
-    ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
-    consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
-    // Add resource dependency information in nodesConnectedIn if the target node
-    // is a consolidation entity
-    if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
-      ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
-          nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
-          requirementId, requirementAssignment);
+
+    /**
+     * Update nodes connected in and out for Depends on and connectivity in consolidation data.
+     *
+     * @param translateTo           the translate to
+     * @param targetResourceId      the target resource id
+     * @param nodeTemplateId        the source node template id
+     * @param requirementAssignment the requirement assignment
+     */
+    public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
+                                                       Resource targetResource, Resource sourceResource,
+                                                       String nodeTemplateId, String requirementId,
+                                                       RequirementAssignment requirementAssignment) {
+        ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
+        consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
+        // Add resource dependency information in nodesConnectedIn if the target node
+        // is a consolidation entity
+        if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
+            ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
+                    nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
+                    requirementId, requirementAssignment);
+        }
+
+        //Add resource dependency information in nodesConnectedOut if the source node
+        //is a consolidation entity
+        if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
+            ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
+                    requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
+                    requirementId, requirementAssignment);
+
+        }
     }
 
-    //Add resource dependency information in nodesConnectedOut if the source node
-    //is a consolidation entity
-    if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
-      ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
-          requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
-          requirementId, requirementAssignment);
 
-    }
-  }
-
-
-  private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
-    return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
-  }
-
-  /**
-   * Update nodes connected from this node in consolidation data.
-   *
-   * @param translateTo             the translate to
-   * @param nodeTemplateId          the node template id of the target node
-   * @param consolidationEntityType the entity type (compute or port)
-   * @param requirementId           the requirement id
-   * @param requirementAssignment   the requirement assignment
-   */
-  public static void updateNodesConnectedOut(TranslateTo translateTo,
-                                             String nodeTemplateId,
-                                             ConsolidationEntityType consolidationEntityType,
-                                             String requirementId,
-                                             RequirementAssignment requirementAssignment) {
-    EntityConsolidationData entityConsolidationData = null;
-    TranslationContext translationContext = translateTo.getContext();
-    ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
-
-    translationContext.updateRequirementAssignmentIdIndex(ToscaUtil.getServiceTemplateFileName
-        (translateTo.getServiceTemplate()), translateTo.getResourceId(), requirementId);
-
-    RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
-        requirementId, requirementAssignment);
-
-    if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
-      String nodeType = DataModelUtil.getNodeTemplate(serviceTemplate, translateTo
-          .getTranslatedId()).getType();
-      entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
-          serviceTemplate, nodeType, translateTo.getTranslatedId());
-    } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
-      entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
-          translateTo.getResourceId(), translateTo.getResource().getType(), translateTo
-          .getTranslatedId());
-    } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE
-        && Objects.nonNull(serviceTemplate.getTopology_template().getNode_templates()
-        .get(translateTo.getTranslatedId()))) {
-      Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
-          getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
-      if (subInterfaceTemplateConsolidationData.isPresent()) {
-        entityConsolidationData = subInterfaceTemplateConsolidationData.get();
-      }
-    } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED
-        || consolidationEntityType == ConsolidationEntityType.NESTED) {
-      entityConsolidationData =
-          getNestedTemplateConsolidationData(translationContext, serviceTemplate,
-              translateTo.getHeatFileName(),
-              translateTo.getTranslatedId());
+    private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
+        return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
     }
 
-    if (Objects.nonNull(entityConsolidationData)) {
-      if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) {
-        entityConsolidationData.setNodesConnectedOut(new HashMap<>());
-      }
+    /**
+     * Update nodes connected from this node in consolidation data.
+     *
+     * @param translateTo             the translate to
+     * @param nodeTemplateId          the node template id of the target node
+     * @param consolidationEntityType the entity type (compute or port)
+     * @param requirementId           the requirement id
+     * @param requirementAssignment   the requirement assignment
+     */
+    public static void updateNodesConnectedOut(TranslateTo translateTo,
+                                                      String nodeTemplateId,
+                                                      ConsolidationEntityType consolidationEntityType,
+                                                      String requirementId,
+                                                      RequirementAssignment requirementAssignment) {
+        TranslationContext translationContext = translateTo.getContext();
+        translationContext.updateRequirementAssignmentIdIndex(
+                ToscaUtil.getServiceTemplateFileName(translateTo.getServiceTemplate()), translateTo.getResourceId(),
+                requirementId);
+
+        Optional<ConsolidationDataHandler> consolidationDataHandler =
+                translationContext.getConsolidationData().getConsolidationDataHandler(consolidationEntityType);
+        consolidationDataHandler.ifPresent(handler -> handler.addNodesConnectedOut(
+                translateTo, nodeTemplateId, requirementId, requirementAssignment));
 
-      entityConsolidationData.getNodesConnectedOut()
-          .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
-          .add(requirementAssignmentData);
-    }
-  }
-
-  /**
-   * Update nodes connected from this node in consolidation data.
-   *
-   * @param translateTo             the translate to
-   * @param sourceNodeTemplateId    the node template id of the source node
-   * @param consolidationEntityType Entity type (compute or port)
-   * @param requirementId           Requirement Id
-   * @param requirementAssignment   the requirement assignment
-   */
-  public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
-                                            ConsolidationEntityType consolidationEntityType,
-                                            String targetResourceId,
-                                            String requirementId,
-                                            RequirementAssignment requirementAssignment) {
-    EntityConsolidationData entityConsolidationData = null;
-    TranslationContext translationContext = translateTo.getContext();
-    ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
-    RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
-        requirementId, requirementAssignment);
-    String dependentNodeTemplateId = requirementAssignment.getNode();
-    if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
-      NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-          dependentNodeTemplateId);
-      String nodeType;
-      if (Objects.isNull(computeNodeTemplate)) {
-        Resource targetResource =
-            translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
-        NameExtractor nodeTypeNameExtractor =
-            TranslationContext.getNameExtractorImpl(targetResource.getType());
-        nodeType =
-            nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate()
-                    .getResources().get(dependentNodeTemplateId),
-                dependentNodeTemplateId, dependentNodeTemplateId);
-      } else {
-        nodeType = computeNodeTemplate.getType();
-      }
-
-      entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
-          serviceTemplate, nodeType, dependentNodeTemplateId);
-    } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
-      entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
-          translateTo.getResourceId(), translateTo.getResource().getType(), dependentNodeTemplateId);
-    }  else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE) {
-      Resource targetResource =
-          translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
-      TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate, translateTo
-          .getHeatOrchestrationTemplate(), targetResource, targetResourceId, null, translationContext);
-      Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
-          getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
-      if (subInterfaceTemplateConsolidationData.isPresent()) {
-        entityConsolidationData = subInterfaceTemplateConsolidationData.get();
-      }
-    } else if (consolidationEntityType == ConsolidationEntityType.NESTED
-        || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) {
-      entityConsolidationData = getNestedTemplateConsolidationData(translationContext,
-          serviceTemplate, translateTo.getHeatFileName(), dependentNodeTemplateId);
     }
 
-    if (entityConsolidationData != null) {
-      if (entityConsolidationData.getNodesConnectedIn() == null) {
-        entityConsolidationData.setNodesConnectedIn(new HashMap<>());
-      }
+    /**
+     * Update nodes connected from this node in consolidation data.
+     *
+     * @param translateTo             the translate to
+     * @param sourceNodeTemplateId    the node template id of the source node
+     * @param consolidationEntityType Entity type (compute or port)
+     * @param targetResourceId           Target Resource Id
+     * @param requirementId           Requirement Id
+     * @param requirementAssignment   the requirement assignment
+     */
+    public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
+                                                     ConsolidationEntityType consolidationEntityType,
+                                                     String targetResourceId,
+                                                     String requirementId,
+                                                     RequirementAssignment requirementAssignment) {
+
+
+        TranslationContext translationContext = translateTo.getContext();
+        Optional<ConsolidationDataHandler> consolidationDataHandler =
+                translationContext.getConsolidationData().getConsolidationDataHandler(consolidationEntityType);
+        String dependentNodeTemplateId = requirementAssignment.getNode();
+        consolidationDataHandler.ifPresent(
+                handler -> handler.addNodesConnectedIn(translateTo, sourceNodeTemplateId, dependentNodeTemplateId,
+                        targetResourceId, requirementId, requirementAssignment));
 
-      entityConsolidationData.getNodesConnectedIn()
-          .computeIfAbsent(sourceNodeTemplateId, k -> new ArrayList<>())
-          .add(requirementAssignmentData);
+    }
 
+    /**
+     * Checks if the current HEAT resource if of type compute.
+     *
+     * @param heatOrchestrationTemplate the heat orchestration template
+     * @param resourceId                the resource id
+     * @return true if the resource is of compute type and false otherwise
+     */
+    public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                   String resourceId) {
+        String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
+        Map<String, ImplementationConfiguration> supportedComputeResources =
+                TranslationContext.getSupportedConsolidationComputeResources();
+        if (supportedComputeResources.containsKey(resourceType)) {
+            return supportedComputeResources.get(resourceType).isEnable();
+        }
+        return false;
     }
-  }
-
-  /**
-   * Checks if the current HEAT resource if of type compute.
-   *
-   * @param heatOrchestrationTemplate the heat orchestration template
-   * @param resourceId                the resource id
-   * @return true if the resource is of compute type and false otherwise
-   */
-  public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
-                                          String resourceId) {
-    String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
-    Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
-        .getSupportedConsolidationComputeResources();
-    if (supportedComputeResources.containsKey(resourceType)) {
-      return supportedComputeResources.get(resourceType).isEnable();
+
+    /**
+     * Checks if the current HEAT resource if of type compute.
+     *
+     * @param resource the resource
+     * @return true if the resource is of compute type and false otherwise
+     */
+    public static boolean isComputeResource(Resource resource) {
+        String resourceType = resource.getType();
+        Map<String, ImplementationConfiguration> supportedComputeResources =
+                TranslationContext.getSupportedConsolidationComputeResources();
+        if (supportedComputeResources.containsKey(resourceType)) {
+            return supportedComputeResources.get(resourceType).isEnable();
+        }
+        return false;
     }
-    return false;
-  }
-
-  /**
-   * Checks if the current HEAT resource if of type compute.
-   *
-   * @param resource the resource
-   * @return true if the resource is of compute type and false otherwise
-   */
-  public static boolean isComputeResource(Resource resource) {
-    String resourceType = resource.getType();
-    Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
-        .getSupportedConsolidationComputeResources();
-    if (supportedComputeResources.containsKey(resourceType)) {
-      return supportedComputeResources.get(resourceType).isEnable();
+
+    /**
+     * Checks if the current HEAT resource if of type port.
+     *
+     * @param heatOrchestrationTemplate the heat orchestration template
+     * @param resourceId                the resource id
+     * @return true if the resource is of port type and false otherwise
+     */
+    public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                String resourceId) {
+        String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
+        Map<String, ImplementationConfiguration> supportedPortResources =
+                TranslationContext.getSupportedConsolidationPortResources();
+        if (supportedPortResources.containsKey(resourceType)) {
+            return supportedPortResources.get(resourceType).isEnable();
+        }
+        return false;
     }
-    return false;
-  }
-
-  /**
-   * Checks if the current HEAT resource if of type port.
-   *
-   * @param heatOrchestrationTemplate the heat orchestration template
-   * @param resourceId                the resource id
-   * @return true if the resource is of port type and false otherwise
-   */
-  public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
-                                       String resourceId) {
-    String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
-    Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
-        .getSupportedConsolidationPortResources();
-    if (supportedPortResources.containsKey(resourceType)) {
-      return supportedPortResources.get(resourceType).isEnable();
+
+    /**
+     * Checks if the current HEAT resource if of type port.
+     *
+     * @param resource the resource
+     * @return true if the resource is of port type and false otherwise
+     */
+    public static boolean isPortResource(Resource resource) {
+        String resourceType = resource.getType();
+        Map<String, ImplementationConfiguration> supportedPortResources =
+                TranslationContext.getSupportedConsolidationPortResources();
+        if (supportedPortResources.containsKey(resourceType)) {
+            return supportedPortResources.get(resourceType).isEnable();
+        }
+        return false;
     }
-    return false;
-  }
-
-  /**
-   * Checks if the current HEAT resource if of type port.
-   *
-   * @param resource the resource
-   * @return true if the resource is of port type and false otherwise
-   */
-  public static boolean isPortResource(Resource resource) {
-    String resourceType = resource.getType();
-    Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
-        .getSupportedConsolidationPortResources();
-    if (supportedPortResources.containsKey(resourceType)) {
-      return supportedPortResources.get(resourceType).isEnable();
+
+    /**
+     * Checks if the current HEAT resource if of type volume.
+     *
+     * @param heatOrchestrationTemplate the heat orchestration template
+     * @param resourceId                the resource id
+     * @return true if the resource is of volume type and false otherwise
+     */
+    public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                  String resourceId) {
+        String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
+        return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
+                       || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
+                                                      .getHeatResource());
     }
-    return false;
-  }
-
-  /**
-   * Checks if the current HEAT resource if of type volume.
-   *
-   * @param heatOrchestrationTemplate the heat orchestration template
-   * @param resourceId                the resource id
-   * @return true if the resource is of volume type and false otherwise
-   */
-  public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
-                                         String resourceId) {
-    String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
-    return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
-        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
-        .getHeatResource());
-  }
-
-  /**
-   * Checks if the current HEAT resource if of type volume.
-   *
-   * @param resource the resource
-   * @return true if the resource is of volume type and false otherwise
-   */
-  public static boolean isVolumeResource(Resource resource) {
-    String resourceType = resource.getType();
-    return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
-        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
-        .getHeatResource());
-  }
-
-  /**
-   * Gets port type.
-   *
-   * @param portNodeTemplateId the port node template id
-   * @return the port type
-   */
-  public static String getPortType(String portNodeTemplateId) {
-
-    if (StringUtils.isBlank(portNodeTemplateId)) {
-      return portNodeTemplateId;
+
+    /**
+     * Checks if the current HEAT resource if of type volume.
+     *
+     * @param resource the resource
+     * @return true if the resource is of volume type and false otherwise
+     */
+    public static boolean isVolumeResource(Resource resource) {
+        String resourceType = resource.getType();
+        return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
+                       || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
+                                                      .getHeatResource());
     }
 
-    String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
+    /**
+     * Gets port type.
+     *
+     * @param portNodeTemplateId the port node template id
+     * @return the port type
+     */
+    public static String getPortType(String portNodeTemplateId) {
 
-    StringBuilder sb = new StringBuilder();
-    int count = 0;
-    for (String token : formattedName.split(UNDERSCORE)) {
+        if (StringUtils.isBlank(portNodeTemplateId)) {
+            return portNodeTemplateId;
+        }
 
-      if (StringUtils.isNotBlank(token)) {
-        count++;
-      }
+        String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
 
-      if (count != 2 || !token.matches(DIGIT_REGEX)) {
-        sb.append(token).append(UNDERSCORE);
-      }
-    }
+        StringBuilder sb = new StringBuilder();
+        int count = 0;
+        for (String token : formattedName.split(UNDERSCORE)) {
+
+            if (StringUtils.isNotBlank(token)) {
+                count++;
+            }
+
+            if (count != 2 || (!StringUtils.isBlank(token) && !token.matches(DIGIT_REGEX))) {
+                sb.append(token).append(UNDERSCORE);
+            }
+        }
 
-    return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
-  }
-
-  /**
-   * Update node template id for the nested node templates in the consolidation data.
-   *
-   * @param translateTo the translate to
-   */
-  public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
-    TranslationContext context = translateTo.getContext();
-    ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
-    getNestedTemplateConsolidationData(
-        context, serviceTemplate, translateTo.getHeatFileName(), translateTo.getTranslatedId());
-  }
-
-  public static void removeSharedResource(ServiceTemplate serviceTemplate,
-                                          HeatOrchestrationTemplate heatOrchestrationTemplate,
-                                          TranslationContext context,
-                                          String paramName,
-                                          String contrailSharedResourceId,
-                                          String sharedTranslatedResourceId) {
-    if (ConsolidationDataUtil.isComputeResource(heatOrchestrationTemplate,
-        contrailSharedResourceId)) {
-      NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-          sharedTranslatedResourceId);
-      EntityConsolidationData entityConsolidationData = getComputeTemplateConsolidationData(
-          context, serviceTemplate, nodeTemplate.getType(), sharedTranslatedResourceId);
-      List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
-          .getOutputParametersGetAttrIn();
-      removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
+        return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
     }
-    if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate,
-        contrailSharedResourceId)) {
-      Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
-      EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, serviceTemplate,
-          contrailSharedResourceId, resource.getType(), sharedTranslatedResourceId);
-      List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
-          .getOutputParametersGetAttrIn();
-      removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
+
+    /**
+     * Update node template id for the nested node templates in the consolidation data.
+     *
+     * @param translateTo the translate to
+     */
+    public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
+        TranslationContext context = translateTo.getContext();
+        ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
+        getNestedTemplateConsolidationData(
+                context, serviceTemplate, translateTo.getHeatFileName(), translateTo.getTranslatedId());
     }
-  }
-
-  private static void removeParamNameFromAttrFuncList(String paramName,
-                                                      List<GetAttrFuncData> getAttrFuncDataList) {
-    Iterator<GetAttrFuncData> itr = getAttrFuncDataList.iterator();
-    while (itr.hasNext()) {
-      GetAttrFuncData getAttrFuncData = itr.next();
-      if (paramName.equals(getAttrFuncData.getFieldName())) {
-        itr.remove();
-      }
+
+    public static void removeSharedResource(ServiceTemplate serviceTemplate,
+                                                   HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                   TranslationContext context,
+                                                   String paramName,
+                                                   String contrailSharedResourceId,
+                                                   String sharedTranslatedResourceId) {
+        Optional<ConsolidationDataHandler> consolidationDataHandler =
+                ConsolidationDataUtil.getConsolidationDataHandler(heatOrchestrationTemplate, context,
+                        contrailSharedResourceId);
+
+        consolidationDataHandler.ifPresent(
+                handler -> handler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
+                        paramName, contrailSharedResourceId, sharedTranslatedResourceId));
     }
-  }
 
-  public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
-                                              String nodeTemplateId, String propertyName,
-                                              String attributeName) {
-    GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
-    getAttrFuncData.setFieldName(propertyName);
-    getAttrFuncData.setAttributeName(attributeName);
-    entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 
-  }
+    public static Optional<ConsolidationDataHandler> getConsolidationDataHandler(
+            HeatOrchestrationTemplate heatOrchestrationTemplate, TranslationContext context,
+            String contrailSharedResourceId) {
+
+        Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
+        ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
+        consolidationEntityType.setEntityType(resource, resource, context);
+        return context.getConsolidationData().getConsolidationDataHandler(
+                consolidationEntityType.getSourceEntityType());
 
-  public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
-                                               String nodeTemplateId, String propertyName,
-                                               String attributeName) {
-    GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
-    getAttrFuncData.setFieldName(propertyName);
-    getAttrFuncData.setAttributeName(attributeName);
-    entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
+    }
+
+    public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
+                                                       String nodeTemplateId, String propertyName,
+                                                       String attributeName) {
+        GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
+        getAttrFuncData.setFieldName(propertyName);
+        getAttrFuncData.setAttributeName(attributeName);
+        entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
+
+    }
 
-  }
+    public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
+                                                        String nodeTemplateId, String propertyName,
+                                                        String attributeName) {
 
-  public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
-                                                                     entityConsolidationData,
-                                                                 String outputParameterName,
-                                                                 String attributeName) {
+        GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
+        getAttrFuncData.setFieldName(propertyName);
+        getAttrFuncData.setAttributeName(attributeName);
+        entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 
+    }
 
-    GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
-    getAttrFuncData.setFieldName(outputParameterName);
-    getAttrFuncData.setAttributeName(attributeName);
-    entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
+    public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
+                                                                           entityConsolidationData,
+                                                                          String outputParameterName,
+                                                                          String attributeName) {
 
-  }
+        GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
+        getAttrFuncData.setFieldName(outputParameterName);
+        getAttrFuncData.setAttributeName(attributeName);
+        entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 
-  public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
-                                                   String portId) {
-    if (MapUtils.isEmpty(compute.getPorts())) {
-      return false;
     }
-    for (List<String> portIdsPerType : compute.getPorts().values()) {
-      if (portIdsPerType.contains(portId)) {
-        return true;
-      }
+
+    public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
+                                                            String portId) {
+        if (MapUtils.isEmpty(compute.getPorts())) {
+            return false;
+        }
+        for (List<String> portIdsPerType : compute.getPorts().values()) {
+            if (portIdsPerType.contains(portId)) {
+                return true;
+            }
+        }
+        return false;
     }
-    return false;
-  }
 
 }