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 org.apache.commons.collections.MapUtils;
  40 import org.openecomp.sdc.be.config.ConfigurationManager;
  41 import org.openecomp.sdc.be.dao.utils.MapUtil;
  42 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
  45 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.elements.PropertiesOwner;
  48
  49 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  50 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  51 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  52 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
  53 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  54 import org.openecomp.sdc.common.log.api.ILogConfiguration;
  55
  56 import static java.util.stream.Collectors.toMap;
  57
  58 public abstract class Component implements PropertiesOwner {
  59
  60         private ComponentMetadataDefinition componentMetadataDefinition;
  61         private Map<String, ArtifactDefinition> artifacts;
  62         private Map<String, ArtifactDefinition> deploymentArtifacts;
  63         private Map<String, ArtifactDefinition> toscaArtifacts;
  64         private List<CategoryDefinition> categories;
  65         private List<ComponentInstance> componentInstances;
  66         private List<RequirementCapabilityRelDef> componentInstancesRelations;
  67         private Map<String, List<ComponentInstanceInput>> componentInstancesInputs;
  68         private Map<String, List<ComponentInstanceProperty>> componentInstancesProperties;
  69         private Map<String, List<ComponentInstanceProperty>> componentInstancesAttributes;
  70         private Map<String, List<CapabilityDefinition>> capabilities;
  71         private Map<String, List<RequirementDefinition>> requirements;
  72         private Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces;
  73         private List<InputDefinition> inputs;
  74         private List<GroupDefinition> groups;
  75         private Map<String, PolicyDefinition> policies;
  76         private String derivedFromGenericType;
  77         private String derivedFromGenericVersion;
  78         private String toscaType;
  79         protected List<AdditionalInformationDefinition> additionalInformation;
  80         private Map<String, CINodeFilterDataDefinition> nodeFilterComponents;
  81         private Map<String, List<UploadNodeFilterInfo>> nodeFilters;
  82         private Map<String, List<UploadNodeFilterInfo>> serviceFilters;
  83         protected List<PropertyDefinition> properties;
  84         private Map<String, InterfaceDefinition> interfaces;
  85     private List<DataTypeDefinition> dataTypes;
  86
  87     public List<DataTypeDefinition> getDataTypes() {
  88         return dataTypes;
  89     }
  90
  91     public void setDataTypes(List<DataTypeDefinition> dataTypes) {
  92         this.dataTypes = dataTypes;
  93     }
  94
  95     public Map<String, InterfaceDefinition> getInterfaces() {
  96                 return interfaces;
  97         }
  98
  99         public void setInterfaces(Map<String, InterfaceDefinition> interfaces) {
 100                 this.interfaces = interfaces;
 101         }
 102
 103     public Component(ComponentMetadataDefinition componentMetadataDefinition) {
 104         this.componentMetadataDefinition = componentMetadataDefinition;
 105     }
 106
 107     public String getDerivedFromGenericVersion() {
 108         return derivedFromGenericVersion;
 109     }
 110
 111     public void setDerivedFromGenericVersion(String derivedFromGenericVersion) {
 112         this.derivedFromGenericVersion = derivedFromGenericVersion;
 113     }
 114
 115     public String getDerivedFromGenericType() {
 116         return derivedFromGenericType;
 117     }
 118
 119     public void setDerivedFromGenericType(String derivedFromGenericType) {
 120         this.derivedFromGenericType = derivedFromGenericType;
 121     }
 122
 123
 124     @JsonIgnore
 125     public ComponentMetadataDefinition getComponentMetadataDefinition() {
 126         return componentMetadataDefinition;
 127     }
 128
 129     public Map<String, ArtifactDefinition> getArtifacts() {
 130         return artifacts;
 131     }
 132
 133     public void setArtifacts(Map<String, ArtifactDefinition> artifacts) {
 134         this.artifacts = artifacts;
 135     }
 136
 137     public Map<String, ArtifactDefinition> getToscaArtifacts() {
 138         return toscaArtifacts;
 139     }
 140
 141     public void setToscaArtifacts(Map<String, ArtifactDefinition> toscaArtifacts) {
 142         this.toscaArtifacts = toscaArtifacts;
 143     }
 144
 145         @Override
 146         public String getUniqueId() {
 147                 return componentMetadataDefinition.getMetadataDataDefinition().getUniqueId();
 148         }
 149
 150     public void setUniqueId(String uniqueId) {
 151         componentMetadataDefinition.getMetadataDataDefinition().setUniqueId(uniqueId);
 152     }
 153
 154     public void setName(String name) {
 155         componentMetadataDefinition.getMetadataDataDefinition().setName(name);
 156     }
 157
 158     public void setVersion(String version) {
 159         componentMetadataDefinition.getMetadataDataDefinition().setVersion(version);
 160     }
 161
 162     public void setHighestVersion(Boolean isHighestVersion) {
 163         componentMetadataDefinition.getMetadataDataDefinition().setHighestVersion(isHighestVersion);
 164     }
 165
 166     public void setCreationDate(Long creationDate) {
 167         componentMetadataDefinition.getMetadataDataDefinition().setCreationDate(creationDate);
 168     }
 169
 170     public void setLastUpdateDate(Long lastUpdateDate) {
 171         componentMetadataDefinition.getMetadataDataDefinition().setLastUpdateDate(lastUpdateDate);
 172     }
 173
 174     public void setDescription(String description) {
 175         componentMetadataDefinition.getMetadataDataDefinition().setDescription(description);
 176     }
 177
 178     public void setState(LifecycleStateEnum state) {
 179         componentMetadataDefinition.getMetadataDataDefinition().setState(state.name());
 180     }
 181
 182     public void setTags(List<String> tags) {
 183         componentMetadataDefinition.getMetadataDataDefinition().setTags(tags);
 184     }
 185
 186     public void setConformanceLevel(String conformanceLevel) {
 187         componentMetadataDefinition.getMetadataDataDefinition().setConformanceLevel(conformanceLevel);
 188     }
 189
 190     public void setIcon(String icon) {
 191         componentMetadataDefinition.getMetadataDataDefinition().setIcon(icon);
 192     }
 193
 194     public void setContactId(String contactId) {
 195         componentMetadataDefinition.getMetadataDataDefinition().setContactId(contactId);
 196     }
 197
 198     public String getCreatorUserId() {
 199         return this.componentMetadataDefinition.getMetadataDataDefinition().getCreatorUserId();
 200     }
 201
 202     public void setCreatorUserId(String creatorUserId) {
 203         this.componentMetadataDefinition.getMetadataDataDefinition().setCreatorUserId(creatorUserId);
 204     }
 205
 206     public String getCreatorFullName() {
 207         return this.componentMetadataDefinition.getMetadataDataDefinition().getCreatorFullName();
 208     }
 209
 210     public void setCreatorFullName(String creatorFullName) {
 211         this.componentMetadataDefinition.getMetadataDataDefinition().setCreatorFullName(creatorFullName);
 212     }
 213
 214     public String getLastUpdaterUserId() {
 215         return this.componentMetadataDefinition.getMetadataDataDefinition().getLastUpdaterUserId();
 216     }
 217
 218     public void setLastUpdaterUserId(String lastUpdaterUserId) {
 219         this.componentMetadataDefinition.getMetadataDataDefinition().setLastUpdaterUserId(lastUpdaterUserId);
 220     }
 221
 222     public String getLastUpdaterFullName() {
 223         return this.componentMetadataDefinition.getMetadataDataDefinition().getLastUpdaterFullName();
 224     }
 225
 226     public void setLastUpdaterFullName(String lastUpdaterFullName) {
 227         this.componentMetadataDefinition.getMetadataDataDefinition().setLastUpdaterFullName(lastUpdaterFullName);
 228     }
 229
 230         @Override
 231         public String getName() {
 232                 return componentMetadataDefinition.getMetadataDataDefinition().getName();
 233         }
 234
 235     public String getVersion() {
 236         return componentMetadataDefinition.getMetadataDataDefinition().getVersion();
 237     }
 238
 239     public Boolean isHighestVersion() {
 240         return componentMetadataDefinition.getMetadataDataDefinition().isHighestVersion();
 241     }
 242
 243     public Long getCreationDate() {
 244         return componentMetadataDefinition.getMetadataDataDefinition().getCreationDate();
 245     }
 246
 247     public Long getLastUpdateDate() {
 248         return componentMetadataDefinition.getMetadataDataDefinition().getLastUpdateDate();
 249     }
 250
 251     public String getDescription() {
 252         return componentMetadataDefinition.getMetadataDataDefinition().getDescription();
 253     }
 254
 255     public LifecycleStateEnum getLifecycleState() {
 256         if (componentMetadataDefinition.getMetadataDataDefinition().getState() != null) {
 257             return LifecycleStateEnum.valueOf(componentMetadataDefinition.getMetadataDataDefinition().getState());
 258         }
 259         else {
 260             return null;
 261         }
 262     }
 263
 264     public List<String> getTags() {
 265         return componentMetadataDefinition.getMetadataDataDefinition().getTags();
 266     }
 267
 268     public String getConformanceLevel() {
 269         return componentMetadataDefinition.getMetadataDataDefinition().getConformanceLevel();
 270     }
 271
 272     public String getIcon() {
 273         return componentMetadataDefinition.getMetadataDataDefinition().getIcon();
 274     }
 275
 276     public String getContactId() {
 277         return componentMetadataDefinition.getMetadataDataDefinition().getContactId();
 278     }
 279
 280     public List<InputDefinition> getInputs() {
 281         return inputs;
 282     }
 283
 284     public List<InputDefinition> safeGetInputs() {
 285         return inputs == null ? new ArrayList<>() : inputs;
 286     }
 287
 288     public void setInputs(List<InputDefinition> inputs) {
 289         this.inputs = inputs;
 290     }
 291
 292     public void setLifecycleState(LifecycleStateEnum state) {
 293         if (state != null) {
 294             this.componentMetadataDefinition.getMetadataDataDefinition().setState(state.name());
 295         }
 296     }
 297
 298     public String getUUID() {
 299         return componentMetadataDefinition.getMetadataDataDefinition().getUUID();
 300     }
 301
 302     public void setUUID(String uUID) {
 303         componentMetadataDefinition.getMetadataDataDefinition().setUUID(uUID);
 304     }
 305
 306     public void setSystemName(String systemName) {
 307         componentMetadataDefinition.getMetadataDataDefinition().setSystemName(systemName);
 308     }
 309
 310     public String getSystemName() {
 311         return componentMetadataDefinition.getMetadataDataDefinition().getSystemName();
 312     }
 313
 314     public void setAllVersions(Map<String, String> allVersions) {
 315         componentMetadataDefinition.getMetadataDataDefinition().setAllVersions(allVersions);
 316     }
 317
 318     public Map<String, String> getAllVersions() {
 319         return componentMetadataDefinition.getMetadataDataDefinition().getAllVersions();
 320     }
 321
 322     public Map<String, ArtifactDefinition> getDeploymentArtifacts() {
 323         return deploymentArtifacts;
 324     }
 325
 326     public void setDeploymentArtifacts(Map<String, ArtifactDefinition> deploymentArtifacts) {
 327         this.deploymentArtifacts = deploymentArtifacts;
 328     }
 329
 330     public Map<String, ArtifactDefinition> getAllArtifacts() {
 331         HashMap<String, ArtifactDefinition> allArtifacts = new HashMap<>();
 332         allArtifacts.putAll(Optional.ofNullable(this.deploymentArtifacts).orElse(emptyMap()));
 333         allArtifacts.putAll(Optional.ofNullable(this.artifacts).orElse(emptyMap()));
 334         return allArtifacts;
 335     }
 336
 337     Optional<ArtifactDefinition> getArtifact(String id) {
 338         HashMap<String, ArtifactDefinition> allArtifacts = new HashMap<>();
 339         allArtifacts.putAll(Optional.ofNullable(this.artifacts).orElse(emptyMap()));
 340         allArtifacts.putAll(Optional.ofNullable(this.deploymentArtifacts).orElse(emptyMap()));
 341         allArtifacts.putAll(Optional.ofNullable(this.toscaArtifacts).orElse(emptyMap()));
 342         return Optional.ofNullable(allArtifacts.get(id));
 343     }
 344
 345     public List<CategoryDefinition> getCategories() {
 346         return categories;
 347     }
 348
 349     public void setCategories(List<CategoryDefinition> categories) {
 350         this.categories = categories;
 351     }
 352
 353         @Override
 354         public String getNormalizedName() {
 355                 return componentMetadataDefinition.getMetadataDataDefinition().getNormalizedName();
 356         }
 357
 358     public void setNormalizedName(String normalizedName) {
 359         componentMetadataDefinition.getMetadataDataDefinition().setNormalizedName(normalizedName);
 360     }
 361
 362     public ComponentTypeEnum getComponentType() {
 363         return this.componentMetadataDefinition.getMetadataDataDefinition().getComponentType();
 364     }
 365
 366     public void setComponentType(ComponentTypeEnum componentType) {
 367         this.componentMetadataDefinition.getMetadataDataDefinition().setComponentType(componentType);
 368     }
 369
 370     public Map<String, List<CapabilityDefinition>> getCapabilities() {
 371         if (MapUtils.isEmpty(capabilities)) {
 372             capabilities = Maps.newHashMap();
 373         }
 374         return capabilities;
 375     }
 376
 377     public void setCapabilities(Map<String, List<CapabilityDefinition>> capabilities) {
 378         this.capabilities = capabilities;
 379     }
 380
 381     public Map<String, List<RequirementDefinition>> getRequirements() {
 382         return requirements;
 383     }
 384
 385     public void setRequirements(Map<String, List<RequirementDefinition>> requirements) {
 386         this.requirements = requirements;
 387     }
 388
 389     public List<ComponentInstance> getComponentInstances() {
 390         return componentInstances;
 391     }
 392
 393     public List<ComponentInstance> safeGetComponentInstances() {
 394         if(componentInstances != null) {
 395                 return componentInstances;
 396         }else {
 397                 return emptyList();
 398         }
 399     }
 400
 401     public Optional<ComponentInstance> fetchInstanceById(String instanceId) {
 402         return Optional.ofNullable(MapUtil.toMap(componentInstances, ComponentInstance::getUniqueId).get(instanceId));
 403     }
 404
 405     public Map<String, ArtifactDefinition> safeGetComponentInstanceDeploymentArtifacts(String componentInstanceId) {
 406         return getComponentInstanceById(componentInstanceId).map(ComponentInstance::safeGetDeploymentArtifacts)
 407                                                             .orElse(emptyMap());
 408     }
 409
 410     public Map<String, ArtifactDefinition> safeGetComponentInstanceInformationalArtifacts(String componentInstanceId) {
 411         return getComponentInstanceById(componentInstanceId).map(ComponentInstance::safeGetInformationalArtifacts)
 412                                                             .orElse(emptyMap());
 413     }
 414
 415     public List<ArtifactDefinition> safeGetComponentInstanceHeatArtifacts(String componentInstanceId) {
 416         return safeGetComponentInstanceDeploymentArtifacts(componentInstanceId)
 417                 .values()
 418                 .stream()
 419                 .filter(artifact -> ArtifactTypeEnum.HEAT_ENV.name().equals(artifact.getArtifactType()))
 420                 .collect(Collectors.toList());
 421     }
 422
 423     public void setComponentInstances(List<ComponentInstance> resourceInstances) {
 424         this.componentInstances = resourceInstances;
 425     }
 426
 427     public List<RequirementCapabilityRelDef> getComponentInstancesRelations() {
 428         return componentInstancesRelations;
 429     }
 430
 431     public void setComponentInstancesRelations(List<RequirementCapabilityRelDef> resourceInstancesRelations) {
 432         this.componentInstancesRelations = resourceInstancesRelations;
 433     }
 434
 435     public Map<String, List<ComponentInstanceProperty>> getComponentInstancesProperties() {
 436         return componentInstancesProperties;
 437     }
 438
 439     public Map<String, List<ComponentInstanceProperty>> safeGetComponentInstancesProperties() {
 440         return componentInstancesProperties == null ? emptyMap() : componentInstancesProperties;
 441     }
 442
 443     public Map<String, List<ComponentInstanceProperty>> safeGetUiComponentInstancesProperties() {
 444         return componentInstancesProperties == null ? emptyMap() : findUiComponentInstancesProperties();
 445     }
 446
 447     private Map<String,List<ComponentInstanceProperty>> findUiComponentInstancesProperties() {
 448         List<String> instancesFromUi = componentInstances.stream()
 449                 .filter(i->!i.isCreatedFromCsar())
 450                 .map(ComponentInstance::getUniqueId)
 451                 .collect(Collectors.toList());
 452         return componentInstancesProperties.entrySet().stream()
 453                 .filter(e -> instancesFromUi.contains(e.getKey()))
 454                 .collect(Collectors.toMap(e->e.getKey(), e->e.getValue()));
 455     }
 456
 457     public Map<String, List<ComponentInstanceInput>> safeGetComponentInstancesInputs() {
 458         return componentInstancesInputs == null ? emptyMap() : componentInstancesInputs;
 459     }
 460
 461     public Map<String, List<ComponentInstanceInput>> safeGetUiComponentInstancesInputs() {
 462         return componentInstancesInputs == null ? emptyMap() : findUiComponentInstancesInputs();
 463     }
 464
 465     private Map<String,List<ComponentInstanceInput>> findUiComponentInstancesInputs() {
 466         List<String> instancesFromUi = componentInstances.stream()
 467                 .filter(i->!i.isCreatedFromCsar())
 468                 .map(ComponentInstance::getUniqueId)
 469                 .collect(Collectors.toList());
 470         return componentInstancesInputs.entrySet().stream()
 471                 .filter(e -> instancesFromUi.contains(e.getKey()))
 472                 .collect(Collectors.toMap(e->e.getKey(), e->e.getValue()));
 473     }
 474
 475     public List<ComponentInstanceProperty> safeGetComponentInstanceProperties(String cmptInstacneId) {
 476         return this.safeGetComponentInstanceEntity(cmptInstacneId, this.componentInstancesProperties);
 477     }
 478
 479     public List<ComponentInstanceInput> safeGetComponentInstanceInput(String comptInstanceId) {
 480         return this.safeGetComponentInstanceEntity(comptInstanceId, this.componentInstancesInputs);
 481     }
 482
 483         public List<ComponentInstanceInterface> safeGetComponentInstanceInterfaces(String cmptInstacneId) {
 484                 return this.safeGetComponentInstanceEntity(cmptInstacneId, this.componentInstancesInterfaces);
 485         }
 486
 487         public void setComponentInstancesProperties(
 488                         Map<String, List<ComponentInstanceProperty>> resourceInstancesProperties) {
 489                 this.componentInstancesProperties = resourceInstancesProperties;
 490         }
 491
 492     public Boolean getIsDeleted() {
 493         return componentMetadataDefinition.getMetadataDataDefinition().isDeleted();
 494     }
 495
 496     public void setIsDeleted(Boolean isDeleted) {
 497         componentMetadataDefinition.getMetadataDataDefinition().setIsDeleted(isDeleted);
 498     }
 499
 500     public String getProjectCode() {
 501         return componentMetadataDefinition.getMetadataDataDefinition().getProjectCode();
 502     }
 503
 504     public void setProjectCode(String projectCode) {
 505         componentMetadataDefinition.getMetadataDataDefinition().setProjectCode(projectCode);
 506     }
 507
 508     public String getCsarUUID() {
 509         return componentMetadataDefinition.getMetadataDataDefinition().getCsarUUID();
 510     }
 511
 512     public void setCsarUUID(String csarUUID) {
 513         componentMetadataDefinition.getMetadataDataDefinition().setCsarUUID(csarUUID);
 514     }
 515
 516     public String getCsarVersion() {
 517         return componentMetadataDefinition.getMetadataDataDefinition().getCsarVersion();
 518     }
 519
 520     public void setCsarVersion(String csarVersion) {
 521         componentMetadataDefinition.getMetadataDataDefinition().setCsarVersion(csarVersion);
 522     }
 523
 524     public String getImportedToscaChecksum() {
 525         return componentMetadataDefinition.getMetadataDataDefinition().getImportedToscaChecksum();
 526     }
 527
 528     public void setImportedToscaChecksum(String importedToscaChecksum) {
 529         componentMetadataDefinition.getMetadataDataDefinition().setImportedToscaChecksum(importedToscaChecksum);
 530     }
 531
 532     public String getInvariantUUID() {
 533         return componentMetadataDefinition.getMetadataDataDefinition().getInvariantUUID();
 534     }
 535
 536     public void setInvariantUUID(String invariantUUID) {
 537         componentMetadataDefinition.getMetadataDataDefinition().setInvariantUUID(invariantUUID);
 538     }
 539
 540     public Optional<ComponentInstance> getComponentInstanceById(String id) {
 541         return getComponentInstanceByPredicate(instance -> id.equals(instance.getUniqueId()));
 542     }
 543
 544     public Optional<ComponentInstance> getComponentInstanceByName(String name) {
 545         return getComponentInstanceByPredicate(instance -> name.equals(instance.getName()));
 546     }
 547
 548     private Optional<ComponentInstance> getComponentInstanceByPredicate(Predicate<ComponentInstance> predicate) {
 549         if (componentInstances == null) {
 550             return Optional.empty();
 551         }
 552         return componentInstances.stream().filter(predicate).findFirst();
 553     }
 554
 555     public List<GroupDefinition> getGroups() {
 556         return groups;
 557     }
 558
 559     public List<GroupDefinition> safeGetGroups() {
 560         return groups == null ? emptyList() : groups;
 561     }
 562
 563     public Optional<GroupDefinition> getGroupById(String id) {
 564         return getGroupByPredicate(group -> group.getUniqueId().equals(id));
 565     }
 566
 567     public Optional<GroupDefinition> getGroupByInvariantName(String name) {
 568         return getGroupByPredicate(group -> name.equals(group.getInvariantName()));
 569     }
 570
 571     public boolean containsGroupWithInvariantName(String invariantName) {
 572         return groups != null && groups.stream().anyMatch(gr -> invariantName.equals(gr.getInvariantName()));
 573     }
 574
 575     private Optional<GroupDefinition> getGroupByPredicate(Predicate<GroupDefinition> predicate) {
 576         if (groups == null) {
 577             return Optional.empty();
 578         }
 579         return groups.stream()
 580                      .filter(predicate)
 581                      .findAny();
 582     }
 583
 584         public Map<String, List<ComponentInstanceInterface>> getComponentInstancesInterfaces() {
 585                 return componentInstancesInterfaces;
 586         }
 587
 588         public void setComponentInstancesInterfaces(Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces) {
 589                 this.componentInstancesInterfaces = componentInstancesInterfaces;
 590         }
 591
 592         public void setGroups(List<GroupDefinition> groups) {
 593                 this.groups = groups;
 594         }
 595
 596   public void addGroups(List<GroupDefinition> groupsToAdd) {
 597     if (groups == null) {
 598       groups = new ArrayList<>();
 599     }
 600     groups.addAll(groupsToAdd);
 601   }
 602
 603         public Map<String, PolicyDefinition> getPolicies() {
 604                 return policies;
 605         }
 606
 607     public void setPolicies(Map<String, PolicyDefinition> policies) {
 608         this.policies = policies;
 609     }
 610
 611     public void addPolicy(PolicyDefinition policyDefinition) {
 612             if(MapUtils.isEmpty(this.policies)) {
 613                 this.policies = new HashMap<>();
 614         }
 615
 616         this.policies.put(policyDefinition.getUniqueId(), policyDefinition);
 617     }
 618
 619         public Map<String, CINodeFilterDataDefinition> getNodeFilterComponents() {
 620                 return nodeFilterComponents;
 621         }
 622
 623         public void setNodeFilterComponents(Map<String, CINodeFilterDataDefinition> nodeFilter) {
 624                 this.nodeFilterComponents = nodeFilter;
 625         }
 626
 627
 628
 629         public Map<String, List<UploadNodeFilterInfo>> getNodeFilters() {
 630                 return nodeFilters;
 631         }
 632
 633         public void setNodeFilters(
 634                         Map<String, List<UploadNodeFilterInfo>> nodeFilters) {
 635                 this.nodeFilters = nodeFilters;
 636         }
 637
 638         public Map<String, List<UploadNodeFilterInfo>> getServiceFilters() {
 639                 return serviceFilters;
 640         }
 641
 642         public void setServiceFilters(
 643                         Map<String, List<UploadNodeFilterInfo>> serviceFilters) {
 644                 this.serviceFilters = serviceFilters;
 645         }
 646
 647         public List<PropertyDefinition> getProperties() {
 648                 return properties;
 649         }
 650
 651         public void setProperties(List<PropertyDefinition> properties) {
 652                 this.properties = properties;
 653         }
 654
 655         public void addProperty(PropertyDefinition propertyDefinition) {
 656             if(org.apache.commons.collections.CollectionUtils.isEmpty(this.properties)) {
 657                 this.properties = new ArrayList<>();
 658         }
 659
 660         this.properties.add(propertyDefinition);;
 661     }
 662
 663         @Override
 664         public int hashCode() {
 665                 final int prime = 31;
 666                 int result = 1;
 667                 result = prime * result + ((artifacts == null) ? 0 : artifacts.hashCode());
 668                 result = prime * result + ((categories == null) ? 0 : categories.hashCode());
 669                 result = prime * result + ((componentMetadataDefinition == null) ? 0 : componentMetadataDefinition.hashCode());
 670                 result = prime * result + ((deploymentArtifacts == null) ? 0 : deploymentArtifacts.hashCode());
 671                 result = prime * result + ((capabilities == null) ? 0 : capabilities.hashCode());
 672                 result = prime * result + ((requirements == null) ? 0 : requirements.hashCode());
 673                 result = prime * result + ((componentInstances == null) ? 0 : componentInstances.hashCode());
 674                 result = prime * result
 675                                 + ((componentInstancesProperties == null) ? 0 : componentInstancesProperties.hashCode());
 676                 result = prime * result
 677                                 + ((componentInstancesAttributes == null) ? 0 : componentInstancesAttributes.hashCode());
 678                 result = prime * result + ((componentInstancesInputs == null) ? 0 : componentInstancesInputs.hashCode());
 679                 result = prime * result + ((componentInstancesRelations == null) ? 0 : componentInstancesRelations.hashCode());
 680                 result = prime * result + ((groups == null) ? 0 : groups.hashCode());
 681                 result = prime * result + ((policies == null) ? 0 : policies.hashCode());
 682                 result = prime * result + ((derivedFromGenericType == null) ? 0 : derivedFromGenericType.hashCode());
 683                 result = prime * result + ((derivedFromGenericVersion == null) ? 0 : derivedFromGenericVersion.hashCode());
 684                 result = prime * result + ((interfaces == null) ? 0 : interfaces.hashCode());
 685                 return result;
 686         }
 687
 688     @Override
 689     public boolean equals(Object obj) {
 690         if (this == obj) {
 691             return true;
 692         }
 693         if (obj == null) {
 694             return false;
 695         }
 696         if (getClass() != obj.getClass()) {
 697             return false;
 698         }
 699         Component other = (Component) obj;
 700         if (artifacts == null) {
 701             if (other.artifacts != null) {
 702                 return false;
 703             }
 704         }
 705         else if (!artifacts.equals(other.artifacts)) {
 706             return false;
 707         }
 708         if (categories == null) {
 709             if (other.categories != null) {
 710                 return false;
 711             }
 712         }
 713         else if (!categories.equals(other.categories)) {
 714             return false;
 715         }
 716         if (componentMetadataDefinition == null) {
 717             if (other.componentMetadataDefinition != null) {
 718                 return false;
 719             }
 720         }
 721         else if (!componentMetadataDefinition.equals(other.componentMetadataDefinition)) {
 722             return false;
 723         }
 724
 725         if (deploymentArtifacts == null) {
 726             if (other.deploymentArtifacts != null) {
 727                 return false;
 728             }
 729         }
 730         else if (!deploymentArtifacts.equals(other.deploymentArtifacts)) {
 731             return false;
 732         }
 733
 734         if (componentInstances == null) {
 735             if (other.componentInstances != null) {
 736                 return false;
 737             }
 738         }
 739         else if (!componentInstances.equals(other.componentInstances)) {
 740             return false;
 741         }
 742         if (componentInstancesProperties == null) {
 743             if (other.componentInstancesProperties != null) {
 744                 return false;
 745             }
 746         }
 747         else if (!componentInstancesProperties.equals(other.componentInstancesProperties)) {
 748             return false;
 749         }
 750
 751         if (!Objects.equals(componentInstancesAttributes, other.componentInstancesAttributes)) {
 752             return false;
 753         }
 754         if (!Objects.equals(componentInstancesInputs, other.componentInstancesInputs)) {
 755             return false;
 756         }
 757         if (componentInstancesRelations == null) {
 758             if (other.componentInstancesRelations != null) {
 759                 return false;
 760             }
 761         }
 762         else if (!componentInstancesRelations.equals(other.componentInstancesRelations)) {
 763             return false;
 764         }
 765         if (requirements == null) {
 766             if (other.requirements != null) {
 767                 return false;
 768             }
 769         }
 770         else if (!requirements.equals(other.requirements)) {
 771             return false;
 772         }
 773         if (capabilities == null) {
 774             if (other.capabilities != null) {
 775                 return false;
 776             }
 777         }
 778         else if (!capabilities.equals(other.capabilities)) {
 779             return false;
 780         }
 781         if (groups == null) {
 782             if (other.groups != null) {
 783                 return false;
 784             }
 785         }
 786         else if (!groups.equals(other.groups)) {
 787             return false;
 788         }
 789         if (policies == null) {
 790             if (other.policies != null) {
 791                 return false;
 792             }
 793         }
 794         else if (!policies.equals(other.policies)) {
 795             return false;
 796         }
 797         if (derivedFromGenericType == null) {
 798             if (other.derivedFromGenericType != null) {
 799                 return false;
 800             }
 801         }
 802         else if (!derivedFromGenericType.equals(other.derivedFromGenericType)) {
 803             return false;
 804         }
 805         if (derivedFromGenericVersion == null) {
 806             if (other.derivedFromGenericVersion != null) {
 807                 return false;
 808             }
 809         }
 810         else if (!derivedFromGenericVersion.equals(other.derivedFromGenericVersion)) {
 811             return false;
 812         }
 813         if (interfaces == null) {
 814             if (other.interfaces != null) {
 815                 return false;
 816             }
 817         }
 818         else if (!interfaces.equals(other.interfaces)) {
 819             return false;
 820         }
 821         else if (!properties.equals(other.properties)) {
 822             return false;
 823         }
 824         else if (!nodeFilterComponents.equals(other.nodeFilterComponents)) {
 825             return false;
 826         }
 827         return true;
 828     }
 829
 830     public void addCategory(String category, String subCategory) {
 831         if (category != null || subCategory != null) {
 832             if (categories == null) {
 833                 categories = new ArrayList<>();
 834             }
 835             CategoryDefinition selectedCategory = null;
 836             for (CategoryDefinition categoryDef : categories) {
 837                 if (categoryDef.getName().equals(category)) {
 838                     selectedCategory = categoryDef;
 839                 }
 840             }
 841             if (selectedCategory == null) {
 842                 selectedCategory = new CategoryDefinition();
 843                 selectedCategory.setName(category);
 844                 categories.add(selectedCategory);
 845             }
 846             List<SubCategoryDefinition> subcategories = selectedCategory.getSubcategories();
 847             if (subcategories == null) {
 848                 subcategories = new ArrayList<>();
 849                 selectedCategory.setSubcategories(subcategories);
 850             }
 851             SubCategoryDefinition selectedSubcategory = null;
 852             for (SubCategoryDefinition subcategory : subcategories) {
 853                 if (subcategory.getName().equals(subCategory)) {
 854                     selectedSubcategory = subcategory;
 855                 }
 856             }
 857             if (selectedSubcategory == null) {
 858                 selectedSubcategory = new SubCategoryDefinition();
 859                 selectedSubcategory.setName(subCategory);
 860                 subcategories.add(selectedSubcategory);
 861             }
 862         }
 863     }
 864
 865     public void addCategory(CategoryDefinition category) {
 866         addCategory(category, null);
 867     }
 868
 869     public void addCategory(CategoryDefinition category, SubCategoryDefinition subCategory) {
 870         if (categories == null) {
 871             categories = new ArrayList<>();
 872         }
 873         boolean foundCat = false;
 874         for (CategoryDefinition cat : categories) {
 875             if (cat.getName().equals(category.getName())) {
 876                 foundCat = true;
 877                 if (subCategory != null) {
 878                     List<SubCategoryDefinition> subcategories = cat.getSubcategories();
 879                     if (subcategories == null) {
 880                         subcategories = new ArrayList<>();
 881                         cat.setSubcategories(subcategories);
 882                     }
 883                     for (SubCategoryDefinition subcat : subcategories) {
 884                         boolean foundSub = false;
 885                         if (subcat.getName().equals(subCategory.getName())) {
 886                             foundSub = true;
 887                         }
 888                         if (!foundSub) {
 889                             subcategories.add(subCategory);
 890                             break;
 891                         }
 892                     }
 893                 }
 894             }
 895         }
 896         if (!foundCat) {
 897             if (subCategory != null) {
 898                 category.addSubCategory(subCategory);
 899             }
 900             categories.add(category);
 901         }
 902     }
 903
 904     public Map<String, List<ComponentInstanceProperty>> getComponentInstancesAttributes() {
 905         return componentInstancesAttributes;
 906     }
 907
 908     public void setComponentInstancesAttributes(
 909             Map<String, List<ComponentInstanceProperty>> componentInstancesAttributes) {
 910         this.componentInstancesAttributes = componentInstancesAttributes;
 911     }
 912
 913     public Map<String, List<ComponentInstanceInput>> getComponentInstancesInputs() {
 914         return componentInstancesInputs;
 915     }
 916
 917     public Map<String, List<PropertyDataDefinition>> safeGetGroupsProperties() {
 918         if (isEmpty(groups)) {
 919             return emptyMap();
 920         }
 921         return groups.stream()
 922               .filter(gr -> Objects.nonNull(gr.getProperties()))
 923               .collect(toMap(GroupDataDefinition::getUniqueId,
 924                              GroupDataDefinition::getProperties));
 925     }
 926
 927     public Map<String, List<PropertyDataDefinition>> safeGetPolicyProperties() {
 928         if (isEmpty(policies)) {
 929             return emptyMap();
 930         }
 931         return policies.values()
 932                 .stream()
 933                 .filter(policy -> Objects.nonNull(policy.getProperties()))
 934                 .collect(toMap(PolicyDataDefinition::getUniqueId,
 935                                PolicyDataDefinition::getProperties));
 936     }
 937
 938     public List<ComponentInstanceInput> safeGetComponentInstanceInputsByName(String cmptInstanceName) {
 939         List<ComponentInstanceInput> emptyPropsList = emptyList();
 940         if (this.componentInstancesInputs == null) {
 941             return emptyPropsList;
 942         }
 943         return this.componentInstances.stream()
 944                                       .filter(ci -> ci.getName().equals(cmptInstanceName))
 945                                       .map(ComponentInstance::getUniqueId)
 946                                       .map(instanceId -> safeGetComponentInstanceEntity(instanceId, this.componentInstancesInputs))
 947                                       .findAny()
 948                                       .orElse(emptyPropsList);
 949     }
 950
 951     private <T> List<T> safeGetComponentInstanceEntity(String cmptInstanceId, Map<String, List<T>> instanceEntities) {
 952         List<T> emptyPropsList = emptyList();
 953         if (instanceEntities == null) {
 954             return emptyPropsList;
 955         }
 956         List<T> cmptInstanceProps = instanceEntities.get(cmptInstanceId);
 957         return cmptInstanceProps == null ? emptyPropsList : cmptInstanceProps;
 958     }
 959
 960
 961     public void setComponentInstancesInputs(Map<String, List<ComponentInstanceInput>> componentInstancesInputs) {
 962         this.componentInstancesInputs = componentInstancesInputs;
 963     }
 964
 965     public void setSpecificComponetTypeArtifacts(Map<String, ArtifactDefinition> specificComponentTypeArtifacts) {
 966         // Implement where needed
 967     }
 968
 969     public void setMetadataDefinition(ComponentMetadataDefinition metadataDefinition) {
 970         this.componentMetadataDefinition = metadataDefinition;
 971     }
 972
 973     public String fetchGenericTypeToscaNameFromConfig() {
 974         // Implement where needed
 975         return ConfigurationManager.getConfigurationManager()
 976                                    .getConfiguration()
 977                                    .getGenericAssetNodeTypes()
 978                                    .get(this.assetType());
 979     }
 980
 981     public String assetType() {
 982         // Implement where needed
 983         return this.getComponentType().getValue();
 984     }
 985
 986     public boolean shouldGenerateInputs() {
 987         // Implement where needed
 988         return true;
 989     }
 990
 991     public boolean deriveFromGeneric() {
 992         // Implement where needed
 993         return true;
 994     }
 995
 996     public void setDerivedFromGenericInfo(Resource genericType) {
 997         derivedFromGenericType = genericType.getToscaResourceName();
 998         derivedFromGenericVersion = genericType.getVersion();
 999     }
1000
1001     public boolean isTopologyTemplate() {
1002         return ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue().equals(toscaType);
1003     }
1004
1005     public String getToscaType() {
1006         return toscaType;
1007     }
1008
1009     public void setToscaType(String toscaType) {
1010         this.toscaType = toscaType;
1011     }
1012
1013     public List<AdditionalInformationDefinition> getAdditionalInformation() {
1014         return additionalInformation;
1015     }
1016
1017     public void setAdditionalInformation(List<AdditionalInformationDefinition> additionalInformation) {
1018         this.additionalInformation = additionalInformation;
1019     }
1020
1021     public PolicyDefinition getPolicyById(String id) {
1022         return policies != null ? policies.get(id) : null;
1023     }
1024
1025     public List<PolicyDefinition> resolvePoliciesList() {
1026         if (policies == null) {
1027             return emptyList();
1028         }
1029         return new ArrayList<>(policies.values());
1030     }
1031
1032     public List<PolicyDefinition> resolvePoliciesContainingTarget(String targetId, PolicyTargetType targetType) {
1033         Predicate<PolicyDefinition> containsTarget = policy -> policy.containsTarget(targetId, targetType);
1034         return resolvePoliciesByPredicate(containsTarget);
1035     }
1036
1037     private List<PolicyDefinition> resolvePoliciesByPredicate(Predicate<PolicyDefinition> policyPredicate) {
1038         if (policies == null) {
1039             return emptyList();
1040         }
1041         return policies.values().stream()
1042                        .filter(policyPredicate)
1043                        .collect(Collectors.toList());
1044     }
1045
1046     public List<GroupDefinition> resolveGroupsByMember(String instanceId) {
1047         if (groups == null) {
1048             return emptyList();
1049         }
1050         return groups.stream()
1051                      .filter(group -> group.containsInstanceAsMember(instanceId))
1052                      .collect(Collectors.toList());
1053     }
1054
1055     public String getActualComponentType() {
1056         return componentMetadataDefinition.getMetadataDataDefinition().getActualComponentType();
1057     }
1058
1059     public Boolean isArchived() { return componentMetadataDefinition.getMetadataDataDefinition().isArchived(); }
1060
1061     public void setArchived(Boolean archived) { componentMetadataDefinition.getMetadataDataDefinition().setArchived(archived); }
1062
1063     public Long getArchiveTime() { return componentMetadataDefinition.getMetadataDataDefinition().getArchiveTime(); }
1064
1065     public void setArchiveTime(Long archiveTime) { componentMetadataDefinition.getMetadataDataDefinition().setArchiveTime(archiveTime); }
1066
1067     public Boolean isVspArchived() { return componentMetadataDefinition.getMetadataDataDefinition().isVspArchived();    }
1068
1069     public void setVspArchived(Boolean vspArchived) { componentMetadataDefinition.getMetadataDataDefinition().setVspArchived(vspArchived); }
1070
1071     //supportability log method return map of component metadata teddy.h
1072     public Map<String,String> getComponentMetadataForSupportLog(){
1073         Map<String,String>componentMetadata=new HashMap<>();
1074         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_NAME,this.getName());
1075         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_VERSION,this.getVersion());
1076         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_COMPONENT_UUID,this.getUUID());
1077         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_CSAR_UUID,this.getCsarUUID());
1078         componentMetadata.put(ILogConfiguration.MDC_SUPPORTABLITY_CSAR_VERSION,this.getCsarVersion());
1079         return componentMetadata;
1080     }
1081
1082
1083 }