catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplate.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.jsontitan.datamodel;
  22
  23 import org.apache.commons.collections.MapUtils;
  24 import org.openecomp.sdc.be.datatypes.elements.*;
  25 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
  26 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
  27 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  28 import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition;
  29 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
  30
  31 import java.util.HashMap;
  32 import java.util.Map;
  33
  34 public class TopologyTemplate extends ToscaElement{
  35
  36     public TopologyTemplate() {
  37         super(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE);
  38     }
  39     private Map<String, PropertyDataDefinition> inputs;
  40     private Map<String, MapPropertiesDataDefinition> instInputs;
  41     private Map<String, ? extends ToscaDataDefinition> heatParameters;
  42     private Map<String, MapPropertiesDataDefinition> instAttributes;
  43     private Map<String, MapPropertiesDataDefinition> instProperties;
  44     private Map<String, GroupDataDefinition> groups;
  45     private Map<String, PolicyDataDefinition> policies;
  46     private Map<String, MapGroupsDataDefinition> instGroups;
  47     private Map<String, ArtifactDataDefinition> serviceApiArtifacts;
  48     private Map<String, ForwardingPathDataDefinition> forwardingPaths;
  49     private Map<String, CompositionDataDefinition> compositions;
  50     private Map<String, MapListCapabilityDataDefinition> calculatedCapabilities;
  51     private Map<String, MapListRequirementDataDefinition> calculatedRequirements;
  52     private Map<String, MapListCapabilityDataDefinition> fullfilledCapabilities;
  53     private Map<String, MapListRequirementDataDefinition> fullfilledRequirements;
  54     private Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties;
  55     private Map<String, MapArtifactDataDefinition> instDeploymentArtifacts;
  56     private Map<String, MapArtifactDataDefinition> instanceArtifacts;
  57     private Map<String, InterfaceDataDefinition> interfaces;
  58     private Map<String, MapInterfaceInstanceDataDefinition> instInterfaces;
  59     private Map<String, MapInterfaceDataDefinition> componentInstInterfaces;
  60
  61     private Map<String, CINodeFilterDataDefinition> nodeFilterComponents;
  62     //Component Instances External References (instanceId -> ExternalRefsMap)
  63     //-----------------------------------------------------------------------
  64     private Map<String, MapComponentInstanceExternalRefs> mapComponentInstancesExternalRefs;
  65
  66     public Map<String, MapComponentInstanceExternalRefs> getMapComponentInstancesExternalRefs() {
  67         return this.mapComponentInstancesExternalRefs;
  68     }
  69
  70     public void setComponentInstancesExternalRefs(Map<String, MapComponentInstanceExternalRefs> mapComponentInstancesExternalRefs) {
  71         this.mapComponentInstancesExternalRefs = mapComponentInstancesExternalRefs;
  72     }
  73     //-----------------------------------------------------------------------
  74
  75     public Map<String, InterfaceDataDefinition> getInterfaces() {
  76       return interfaces;
  77     }
  78
  79     public void setInterfaces(Map<String, InterfaceDataDefinition> interfaces) {
  80       this.interfaces = interfaces;
  81     }
  82
  83     public Map<String, MapInterfaceInstanceDataDefinition> getInstInterfaces() {
  84         return instInterfaces;
  85     }
  86
  87     public void setInstInterfaces(
  88             Map<String, MapInterfaceInstanceDataDefinition> instInterfaces) {
  89         this.instInterfaces = instInterfaces;
  90     }
  91
  92     public void addInstInterface(String compId, MapInterfaceInstanceDataDefinition
  93             mapInterfaceInstanceDataDefinition) {
  94         if(MapUtils.isEmpty(this.instInterfaces)) {
  95             this.instInterfaces = new HashMap<>();
  96         }
  97
  98         this.instInterfaces.put(compId, mapInterfaceInstanceDataDefinition);
  99     }
 100
 101     public Map<String, MapInterfaceDataDefinition> getComponentInstInterfaces() {
 102         return componentInstInterfaces;
 103     }
 104
 105     public void setComponentInstInterfaces(
 106             Map<String, MapInterfaceDataDefinition> componentInstInterfaces) {
 107         this.componentInstInterfaces = componentInstInterfaces;
 108     }
 109
 110     public void addComponentInstanceInterfaceMap(String componentInstanceId, MapInterfaceDataDefinition
 111             mapInterfaceDataDefinition) {
 112         if(MapUtils.isEmpty(this.componentInstInterfaces)) {
 113             this.componentInstInterfaces = new HashMap<>();
 114         }
 115
 116         this.componentInstInterfaces.put(componentInstanceId, mapInterfaceDataDefinition);
 117     }
 118
 119
 120     public Map<String, PropertyDataDefinition> getInputs() {
 121         return inputs;
 122     }
 123     public void setInputs(Map<String, PropertyDataDefinition> inputs) {
 124         this.inputs = inputs;
 125     }
 126     public Map<String, MapPropertiesDataDefinition> getInstInputs() {
 127         return instInputs;
 128     }
 129     public void setInstInputs(Map<String, MapPropertiesDataDefinition> instInputs) {
 130         this.instInputs = instInputs;
 131     }
 132     public Map<String, ? extends ToscaDataDefinition> getHeatParameters() {
 133         return heatParameters;
 134     }
 135     public void setHeatParameters(Map<String, ? extends ToscaDataDefinition> heatParameters) {
 136         this.heatParameters = heatParameters;
 137     }
 138     public Map<String, MapPropertiesDataDefinition> getInstAttributes() {
 139         return instAttributes;
 140     }
 141     public void setInstAttributes(Map<String, MapPropertiesDataDefinition> instAttributes) {
 142         this.instAttributes = instAttributes;
 143     }
 144     public Map<String, MapPropertiesDataDefinition> getInstProperties() {
 145         return instProperties;
 146     }
 147     public void setInstProperties(Map<String, MapPropertiesDataDefinition> instProperties) {
 148         this.instProperties = instProperties;
 149     }
 150     public Map<String, GroupDataDefinition> getGroups() {
 151         return groups;
 152     }
 153     public void setGroups(Map<String, GroupDataDefinition> groups) {
 154         this.groups = groups;
 155     }
 156     public Map<String, PolicyDataDefinition> getPolicies() {
 157         return policies;
 158     }
 159     public void setPolicies(Map<String, PolicyDataDefinition> policies) {
 160         this.policies = policies;
 161     }
 162     public Map<String, MapGroupsDataDefinition> getInstGroups() {
 163         return instGroups;
 164     }
 165     public void setInstGroups(Map<String, MapGroupsDataDefinition> instGroups) {
 166         this.instGroups = instGroups;
 167     }
 168     public Map<String, ArtifactDataDefinition> getServiceApiArtifacts() {
 169         return serviceApiArtifacts;
 170     }
 171     public void setServiceApiArtifacts(Map<String, ArtifactDataDefinition> serviceApiArtifacts) {
 172         this.serviceApiArtifacts = serviceApiArtifacts;
 173     }
 174     public Map<String, CompositionDataDefinition> getCompositions() {
 175         return compositions;
 176     }
 177     public void setCompositions(Map<String, CompositionDataDefinition> compositions) {
 178         this.compositions = compositions;
 179     }
 180     public Map<String, MapListCapabilityDataDefinition> getCalculatedCapabilities() {
 181         return calculatedCapabilities;
 182     }
 183     public void setCalculatedCapabilities(Map<String, MapListCapabilityDataDefinition> calculatedCapabilities) {
 184         this.calculatedCapabilities = calculatedCapabilities;
 185     }
 186     public Map<String, MapListRequirementDataDefinition> getCalculatedRequirements() {
 187         return calculatedRequirements;
 188     }
 189     public void setCalculatedRequirements(Map<String, MapListRequirementDataDefinition> calculatedRequirements) {
 190         this.calculatedRequirements = calculatedRequirements;
 191     }
 192     public Map<String, MapListCapabilityDataDefinition> getFullfilledCapabilities() {
 193         return fullfilledCapabilities;
 194     }
 195     public void setFullfilledCapabilities(Map<String, MapListCapabilityDataDefinition> fullfilledCapabilities) {
 196         this.fullfilledCapabilities = fullfilledCapabilities;
 197     }
 198     public Map<String, MapListRequirementDataDefinition> getFullfilledRequirements() {
 199         return fullfilledRequirements;
 200     }
 201     public void setFullfilledRequirements(Map<String, MapListRequirementDataDefinition> fullfilledRequirements) {
 202         this.fullfilledRequirements = fullfilledRequirements;
 203     }
 204
 205     public Map<String, MapArtifactDataDefinition> getInstDeploymentArtifacts() {
 206         return instDeploymentArtifacts;
 207     }
 208     public void setInstDeploymentArtifacts(Map<String, MapArtifactDataDefinition> instDeploymentArtifacts) {
 209         this.instDeploymentArtifacts = instDeploymentArtifacts;
 210     }
 211
 212     public Map<String, MapCapabilityProperty> getCalculatedCapabilitiesProperties() {
 213         return calculatedCapabilitiesProperties;
 214     }
 215     public void setCalculatedCapabilitiesProperties(Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties) {
 216         this.calculatedCapabilitiesProperties = calculatedCapabilitiesProperties;
 217     }
 218
 219     public Map<String, MapArtifactDataDefinition> getInstanceArtifacts() {
 220         return instanceArtifacts;
 221     }
 222     public void setInstanceArtifacts(Map<String, MapArtifactDataDefinition> instanceArtifacts) {
 223         this.instanceArtifacts = instanceArtifacts;
 224     }
 225
 226     public Map<String, ForwardingPathDataDefinition> getForwardingPaths() {
 227         return forwardingPaths;
 228     }
 229
 230     public void setForwardingPaths(Map<String, ForwardingPathDataDefinition> forwardingPaths) {
 231         this.forwardingPaths = forwardingPaths;
 232     }
 233
 234     public Map<String, CINodeFilterDataDefinition> getNodeFilterComponents() {
 235         return nodeFilterComponents;
 236     }
 237
 238     public void setNodeFilterComponents(Map<String, CINodeFilterDataDefinition> nodeFilters) {
 239         this.nodeFilterComponents = nodeFilters;
 240     }
 241
 242       /**
 243      * Adds component instance to composition of topology template
 244      * Note that component instance will be overrided in case if the topology template already contains a component instance with the same name
 245      * @param componentInstance
 246      */
 247     public void addComponentInstance(ComponentInstanceDataDefinition componentInstance){
 248         if(getCompositions() == null){
 249             compositions = new HashMap<>();
 250         }
 251         if(MapUtils.isEmpty(getCompositions())){
 252             compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition());
 253         }
 254         if(MapUtils.isEmpty(getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances())){
 255             getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(new HashMap<>());
 256         }
 257         getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances().put(componentInstance.getUniqueId(), componentInstance);
 258     }
 259     /**
 260      * Returns map of component instances from composition
 261      * @return
 262      */
 263     public Map<String, ComponentInstanceDataDefinition> getComponentInstances() {
 264         Map<String, ComponentInstanceDataDefinition> instances = null;
 265         if(getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){
 266             instances = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances();
 267         }
 268         return instances;
 269     }
 270
 271
 272     /**
 273      * Sets map of component instances to composition of topology template
 274      * Note that component instances will be overrided in case if the topology template already contains a component instances
 275      * @param instances
 276      */
 277     public void setComponentInstances(Map<String, ComponentInstanceDataDefinition> instances) {
 278         if(getCompositions() == null){
 279             compositions = new HashMap<>();
 280         }
 281         if(MapUtils.isEmpty(getCompositions())){
 282             compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition());
 283         }
 284         getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(instances);
 285     }
 286     public Map<String, RelationshipInstDataDefinition> getRelations() {
 287         Map<String, RelationshipInstDataDefinition> relations = null;
 288         if( getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){
 289             relations = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getRelations();
 290         }
 291         return relations;
 292     }
 293 }