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.DataTypeDefinition;
  29 import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition;
  30 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
  31
  32 import java.util.HashMap;
  33 import java.util.Map;
  34
  35 public class TopologyTemplate extends ToscaElement{
  36
  37     public TopologyTemplate() {
  38         super(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE);
  39     }
  40     private Map<String, PropertyDataDefinition> inputs;
  41     private Map<String, MapPropertiesDataDefinition> instInputs;
  42     private Map<String, ? extends ToscaDataDefinition> heatParameters;
  43     private Map<String, MapPropertiesDataDefinition> instAttributes;
  44     private Map<String, MapPropertiesDataDefinition> instProperties;
  45     private Map<String, GroupDataDefinition> groups;
  46     private Map<String, PolicyDataDefinition> policies;
  47     private Map<String, MapGroupsDataDefinition> instGroups;
  48     private Map<String, ArtifactDataDefinition> serviceApiArtifacts;
  49     private Map<String, ForwardingPathDataDefinition> forwardingPaths;
  50     private Map<String, CompositionDataDefinition> compositions;
  51     private Map<String, MapListCapabilityDataDefinition> calculatedCapabilities;
  52     private Map<String, MapListRequirementDataDefinition> calculatedRequirements;
  53     private Map<String, MapListCapabilityDataDefinition> fullfilledCapabilities;
  54     private Map<String, MapListRequirementDataDefinition> fullfilledRequirements;
  55     private Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties;
  56     private Map<String, MapArtifactDataDefinition> instDeploymentArtifacts;
  57     private Map<String, MapArtifactDataDefinition> instanceArtifacts;
  58     private Map<String, InterfaceDataDefinition> interfaces;
  59     private Map<String, MapInterfaceInstanceDataDefinition> instInterfaces;
  60     private Map<String, MapInterfaceDataDefinition> componentInstInterfaces;
  61     private Map<String, DataTypeDataDefinition> dataTypes;
  62
  63     private Map<String, CINodeFilterDataDefinition> nodeFilterComponents;
  64     //Component Instances External References (instanceId -> ExternalRefsMap)
  65     //-----------------------------------------------------------------------
  66     private Map<String, MapComponentInstanceExternalRefs> mapComponentInstancesExternalRefs;
  67
  68     public Map<String, MapComponentInstanceExternalRefs> getMapComponentInstancesExternalRefs() {
  69         return this.mapComponentInstancesExternalRefs;
  70     }
  71
  72     public void setComponentInstancesExternalRefs(Map<String, MapComponentInstanceExternalRefs> mapComponentInstancesExternalRefs) {
  73         this.mapComponentInstancesExternalRefs = mapComponentInstancesExternalRefs;
  74     }
  75     //-----------------------------------------------------------------------
  76
  77     public Map<String, InterfaceDataDefinition> getInterfaces() {
  78       return interfaces;
  79     }
  80
  81     public void setInterfaces(Map<String, InterfaceDataDefinition> interfaces) {
  82       this.interfaces = interfaces;
  83     }
  84
  85     public Map<String, MapInterfaceInstanceDataDefinition> getInstInterfaces() {
  86         return instInterfaces;
  87     }
  88
  89     public void setInstInterfaces(
  90             Map<String, MapInterfaceInstanceDataDefinition> instInterfaces) {
  91         this.instInterfaces = instInterfaces;
  92     }
  93
  94     public void addInstInterface(String compId, MapInterfaceInstanceDataDefinition
  95             mapInterfaceInstanceDataDefinition) {
  96         if(MapUtils.isEmpty(this.instInterfaces)) {
  97             this.instInterfaces = new HashMap<>();
  98         }
  99
 100         this.instInterfaces.put(compId, mapInterfaceInstanceDataDefinition);
 101     }
 102
 103     public Map<String, MapInterfaceDataDefinition> getComponentInstInterfaces() {
 104         return componentInstInterfaces;
 105     }
 106
 107     public void setComponentInstInterfaces(
 108             Map<String, MapInterfaceDataDefinition> componentInstInterfaces) {
 109         this.componentInstInterfaces = componentInstInterfaces;
 110     }
 111
 112     public void addComponentInstanceInterfaceMap(String componentInstanceId, MapInterfaceDataDefinition
 113             mapInterfaceDataDefinition) {
 114         if(MapUtils.isEmpty(this.componentInstInterfaces)) {
 115             this.componentInstInterfaces = new HashMap<>();
 116         }
 117
 118         this.componentInstInterfaces.put(componentInstanceId, mapInterfaceDataDefinition);
 119     }
 120
 121
 122     public Map<String, PropertyDataDefinition> getInputs() {
 123         return inputs;
 124     }
 125     public void setInputs(Map<String, PropertyDataDefinition> inputs) {
 126         this.inputs = inputs;
 127     }
 128     public Map<String, MapPropertiesDataDefinition> getInstInputs() {
 129         return instInputs;
 130     }
 131     public void setInstInputs(Map<String, MapPropertiesDataDefinition> instInputs) {
 132         this.instInputs = instInputs;
 133     }
 134     public Map<String, ? extends ToscaDataDefinition> getHeatParameters() {
 135         return heatParameters;
 136     }
 137     public void setHeatParameters(Map<String, ? extends ToscaDataDefinition> heatParameters) {
 138         this.heatParameters = heatParameters;
 139     }
 140     public Map<String, MapPropertiesDataDefinition> getInstAttributes() {
 141         return instAttributes;
 142     }
 143     public void setInstAttributes(Map<String, MapPropertiesDataDefinition> instAttributes) {
 144         this.instAttributes = instAttributes;
 145     }
 146     public Map<String, MapPropertiesDataDefinition> getInstProperties() {
 147         return instProperties;
 148     }
 149     public void setInstProperties(Map<String, MapPropertiesDataDefinition> instProperties) {
 150         this.instProperties = instProperties;
 151     }
 152     public Map<String, GroupDataDefinition> getGroups() {
 153         return groups;
 154     }
 155     public void setGroups(Map<String, GroupDataDefinition> groups) {
 156         this.groups = groups;
 157     }
 158     public Map<String, PolicyDataDefinition> getPolicies() {
 159         return policies;
 160     }
 161     public void setPolicies(Map<String, PolicyDataDefinition> policies) {
 162         this.policies = policies;
 163     }
 164     public Map<String, MapGroupsDataDefinition> getInstGroups() {
 165         return instGroups;
 166     }
 167     public void setInstGroups(Map<String, MapGroupsDataDefinition> instGroups) {
 168         this.instGroups = instGroups;
 169     }
 170     public Map<String, ArtifactDataDefinition> getServiceApiArtifacts() {
 171         return serviceApiArtifacts;
 172     }
 173     public void setServiceApiArtifacts(Map<String, ArtifactDataDefinition> serviceApiArtifacts) {
 174         this.serviceApiArtifacts = serviceApiArtifacts;
 175     }
 176     public Map<String, CompositionDataDefinition> getCompositions() {
 177         return compositions;
 178     }
 179     public void setCompositions(Map<String, CompositionDataDefinition> compositions) {
 180         this.compositions = compositions;
 181     }
 182     public Map<String, MapListCapabilityDataDefinition> getCalculatedCapabilities() {
 183         return calculatedCapabilities;
 184     }
 185     public void setCalculatedCapabilities(Map<String, MapListCapabilityDataDefinition> calculatedCapabilities) {
 186         this.calculatedCapabilities = calculatedCapabilities;
 187     }
 188     public Map<String, MapListRequirementDataDefinition> getCalculatedRequirements() {
 189         return calculatedRequirements;
 190     }
 191     public void setCalculatedRequirements(Map<String, MapListRequirementDataDefinition> calculatedRequirements) {
 192         this.calculatedRequirements = calculatedRequirements;
 193     }
 194     public Map<String, MapListCapabilityDataDefinition> getFullfilledCapabilities() {
 195         return fullfilledCapabilities;
 196     }
 197     public void setFullfilledCapabilities(Map<String, MapListCapabilityDataDefinition> fullfilledCapabilities) {
 198         this.fullfilledCapabilities = fullfilledCapabilities;
 199     }
 200     public Map<String, MapListRequirementDataDefinition> getFullfilledRequirements() {
 201         return fullfilledRequirements;
 202     }
 203     public void setFullfilledRequirements(Map<String, MapListRequirementDataDefinition> fullfilledRequirements) {
 204         this.fullfilledRequirements = fullfilledRequirements;
 205     }
 206
 207     public Map<String, MapArtifactDataDefinition> getInstDeploymentArtifacts() {
 208         return instDeploymentArtifacts;
 209     }
 210     public void setInstDeploymentArtifacts(Map<String, MapArtifactDataDefinition> instDeploymentArtifacts) {
 211         this.instDeploymentArtifacts = instDeploymentArtifacts;
 212     }
 213
 214     public Map<String, MapCapabilityProperty> getCalculatedCapabilitiesProperties() {
 215         return calculatedCapabilitiesProperties;
 216     }
 217     public void setCalculatedCapabilitiesProperties(Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties) {
 218         this.calculatedCapabilitiesProperties = calculatedCapabilitiesProperties;
 219     }
 220
 221     public Map<String, MapArtifactDataDefinition> getInstanceArtifacts() {
 222         return instanceArtifacts;
 223     }
 224     public void setInstanceArtifacts(Map<String, MapArtifactDataDefinition> instanceArtifacts) {
 225         this.instanceArtifacts = instanceArtifacts;
 226     }
 227
 228     public Map<String, ForwardingPathDataDefinition> getForwardingPaths() {
 229         return forwardingPaths;
 230     }
 231
 232     public void setForwardingPaths(Map<String, ForwardingPathDataDefinition> forwardingPaths) {
 233         this.forwardingPaths = forwardingPaths;
 234     }
 235
 236     public Map<String, CINodeFilterDataDefinition> getNodeFilterComponents() {
 237         return nodeFilterComponents;
 238     }
 239
 240     public void setNodeFilterComponents(Map<String, CINodeFilterDataDefinition> nodeFilters) {
 241         this.nodeFilterComponents = nodeFilters;
 242     }
 243
 244     /**
 245      * Gets data types.
 246      * @return Current data types.
 247      */
 248     public Map<String, DataTypeDataDefinition> getDataTypes() {
 249         return dataTypes;
 250     }
 251
 252     /**
 253      * Sets data types.
 254      * @param dataTypes New data types.
 255      */
 256     public void setDataTypes(Map<String, DataTypeDataDefinition> dataTypes) {
 257         this.dataTypes = dataTypes;
 258     }
 259
 260       /**
 261      * Adds component instance to composition of topology template
 262      * Note that component instance will be overrided in case if the topology template already contains a component instance with the same name
 263      * @param componentInstance
 264      */
 265     public void addComponentInstance(ComponentInstanceDataDefinition componentInstance){
 266         if(getCompositions() == null){
 267             compositions = new HashMap<>();
 268         }
 269         if(MapUtils.isEmpty(getCompositions())){
 270             compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition());
 271         }
 272         if(MapUtils.isEmpty(getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances())){
 273             getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(new HashMap<>());
 274         }
 275         getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances().put(componentInstance.getUniqueId(), componentInstance);
 276     }
 277     /**
 278      * Returns map of component instances from composition
 279      * @return
 280      */
 281     public Map<String, ComponentInstanceDataDefinition> getComponentInstances() {
 282         Map<String, ComponentInstanceDataDefinition> instances = null;
 283         if(getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){
 284             instances = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getComponentInstances();
 285         }
 286         return instances;
 287     }
 288
 289
 290     /**
 291      * Sets map of component instances to composition of topology template
 292      * Note that component instances will be overrided in case if the topology template already contains a component instances
 293      * @param instances
 294      */
 295     public void setComponentInstances(Map<String, ComponentInstanceDataDefinition> instances) {
 296         if(getCompositions() == null){
 297             compositions = new HashMap<>();
 298         }
 299         if(MapUtils.isEmpty(getCompositions())){
 300             compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), new CompositionDataDefinition());
 301         }
 302         getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).setComponentInstances(instances);
 303     }
 304     public Map<String, RelationshipInstDataDefinition> getRelations() {
 305         Map<String, RelationshipInstDataDefinition> relations = null;
 306         if( getCompositions() != null && getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()) != null ){
 307             relations = getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue()).getRelations();
 308         }
 309         return relations;
 310     }
 311 }