catalog-model/src/main/java/org/openecomp/sdc/be/model/Component.java

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