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