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 package org.openecomp.sdc.be.model;
  21
  22 import static java.util.Collections.emptyList;
  23 import static java.util.Collections.emptyMap;
  24 import static java.util.stream.Collectors.toMap;
  25 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  26 import static org.apache.commons.collections.MapUtils.isEmpty;
  27
  28 import com.fasterxml.jackson.annotation.JsonIgnore;
  29 import com.google.common.collect.Maps;
  30 import java.util.ArrayList;
  31 import java.util.Collections;
  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 lombok.EqualsAndHashCode;
  40 import lombok.Getter;
  41 import lombok.Setter;
  42 import org.apache.commons.collections.MapUtils;
  43 import org.openecomp.sdc.be.config.ConfigurationManager;
  44 import org.openecomp.sdc.be.dao.utils.MapUtil;
  45 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
  49 import org.openecomp.sdc.be.datatypes.elements.PropertiesOwner;
  50 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  53 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  54 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  55 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
  56 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  57 import org.openecomp.sdc.common.log.api.ILogConfiguration;
  58
  59 @Getter
  60 @Setter
  61 @EqualsAndHashCode(onlyExplicitlyIncluded = true)
  62 public abstract class Component implements PropertiesOwner {
  63
  64     protected List<AdditionalInformationDefinition> additionalInformation;
  65     protected List<PropertyDefinition> properties;
  66     protected List<AttributeDefinition> attributes;
  67     private ComponentMetadataDefinition componentMetadataDefinition;
  68     private Map<String, ArtifactDefinition> artifacts;
  69     private Map<String, ArtifactDefinition> deploymentArtifacts;
  70     private Map<String, ArtifactDefinition> toscaArtifacts;
  71     @EqualsAndHashCode.Include
  72     private List<CategoryDefinition> categories;
  73     private List<ComponentInstance> componentInstances;
  74     private List<RequirementCapabilityRelDef> componentInstancesRelations;
  75     private Map<String, List<ComponentInstanceInput>> componentInstancesInputs;
  76     private Map<String, List<ComponentInstanceOutput>> componentInstancesOutputs;
  77     private Map<String, List<ComponentInstanceProperty>> componentInstancesProperties;
  78     private Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes;
  79     private Map<String, List<CapabilityDefinition>> capabilities;
  80     private Map<String, List<RequirementDefinition>> requirements;
  81     private Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces;
  82     private List<InputDefinition> inputs;
  83     private List<OutputDefinition> outputs;
  84     private List<GroupDefinition> groups;
  85     private Map<String, PolicyDefinition> policies;
  86     private String derivedFromGenericType;
  87     private String derivedFromGenericVersion;
  88     private String toscaType;
  89     private Map<String, CINodeFilterDataDefinition> nodeFilterComponents;
  90     private Map<String, InterfaceDefinition> interfaces;
  91     private List<DataTypeDefinition> dataTypes;
  92     private SubstitutionFilterDataDefinition substitutionFilter;
  93     private String model;
  94
  95     protected Component(ComponentMetadataDefinition componentMetadataDefinition) {
  96         this.componentMetadataDefinition = componentMetadataDefinition;
  97     }
  98
  99     public Map<String, String> getCategorySpecificMetadata() {
 100         final Map<String, String> categorySpecificMetadata = componentMetadataDefinition.getMetadataDataDefinition().getCategorySpecificMetadata();
 101         return categorySpecificMetadata == null ? Collections.emptyMap() : categorySpecificMetadata;
 102     }
 103
 104     public void setCategorySpecificMetadata(final Map<String, String> categorySpecificMetadata) {
 105         componentMetadataDefinition.getMetadataDataDefinition().setCategorySpecificMetadata(categorySpecificMetadata);
 106     }
 107
 108     public String getModel() {
 109         return getComponentMetadataDefinition().getMetadataDataDefinition().getModel();
 110     }
 111
 112     public void setModel(final String model) {
 113         getComponentMetadataDefinition().getMetadataDataDefinition().setModel(model);
 114     }
 115
 116     @JsonIgnore
 117     public ComponentMetadataDefinition getComponentMetadataDefinition() {
 118         return componentMetadataDefinition;
 119     }
 120
 121     @Override
 122     @EqualsAndHashCode.Include
 123     public String getUniqueId() {
 124         return componentMetadataDefinition.getMetadataDataDefinition().getUniqueId();
 125     }
 126
 127     public void setUniqueId(String uniqueId) {
 128         componentMetadataDefinition.getMetadataDataDefinition().setUniqueId(uniqueId);
 129     }
 130
 131     public void setHighestVersion(Boolean isHighestVersion) {
 132         componentMetadataDefinition.getMetadataDataDefinition().setHighestVersion(isHighestVersion);
 133     }
 134
 135     public void setState(LifecycleStateEnum state) {
 136         componentMetadataDefinition.getMetadataDataDefinition().setState(state.name());
 137     }
 138
 139     public String getCreatorUserId() {
 140         return this.componentMetadataDefinition.getMetadataDataDefinition().getCreatorUserId();
 141     }
 142
 143     public void setCreatorUserId(String creatorUserId) {
 144         this.componentMetadataDefinition.getMetadataDataDefinition().setCreatorUserId(creatorUserId);
 145     }
 146
 147     public String getCreatorFullName() {
 148         return this.componentMetadataDefinition.getMetadataDataDefinition().getCreatorFullName();
 149     }
 150
 151     public void setCreatorFullName(String creatorFullName) {
 152         this.componentMetadataDefinition.getMetadataDataDefinition().setCreatorFullName(creatorFullName);
 153     }
 154
 155     public String getLastUpdaterUserId() {
 156         return this.componentMetadataDefinition.getMetadataDataDefinition().getLastUpdaterUserId();
 157     }
 158
 159     public void setLastUpdaterUserId(String lastUpdaterUserId) {
 160         this.componentMetadataDefinition.getMetadataDataDefinition().setLastUpdaterUserId(lastUpdaterUserId);
 161     }
 162
 163     public String getLastUpdaterFullName() {
 164         return this.componentMetadataDefinition.getMetadataDataDefinition().getLastUpdaterFullName();
 165     }
 166
 167     public void setLastUpdaterFullName(String lastUpdaterFullName) {
 168         this.componentMetadataDefinition.getMetadataDataDefinition().setLastUpdaterFullName(lastUpdaterFullName);
 169     }
 170
 171     @Override
 172     @EqualsAndHashCode.Include
 173     public String getName() {
 174         return componentMetadataDefinition.getMetadataDataDefinition().getName();
 175     }
 176
 177     public void setName(String name) {
 178         componentMetadataDefinition.getMetadataDataDefinition().setName(name);
 179     }
 180
 181     public String getVersion() {
 182         return componentMetadataDefinition.getMetadataDataDefinition().getVersion();
 183     }
 184
 185     public void setVersion(String version) {
 186         componentMetadataDefinition.getMetadataDataDefinition().setVersion(version);
 187     }
 188
 189     public Boolean isHighestVersion() {
 190         return componentMetadataDefinition.getMetadataDataDefinition().isHighestVersion();
 191     }
 192
 193     public Long getCreationDate() {
 194         return componentMetadataDefinition.getMetadataDataDefinition().getCreationDate();
 195     }
 196
 197     public void setCreationDate(Long creationDate) {
 198         componentMetadataDefinition.getMetadataDataDefinition().setCreationDate(creationDate);
 199     }
 200
 201     public Long getLastUpdateDate() {
 202         return componentMetadataDefinition.getMetadataDataDefinition().getLastUpdateDate();
 203     }
 204
 205     public void setLastUpdateDate(Long lastUpdateDate) {
 206         componentMetadataDefinition.getMetadataDataDefinition().setLastUpdateDate(lastUpdateDate);
 207     }
 208
 209     public String getDescription() {
 210         return componentMetadataDefinition.getMetadataDataDefinition().getDescription();
 211     }
 212
 213     public void setDescription(String description) {
 214         componentMetadataDefinition.getMetadataDataDefinition().setDescription(description);
 215     }
 216
 217     public LifecycleStateEnum getLifecycleState() {
 218         if (componentMetadataDefinition.getMetadataDataDefinition().getState() != null) {
 219             return LifecycleStateEnum.valueOf(componentMetadataDefinition.getMetadataDataDefinition().getState());
 220         } else {
 221             return null;
 222         }
 223     }
 224
 225     public void setLifecycleState(LifecycleStateEnum state) {
 226         if (state != null) {
 227             this.componentMetadataDefinition.getMetadataDataDefinition().setState(state.name());
 228         }
 229     }
 230
 231     public List<String> getTags() {
 232         return componentMetadataDefinition.getMetadataDataDefinition().getTags();
 233     }
 234
 235     public void setTags(List<String> tags) {
 236         componentMetadataDefinition.getMetadataDataDefinition().setTags(tags);
 237     }
 238
 239     public String getConformanceLevel() {
 240         return componentMetadataDefinition.getMetadataDataDefinition().getConformanceLevel();
 241     }
 242
 243     public void setConformanceLevel(String conformanceLevel) {
 244         componentMetadataDefinition.getMetadataDataDefinition().setConformanceLevel(conformanceLevel);
 245     }
 246
 247     public String getIcon() {
 248         return componentMetadataDefinition.getMetadataDataDefinition().getIcon();
 249     }
 250
 251     public void setIcon(String icon) {
 252         componentMetadataDefinition.getMetadataDataDefinition().setIcon(icon);
 253     }
 254
 255     public String getContactId() {
 256         return componentMetadataDefinition.getMetadataDataDefinition().getContactId();
 257     }
 258
 259     public void setContactId(String contactId) {
 260         componentMetadataDefinition.getMetadataDataDefinition().setContactId(contactId);
 261     }
 262
 263     public List<InputDefinition> safeGetInputs() {
 264         return inputs == null ? new ArrayList<>() : inputs;
 265     }
 266
 267     public String getUUID() {
 268         return componentMetadataDefinition.getMetadataDataDefinition().getUUID();
 269     }
 270
 271     public void setUUID(String uUID) {
 272         componentMetadataDefinition.getMetadataDataDefinition().setUUID(uUID);
 273     }
 274
 275     public String getSystemName() {
 276         return componentMetadataDefinition.getMetadataDataDefinition().getSystemName();
 277     }
 278
 279     public void setSystemName(String systemName) {
 280         componentMetadataDefinition.getMetadataDataDefinition().setSystemName(systemName);
 281     }
 282
 283     public Map<String, String> getAllVersions() {
 284         return componentMetadataDefinition.getMetadataDataDefinition().getAllVersions();
 285     }
 286
 287     public void setAllVersions(Map<String, String> allVersions) {
 288         componentMetadataDefinition.getMetadataDataDefinition().setAllVersions(allVersions);
 289     }
 290
 291     public Map<String, ArtifactDefinition> getAllArtifacts() {
 292         HashMap<String, ArtifactDefinition> allArtifacts = new HashMap<>();
 293         allArtifacts.putAll(Optional.ofNullable(this.deploymentArtifacts).orElse(emptyMap()));
 294         allArtifacts.putAll(Optional.ofNullable(this.artifacts).orElse(emptyMap()));
 295         return allArtifacts;
 296     }
 297
 298     @Override
 299     @EqualsAndHashCode.Include
 300     public String getNormalizedName() {
 301         return componentMetadataDefinition.getMetadataDataDefinition().getNormalizedName();
 302     }
 303
 304     public void setNormalizedName(String normalizedName) {
 305         componentMetadataDefinition.getMetadataDataDefinition().setNormalizedName(normalizedName);
 306     }
 307
 308     public ComponentTypeEnum getComponentType() {
 309         return this.componentMetadataDefinition.getMetadataDataDefinition().getComponentType();
 310     }
 311
 312     public void setComponentType(ComponentTypeEnum componentType) {
 313         this.componentMetadataDefinition.getMetadataDataDefinition().setComponentType(componentType);
 314     }
 315
 316     public boolean isService() {
 317         return getComponentType() == ComponentTypeEnum.SERVICE;
 318     }
 319
 320     public Map<String, List<CapabilityDefinition>> getCapabilities() {
 321         if (MapUtils.isEmpty(capabilities)) {
 322             capabilities = Maps.newHashMap();
 323         }
 324         return capabilities;
 325     }
 326
 327     public List<ComponentInstance> safeGetComponentInstances() {
 328         if (componentInstances != null) {
 329             return componentInstances;
 330         } else {
 331             return emptyList();
 332         }
 333     }
 334
 335     public Optional<ComponentInstance> fetchInstanceById(String instanceId) {
 336         return Optional.ofNullable(MapUtil.toMap(componentInstances, ComponentInstance::getUniqueId).get(instanceId));
 337     }
 338
 339     public Map<String, ArtifactDefinition> safeGetComponentInstanceDeploymentArtifacts(String componentInstanceId) {
 340         return getComponentInstanceById(componentInstanceId).map(ComponentInstance::safeGetDeploymentArtifacts).orElse(emptyMap());
 341     }
 342
 343     public Map<String, ArtifactDefinition> safeGetComponentInstanceInformationalArtifacts(String componentInstanceId) {
 344         return getComponentInstanceById(componentInstanceId).map(ComponentInstance::safeGetInformationalArtifacts).orElse(emptyMap());
 345     }
 346
 347     public List<ArtifactDefinition> safeGetComponentInstanceHeatArtifacts(String componentInstanceId) {
 348         return safeGetComponentInstanceDeploymentArtifacts(componentInstanceId).values().stream()
 349             .filter(artifact -> ArtifactTypeEnum.HEAT_ENV.getType().equals(artifact.getArtifactType())).collect(Collectors.toList());
 350     }
 351
 352     public Map<String, List<ComponentInstanceProperty>> safeGetComponentInstancesProperties() {
 353         return componentInstancesProperties == null ? emptyMap() : componentInstancesProperties;
 354     }
 355
 356     public Map<String, List<ComponentInstanceAttribute>> safeGetComponentInstancesAttributes() {
 357         return componentInstancesAttributes == null ? emptyMap() : componentInstancesAttributes;
 358     }
 359
 360     public Map<String, List<ComponentInstanceProperty>> safeGetUiComponentInstancesProperties() {
 361         return componentInstancesProperties == null ? emptyMap() : findUiComponentInstancesProperties();
 362     }
 363
 364     private Map<String, List<ComponentInstanceProperty>> findUiComponentInstancesProperties() {
 365         List<String> instancesFromUi = componentInstances.stream().filter(i -> !i.isCreatedFromCsar()).map(ComponentInstance::getUniqueId)
 366             .collect(Collectors.toList());
 367         return componentInstancesProperties.entrySet().stream().filter(e -> instancesFromUi.contains(e.getKey()))
 368             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 369     }
 370
 371     public Map<String, List<ComponentInstanceInput>> safeGetComponentInstancesInputs() {
 372         return componentInstancesInputs == null ? emptyMap() : componentInstancesInputs;
 373     }
 374
 375     public Map<String, List<ComponentInstanceInput>> safeGetUiComponentInstancesInputs() {
 376         return componentInstancesInputs == null ? emptyMap() : findUiComponentInstancesInputs();
 377     }
 378
 379     private Map<String, List<ComponentInstanceInput>> findUiComponentInstancesInputs() {
 380         List<String> instancesFromUi = componentInstances.stream().filter(i -> !i.isCreatedFromCsar()).map(ComponentInstance::getUniqueId)
 381             .collect(Collectors.toList());
 382         return componentInstancesInputs.entrySet().stream().filter(e -> instancesFromUi.contains(e.getKey()))
 383             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 384     }
 385
 386     public List<ComponentInstanceProperty> safeGetComponentInstanceProperties(String cmptInstacneId) {
 387         return this.safeGetComponentInstanceEntity(cmptInstacneId, this.componentInstancesProperties);
 388     }
 389
 390     public List<ComponentInstanceInput> safeGetComponentInstanceInput(String comptInstanceId) {
 391         return this.safeGetComponentInstanceEntity(comptInstanceId, this.componentInstancesInputs);
 392     }
 393
 394     public List<ComponentInstanceInterface> safeGetComponentInstanceInterfaces(String cmptInstacneId) {
 395         return this.safeGetComponentInstanceEntity(cmptInstacneId, this.componentInstancesInterfaces);
 396     }
 397
 398     public Boolean getIsDeleted() {
 399         return componentMetadataDefinition.getMetadataDataDefinition().isDeleted();
 400     }
 401
 402     public void setIsDeleted(Boolean isDeleted) {
 403         componentMetadataDefinition.getMetadataDataDefinition().setIsDeleted(isDeleted);
 404     }
 405
 406     public String getProjectCode() {
 407         return componentMetadataDefinition.getMetadataDataDefinition().getProjectCode();
 408     }
 409
 410     public void setProjectCode(String projectCode) {
 411         componentMetadataDefinition.getMetadataDataDefinition().setProjectCode(projectCode);
 412     }
 413
 414     public String getCsarUUID() {
 415         return componentMetadataDefinition.getMetadataDataDefinition().getCsarUUID();
 416     }
 417
 418     public void setCsarUUID(String csarUUID) {
 419         componentMetadataDefinition.getMetadataDataDefinition().setCsarUUID(csarUUID);
 420     }
 421
 422     public String getCsarVersion() {
 423         return componentMetadataDefinition.getMetadataDataDefinition().getCsarVersion();
 424     }
 425
 426     public void setCsarVersion(String csarVersion) {
 427         componentMetadataDefinition.getMetadataDataDefinition().setCsarVersion(csarVersion);
 428     }
 429
 430     public String getImportedToscaChecksum() {
 431         return componentMetadataDefinition.getMetadataDataDefinition().getImportedToscaChecksum();
 432     }
 433
 434     public void setImportedToscaChecksum(String importedToscaChecksum) {
 435         componentMetadataDefinition.getMetadataDataDefinition().setImportedToscaChecksum(importedToscaChecksum);
 436     }
 437
 438     public String getInvariantUUID() {
 439         return componentMetadataDefinition.getMetadataDataDefinition().getInvariantUUID();
 440     }
 441
 442     public void setInvariantUUID(String invariantUUID) {
 443         componentMetadataDefinition.getMetadataDataDefinition().setInvariantUUID(invariantUUID);
 444     }
 445
 446     public Optional<ComponentInstance> getComponentInstanceById(String id) {
 447         return getComponentInstanceByPredicate(instance -> id.equals(instance.getUniqueId()));
 448     }
 449
 450     public Optional<ComponentInstance> getComponentInstanceByName(String name) {
 451         return getComponentInstanceByPredicate(instance -> name.equals(instance.getName()));
 452     }
 453
 454     private Optional<ComponentInstance> getComponentInstanceByPredicate(Predicate<ComponentInstance> predicate) {
 455         if (componentInstances == null) {
 456             return Optional.empty();
 457         }
 458         return componentInstances.stream().filter(predicate).findFirst();
 459     }
 460
 461     public List<GroupDefinition> safeGetGroups() {
 462         return groups == null ? emptyList() : groups;
 463     }
 464
 465     public Optional<GroupDefinition> getGroupById(String id) {
 466         return getGroupByPredicate(group -> group.getUniqueId().equals(id));
 467     }
 468
 469     public Optional<GroupDefinition> getGroupByInvariantName(String name) {
 470         return getGroupByPredicate(group -> name.equals(group.getInvariantName()));
 471     }
 472
 473     public boolean containsGroupWithInvariantName(String invariantName) {
 474         return groups != null && groups.stream().anyMatch(gr -> invariantName.equals(gr.getInvariantName()));
 475     }
 476
 477     private Optional<GroupDefinition> getGroupByPredicate(Predicate<GroupDefinition> predicate) {
 478         if (groups == null) {
 479             return Optional.empty();
 480         }
 481         return groups.stream().filter(predicate).findAny();
 482     }
 483
 484     public void addGroups(List<GroupDefinition> groupsToAdd) {
 485         if (groups == null) {
 486             groups = new ArrayList<>();
 487         }
 488         groups.addAll(groupsToAdd);
 489     }
 490
 491     public void addPolicy(PolicyDefinition policyDefinition) {
 492         if (MapUtils.isEmpty(this.policies)) {
 493             this.policies = new HashMap<>();
 494         }
 495         this.policies.put(policyDefinition.getUniqueId(), policyDefinition);
 496     }
 497
 498     public void addProperty(PropertyDefinition propertyDefinition) {
 499         if (org.apache.commons.collections.CollectionUtils.isEmpty(this.properties)) {
 500             this.properties = new ArrayList<>();
 501         }
 502         this.properties.add(propertyDefinition);
 503     }
 504
 505     public void addCategory(String category, String subCategory) {
 506         if (category != null || subCategory != null) {
 507             if (categories == null) {
 508                 categories = new ArrayList<>();
 509             }
 510             CategoryDefinition selectedCategory = null;
 511             for (CategoryDefinition categoryDef : categories) {
 512                 if (categoryDef.getName().equals(category)) {
 513                     selectedCategory = categoryDef;
 514                 }
 515             }
 516             if (selectedCategory == null) {
 517                 selectedCategory = new CategoryDefinition();
 518                 selectedCategory.setName(category);
 519                 categories.add(selectedCategory);
 520             }
 521             List<SubCategoryDefinition> subcategories = selectedCategory.getSubcategories();
 522             if (subcategories == null) {
 523                 subcategories = new ArrayList<>();
 524                 selectedCategory.setSubcategories(subcategories);
 525             }
 526             SubCategoryDefinition selectedSubcategory = null;
 527             for (SubCategoryDefinition subcategory : subcategories) {
 528                 if (subcategory.getName().equals(subCategory)) {
 529                     selectedSubcategory = subcategory;
 530                 }
 531             }
 532             if (selectedSubcategory == null) {
 533                 selectedSubcategory = new SubCategoryDefinition();
 534                 selectedSubcategory.setName(subCategory);
 535                 subcategories.add(selectedSubcategory);
 536             }
 537         }
 538     }
 539
 540     public void addCategory(CategoryDefinition category) {
 541         addCategory(category, null);
 542     }
 543
 544     public void addCategory(CategoryDefinition category, SubCategoryDefinition subCategory) {
 545         if (categories == null) {
 546             categories = new ArrayList<>();
 547         }
 548         boolean foundCat = false;
 549         for (CategoryDefinition cat : categories) {
 550             if (cat.getName().equals(category.getName())) {
 551                 foundCat = true;
 552                 if (subCategory != null) {
 553                     List<SubCategoryDefinition> subcategories = cat.getSubcategories();
 554                     if (subcategories == null) {
 555                         subcategories = new ArrayList<>();
 556                         cat.setSubcategories(subcategories);
 557                     }
 558                     for (SubCategoryDefinition subcat : subcategories) {
 559                         boolean foundSub = false;
 560                         if (subcat.getName().equals(subCategory.getName())) {
 561                             foundSub = true;
 562                         }
 563                         if (!foundSub) {
 564                             subcategories.add(subCategory);
 565                             break;
 566                         }
 567                     }
 568                 }
 569             }
 570         }
 571         if (!foundCat) {
 572             if (subCategory != null) {
 573                 category.addSubCategory(subCategory);
 574             }
 575             categories.add(category);
 576         }
 577     }
 578
 579     public Map<String, List<PropertyDataDefinition>> safeGetGroupsProperties() {
 580         if (isEmpty(groups)) {
 581             return emptyMap();
 582         }
 583         return groups.stream().filter(gr -> Objects.nonNull(gr.getProperties()))
 584             .collect(toMap(GroupDataDefinition::getUniqueId, GroupDataDefinition::getProperties));
 585     }
 586
 587     public Map<String, List<PropertyDataDefinition>> safeGetPolicyProperties() {
 588         if (isEmpty(policies)) {
 589             return emptyMap();
 590         }
 591         return policies.values().stream().filter(policy -> Objects.nonNull(policy.getProperties()))
 592             .collect(toMap(PolicyDataDefinition::getUniqueId, PolicyDataDefinition::getProperties));
 593     }
 594
 595     public List<ComponentInstanceInput> safeGetComponentInstanceInputsByName(String cmptInstanceName) {
 596         List<ComponentInstanceInput> emptyPropsList = emptyList();
 597         if (this.componentInstancesInputs == null) {
 598             return emptyPropsList;
 599         }
 600         return this.componentInstances.stream().filter(ci -> ci.getName().equals(cmptInstanceName)).map(ComponentInstance::getUniqueId)
 601             .map(instanceId -> safeGetComponentInstanceEntity(instanceId, this.componentInstancesInputs)).findAny().orElse(emptyPropsList);
 602     }
 603
 604     private <T> List<T> safeGetComponentInstanceEntity(String cmptInstanceId, Map<String, List<T>> instanceEntities) {
 605         List<T> emptyPropsList = emptyList();
 606         if (instanceEntities == null) {
 607             return emptyPropsList;
 608         }
 609         List<T> cmptInstanceProps = instanceEntities.get(cmptInstanceId);
 610         return cmptInstanceProps == null ? emptyPropsList : cmptInstanceProps;
 611     }
 612
 613     public void setSpecificComponetTypeArtifacts(Map<String, ArtifactDefinition> specificComponentTypeArtifacts) {
 614         // Implement where needed
 615     }
 616
 617     public String fetchGenericTypeToscaNameFromConfig() {
 618         return ConfigurationManager.getConfigurationManager().getConfiguration().getGenericAssetNodeTypes().get(this.assetType());
 619     }
 620
 621     protected <A> Optional<A> getHeadOption(List<A> list) {
 622         return list == null || list.isEmpty() ? Optional.empty() : Optional.ofNullable(list.get(0));
 623     }
 624
 625     public String assetType() {
 626         // Implement where needed
 627         return this.getComponentType().getValue();
 628     }
 629
 630     public boolean shouldGenerateInputs() {
 631         // Implement where needed
 632         return true;
 633     }
 634
 635     public boolean deriveFromGeneric() {
 636         // Implement where needed
 637         return true;
 638     }
 639
 640     public void setDerivedFromGenericInfo(Resource genericType) {
 641         derivedFromGenericType = genericType.getToscaResourceName();
 642         derivedFromGenericVersion = genericType.getVersion();
 643     }
 644
 645     public boolean isTopologyTemplate() {
 646         return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue().equals(toscaType);
 647     }
 648
 649     public PolicyDefinition getPolicyById(String id) {
 650         return policies != null ? policies.get(id) : null;
 651     }
 652
 653     public List<PolicyDefinition> resolvePoliciesList() {
 654         if (policies == null) {
 655             return emptyList();
 656         }
 657         return new ArrayList<>(policies.values());
 658     }
 659
 660     public List<PolicyDefinition> resolvePoliciesContainingTarget(String targetId, PolicyTargetType targetType) {
 661         Predicate<PolicyDefinition> containsTarget = policy -> policy.containsTarget(targetId, targetType);
 662         return resolvePoliciesByPredicate(containsTarget);
 663     }
 664
 665     private List<PolicyDefinition> resolvePoliciesByPredicate(Predicate<PolicyDefinition> policyPredicate) {
 666         if (policies == null) {
 667             return emptyList();
 668         }
 669         return policies.values().stream().filter(policyPredicate).collect(Collectors.toList());
 670     }
 671
 672     public List<GroupDefinition> resolveGroupsByMember(String instanceId) {
 673         if (groups == null) {
 674             return emptyList();
 675         }
 676         return groups.stream().filter(group -> group.containsInstanceAsMember(instanceId)).collect(Collectors.toList());
 677     }
 678
 679     public String getActualComponentType() {
 680         return componentMetadataDefinition.getMetadataDataDefinition().getActualComponentType();
 681     }
 682
 683     public Boolean isArchived() {
 684         return componentMetadataDefinition.getMetadataDataDefinition().isArchived();
 685     }
 686
 687     public void setArchived(Boolean archived) {
 688         componentMetadataDefinition.getMetadataDataDefinition().setArchived(archived);
 689     }
 690
 691     public Long getArchiveTime() {
 692         return componentMetadataDefinition.getMetadataDataDefinition().getArchiveTime();
 693     }
 694
 695     public void setArchiveTime(Long archiveTime) {
 696         componentMetadataDefinition.getMetadataDataDefinition().setArchiveTime(archiveTime);
 697     }
 698
 699     public Boolean isVspArchived() {
 700         return componentMetadataDefinition.getMetadataDataDefinition().isVspArchived();
 701     }
 702
 703     public void setVspArchived(Boolean vspArchived) {
 704         componentMetadataDefinition.getMetadataDataDefinition().setVspArchived(vspArchived);
 705     }
 706
 707     // supportability log method return map of component metadata teddy.h
 708     public Map<String, String> getComponentMetadataForSupportLog() {
 709         Map<String, String> componentMetadata = new HashMap<>();
 710         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_NAME, this.getName());
 711         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_VERSION, this.getVersion());
 712         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_UUID, this.getUUID());
 713         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_CSAR_UUID, this.getCsarUUID());
 714         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_CSAR_VERSION, this.getCsarVersion());
 715         return componentMetadata;
 716     }
 717 }