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