catalog-model/src/main/java/org/openecomp/sdc/be/model/Component.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;
  22
  23 import static java.util.Collections.emptyList;
  24 import static java.util.Collections.emptyMap;
  25 import static java.util.stream.Collectors.toMap;
  26 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  27 import static org.apache.commons.collections.MapUtils.isEmpty;
  28
  29 import com.fasterxml.jackson.annotation.JsonIgnore;
  30 import com.google.common.collect.Maps;
  31 import java.util.ArrayList;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Objects;
  36 import java.util.Optional;
  37 import java.util.function.Predicate;
  38 import java.util.stream.Collectors;
  39 import org.apache.commons.collections.MapUtils;
  40 import org.openecomp.sdc.be.config.ConfigurationManager;
  41 import org.openecomp.sdc.be.dao.utils.MapUtil;
  42 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
  46 import org.openecomp.sdc.be.datatypes.elements.PropertiesOwner;
  47 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  49 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  50 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  51 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
  52 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  53 import org.openecomp.sdc.common.log.api.ILogConfiguration;
  54
  55 public abstract class Component implements PropertiesOwner {
  56
  57         private ComponentMetadataDefinition componentMetadataDefinition;
  58         private Map<String, ArtifactDefinition> artifacts;
  59         private Map<String, ArtifactDefinition> deploymentArtifacts;
  60         private Map<String, ArtifactDefinition> toscaArtifacts;
  61         private List<CategoryDefinition> categories;
  62         private List<ComponentInstance> componentInstances;
  63         private List<RequirementCapabilityRelDef> componentInstancesRelations;
  64         private Map<String, List<ComponentInstanceInput>> componentInstancesInputs;
  65         private Map<String, List<ComponentInstanceProperty>> componentInstancesProperties;
  66         private Map<String, List<ComponentInstanceProperty>> componentInstancesAttributes;
  67         private Map<String, List<CapabilityDefinition>> capabilities;
  68         private Map<String, List<RequirementDefinition>> requirements;
  69         private Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces;
  70         private List<InputDefinition> inputs;
  71         private List<GroupDefinition> groups;
  72         private Map<String, PolicyDefinition> policies;
  73         private String derivedFromGenericType;
  74         private String derivedFromGenericVersion;
  75         private String toscaType;
  76         protected List<AdditionalInformationDefinition> additionalInformation;
  77         private Map<String, CINodeFilterDataDefinition> nodeFilterComponents;
  78         private Map<String, List<UploadNodeFilterInfo>> nodeFilters;
  79         private Map<String, List<UploadNodeFilterInfo>> serviceFilters;
  80         protected List<PropertyDefinition> properties;
  81         private Map<String, InterfaceDefinition> interfaces;
  82     private List<DataTypeDefinition> dataTypes;
  83
  84     public List<DataTypeDefinition> getDataTypes() {
  85         return dataTypes;
  86     }
  87
  88     public void setDataTypes(List<DataTypeDefinition> dataTypes) {
  89         this.dataTypes = dataTypes;
  90     }
  91
  92     public Map<String, InterfaceDefinition> getInterfaces() {
  93                 return interfaces;
  94         }
  95
  96         public void setInterfaces(Map<String, InterfaceDefinition> interfaces) {
  97                 this.interfaces = interfaces;
  98         }
  99
 100     public Component(ComponentMetadataDefinition componentMetadataDefinition) {
 101         this.componentMetadataDefinition = componentMetadataDefinition;
 102     }
 103
 104     public String getDerivedFromGenericVersion() {
 105         return derivedFromGenericVersion;
 106     }
 107
 108     public void setDerivedFromGenericVersion(String derivedFromGenericVersion) {
 109         this.derivedFromGenericVersion = derivedFromGenericVersion;
 110     }
 111
 112     public String getDerivedFromGenericType() {
 113         return derivedFromGenericType;
 114     }
 115
 116     public void setDerivedFromGenericType(String derivedFromGenericType) {
 117         this.derivedFromGenericType = derivedFromGenericType;
 118     }
 119
 120
 121     @JsonIgnore
 122     public ComponentMetadataDefinition getComponentMetadataDefinition() {
 123         return componentMetadataDefinition;
 124     }
 125
 126     public Map<String, ArtifactDefinition> getArtifacts() {
 127         return artifacts;
 128     }
 129
 130     public void setArtifacts(Map<String, ArtifactDefinition> artifacts) {
 131         this.artifacts = artifacts;
 132     }
 133
 134     public Map<String, ArtifactDefinition> getToscaArtifacts() {
 135         return toscaArtifacts;
 136     }
 137
 138     public void setToscaArtifacts(Map<String, ArtifactDefinition> toscaArtifacts) {
 139         this.toscaArtifacts = toscaArtifacts;
 140     }
 141
 142         @Override
 143         public String getUniqueId() {
 144                 return componentMetadataDefinition.getMetadataDataDefinition().getUniqueId();
 145         }
 146
 147     public void setUniqueId(String uniqueId) {
 148         componentMetadataDefinition.getMetadataDataDefinition().setUniqueId(uniqueId);
 149     }
 150
 151     public void setName(String name) {
 152         componentMetadataDefinition.getMetadataDataDefinition().setName(name);
 153     }
 154
 155     public void setVersion(String version) {
 156         componentMetadataDefinition.getMetadataDataDefinition().setVersion(version);
 157     }
 158
 159     public void setHighestVersion(Boolean isHighestVersion) {
 160         componentMetadataDefinition.getMetadataDataDefinition().setHighestVersion(isHighestVersion);
 161     }
 162
 163     public void setCreationDate(Long creationDate) {
 164         componentMetadataDefinition.getMetadataDataDefinition().setCreationDate(creationDate);
 165     }
 166
 167     public void setLastUpdateDate(Long lastUpdateDate) {
 168         componentMetadataDefinition.getMetadataDataDefinition().setLastUpdateDate(lastUpdateDate);
 169     }
 170
 171     public void setDescription(String description) {
 172         componentMetadataDefinition.getMetadataDataDefinition().setDescription(description);
 173     }
 174
 175     public void setState(LifecycleStateEnum state) {
 176         componentMetadataDefinition.getMetadataDataDefinition().setState(state.name());
 177     }
 178
 179     public void setTags(List<String> tags) {
 180         componentMetadataDefinition.getMetadataDataDefinition().setTags(tags);
 181     }
 182
 183     public void setConformanceLevel(String conformanceLevel) {
 184         componentMetadataDefinition.getMetadataDataDefinition().setConformanceLevel(conformanceLevel);
 185     }
 186
 187     public void setIcon(String icon) {
 188         componentMetadataDefinition.getMetadataDataDefinition().setIcon(icon);
 189     }
 190
 191     public void setContactId(String contactId) {
 192         componentMetadataDefinition.getMetadataDataDefinition().setContactId(contactId);
 193     }
 194
 195     public String getCreatorUserId() {
 196         return this.componentMetadataDefinition.getMetadataDataDefinition().getCreatorUserId();
 197     }
 198
 199     public void setCreatorUserId(String creatorUserId) {
 200         this.componentMetadataDefinition.getMetadataDataDefinition().setCreatorUserId(creatorUserId);
 201     }
 202
 203     public String getCreatorFullName() {
 204         return this.componentMetadataDefinition.getMetadataDataDefinition().getCreatorFullName();
 205     }
 206
 207     public void setCreatorFullName(String creatorFullName) {
 208         this.componentMetadataDefinition.getMetadataDataDefinition().setCreatorFullName(creatorFullName);
 209     }
 210
 211     public String getLastUpdaterUserId() {
 212         return this.componentMetadataDefinition.getMetadataDataDefinition().getLastUpdaterUserId();
 213     }
 214
 215     public void setLastUpdaterUserId(String lastUpdaterUserId) {
 216         this.componentMetadataDefinition.getMetadataDataDefinition().setLastUpdaterUserId(lastUpdaterUserId);
 217     }
 218
 219     public String getLastUpdaterFullName() {
 220         return this.componentMetadataDefinition.getMetadataDataDefinition().getLastUpdaterFullName();
 221     }
 222
 223     public void setLastUpdaterFullName(String lastUpdaterFullName) {
 224         this.componentMetadataDefinition.getMetadataDataDefinition().setLastUpdaterFullName(lastUpdaterFullName);
 225     }
 226
 227         @Override
 228         public String getName() {
 229                 return componentMetadataDefinition.getMetadataDataDefinition().getName();
 230         }
 231
 232     public String getVersion() {
 233         return componentMetadataDefinition.getMetadataDataDefinition().getVersion();
 234     }
 235
 236     public Boolean isHighestVersion() {
 237         return componentMetadataDefinition.getMetadataDataDefinition().isHighestVersion();
 238     }
 239
 240     public Long getCreationDate() {
 241         return componentMetadataDefinition.getMetadataDataDefinition().getCreationDate();
 242     }
 243
 244     public Long getLastUpdateDate() {
 245         return componentMetadataDefinition.getMetadataDataDefinition().getLastUpdateDate();
 246     }
 247
 248     public String getDescription() {
 249         return componentMetadataDefinition.getMetadataDataDefinition().getDescription();
 250     }
 251
 252     public LifecycleStateEnum getLifecycleState() {
 253         if (componentMetadataDefinition.getMetadataDataDefinition().getState() != null) {
 254             return LifecycleStateEnum.valueOf(componentMetadataDefinition.getMetadataDataDefinition().getState());
 255         }
 256         else {
 257             return null;
 258         }
 259     }
 260
 261     public List<String> getTags() {
 262         return componentMetadataDefinition.getMetadataDataDefinition().getTags();
 263     }
 264
 265     public String getConformanceLevel() {
 266         return componentMetadataDefinition.getMetadataDataDefinition().getConformanceLevel();
 267     }
 268
 269     public String getIcon() {
 270         return componentMetadataDefinition.getMetadataDataDefinition().getIcon();
 271     }
 272
 273     public String getContactId() {
 274         return componentMetadataDefinition.getMetadataDataDefinition().getContactId();
 275     }
 276
 277     public List<InputDefinition> getInputs() {
 278         return inputs;
 279     }
 280
 281     public List<InputDefinition> safeGetInputs() {
 282         return inputs == null ? new ArrayList<>() : inputs;
 283     }
 284
 285     public void setInputs(List<InputDefinition> inputs) {
 286         this.inputs = inputs;
 287     }
 288
 289     public void setLifecycleState(LifecycleStateEnum state) {
 290         if (state != null) {
 291             this.componentMetadataDefinition.getMetadataDataDefinition().setState(state.name());
 292         }
 293     }
 294
 295     public String getUUID() {
 296         return componentMetadataDefinition.getMetadataDataDefinition().getUUID();
 297     }
 298
 299     public void setUUID(String uUID) {
 300         componentMetadataDefinition.getMetadataDataDefinition().setUUID(uUID);
 301     }
 302
 303     public void setSystemName(String systemName) {
 304         componentMetadataDefinition.getMetadataDataDefinition().setSystemName(systemName);
 305     }
 306
 307     public String getSystemName() {
 308         return componentMetadataDefinition.getMetadataDataDefinition().getSystemName();
 309     }
 310
 311     public void setAllVersions(Map<String, String> allVersions) {
 312         componentMetadataDefinition.getMetadataDataDefinition().setAllVersions(allVersions);
 313     }
 314
 315     public Map<String, String> getAllVersions() {
 316         return componentMetadataDefinition.getMetadataDataDefinition().getAllVersions();
 317     }
 318
 319     public Map<String, ArtifactDefinition> getDeploymentArtifacts() {
 320         return deploymentArtifacts;
 321     }
 322
 323     public void setDeploymentArtifacts(Map<String, ArtifactDefinition> deploymentArtifacts) {
 324         this.deploymentArtifacts = deploymentArtifacts;
 325     }
 326
 327     public Map<String, ArtifactDefinition> getAllArtifacts() {
 328         HashMap<String, ArtifactDefinition> allArtifacts = new HashMap<>();
 329         allArtifacts.putAll(Optional.ofNullable(this.deploymentArtifacts).orElse(emptyMap()));
 330         allArtifacts.putAll(Optional.ofNullable(this.artifacts).orElse(emptyMap()));
 331         return allArtifacts;
 332     }
 333
 334     Optional<ArtifactDefinition> getArtifact(String id) {
 335         HashMap<String, ArtifactDefinition> allArtifacts = new HashMap<>();
 336         allArtifacts.putAll(Optional.ofNullable(this.artifacts).orElse(emptyMap()));
 337         allArtifacts.putAll(Optional.ofNullable(this.deploymentArtifacts).orElse(emptyMap()));
 338         allArtifacts.putAll(Optional.ofNullable(this.toscaArtifacts).orElse(emptyMap()));
 339         return Optional.ofNullable(allArtifacts.get(id));
 340     }
 341
 342     public List<CategoryDefinition> getCategories() {
 343         return categories;
 344     }
 345
 346     public void setCategories(List<CategoryDefinition> categories) {
 347         this.categories = categories;
 348     }
 349
 350         @Override
 351         public String getNormalizedName() {
 352                 return componentMetadataDefinition.getMetadataDataDefinition().getNormalizedName();
 353         }
 354
 355     public void setNormalizedName(String normalizedName) {
 356         componentMetadataDefinition.getMetadataDataDefinition().setNormalizedName(normalizedName);
 357     }
 358
 359     public ComponentTypeEnum getComponentType() {
 360         return this.componentMetadataDefinition.getMetadataDataDefinition().getComponentType();
 361     }
 362
 363     public void setComponentType(ComponentTypeEnum componentType) {
 364         this.componentMetadataDefinition.getMetadataDataDefinition().setComponentType(componentType);
 365     }
 366
 367     public Map<String, List<CapabilityDefinition>> getCapabilities() {
 368         if (MapUtils.isEmpty(capabilities)) {
 369             capabilities = Maps.newHashMap();
 370         }
 371         return capabilities;
 372     }
 373
 374     public void setCapabilities(Map<String, List<CapabilityDefinition>> capabilities) {
 375         this.capabilities = capabilities;
 376     }
 377
 378     public Map<String, List<RequirementDefinition>> getRequirements() {
 379         return requirements;
 380     }
 381
 382     public void setRequirements(Map<String, List<RequirementDefinition>> requirements) {
 383         this.requirements = requirements;
 384     }
 385
 386     public List<ComponentInstance> getComponentInstances() {
 387         return componentInstances;
 388     }
 389
 390     public List<ComponentInstance> safeGetComponentInstances() {
 391         if(componentInstances != null) {
 392                 return componentInstances;
 393         }else {
 394                 return emptyList();
 395         }
 396     }
 397
 398     public Optional<ComponentInstance> fetchInstanceById(String instanceId) {
 399         return Optional.ofNullable(MapUtil.toMap(componentInstances, ComponentInstance::getUniqueId).get(instanceId));
 400     }
 401
 402     public Map<String, ArtifactDefinition> safeGetComponentInstanceDeploymentArtifacts(String componentInstanceId) {
 403         return getComponentInstanceById(componentInstanceId).map(ComponentInstance::safeGetDeploymentArtifacts)
 404                                                             .orElse(emptyMap());
 405     }
 406
 407     public Map<String, ArtifactDefinition> safeGetComponentInstanceInformationalArtifacts(String componentInstanceId) {
 408         return getComponentInstanceById(componentInstanceId).map(ComponentInstance::safeGetInformationalArtifacts)
 409                                                             .orElse(emptyMap());
 410     }
 411
 412     public List<ArtifactDefinition> safeGetComponentInstanceHeatArtifacts(String componentInstanceId) {
 413         return safeGetComponentInstanceDeploymentArtifacts(componentInstanceId)
 414                 .values()
 415                 .stream()
 416                 .filter(artifact -> ArtifactTypeEnum.HEAT_ENV.name().equals(artifact.getArtifactType()))
 417                 .collect(Collectors.toList());
 418     }
 419
 420     public void setComponentInstances(List<ComponentInstance> resourceInstances) {
 421         this.componentInstances = resourceInstances;
 422     }
 423
 424     public List<RequirementCapabilityRelDef> getComponentInstancesRelations() {
 425         return componentInstancesRelations;
 426     }
 427
 428     public void setComponentInstancesRelations(List<RequirementCapabilityRelDef> resourceInstancesRelations) {
 429         this.componentInstancesRelations = resourceInstancesRelations;
 430     }
 431
 432     public Map<String, List<ComponentInstanceProperty>> getComponentInstancesProperties() {
 433         return componentInstancesProperties;
 434     }
 435
 436     public Map<String, List<ComponentInstanceProperty>> safeGetComponentInstancesProperties() {
 437         return componentInstancesProperties == null ? emptyMap() : componentInstancesProperties;
 438     }
 439
 440     public Map<String, List<ComponentInstanceProperty>> safeGetUiComponentInstancesProperties() {
 441         return componentInstancesProperties == null ? emptyMap() : findUiComponentInstancesProperties();
 442     }
 443
 444     private Map<String,List<ComponentInstanceProperty>> findUiComponentInstancesProperties() {
 445         List<String> instancesFromUi = componentInstances.stream()
 446                 .filter(i->!i.isCreatedFromCsar())
 447                 .map(ComponentInstance::getUniqueId)
 448                 .collect(Collectors.toList());
 449         return componentInstancesProperties.entrySet().stream()
 450                 .filter(e -> instancesFromUi.contains(e.getKey()))
 451                 .collect(Collectors.toMap(e->e.getKey(), e->e.getValue()));
 452     }
 453
 454     public Map<String, List<ComponentInstanceInput>> safeGetComponentInstancesInputs() {
 455         return componentInstancesInputs == null ? emptyMap() : componentInstancesInputs;
 456     }
 457
 458     public Map<String, List<ComponentInstanceInput>> safeGetUiComponentInstancesInputs() {
 459         return componentInstancesInputs == null ? emptyMap() : findUiComponentInstancesInputs();
 460     }
 461
 462     private Map<String,List<ComponentInstanceInput>> findUiComponentInstancesInputs() {
 463         List<String> instancesFromUi = componentInstances.stream()
 464                 .filter(i->!i.isCreatedFromCsar())
 465                 .map(ComponentInstance::getUniqueId)
 466                 .collect(Collectors.toList());
 467         return componentInstancesInputs.entrySet().stream()
 468                 .filter(e -> instancesFromUi.contains(e.getKey()))
 469                 .collect(Collectors.toMap(e->e.getKey(), e->e.getValue()));
 470     }
 471
 472     public List<ComponentInstanceProperty> safeGetComponentInstanceProperties(String cmptInstacneId) {
 473         return this.safeGetComponentInstanceEntity(cmptInstacneId, this.componentInstancesProperties);
 474     }
 475
 476     public List<ComponentInstanceInput> safeGetComponentInstanceInput(String comptInstanceId) {
 477         return this.safeGetComponentInstanceEntity(comptInstanceId, this.componentInstancesInputs);
 478     }
 479
 480         public List<ComponentInstanceInterface> safeGetComponentInstanceInterfaces(String cmptInstacneId) {
 481                 return this.safeGetComponentInstanceEntity(cmptInstacneId, this.componentInstancesInterfaces);
 482         }
 483
 484         public void setComponentInstancesProperties(
 485                         Map<String, List<ComponentInstanceProperty>> resourceInstancesProperties) {
 486                 this.componentInstancesProperties = resourceInstancesProperties;
 487         }
 488
 489     public Boolean getIsDeleted() {
 490         return componentMetadataDefinition.getMetadataDataDefinition().isDeleted();
 491     }
 492
 493     public void setIsDeleted(Boolean isDeleted) {
 494         componentMetadataDefinition.getMetadataDataDefinition().setIsDeleted(isDeleted);
 495     }
 496
 497     public String getProjectCode() {
 498         return componentMetadataDefinition.getMetadataDataDefinition().getProjectCode();
 499     }
 500
 501     public void setProjectCode(String projectCode) {
 502         componentMetadataDefinition.getMetadataDataDefinition().setProjectCode(projectCode);
 503     }
 504
 505     public String getCsarUUID() {
 506         return componentMetadataDefinition.getMetadataDataDefinition().getCsarUUID();
 507     }
 508
 509     public void setCsarUUID(String csarUUID) {
 510         componentMetadataDefinition.getMetadataDataDefinition().setCsarUUID(csarUUID);
 511     }
 512
 513     public String getCsarVersion() {
 514         return componentMetadataDefinition.getMetadataDataDefinition().getCsarVersion();
 515     }
 516
 517     public void setCsarVersion(String csarVersion) {
 518         componentMetadataDefinition.getMetadataDataDefinition().setCsarVersion(csarVersion);
 519     }
 520
 521     public String getImportedToscaChecksum() {
 522         return componentMetadataDefinition.getMetadataDataDefinition().getImportedToscaChecksum();
 523     }
 524
 525     public void setImportedToscaChecksum(String importedToscaChecksum) {
 526         componentMetadataDefinition.getMetadataDataDefinition().setImportedToscaChecksum(importedToscaChecksum);
 527     }
 528
 529     public String getInvariantUUID() {
 530         return componentMetadataDefinition.getMetadataDataDefinition().getInvariantUUID();
 531     }
 532
 533     public void setInvariantUUID(String invariantUUID) {
 534         componentMetadataDefinition.getMetadataDataDefinition().setInvariantUUID(invariantUUID);
 535     }
 536
 537     public Optional<ComponentInstance> getComponentInstanceById(String id) {
 538         return getComponentInstanceByPredicate(instance -> id.equals(instance.getUniqueId()));
 539     }
 540
 541     public Optional<ComponentInstance> getComponentInstanceByName(String name) {
 542         return getComponentInstanceByPredicate(instance -> name.equals(instance.getName()));
 543     }
 544
 545     private Optional<ComponentInstance> getComponentInstanceByPredicate(Predicate<ComponentInstance> predicate) {
 546         if (componentInstances == null) {
 547             return Optional.empty();
 548         }
 549         return componentInstances.stream().filter(predicate).findFirst();
 550     }
 551
 552     public List<GroupDefinition> getGroups() {
 553         return groups;
 554     }
 555
 556     public List<GroupDefinition> safeGetGroups() {
 557         return groups == null ? emptyList() : groups;
 558     }
 559
 560     public Optional<GroupDefinition> getGroupById(String id) {
 561         return getGroupByPredicate(group -> group.getUniqueId().equals(id));
 562     }
 563
 564     public Optional<GroupDefinition> getGroupByInvariantName(String name) {
 565         return getGroupByPredicate(group -> name.equals(group.getInvariantName()));
 566     }
 567
 568     public boolean containsGroupWithInvariantName(String invariantName) {
 569         return groups != null && groups.stream().anyMatch(gr -> invariantName.equals(gr.getInvariantName()));
 570     }
 571
 572     private Optional<GroupDefinition> getGroupByPredicate(Predicate<GroupDefinition> predicate) {
 573         if (groups == null) {
 574             return Optional.empty();
 575         }
 576         return groups.stream()
 577                      .filter(predicate)
 578                      .findAny();
 579     }
 580
 581         public Map<String, List<ComponentInstanceInterface>> getComponentInstancesInterfaces() {
 582                 return componentInstancesInterfaces;
 583         }
 584
 585         public void setComponentInstancesInterfaces(Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces) {
 586                 this.componentInstancesInterfaces = componentInstancesInterfaces;
 587         }
 588
 589         public void setGroups(List<GroupDefinition> groups) {
 590                 this.groups = groups;
 591         }
 592
 593   public void addGroups(List<GroupDefinition> groupsToAdd) {
 594     if (groups == null) {
 595       groups = new ArrayList<>();
 596     }
 597     groups.addAll(groupsToAdd);
 598   }
 599
 600         public Map<String, PolicyDefinition> getPolicies() {
 601                 return policies;
 602         }
 603
 604     public void setPolicies(Map<String, PolicyDefinition> policies) {
 605         this.policies = policies;
 606     }
 607
 608     public void addPolicy(PolicyDefinition policyDefinition) {
 609             if(MapUtils.isEmpty(this.policies)) {
 610                 this.policies = new HashMap<>();
 611         }
 612
 613         this.policies.put(policyDefinition.getUniqueId(), policyDefinition);
 614     }
 615
 616         public Map<String, CINodeFilterDataDefinition> getNodeFilterComponents() {
 617                 return nodeFilterComponents;
 618         }
 619
 620         public void setNodeFilterComponents(Map<String, CINodeFilterDataDefinition> nodeFilter) {
 621                 this.nodeFilterComponents = nodeFilter;
 622         }
 623
 624
 625
 626         public Map<String, List<UploadNodeFilterInfo>> getNodeFilters() {
 627                 return nodeFilters;
 628         }
 629
 630         public void setNodeFilters(
 631                         Map<String, List<UploadNodeFilterInfo>> nodeFilters) {
 632                 this.nodeFilters = nodeFilters;
 633         }
 634
 635         public Map<String, List<UploadNodeFilterInfo>> getServiceFilters() {
 636                 return serviceFilters;
 637         }
 638
 639         public void setServiceFilters(
 640                         Map<String, List<UploadNodeFilterInfo>> serviceFilters) {
 641                 this.serviceFilters = serviceFilters;
 642         }
 643
 644         public List<PropertyDefinition> getProperties() {
 645                 return properties;
 646         }
 647
 648         public void setProperties(List<PropertyDefinition> properties) {
 649                 this.properties = properties;
 650         }
 651
 652         public void addProperty(PropertyDefinition propertyDefinition) {
 653             if(org.apache.commons.collections.CollectionUtils.isEmpty(this.properties)) {
 654                 this.properties = new ArrayList<>();
 655         }
 656
 657         this.properties.add(propertyDefinition);;
 658     }
 659
 660         @Override
 661         public int hashCode() {
 662                 final int prime = 31;
 663                 int result = 1;
 664                 result = prime * result + ((artifacts == null) ? 0 : artifacts.hashCode());
 665                 result = prime * result + ((categories == null) ? 0 : categories.hashCode());
 666                 result = prime * result + ((componentMetadataDefinition == null) ? 0 : componentMetadataDefinition.hashCode());
 667                 result = prime * result + ((deploymentArtifacts == null) ? 0 : deploymentArtifacts.hashCode());
 668                 result = prime * result + ((capabilities == null) ? 0 : capabilities.hashCode());
 669                 result = prime * result + ((requirements == null) ? 0 : requirements.hashCode());
 670                 result = prime * result + ((componentInstances == null) ? 0 : componentInstances.hashCode());
 671                 result = prime * result
 672                                 + ((componentInstancesProperties == null) ? 0 : componentInstancesProperties.hashCode());
 673                 result = prime * result
 674                                 + ((componentInstancesAttributes == null) ? 0 : componentInstancesAttributes.hashCode());
 675                 result = prime * result + ((componentInstancesInputs == null) ? 0 : componentInstancesInputs.hashCode());
 676                 result = prime * result + ((componentInstancesRelations == null) ? 0 : componentInstancesRelations.hashCode());
 677                 result = prime * result + ((groups == null) ? 0 : groups.hashCode());
 678                 result = prime * result + ((policies == null) ? 0 : policies.hashCode());
 679                 result = prime * result + ((derivedFromGenericType == null) ? 0 : derivedFromGenericType.hashCode());
 680                 result = prime * result + ((derivedFromGenericVersion == null) ? 0 : derivedFromGenericVersion.hashCode());
 681                 result = prime * result + ((interfaces == null) ? 0 : interfaces.hashCode());
 682                 return result;
 683         }
 684
 685     @Override
 686     public boolean equals(Object obj) {
 687         if (this == obj) {
 688             return true;
 689         }
 690         if (obj == null) {
 691             return false;
 692         }
 693         if (getClass() != obj.getClass()) {
 694             return false;
 695         }
 696         Component other = (Component) obj;
 697         if (artifacts == null) {
 698             if (other.artifacts != null) {
 699                 return false;
 700             }
 701         }
 702         else if (!artifacts.equals(other.artifacts)) {
 703             return false;
 704         }
 705         if (categories == null) {
 706             if (other.categories != null) {
 707                 return false;
 708             }
 709         }
 710         else if (!categories.equals(other.categories)) {
 711             return false;
 712         }
 713         if (componentMetadataDefinition == null) {
 714             if (other.componentMetadataDefinition != null) {
 715                 return false;
 716             }
 717         }
 718         else if (!componentMetadataDefinition.equals(other.componentMetadataDefinition)) {
 719             return false;
 720         }
 721
 722         if (deploymentArtifacts == null) {
 723             if (other.deploymentArtifacts != null) {
 724                 return false;
 725             }
 726         }
 727         else if (!deploymentArtifacts.equals(other.deploymentArtifacts)) {
 728             return false;
 729         }
 730
 731         if (componentInstances == null) {
 732             if (other.componentInstances != null) {
 733                 return false;
 734             }
 735         }
 736         else if (!componentInstances.equals(other.componentInstances)) {
 737             return false;
 738         }
 739         if (componentInstancesProperties == null) {
 740             if (other.componentInstancesProperties != null) {
 741                 return false;
 742             }
 743         }
 744         else if (!componentInstancesProperties.equals(other.componentInstancesProperties)) {
 745             return false;
 746         }
 747
 748         if (!Objects.equals(componentInstancesAttributes, other.componentInstancesAttributes)) {
 749             return false;
 750         }
 751         if (!Objects.equals(componentInstancesInputs, other.componentInstancesInputs)) {
 752             return false;
 753         }
 754         if (componentInstancesRelations == null) {
 755             if (other.componentInstancesRelations != null) {
 756                 return false;
 757             }
 758         }
 759         else if (!componentInstancesRelations.equals(other.componentInstancesRelations)) {
 760             return false;
 761         }
 762         if (requirements == null) {
 763             if (other.requirements != null) {
 764                 return false;
 765             }
 766         }
 767         else if (!requirements.equals(other.requirements)) {
 768             return false;
 769         }
 770         if (capabilities == null) {
 771             if (other.capabilities != null) {
 772                 return false;
 773             }
 774         }
 775         else if (!capabilities.equals(other.capabilities)) {
 776             return false;
 777         }
 778         if (groups == null) {
 779             if (other.groups != null) {
 780                 return false;
 781             }
 782         }
 783         else if (!groups.equals(other.groups)) {
 784             return false;
 785         }
 786         if (policies == null) {
 787             if (other.policies != null) {
 788                 return false;
 789             }
 790         }
 791         else if (!policies.equals(other.policies)) {
 792             return false;
 793         }
 794         if (derivedFromGenericType == null) {
 795             if (other.derivedFromGenericType != null) {
 796                 return false;
 797             }
 798         }
 799         else if (!derivedFromGenericType.equals(other.derivedFromGenericType)) {
 800             return false;
 801         }
 802         if (derivedFromGenericVersion == null) {
 803             if (other.derivedFromGenericVersion != null) {
 804                 return false;
 805             }
 806         }
 807         else if (!derivedFromGenericVersion.equals(other.derivedFromGenericVersion)) {
 808             return false;
 809         }
 810         if (interfaces == null) {
 811             if (other.interfaces != null) {
 812                 return false;
 813             }
 814         }
 815         else if (!interfaces.equals(other.interfaces)) {
 816             return false;
 817         }
 818         if (properties == null) {
 819             if (other.properties != null) {
 820                 return false;
 821             }
 822         }
 823         else if (!properties.equals(other.properties)) {
 824             return false;
 825         }
 826         else if (!nodeFilterComponents.equals(other.nodeFilterComponents)) {
 827             return false;
 828         }
 829         return true;
 830     }
 831
 832     public void addCategory(String category, String subCategory) {
 833         if (category != null || subCategory != null) {
 834             if (categories == null) {
 835                 categories = new ArrayList<>();
 836             }
 837             CategoryDefinition selectedCategory = null;
 838             for (CategoryDefinition categoryDef : categories) {
 839                 if (categoryDef.getName().equals(category)) {
 840                     selectedCategory = categoryDef;
 841                 }
 842             }
 843             if (selectedCategory == null) {
 844                 selectedCategory = new CategoryDefinition();
 845                 selectedCategory.setName(category);
 846                 categories.add(selectedCategory);
 847             }
 848             List<SubCategoryDefinition> subcategories = selectedCategory.getSubcategories();
 849             if (subcategories == null) {
 850                 subcategories = new ArrayList<>();
 851                 selectedCategory.setSubcategories(subcategories);
 852             }
 853             SubCategoryDefinition selectedSubcategory = null;
 854             for (SubCategoryDefinition subcategory : subcategories) {
 855                 if (subcategory.getName().equals(subCategory)) {
 856                     selectedSubcategory = subcategory;
 857                 }
 858             }
 859             if (selectedSubcategory == null) {
 860                 selectedSubcategory = new SubCategoryDefinition();
 861                 selectedSubcategory.setName(subCategory);
 862                 subcategories.add(selectedSubcategory);
 863             }
 864         }
 865     }
 866
 867     public void addCategory(CategoryDefinition category) {
 868         addCategory(category, null);
 869     }
 870
 871     public void addCategory(CategoryDefinition category, SubCategoryDefinition subCategory) {
 872         if (categories == null) {
 873             categories = new ArrayList<>();
 874         }
 875         boolean foundCat = false;
 876         for (CategoryDefinition cat : categories) {
 877             if (cat.getName().equals(category.getName())) {
 878                 foundCat = true;
 879                 if (subCategory != null) {
 880                     List<SubCategoryDefinition> subcategories = cat.getSubcategories();
 881                     if (subcategories == null) {
 882                         subcategories = new ArrayList<>();
 883                         cat.setSubcategories(subcategories);
 884                     }
 885                     for (SubCategoryDefinition subcat : subcategories) {
 886                         boolean foundSub = false;
 887                         if (subcat.getName().equals(subCategory.getName())) {
 888                             foundSub = true;
 889                         }
 890                         if (!foundSub) {
 891                             subcategories.add(subCategory);
 892                             break;
 893                         }
 894                     }
 895                 }
 896             }
 897         }
 898         if (!foundCat) {
 899             if (subCategory != null) {
 900                 category.addSubCategory(subCategory);
 901             }
 902             categories.add(category);
 903         }
 904     }
 905
 906     public Map<String, List<ComponentInstanceProperty>> getComponentInstancesAttributes() {
 907         return componentInstancesAttributes;
 908     }
 909
 910     public void setComponentInstancesAttributes(
 911             Map<String, List<ComponentInstanceProperty>> componentInstancesAttributes) {
 912         this.componentInstancesAttributes = componentInstancesAttributes;
 913     }
 914
 915     public Map<String, List<ComponentInstanceInput>> getComponentInstancesInputs() {
 916         return componentInstancesInputs;
 917     }
 918
 919     public Map<String, List<PropertyDataDefinition>> safeGetGroupsProperties() {
 920         if (isEmpty(groups)) {
 921             return emptyMap();
 922         }
 923         return groups.stream()
 924               .filter(gr -> Objects.nonNull(gr.getProperties()))
 925               .collect(toMap(GroupDataDefinition::getUniqueId,
 926                              GroupDataDefinition::getProperties));
 927     }
 928
 929     public Map<String, List<PropertyDataDefinition>> safeGetPolicyProperties() {
 930         if (isEmpty(policies)) {
 931             return emptyMap();
 932         }
 933         return policies.values()
 934                 .stream()
 935                 .filter(policy -> Objects.nonNull(policy.getProperties()))
 936                 .collect(toMap(PolicyDataDefinition::getUniqueId,
 937                                PolicyDataDefinition::getProperties));
 938     }
 939
 940     public List<ComponentInstanceInput> safeGetComponentInstanceInputsByName(String cmptInstanceName) {
 941         List<ComponentInstanceInput> emptyPropsList = emptyList();
 942         if (this.componentInstancesInputs == null) {
 943             return emptyPropsList;
 944         }
 945         return this.componentInstances.stream()
 946                                       .filter(ci -> ci.getName().equals(cmptInstanceName))
 947                                       .map(ComponentInstance::getUniqueId)
 948                                       .map(instanceId -> safeGetComponentInstanceEntity(instanceId, this.componentInstancesInputs))
 949                                       .findAny()
 950                                       .orElse(emptyPropsList);
 951     }
 952
 953     private <T> List<T> safeGetComponentInstanceEntity(String cmptInstanceId, Map<String, List<T>> instanceEntities) {
 954         List<T> emptyPropsList = emptyList();
 955         if (instanceEntities == null) {
 956             return emptyPropsList;
 957         }
 958         List<T> cmptInstanceProps = instanceEntities.get(cmptInstanceId);
 959         return cmptInstanceProps == null ? emptyPropsList : cmptInstanceProps;
 960     }
 961
 962
 963     public void setComponentInstancesInputs(Map<String, List<ComponentInstanceInput>> componentInstancesInputs) {
 964         this.componentInstancesInputs = componentInstancesInputs;
 965     }
 966
 967     public void setSpecificComponetTypeArtifacts(Map<String, ArtifactDefinition> specificComponentTypeArtifacts) {
 968         // Implement where needed
 969     }
 970
 971     public void setMetadataDefinition(ComponentMetadataDefinition metadataDefinition) {
 972         this.componentMetadataDefinition = metadataDefinition;
 973     }
 974
 975     public String fetchGenericTypeToscaNameFromConfig() {
 976         // Implement where needed
 977         return ConfigurationManager.getConfigurationManager()
 978                                    .getConfiguration()
 979                                    .getGenericAssetNodeTypes()
 980                                    .get(this.assetType());
 981     }
 982
 983     public String assetType() {
 984         // Implement where needed
 985         return this.getComponentType().getValue();
 986     }
 987
 988     public boolean shouldGenerateInputs() {
 989         // Implement where needed
 990         return true;
 991     }
 992
 993     public boolean deriveFromGeneric() {
 994         // Implement where needed
 995         return true;
 996     }
 997
 998     public void setDerivedFromGenericInfo(Resource genericType) {
 999         derivedFromGenericType = genericType.getToscaResourceName();
1000         derivedFromGenericVersion = genericType.getVersion();
1001     }
1002
1003     public boolean isTopologyTemplate() {
1004         return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue().equals(toscaType);
1005     }
1006
1007     public String getToscaType() {
1008         return toscaType;
1009     }
1010
1011     public void setToscaType(String toscaType) {
1012         this.toscaType = toscaType;
1013     }
1014
1015     public List<AdditionalInformationDefinition> getAdditionalInformation() {
1016         return additionalInformation;
1017     }
1018
1019     public void setAdditionalInformation(List<AdditionalInformationDefinition> additionalInformation) {
1020         this.additionalInformation = additionalInformation;
1021     }
1022
1023     public PolicyDefinition getPolicyById(String id) {
1024         return policies != null ? policies.get(id) : null;
1025     }
1026
1027     public List<PolicyDefinition> resolvePoliciesList() {
1028         if (policies == null) {
1029             return emptyList();
1030         }
1031         return new ArrayList<>(policies.values());
1032     }
1033
1034     public List<PolicyDefinition> resolvePoliciesContainingTarget(String targetId, PolicyTargetType targetType) {
1035         Predicate<PolicyDefinition> containsTarget = policy -> policy.containsTarget(targetId, targetType);
1036         return resolvePoliciesByPredicate(containsTarget);
1037     }
1038
1039     private List<PolicyDefinition> resolvePoliciesByPredicate(Predicate<PolicyDefinition> policyPredicate) {
1040         if (policies == null) {
1041             return emptyList();
1042         }
1043         return policies.values().stream()
1044                        .filter(policyPredicate)
1045                        .collect(Collectors.toList());
1046     }
1047
1048     public List<GroupDefinition> resolveGroupsByMember(String instanceId) {
1049         if (groups == null) {
1050             return emptyList();
1051         }
1052         return groups.stream()
1053                      .filter(group -> group.containsInstanceAsMember(instanceId))
1054                      .collect(Collectors.toList());
1055     }
1056
1057     public String getActualComponentType() {
1058         return componentMetadataDefinition.getMetadataDataDefinition().getActualComponentType();
1059     }
1060
1061     public Boolean isArchived() { return componentMetadataDefinition.getMetadataDataDefinition().isArchived(); }
1062
1063     public void setArchived(Boolean archived) { componentMetadataDefinition.getMetadataDataDefinition().setArchived(archived); }
1064
1065     public Long getArchiveTime() { return componentMetadataDefinition.getMetadataDataDefinition().getArchiveTime(); }
1066
1067     public void setArchiveTime(Long archiveTime) { componentMetadataDefinition.getMetadataDataDefinition().setArchiveTime(archiveTime); }
1068
1069     public Boolean isVspArchived() { return componentMetadataDefinition.getMetadataDataDefinition().isVspArchived();    }
1070
1071     public void setVspArchived(Boolean vspArchived) { componentMetadataDefinition.getMetadataDataDefinition().setVspArchived(vspArchived); }
1072
1073     //supportability log method return map of component metadata teddy.h
1074     public Map<String,String> getComponentMetadataForSupportLog(){
1075         Map<String,String>componentMetadata=new HashMap<>();
1076         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_NAME,this.getName());
1077         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_VERSION,this.getVersion());
1078         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_UUID,this.getUUID());
1079         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_CSAR_UUID,this.getCsarUUID());
1080         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_CSAR_VERSION,this.getCsarVersion());
1081         return componentMetadata;
1082     }
1083
1084
1085 }