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