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