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