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