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