catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ResourceOperation.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.operations.impl;
  22
  23 import com.google.gson.Gson;
  24 import com.google.gson.GsonBuilder;
  25 import com.thinkaurelius.titan.core.TitanGraph;
  26 import com.thinkaurelius.titan.core.TitanVertex;
  27 import fj.data.Either;
  28 import org.apache.commons.collections.CollectionUtils;
  29 import org.apache.commons.lang3.StringUtils;
  30 import org.apache.commons.lang3.tuple.ImmutablePair;
  31 import org.apache.tinkerpop.gremlin.structure.Vertex;
  32 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  33 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  34 import org.openecomp.sdc.be.dao.api.ActionStatus;
  35 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  36 import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
  37 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  38 import org.openecomp.sdc.be.dao.graph.datatype.RelationEndPoint;
  39 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  40 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  41 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  42 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  43 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  45 import org.openecomp.sdc.be.datatypes.enums.FilterKeyEnum;
  46 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  48 import org.openecomp.sdc.be.model.*;
  49 import org.openecomp.sdc.be.model.cache.ComponentCache;
  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.operations.api.IAdditionalInformationOperation;
  53 import org.openecomp.sdc.be.model.operations.api.IArtifactOperation;
  54 import org.openecomp.sdc.be.model.operations.api.IAttributeOperation;
  55 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  56 import org.openecomp.sdc.be.model.operations.api.IResourceOperation;
  57 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  58 import org.openecomp.sdc.be.model.operations.migration.MigrationMalformedDataLogger;
  59 import org.openecomp.sdc.be.model.operations.utils.GraphDeleteUtil;
  60 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  61 import org.openecomp.sdc.be.resources.data.PropertyData;
  62 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  63 import org.openecomp.sdc.be.resources.data.TagData;
  64 import org.openecomp.sdc.be.resources.data.UniqueIdData;
  65 import org.openecomp.sdc.be.resources.data.UserData;
  66 import org.openecomp.sdc.be.resources.data.category.CategoryData;
  67 import org.openecomp.sdc.be.resources.data.category.SubCategoryData;
  68 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  69 import org.openecomp.sdc.common.datastructure.Wrapper;
  70 import org.openecomp.sdc.common.util.PairUtils;
  71 import org.openecomp.sdc.common.util.ValidationUtils;
  72 import org.slf4j.Logger;
  73 import org.slf4j.LoggerFactory;
  74 import org.slf4j.MDC;
  75
  76 import java.util.ArrayList;
  77 import java.util.HashMap;
  78 import java.util.Iterator;
  79 import java.util.List;
  80 import java.util.Map;
  81 import java.util.Map.Entry;
  82 import java.util.Optional;
  83 import java.util.Set;
  84 import java.util.UUID;
  85 import java.util.function.Predicate;
  86 import java.util.regex.Pattern;
  87 import java.util.stream.Collectors;
  88
  89 @org.springframework.stereotype.Component("resource-operation")
  90 @Deprecated
  91 public class ResourceOperation extends ComponentOperation implements IResourceOperation {
  92
  93         public ResourceOperation() {
  94                 super();
  95         }
  96
  97         private static Logger log = LoggerFactory.getLogger(ResourceOperation.class.getName());
  98
  99         @javax.annotation.Resource
 100         private PropertyOperation propertyOperation;
 101
 102         @javax.annotation.Resource
 103         private IAttributeOperation attributeOperation;
 104
 105         @javax.annotation.Resource
 106         private RequirementOperation requirementOperation;
 107
 108         @javax.annotation.Resource
 109         private CapabilityOperation capabilityOperation;
 110
 111         @javax.annotation.Resource
 112         private InterfaceLifecycleOperation interfaceLifecycleOperation;
 113
 114         @javax.annotation.Resource
 115         private IElementOperation elementOperation;
 116
 117         @javax.annotation.Resource
 118         private IAdditionalInformationOperation addioAdditionalInformationOperation;
 119
 120         @javax.annotation.Resource
 121         private GroupOperation groupOperation;
 122
 123         @javax.annotation.Resource
 124         private ComponentCache componentCache;
 125
 126         private Gson prettyJson = new GsonBuilder().setPrettyPrinting().create();
 127
 128         private GraphDeleteUtil graphDeleteUtil = new GraphDeleteUtil();
 129
 130         public static Pattern uuidNewVersion = Pattern.compile("^\\d{1,}.1");
 131         public static Pattern uuidNormativeNewVersion = Pattern.compile("^\\d{1,}.0");
 132
 133         @Override
 134         public Either<Resource, StorageOperationStatus> createResource(Resource resource) {
 135                 return createResource(resource, false);
 136         }
 137
 138         @Override
 139         public Either<Resource, StorageOperationStatus> createResource(Resource resource, boolean inTransaction) {
 140
 141                 Either<Resource, StorageOperationStatus> result = null;
 142
 143                 try {
 144                         generateUUID(resource);
 145
 146                         ResourceMetadataData resourceData = getResourceMetaDataFromResource(resource);
 147                         String resourceUniqueId = resource.getUniqueId();
 148                         if (resourceUniqueId == null) {
 149                                 resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId();
 150                                 resourceData.getMetadataDataDefinition().setUniqueId(resourceUniqueId);
 151                         }
 152                         resourceData.getMetadataDataDefinition().setHighestVersion(true);
 153
 154                         String userId = resource.getCreatorUserId();
 155
 156                         Either<TitanVertex, TitanOperationStatus> findUser = findUserVertex(userId);
 157
 158                         if (findUser.isRight()) {
 159                                 TitanOperationStatus status = findUser.right().value();
 160                                 log.error("Cannot find user {} in the graph. status is {}", userId, status);
 161                                 return sendError(status, StorageOperationStatus.USER_NOT_FOUND);
 162                         }
 163
 164                         TitanVertex creatorVertex = findUser.left().value();
 165                         TitanVertex updaterVertex = creatorVertex;
 166                         String updaterUserId = resource.getLastUpdaterUserId();
 167                         if (updaterUserId != null && !updaterUserId.equals(userId)) {
 168                                 findUser = findUserVertex(updaterUserId);
 169                                 if (findUser.isRight()) {
 170                                         TitanOperationStatus status = findUser.right().value();
 171                                         log.error("Cannot find user {} in the graph. status is {}", userId, status);
 172                                         return sendError(status, StorageOperationStatus.USER_NOT_FOUND);
 173                                 } else {
 174                                         updaterVertex = findUser.left().value();
 175                                 }
 176                         }
 177
 178                         // get derived from resources
 179                         List<ResourceMetadataData> derivedResources = null;
 180                         Either<List<ResourceMetadataData>, StorageOperationStatus> derivedResourcesResult = findDerivedResources(resource);
 181                         if (derivedResourcesResult.isRight()) {
 182                                 result = Either.right(derivedResourcesResult.right().value());
 183                                 return result;
 184                         } else {
 185                                 derivedResources = derivedResourcesResult.left().value();
 186                         }
 187
 188                         List<String> tags = resource.getTags();
 189                         if (tags != null && false == tags.isEmpty()) {
 190                                 Either<List<TagData>, StorageOperationStatus> tagsResult = createNewTagsList(tags);
 191                                 if (tagsResult.isRight()) {
 192                                         result = Either.right(tagsResult.right().value());
 193                                         return result;
 194                                 }
 195                                 List<TagData> tagsToCreate = tagsResult.left().value();
 196                                 StorageOperationStatus status = createTagNodesOnGraph(tagsToCreate);
 197                                 if (!status.equals(StorageOperationStatus.OK)) {
 198                                         result = Either.right(status);
 199                                         return result;
 200                                 }
 201                         }
 202
 203                         Either<TitanVertex, TitanOperationStatus> createdVertex = titanGenericDao.createNode(resourceData);
 204                         if (createdVertex.isRight()) {
 205                                 TitanOperationStatus status = createdVertex.right().value();
 206                                 log.error("Error returned after creating resource data node {}. status returned is ", resourceData, status);
 207                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
 208                                 return result;
 209                         }
 210                         TitanVertex metadataVertex = createdVertex.left().value();
 211
 212                         TitanOperationStatus associateMetadata = associateMetadataToResource(resourceData, creatorVertex, updaterVertex, derivedResources, metadataVertex);
 213                         if (associateMetadata != TitanOperationStatus.OK) {
 214                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateMetadata));
 215                                 return result;
 216                         }
 217                         StorageOperationStatus associateCategory = assosiateMetadataToCategory(resource, resourceData);
 218                         if (associateCategory != StorageOperationStatus.OK) {
 219                                 result = Either.right(associateCategory);
 220                                 return result;
 221                         }
 222
 223                         TitanOperationStatus associateProperties = associatePropertiesToResource(metadataVertex, resourceUniqueId, resource.getProperties(), derivedResources);
 224                         if (associateProperties != TitanOperationStatus.OK) {
 225                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateProperties));
 226                                 return result;
 227                         }
 228
 229                         TitanOperationStatus associateAttributes = associateAttributesToResource(metadataVertex, resource.getAttributes(), resourceUniqueId);
 230                         if (associateAttributes != TitanOperationStatus.OK) {
 231                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateAttributes));
 232                                 return result;
 233                         }
 234
 235                         TitanOperationStatus associateInputs = associateInputsToComponent(metadataVertex, resourceUniqueId, resource.getInputs());
 236                         if (associateInputs != TitanOperationStatus.OK) {
 237                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateInputs));
 238                                 return result;
 239                         }
 240
 241                         StorageOperationStatus associateRequirements = associateRequirementsToResource(metadataVertex, resourceUniqueId, resource.getRequirements());
 242                         if (associateRequirements != StorageOperationStatus.OK) {
 243                                 result = Either.right(associateRequirements);
 244                                 return result;
 245                         }
 246
 247                         StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(metadataVertex, resourceUniqueId, resource.getCapabilities());
 248                         if (associateCapabilities != StorageOperationStatus.OK) {
 249                                 result = Either.right(associateCapabilities);
 250                                 return result;
 251                         }
 252
 253                         StorageOperationStatus associateInterfaces = associateInterfacesToResource(resourceData, resource.getInterfaces(), metadataVertex);
 254                         if (associateInterfaces != StorageOperationStatus.OK) {
 255                                 result = Either.right(associateInterfaces);
 256                                 return result;
 257                         }
 258
 259                         Map<String, ArtifactDefinition> resourceArtifacts = resource.getArtifacts();
 260                         Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
 261                         Map<String, ArtifactDefinition> toscaArtifacts = resource.getToscaArtifacts();
 262                         if (resourceArtifacts != null) {
 263                                 if (deploymentArtifacts != null) {
 264                                         resourceArtifacts.putAll(deploymentArtifacts);
 265                                 }
 266                         } else {
 267                                 resourceArtifacts = deploymentArtifacts;
 268                         }
 269                         if (toscaArtifacts != null) {
 270                                 if (resourceArtifacts != null) {
 271                                         resourceArtifacts.putAll(toscaArtifacts);
 272                                 } else {
 273                                         resourceArtifacts = toscaArtifacts;
 274                                 }
 275                         }
 276
 277                         StorageOperationStatus associateArtifacts = associateArtifactsToResource(metadataVertex, resourceUniqueId, resourceArtifacts);
 278                         if (associateArtifacts != StorageOperationStatus.OK) {
 279                                 result = Either.right(associateArtifacts);
 280                                 return result;
 281                         }
 282
 283                         List<AdditionalInformationDefinition> additionalInformation = resource.getAdditionalInformation();
 284                         StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(metadataVertex, resourceUniqueId, additionalInformation);
 285                         if (addAdditionalInformation != StorageOperationStatus.OK) {
 286                                 result = Either.right(addAdditionalInformation);
 287                                 return result;
 288                         }
 289
 290                         result = this.getResource(resourceUniqueId, true);
 291                         if (result.isRight()) {
 292                                 log.error("Cannot get full resource from the graph. status is {}", result.right().value());
 293                                 return Either.right(result.right().value());
 294                         }
 295
 296                         if (log.isDebugEnabled()) {
 297                                 String json = prettyJson.toJson(result.left().value());
 298                                 log.debug("Resource retrieved is {}", json);
 299                         }
 300
 301                         return result;
 302
 303                 } finally {
 304                         if (false == inTransaction) {
 305                                 if (result == null || result.isRight()) {
 306                                         log.error("Going to execute rollback on graph.");
 307                                         titanGenericDao.rollback();
 308                                 } else {
 309                                         log.debug("Going to execute commit on graph.");
 310                                         titanGenericDao.commit();
 311                                 }
 312                         }
 313                 }
 314         }
 315
 316         private StorageOperationStatus assosiateMetadataToCategory(Resource resource, ResourceMetadataData resourceData) {
 317                 // get category
 318                 String categoryName = resource.getCategories().get(0).getName();
 319                 String subcategoryName = resource.getCategories().get(0).getSubcategories().get(0).getName();
 320
 321                 CategoryData categoryData = null;
 322                 Either<CategoryData, StorageOperationStatus> categoryResult = elementOperation.getNewCategoryData(categoryName, NodeTypeEnum.ResourceNewCategory, CategoryData.class);
 323                 if (categoryResult.isRight()) {
 324                         StorageOperationStatus status = categoryResult.right().value();
 325                         log.error("Cannot find category {} in the graph. status is {}", categoryName, status);
 326                         return categoryResult.right().value();
 327                 }
 328                 categoryData = categoryResult.left().value();
 329                 if (categoryData != null) {
 330                         Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceNewCategory), (String) categoryData.getUniqueId(),
 331                                         GraphEdgeLabels.SUB_CATEGORY, NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
 332                         if (childrenNodes.isRight()) {
 333                                 log.debug("Faield to fetch sub categories for  resource category {}", categoryData.getCategoryDataDefinition().getName());
 334                                 return DaoStatusConverter.convertTitanStatusToStorageStatus(childrenNodes.right().value());
 335                         }
 336                         for (ImmutablePair<SubCategoryData, GraphEdge> pair : childrenNodes.left().value()) {
 337                                 SubCategoryData subcategoryData = pair.left;
 338                                 if (subcategoryData.getSubCategoryDataDefinition().getName().equals(subcategoryName)) {
 339                                         Either<GraphRelation, TitanOperationStatus> result = titanGenericDao.createRelation(resourceData, subcategoryData, GraphEdgeLabels.CATEGORY, null);
 340                                         log.debug("After associating resource {} to subcategory {}. Edge type is {}", resourceData.getUniqueId(), subcategoryData, GraphEdgeLabels.CATEGORY);
 341                                         if (result.isRight()) {
 342                                                 log.error("Faield to associate resource {} to category {}. Edge type is {}", resourceData.getUniqueId(), categoryData, GraphEdgeLabels.CATEGORY);
 343                                                 return DaoStatusConverter.convertTitanStatusToStorageStatus(result.right().value());
 344                                         }
 345
 346                                 }
 347                         }
 348                 }
 349                 return StorageOperationStatus.OK;
 350         }
 351
 352         private StorageOperationStatus addAdditionalInformationToResource(TitanVertex metadataVertex, String resourceUniqueId, List<AdditionalInformationDefinition> additionalInformation) {
 353
 354                 StorageOperationStatus result = null;
 355                 if (additionalInformation == null || true == additionalInformation.isEmpty()) {
 356                         result = super.addAdditionalInformation(NodeTypeEnum.Resource, resourceUniqueId, null, metadataVertex);
 357                 } else {
 358                         if (additionalInformation.size() == 1) {
 359                                 result = super.addAdditionalInformation(NodeTypeEnum.Resource, resourceUniqueId, additionalInformation.get(0));
 360                         } else {
 361                                 result = StorageOperationStatus.BAD_REQUEST;
 362                                 log.info("Cannot create resource with more than one additional information object. The number of received object is {}", additionalInformation.size());
 363                         }
 364                 }
 365                 return result;
 366         }
 367
 368         private void generateUUID(Resource resource) {
 369                 String prevUUID = resource.getUUID();
 370                 String version = resource.getVersion();
 371                 if ((prevUUID == null && uuidNormativeNewVersion.matcher(version).matches()) || uuidNewVersion.matcher(version).matches()) {
 372                         UUID uuid = UUID.randomUUID();
 373                         resource.setUUID(uuid.toString());
 374                         MDC.put("serviceInstanceID", uuid.toString());
 375                 }
 376         }
 377
 378         @Override
 379         public Either<Resource, StorageOperationStatus> overrideResource(Resource resource, Resource resourceSaved, boolean inTransaction) {
 380                 Either<Resource, StorageOperationStatus> result = null;
 381                 try {
 382                         String resourceId = resourceSaved.getUniqueId();
 383
 384                         // override interfaces to copy only resource's interfaces and not
 385                         // derived interfaces
 386                         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfacesOfResourceOnly = interfaceLifecycleOperation.getAllInterfacesOfResource(resourceSaved.getUniqueId(), false, true);
 387                         if (interfacesOfResourceOnly.isRight()) {
 388                                 log.error("failed to get interfaces of resource. resourceId {} status is {}", resourceId, interfacesOfResourceOnly.right().value());
 389                                 result = Either.right(interfacesOfResourceOnly.right().value());
 390                                 return result;
 391                         }
 392                         resource.setInterfaces(interfacesOfResourceOnly.left().value());
 393                         resource.setArtifacts(resourceSaved.getArtifacts());
 394                         resource.setDeploymentArtifacts(resourceSaved.getDeploymentArtifacts());
 395                         resource.setGroups(resourceSaved.getGroups());
 396                         resource.setInputs(null);
 397                         resource.setLastUpdateDate(null);
 398                         resource.setHighestVersion(true);
 399
 400                         // delete former resource
 401                         Either<Resource, StorageOperationStatus> deleteResource = deleteResource(resourceId, true);
 402                         if (deleteResource.isRight()) {
 403                                 log.error("failed to delete old resource with id {}. status = {}", resourceId, deleteResource.right().value());
 404                                 result = deleteResource;
 405                                 return result;
 406                         }
 407
 408                         Either<Resource, StorageOperationStatus> createResource = createResource(resource, true);
 409                         if (createResource.isRight()) {
 410                                 log.error("failed to create new version of resource {} status = {}", resourceId, createResource.right().value());
 411                                 result = createResource;
 412                                 return result;
 413                         }
 414                         Resource newResource = createResource.left().value();
 415
 416                         Either<List<GroupDefinition>, StorageOperationStatus> cloneGroupEither = cloneGroups(resource, newResource, null, inTransaction);
 417                         if (cloneGroupEither.isLeft()) {
 418                                 newResource.setGroups(cloneGroupEither.left().value());
 419                         } else if (cloneGroupEither.right().value() != StorageOperationStatus.OK) {
 420                                 log.error("failed to clone group of resource {} status = {}", resourceId, cloneGroupEither.right().value());
 421                                 result = Either.right(cloneGroupEither.right().value());
 422                                 return result;
 423                         }
 424
 425                         result = Either.left(newResource);
 426                         return result;
 427                 } finally {
 428                         if (false == inTransaction) {
 429                                 if (result == null || result.isRight()) {
 430                                         log.error("Going to execute rollback on graph.");
 431                                         titanGenericDao.rollback();
 432                                 } else {
 433                                         log.debug("Going to execute commit on graph.");
 434                                         titanGenericDao.commit();
 435                                 }
 436                         }
 437                 }
 438
 439         }
 440
 441         private StorageOperationStatus associateCapabilitiesToResource(TitanVertex metadataVertex, String resourceIda, Map<String, List<CapabilityDefinition>> capabilities) {
 442                 StorageOperationStatus addCapabilityToResource = null;
 443                 if (capabilities != null) {
 444                         for (Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) {
 445
 446                                 List<CapabilityDefinition> capDefinition = entry.getValue();
 447                                 for (CapabilityDefinition item : capDefinition) {
 448                                         addCapabilityToResource = capabilityOperation.addCapability(metadataVertex, resourceIda, item.getName(), item, true);
 449                                         if (!addCapabilityToResource.equals(StorageOperationStatus.OK)) {
 450                                                 return addCapabilityToResource;
 451                                         }
 452
 453                                 }
 454                         }
 455
 456                 }
 457                 return StorageOperationStatus.OK;
 458         }
 459
 460         private StorageOperationStatus associateRequirementsToResource(TitanVertex metadataVertex, String resourceId, Map<String, List<RequirementDefinition>> requirements) {
 461
 462                 if (requirements != null) {
 463                         for (Entry<String, List<RequirementDefinition>> entry : requirements.entrySet()) {
 464
 465                                 List<RequirementDefinition> reqDefinition = entry.getValue();
 466                                 for (RequirementDefinition item : reqDefinition) {
 467                                         StorageOperationStatus addRequirementToResource = requirementOperation.addRequirementToResource(metadataVertex, item.getName(), item, resourceId, true);
 468
 469                                         if (!addRequirementToResource.equals(StorageOperationStatus.OK)) {
 470                                                 return addRequirementToResource;
 471                                         }
 472                                 }
 473                         }
 474                 }
 475                 return StorageOperationStatus.OK;
 476         }
 477
 478         private StorageOperationStatus associateArtifactsToResource(TitanVertex metadataVertex, String resourceId, Map<String, ArtifactDefinition> artifacts) {
 479
 480                 StorageOperationStatus status = StorageOperationStatus.OK;
 481                 if (artifacts != null) {
 482                         Map<ArtifactDefinition, ArtifactDefinition> heatEnvMap = new HashMap<ArtifactDefinition, ArtifactDefinition>();
 483                         for (Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {
 484
 485                                 ArtifactDefinition artifactDefinition = entry.getValue();
 486
 487                                 ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactDefinition.getArtifactType());
 488                                 if(artifactType != ArtifactTypeEnum.HEAT_ENV){
 489                                         status = artifactOperation.addArifactToComponent(artifactDefinition, resourceId, NodeTypeEnum.Resource, false, metadataVertex);
 490                                 }else{
 491                                         Optional<ArtifactDefinition> op = artifacts.values().stream().filter(p -> p.getUniqueId().equals(artifactDefinition.getGeneratedFromId())).findAny();
 492                                         if(op.isPresent()){
 493                                                 heatEnvMap.put(artifactDefinition, op.get());
 494                                         }
 495
 496
 497                                 }
 498
 499                                 if (!status.equals(StorageOperationStatus.OK)) {
 500                                         return status;
 501                                 }
 502                         }
 503                         for(Entry<ArtifactDefinition, ArtifactDefinition> entry : heatEnvMap.entrySet()){
 504                                 Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact = artifactOperation.addHeatEnvArtifact(entry.getKey(), entry.getValue(), resourceId, NodeTypeEnum.Resource, false);
 505                                 if (addHeatEnvArtifact.isRight()) {
 506                                         log.debug("failed to create heat env artifact on resource instance");
 507                                         return addHeatEnvArtifact.right().value();
 508                                 }
 509                         }
 510                 }
 511                 return status;
 512
 513         }
 514
 515         private StorageOperationStatus associateInterfacesToResource(ResourceMetadataData resourceData, Map<String, InterfaceDefinition> interfaces, TitanVertex metadataVertex) {
 516
 517                 if (interfaces != null) {
 518                         for (Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {
 519
 520                                 InterfaceDefinition interfaceDefinition = entry.getValue();
 521                                 StorageOperationStatus status;
 522                                 if (((ResourceMetadataDataDefinition) resourceData.getMetadataDataDefinition()).isAbstract()) {
 523                                         status = interfaceLifecycleOperation.associateInterfaceToNode(resourceData, interfaceDefinition, metadataVertex);
 524                                 } else {
 525                                         status = interfaceLifecycleOperation.createInterfaceOnResource(interfaceDefinition, resourceData.getMetadataDataDefinition().getUniqueId(), interfaceDefinition.getType(), false, true, metadataVertex);
 526                                 }
 527
 528                                 if (!status.equals(StorageOperationStatus.OK)) {
 529                                         return status;
 530                                 }
 531                         }
 532                 }
 533                 return StorageOperationStatus.OK;
 534
 535         }
 536
 537         private Either<Resource, StorageOperationStatus> sendError(TitanOperationStatus status, StorageOperationStatus statusIfNotFound) {
 538                 Either<Resource, StorageOperationStatus> result;
 539                 if (status == TitanOperationStatus.NOT_FOUND) {
 540                         result = Either.right(statusIfNotFound);
 541                         return result;
 542                 } else {
 543                         result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
 544                         return result;
 545                 }
 546         }
 547
 548         private TitanOperationStatus associatePropertiesToResource(TitanVertex metadatVertex, String resourceId, List<PropertyDefinition> properties, List<ResourceMetadataData> derivedResources) {
 549
 550                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = applicationDataTypeCache.getAll();
 551                 if (allDataTypes.isRight()) {
 552                         TitanOperationStatus status = allDataTypes.right().value();
 553                         log.debug("Cannot find any data type. Status is {}.", status);
 554                         return status;
 555                 }
 556
 557                 Map<String, PropertyDefinition> convertedProperties = new HashMap<>();
 558
 559                 if (properties != null) {
 560                         for (PropertyDefinition propertyDefinition : properties) {
 561                                 convertedProperties.put(propertyDefinition.getName(), propertyDefinition);
 562                         }
 563
 564                         Either<Map<String, PropertyDefinition>, TitanOperationStatus> getPropertiesOfAllDerivedFromRes = getPropertiesOfAllDerivedFrom(derivedResources);
 565
 566                         if(getPropertiesOfAllDerivedFromRes.isRight()){
 567                                 TitanOperationStatus status = getPropertiesOfAllDerivedFromRes.right().value();
 568                                 log.debug("Cannot fetch properties of all derived from resources. Status is {}.", status);
 569                                 return status;
 570                         }
 571
 572                         Map<String, PropertyDefinition> allDerivedFromProperties = getPropertiesOfAllDerivedFromRes.left().value();
 573
 574                         TitanOperationStatus validatePropertyNamesUniqunessStatus = validatePropertyNamesUniquness(properties, allDerivedFromProperties);
 575
 576                         if(validatePropertyNamesUniqunessStatus != TitanOperationStatus.OK){
 577                                 return validatePropertyNamesUniqunessStatus;
 578                         }
 579
 580                         return propertyOperation.addPropertiesToGraph(metadatVertex, convertedProperties, allDataTypes.left().value(), resourceId);
 581                 }
 582
 583                 return TitanOperationStatus.OK;
 584
 585         }
 586
 587         private TitanOperationStatus validatePropertyNamesUniquness(List<PropertyDefinition> properties, Map<String, PropertyDefinition> allDerivedFromProperties) {
 588
 589                 TitanOperationStatus result  = TitanOperationStatus.OK;
 590                 Optional<PropertyDefinition> propertyOptional= properties.stream()
 591                                 //filters out properties with the same name and different type
 592                                 .filter(prop -> allDerivedFromProperties.containsKey(prop.getName()) && !prop.getType().equals(allDerivedFromProperties.get(prop.getName()).getType()))
 593                                 //Searches for any matching value
 594                                 .findAny();
 595                 if(propertyOptional.isPresent()){
 596                         log.error("Property with name {} and type {} already exists in derived from resource. ", propertyOptional.get().getName(), allDerivedFromProperties.get( propertyOptional.get().getName()).getType());
 597                         result = TitanOperationStatus.ALREADY_EXIST;
 598                 }
 599                 return result;
 600         }
 601
 602         private Either<Map<String, PropertyDefinition>, TitanOperationStatus> getPropertiesOfAllDerivedFrom(List<ResourceMetadataData> derivedResources) {
 603                 Map<String, PropertyDefinition> allDerivedProperties = new HashMap<>();
 604                 Either<Map<String, PropertyDefinition>, TitanOperationStatus> getPropertiesOfAllDerivedFromRes = Either.left(allDerivedProperties);
 605                 String currResourceName = null ;
 606                 if(!CollectionUtils.isEmpty(derivedResources)){
 607                         try{
 608                                 for(int i = derivedResources.size() - 1; i >= 0 ; --i){
 609                                         ResourceMetadataData currDerivedResource = derivedResources.get(i);
 610                                         currResourceName = currDerivedResource.getMetadataDataDefinition().getName();
 611                                         Either<List<ImmutablePair<PropertyData, GraphEdge>>, TitanOperationStatus>  res =
 612                                                         titanGenericDao.getChildrenNodes( currDerivedResource.getUniqueIdKey(), (String)currDerivedResource.getUniqueId(), GraphEdgeLabels.PROPERTY, NodeTypeEnum.Property, PropertyData.class);
 613                                         if(res.isRight() && res.right().value() != TitanOperationStatus.NOT_FOUND){
 614                                                 getPropertiesOfAllDerivedFromRes = Either.right(res.right().value());
 615                                                 break;
 616                                         }else if(res.isLeft()){
 617                                                 allDerivedProperties.putAll(res.left().value().stream()
 618                                                                 //Maps PropertyData converted to PropertyDefinition
 619                                                                 .map(pair->     propertyOperation.convertPropertyDataToPropertyDefinition(pair.getLeft(), (String)pair.getRight().getProperties().get(GraphPropertiesDictionary.NAME.getProperty()), (String)currDerivedResource.getUniqueId()))
 620                                                                 //and collects it to a map
 621                                                                 .collect(Collectors.toMap(entry->entry.getName(), entry->entry)));
 622                                         }
 623                                 }
 624                         }
 625                         catch(Exception e){
 626                                 log.error("Exception occured during fetch properties of resource {}. ", currResourceName);
 627                         }
 628                 }
 629                 return getPropertiesOfAllDerivedFromRes;
 630         }
 631
 632         private TitanOperationStatus associateAttributesToResource(TitanVertex metadataVertex, List<PropertyDefinition> attributes, String resourceId) {
 633                 TitanOperationStatus operationStatus = TitanOperationStatus.OK;
 634
 635                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = applicationDataTypeCache.getAll();
 636                 if (allDataTypes.isRight()) {
 637                         TitanOperationStatus status = allDataTypes.right().value();
 638                         log.debug("Cannot find any data type. Status is {}.", status);
 639                         return status;
 640                 }
 641
 642                 if (attributes != null) {
 643                         Map<String, PropertyDefinition> convertedAttributes = attributes.stream().collect(Collectors.toMap(e -> e.getName(), e -> e));
 644                         operationStatus = attributeOperation.addAttributesToGraph(metadataVertex, convertedAttributes, resourceId, allDataTypes.left().value());
 645                 }
 646                 return operationStatus;
 647         }
 648
 649         private TitanOperationStatus associateMetadataToResource(ResourceMetadataData resourceData, TitanVertex creatorVertex, TitanVertex updaterVertex, List<ResourceMetadataData> derivedResources, TitanVertex metadataVertex) {
 650
 651                 Map<String, Object> props = new HashMap<String, Object>();
 652                 props.put(GraphPropertiesDictionary.STATE.getProperty(), resourceData.getMetadataDataDefinition().getState());
 653
 654                 TitanOperationStatus result = titanGenericDao.createEdge(updaterVertex, metadataVertex, GraphEdgeLabels.STATE, props);
 655                 log.debug("After associating user {} to resource {}. Edge type is {}", updaterVertex, resourceData.getUniqueId(), GraphEdgeLabels.STATE);
 656                 if (!result.equals(TitanOperationStatus.OK)) {
 657                         return result;
 658                 }
 659                 result = titanGenericDao.createEdge(updaterVertex, metadataVertex, GraphEdgeLabels.LAST_MODIFIER, null);
 660                 log.debug("After associating user {}  to resource {}. Edge type is {}", updaterVertex, resourceData.getUniqueId(), GraphEdgeLabels.LAST_MODIFIER);
 661                 if (!result.equals(TitanOperationStatus.OK)) {
 662                         log.error("Failed to associate user {}  to resource {}. Edge type is {}", updaterVertex, resourceData.getUniqueId(), GraphEdgeLabels.LAST_MODIFIER);
 663                         return result;
 664                 }
 665
 666                 result = titanGenericDao.createEdge(creatorVertex, metadataVertex, GraphEdgeLabels.CREATOR, null);
 667                 log.debug("After associating user {} to resource {}. Edge type is {} ", creatorVertex, resourceData.getUniqueId(), GraphEdgeLabels.CREATOR);
 668                 if (!result.equals(TitanOperationStatus.OK)) {
 669                         log.error("Failed to associate user {} to resource {}. Edge type is {} ", creatorVertex, resourceData.getUniqueId(), GraphEdgeLabels.CREATOR);
 670                         return result;
 671                 }
 672                 // TODO Evg : need to change too..
 673                 if (derivedResources != null) {
 674                         for (ResourceMetadataData derivedResource : derivedResources) {
 675                                 log.debug("After associating resource {} to parent resource {}. Edge type is {}", resourceData.getUniqueId(), derivedResource.getUniqueId(), GraphEdgeLabels.DERIVED_FROM);
 676                                 Either<GraphRelation, TitanOperationStatus> createRelationResult = titanGenericDao.createRelation(resourceData, derivedResource, GraphEdgeLabels.DERIVED_FROM, null);
 677                                 if (createRelationResult.isRight()) {
 678                                         log.error("Failed to associate resource {} to derived ", resourceData.getUniqueId());
 679                                         return createRelationResult.right().value();
 680                                 }
 681                         }
 682                 }
 683
 684                 return TitanOperationStatus.OK;
 685         }
 686
 687         public Either<List<ResourceMetadataData>, StorageOperationStatus> findDerivedResources(Resource resource) {
 688
 689                 List<ResourceMetadataData> derivedResources = new ArrayList<ResourceMetadataData>();
 690                 List<String> derivedFromResources = resource.getDerivedFrom();
 691                 if (derivedFromResources != null && false == derivedFromResources.isEmpty()) {
 692
 693                         for (String parentResource : derivedFromResources) {
 694
 695                                 Map<String, Object> propertiesToMatch = new HashMap<String, Object>();
 696                                 propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
 697                                 // propertiesToMatch.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(),
 698                                 // true);
 699                                 propertiesToMatch.put(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), parentResource);
 700                                 propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
 701
 702                                 Either<List<ResourceMetadataData>, TitanOperationStatus> getParentResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
 703                                 List<ResourceMetadataData> resources = null;
 704                                 if (getParentResources.isRight()) {
 705                                         /*
 706                                          * log.debug( "Cannot find parent resource by tosca resource name {} in the graph. Try to find by name", parentResource);
 707                                          * Map<String, Object> propertiesWithResourceNameToMatch = new HashMap<String, Object>();
 708                                          * propertiesWithResourceNameToMatch.put( GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name()); propertiesWithResourceNameToMatch.put( GraphPropertiesDictionary.NAME.getProperty(), parentResource);
 709                                          * propertiesWithResourceNameToMatch.put( GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty( ), true);
 710                                          *
 711                                          * getParentResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesWithResourceNameToMatch, ResourceData.class); if (getParentResources.isRight()) { log.error(
 712                                          * "Cannot find parent resource by tosca resource name" + parentResource + " in the graph."); return Either.right(StorageOperationStatus. PARENT_RESOURCE_NOT_FOUND); }else{ resources = getParentResources.left().value();
 713                                          * hea
 714                                          * }
 715                                          */
 716                                         log.error("Cannot find parent resource by tosca resource name {} in the graph.", parentResource);
 717                                         return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
 718
 719                                 } else {
 720                                         resources = getParentResources.left().value();
 721                                         if (resources == null || resources.size() == 0) {
 722                                                 log.error("Cannot find parent resource by tosc name {} in the graph. resources size is empty", parentResource);
 723                                                 return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
 724                                         } else {
 725                                                 if (resources.size() > 1) {
 726                                                         log.error("Multiple parent resources called {} found in the graph.", parentResource);
 727                                                         return Either.right(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND);
 728                                                 }
 729                                                 ResourceMetadataData parentResourceData = resources.get(0);
 730                                                 derivedResources.add(parentResourceData);
 731                                         }
 732
 733                                 }
 734
 735                         }
 736                 }
 737                 return Either.left(derivedResources);
 738         }
 739
 740         private ResourceMetadataData getResourceMetaDataFromResource(Resource resource) {
 741                 ResourceMetadataData resourceData = new ResourceMetadataData((ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
 742                 if (resource.getNormalizedName() == null || resource.getNormalizedName().isEmpty()) {
 743                         resourceData.getMetadataDataDefinition().setNormalizedName(ValidationUtils.normaliseComponentName(resource.getName()));
 744                 }
 745                 if (resource.getSystemName() == null || resource.getSystemName().isEmpty()) {
 746                         resourceData.getMetadataDataDefinition().setSystemName(ValidationUtils.convertToSystemName(resource.getName()));
 747                 }
 748
 749                 LifecycleStateEnum lifecycleStateEnum = resource.getLifecycleState();
 750                 if (lifecycleStateEnum == null) {
 751                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 752                 }
 753                 long currentDate = System.currentTimeMillis();
 754                 if (resource.getCreationDate() == null) {
 755                         resourceData.getMetadataDataDefinition().setCreationDate(currentDate);
 756                 }
 757                 resourceData.getMetadataDataDefinition().setLastUpdateDate(currentDate);
 758
 759                 return resourceData;
 760         }
 761
 762         private ResourceMetadataData getResourceMetaDataForUpdate(Resource resource) {
 763                 // PA - please note: if you add here any fields, make sure they are
 764                 // validated (if needed)
 765                 // at ResourceBusinessLogic.validateResourceFieldsBeforeUpdate() and
 766                 // tested at ResourceBusinessLogicTest.
 767                 ResourceMetadataData resourceData = getResourceMetaDataFromResource(resource);
 768                 // resourceData.setLastUpdateDate(System.currentTimeMillis());
 769                 // resourceData.setHighestVersion(resource.isHighestVersion());
 770                 // resourceData.setNormalizedName(resource.getNormalizedName());
 771                 // resourceData.setResourceType(resource.getResourceType().name());
 772
 773                 return resourceData;
 774         }
 775
 776         public Either<Resource, StorageOperationStatus> getResource(String uniqueId) {
 777                 return getResource(uniqueId, false);
 778         }
 779
 780         public Either<Resource, StorageOperationStatus> getResource(String uniqueId, boolean inTransaction) {
 781                 ComponentParametersView componentParametersView = new ComponentParametersView();
 782                 return getResource(uniqueId, componentParametersView, inTransaction);
 783         }
 784
 785         private TitanOperationStatus setComponentInstancesAttributesFromGraph(String uniqueId, Resource component) {
 786                 Map<String, List<ComponentInstanceProperty>> resourceInstancesAttributes = new HashMap<>();
 787                 TitanOperationStatus status = TitanOperationStatus.OK;
 788                 List<ComponentInstance> componentInstances = component.getComponentInstances();
 789                 if (componentInstances != null) {
 790                         for (ComponentInstance resourceInstance : componentInstances) {
 791                                 Either<List<ComponentInstanceProperty>, TitanOperationStatus> eitherRIAttributes = attributeOperation.getAllAttributesOfResourceInstance(resourceInstance);
 792                                 if (eitherRIAttributes.isRight()) {
 793                                         status = eitherRIAttributes.right().value();
 794                                         break;
 795                                 } else {
 796                                         resourceInstancesAttributes.put(resourceInstance.getUniqueId(), eitherRIAttributes.left().value());
 797                                 }
 798                         }
 799
 800                         component.setComponentInstancesAttributes(resourceInstancesAttributes);
 801                 }
 802
 803                 return status;
 804
 805         }
 806
 807         private StorageOperationStatus setResourceAdditionalInformationFromGraph(String uniqueId, Resource resource) {
 808
 809                 List<AdditionalInformationDefinition> additionalInformation = new ArrayList<>();
 810
 811                 Either<AdditionalInformationDefinition, StorageOperationStatus> either = additionalInformationOperation.getAllAdditionalInformationParameters(NodeTypeEnum.Resource, uniqueId, true, true);
 812
 813                 if (either.isRight()) {
 814                         StorageOperationStatus status = either.right().value();
 815                         if (status == StorageOperationStatus.NOT_FOUND) {
 816                                 return StorageOperationStatus.OK;
 817                         }
 818                         return status;
 819                 }
 820
 821                 AdditionalInformationDefinition additionalInformationDefinition = either.left().value();
 822                 additionalInformation.add(additionalInformationDefinition);
 823
 824                 resource.setAdditionalInformation(additionalInformation);
 825
 826                 return StorageOperationStatus.OK;
 827
 828         }
 829
 830         private StorageOperationStatus setResourceInterfacesFromGraph(String uniqueId, Resource resource) {
 831
 832                 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> statusRes = interfaceLifecycleOperation.getAllInterfacesOfResource(uniqueId, true, true);
 833                 if (statusRes.isRight()) {
 834                         return statusRes.right().value();
 835                 }
 836                 Map<String, InterfaceDefinition> value = statusRes.left().value();
 837
 838                 resource.setInterfaces(value);
 839
 840                 return StorageOperationStatus.OK;
 841         }
 842
 843         private StorageOperationStatus setResourceCapabilitiesFromGraph(String uniqueId, Resource resource) {
 844                 StorageOperationStatus retStatus;
 845                 Either<Map<String, CapabilityDefinition>, StorageOperationStatus> result = capabilityOperation.getAllCapabilitiesOfResource(uniqueId, true, true);
 846                 if (result.isRight()) {
 847                         StorageOperationStatus status = result.right().value();
 848                         if (status != StorageOperationStatus.NOT_FOUND) {
 849                                 retStatus = status;
 850                         } else {
 851                                 retStatus = StorageOperationStatus.OK;
 852                         }
 853                 } else {
 854                         Map<String, CapabilityDefinition> capabilities = result.left().value();
 855                         if (capabilities != null && !capabilities.isEmpty() && resource.getResourceType().equals(ResourceTypeEnum.VF)) {
 856                                 MigrationMalformedDataLogger.reportMalformedVF(resource.getUniqueId(), String.format("VF %s with id %s has direct capabilities.!!!!!!!!!!!!!", resource.getName(), resource.getUniqueId()));
 857                         }
 858                         if (capabilities == null || capabilities.isEmpty() || resource.getResourceType().equals(ResourceTypeEnum.VF)) {
 859                                 Either<Map<String, List<CapabilityDefinition>>, TitanOperationStatus> eitherCapabilities = super.getCapabilities(resource, NodeTypeEnum.Resource, true);
 860                                 if (eitherCapabilities.isLeft()) {
 861                                         retStatus = StorageOperationStatus.OK;
 862                                         Map<String, List<CapabilityDefinition>> calculatedCapabilities = eitherCapabilities.left().value();
 863                                         resource.setCapabilities(calculatedCapabilities);
 864                                 } else {
 865                                         retStatus = StorageOperationStatus.GENERAL_ERROR;
 866                                 }
 867
 868                         } else {
 869                                 retStatus = StorageOperationStatus.OK;
 870                                 resource.setCapabilities(capabilityOperation.convertCapabilityMap(capabilities, null, null));
 871                         }
 872
 873                 }
 874                 return retStatus;
 875
 876         }
 877
 878         public Either<Map<String, List<CapabilityDefinition>>, TitanOperationStatus> getCapabilities(org.openecomp.sdc.be.model.Component component, NodeTypeEnum componentTypeEnum, boolean inTransaction) {
 879
 880                 try {
 881                         Either<Map<String, CapabilityDefinition>, StorageOperationStatus> result = capabilityOperation.getAllCapabilitiesOfResource(component.getUniqueId(), true, true);
 882                         if (result.isRight() || result.left().value().isEmpty()) {
 883                                 final Either<Map<String, List<CapabilityDefinition>>, TitanOperationStatus> eitherCapabilities = super.getCapabilities(component, componentTypeEnum, inTransaction);
 884                                 return eitherCapabilities;
 885                         } else {
 886                                 return Either.left(capabilityOperation.convertCapabilityMap(result.left().value(), null, null));
 887                         }
 888                 } finally {
 889                         if (inTransaction == false) {
 890                                 titanGenericDao.commit();
 891                         }
 892                 }
 893         }
 894
 895         public Either<Map<String, List<RequirementDefinition>>, TitanOperationStatus> getRequirements(org.openecomp.sdc.be.model.Component component, NodeTypeEnum componentTypeEnum, boolean inTransaction) {
 896                 try {
 897                         Either<Map<String, RequirementDefinition>, StorageOperationStatus> result = requirementOperation.getAllResourceRequirements(component.getUniqueId(), true);
 898                         if (result.isRight() || result.left().value().isEmpty()) {
 899                                 final Either<Map<String, List<RequirementDefinition>>, TitanOperationStatus> eitherCapabilities = super.getRequirements(component, componentTypeEnum, true);
 900                                 return eitherCapabilities;
 901                         } else {
 902                                 return Either.left(requirementOperation.convertRequirementMap(result.left().value(), null, null));
 903                         }
 904                 } finally {
 905                         if (inTransaction == false) {
 906                                 titanGenericDao.commit();
 907                         }
 908                 }
 909
 910         }
 911
 912         private StorageOperationStatus setResourceRequirementsFromGraph(String uniqueId, Resource resource, boolean inTransaction) {
 913                 StorageOperationStatus retStatus;
 914                 Either<Map<String, RequirementDefinition>, StorageOperationStatus> result = requirementOperation.getAllResourceRequirements(uniqueId, inTransaction);
 915                 ;
 916                 if (result.isRight()) {
 917                         StorageOperationStatus status = result.right().value();
 918                         if (status != StorageOperationStatus.NOT_FOUND) {
 919                                 retStatus = status;
 920                         } else {
 921                                 retStatus = StorageOperationStatus.OK;
 922                         }
 923                 } else {
 924                         Map<String, RequirementDefinition> requirements = result.left().value();
 925                         if (requirements != null && !requirements.isEmpty() && resource.getResourceType().equals(ResourceTypeEnum.VF)) {
 926                                 MigrationMalformedDataLogger.reportMalformedVF(resource.getUniqueId(), String.format("VF %s with id %s has direct requirements.!!!!!!!!!!!!!", resource.getName(), resource.getUniqueId()));
 927                         }
 928                         if (requirements == null || requirements.isEmpty() || resource.getResourceType() == ResourceTypeEnum.VF) {
 929                                 Either<Map<String, List<RequirementDefinition>>, TitanOperationStatus> eitherCapabilities = super.getRequirements(resource, NodeTypeEnum.Resource, true);
 930                                 if (eitherCapabilities.isLeft()) {
 931                                         retStatus = StorageOperationStatus.OK;
 932                                         Map<String, List<RequirementDefinition>> calculatedCapabilities = eitherCapabilities.left().value();
 933                                         resource.setRequirements(calculatedCapabilities);
 934                                 } else {
 935                                         retStatus = StorageOperationStatus.GENERAL_ERROR;
 936                                 }
 937
 938                         } else {
 939                                 retStatus = StorageOperationStatus.OK;
 940                                 resource.setRequirements(requirementOperation.convertRequirementMap(requirements, null, null));
 941                         }
 942
 943                 }
 944                 return retStatus;
 945         }
 946
 947         private TitanOperationStatus setResourcePropertiesFromGraph(String uniqueId, Resource resource) {
 948
 949                 List<PropertyDefinition> properties = new ArrayList<>();
 950                 TitanOperationStatus status = propertyOperation.findAllResourcePropertiesRecursively(uniqueId, properties);
 951                 if (status == TitanOperationStatus.OK) {
 952                         resource.setProperties(properties);
 953                 }
 954
 955                 return status;
 956
 957         }
 958
 959         private TitanOperationStatus setResourceAttributesFromGraph(String uniqueId, Resource resource) {
 960
 961                 List<PropertyDefinition> attributes = new ArrayList<>();
 962                 TitanOperationStatus status = attributeOperation.findAllResourceAttributesRecursively(uniqueId, attributes);
 963                 if (status == TitanOperationStatus.OK) {
 964                         resource.setAttributes(attributes);
 965                 }
 966
 967                 return status;
 968
 969         }
 970
 971         private TitanOperationStatus setResourceDerivedFromGraph(String uniqueId, Resource resource) {
 972                 List<String> derivedFromList = new ArrayList<String>();
 973
 974                 TitanOperationStatus listFromGraphStatus = fillResourceDerivedListFromGraph(uniqueId, derivedFromList);
 975                 if (!TitanOperationStatus.OK.equals(listFromGraphStatus)) {
 976                         return listFromGraphStatus;
 977                 }
 978
 979                 if (false == derivedFromList.isEmpty()) {
 980                         if (derivedFromList.size() > 1) {
 981                                 List<String> lastDerivedFrom = new ArrayList<String>();
 982                                 lastDerivedFrom.add(derivedFromList.get(1));
 983                                 resource.setDerivedFrom(lastDerivedFrom);
 984                                 resource.setDerivedList(derivedFromList);
 985                         } else {
 986                                 resource.setDerivedFrom(null);
 987                                 resource.setDerivedList(derivedFromList);
 988                         }
 989
 990                 }
 991
 992                 return TitanOperationStatus.OK;
 993         }
 994
 995         public TitanOperationStatus fillResourceDerivedListFromGraph(String uniqueId, List<String> derivedFromList) {
 996                 // Either<List<ImmutablePair<ResourceMetadataData, GraphEdge>>,
 997                 // TitanOperationStatus> childrenNodes =
 998                 // titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource),
 999                 // uniqueId, GraphEdgeLabels.DERIVED_FROM,
1000                 // NodeTypeEnum.Resource, ResourceMetadataData.class);
1001                 //
1002                 // if (childrenNodes.isRight() && (childrenNodes.right().value() !=
1003                 // TitanOperationStatus.NOT_FOUND)) {
1004                 // return childrenNodes.right().value();
1005                 // } else if (childrenNodes.isLeft()) {
1006                 //
1007                 // List<ImmutablePair<ResourceMetadataData, GraphEdge>> pairList =
1008                 // childrenNodes.left().value();
1009                 // for (ImmutablePair<ResourceMetadataData, GraphEdge> pair : pairList)
1010                 // {
1011                 // derivedFromList.add(pair.left.getMetadataDataDefinition().getName());
1012                 // return
1013                 // fillResourceDerivedListFromGraph(pair.left.getMetadataDataDefinition().getUniqueId(),
1014                 // derivedFromList);
1015                 // }
1016                 // }
1017                 List<ResourceMetadataData> derivedData = new ArrayList<ResourceMetadataData>();
1018                 TitanOperationStatus findResourcesPathRecursively = findResourcesPathRecursively(uniqueId, derivedData);
1019                 if (!findResourcesPathRecursively.equals(TitanOperationStatus.OK)) {
1020                         return findResourcesPathRecursively;
1021                 }
1022                 derivedData.forEach(resourceData -> derivedFromList.add(((ResourceMetadataDataDefinition) resourceData.getMetadataDataDefinition()).getToscaResourceName()));
1023                 return TitanOperationStatus.OK;
1024         }
1025
1026         private TitanOperationStatus setResourceLastModifierFromGraph(Resource resource, String resourceId) {
1027
1028                 Either<ImmutablePair<UserData, GraphEdge>, TitanOperationStatus> parentNode = titanGenericDao.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.LAST_MODIFIER, NodeTypeEnum.User,
1029                                 UserData.class);
1030                 if (parentNode.isRight()) {
1031                         return parentNode.right().value();
1032                 }
1033
1034                 ImmutablePair<UserData, GraphEdge> value = parentNode.left().value();
1035                 if (log.isDebugEnabled())
1036                         log.debug("Found parent node {}", value);
1037                 UserData userData = value.getKey();
1038
1039                 if (log.isDebugEnabled())
1040                         log.debug("Build resource : set last modifier userId to {}", userData.getUserId());
1041                 String fullName = buildFullName(userData);
1042                 if (log.isDebugEnabled())
1043                         log.debug("Build resource : set last modifier full name to {}", fullName);
1044                 resource.setLastUpdaterUserId(userData.getUserId());
1045                 resource.setLastUpdaterFullName(fullName);
1046
1047                 return TitanOperationStatus.OK;
1048         }
1049
1050         private TitanOperationStatus setResourceCreatorFromGraph(Resource resource, String resourceId) {
1051
1052                 Either<ImmutablePair<UserData, GraphEdge>, TitanOperationStatus> parentNode = titanGenericDao.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.CREATOR, NodeTypeEnum.User, UserData.class);
1053                 if (parentNode.isRight()) {
1054                         log.debug("Failed to find the creator of resource {}", resourceId);
1055                         return parentNode.right().value();
1056                 }
1057
1058                 ImmutablePair<UserData, GraphEdge> value = parentNode.left().value();
1059                 if (log.isDebugEnabled())
1060                         log.debug("Found parent node {}", value);
1061                 UserData userData = value.getKey();
1062                 if (log.isDebugEnabled())
1063                         log.debug("Build resource : set creator userId to {}", userData.getUserId());
1064                 String fullName = buildFullName(userData);
1065                 if (log.isDebugEnabled())
1066                         log.debug("Build resource : set creator full name to {}", fullName);
1067                 resource.setCreatorUserId(userData.getUserId());
1068                 resource.setCreatorFullName(fullName);
1069
1070                 return TitanOperationStatus.OK;
1071         }
1072
1073         @Override
1074         TitanOperationStatus setComponentCategoriesFromGraph(Component resource) {
1075                 String uniqueId = resource.getUniqueId();
1076                 Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> parentNode = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), uniqueId, GraphEdgeLabels.CATEGORY,
1077                                 NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
1078                 if (parentNode.isRight()) {
1079                         return parentNode.right().value();
1080                 }
1081
1082                 List<ImmutablePair<SubCategoryData, GraphEdge>> listValue = parentNode.left().value();
1083                 log.debug("Result after looking for subcategory nodes pointed by resource {}. status is {}", uniqueId, listValue);
1084                 if (listValue.size() > 1) {
1085                         log.error("Multiple edges foud between resource {} to subcategory nodes.", uniqueId);
1086                 }
1087                 ImmutablePair<SubCategoryData, GraphEdge> value = listValue.get(0);
1088                 log.debug("Found parent node {}", value);
1089
1090                 SubCategoryData subcategoryData = value.getKey();
1091
1092                 Either<ImmutablePair<CategoryData, GraphEdge>, TitanOperationStatus> categoryNode = titanGenericDao.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceSubcategory), (String) subcategoryData.getUniqueId(),
1093                                 GraphEdgeLabels.SUB_CATEGORY, NodeTypeEnum.ResourceNewCategory, CategoryData.class);
1094                 if (categoryNode.isRight()) {
1095                         return categoryNode.right().value();
1096                 }
1097
1098                 CategoryData categoryData = categoryNode.left().value().left;
1099                 CategoryDefinition catDef = new CategoryDefinition(categoryData.getCategoryDataDefinition());
1100                 SubCategoryDefinition subcatDef = new SubCategoryDefinition(subcategoryData.getSubCategoryDataDefinition());
1101
1102                 resource.addCategory(catDef, subcatDef);
1103                 return TitanOperationStatus.OK;
1104         }
1105
1106         public String buildFullName(UserData userData) {
1107
1108                 String fullName = userData.getFirstName();
1109                 if (fullName == null) {
1110                         fullName = "";
1111                 } else {
1112                         fullName = fullName + " ";
1113                 }
1114                 String lastName = userData.getLastName();
1115                 if (lastName != null) {
1116                         fullName += lastName;
1117                 }
1118                 return fullName;
1119         }
1120
1121         private Resource convertResourceDataToResource(ResourceMetadataData resourceData) {
1122
1123                 ResourceMetadataDefinition resourceMetadataDataDefinition = new ResourceMetadataDefinition((ResourceMetadataDataDefinition) resourceData.getMetadataDataDefinition());
1124
1125                 Resource resource = new Resource(resourceMetadataDataDefinition);
1126
1127                 return resource;
1128         }
1129
1130         @Override
1131         public Either<Resource, StorageOperationStatus> deleteResource(String resourceId) {
1132                 return deleteResource(resourceId, false);
1133         }
1134
1135         @Override
1136         public Either<Resource, StorageOperationStatus> updateResource(Resource resource) {
1137
1138                 return updateResource(resource, false);
1139
1140         }
1141
1142         @Override
1143         public Either<Integer, StorageOperationStatus> getNumberOfResourcesByName(String resourceName) {
1144
1145                 Map<String, Object> propertiesToMatch = new HashMap<String, Object>();
1146                 propertiesToMatch.put(GraphPropertiesDictionary.NAME.getProperty(), resourceName);
1147
1148                 Either<List<ResourceMetadataData>, TitanOperationStatus> getParentResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
1149                 log.debug("result after searching for resources called {} is {}", resourceName, getParentResources);
1150                 if (getParentResources.isRight()) {
1151                         TitanOperationStatus titanStatus = getParentResources.right().value();
1152                         if (titanStatus == TitanOperationStatus.NOT_FOUND) {
1153                                 log.debug("Number of returned resources is 0.");
1154                                 return Either.left(0);
1155                         }
1156                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus));
1157                 } else {
1158                         List<ResourceMetadataData> value = getParentResources.left().value();
1159                         int numberOFResources = (value == null ? 0 : value.size());
1160                         log.debug("The number of resources returned after searching for resource called {} is {}", resourceName, numberOFResources);
1161                         return Either.left(numberOFResources);
1162                 }
1163         }
1164
1165         public PropertyOperation getPropertyOperation() {
1166                 return propertyOperation;
1167         }
1168
1169         public void setPropertyOperation(PropertyOperation propertyOperation) {
1170                 this.propertyOperation = propertyOperation;
1171         }
1172
1173         public RequirementOperation getRequirementOperation() {
1174                 return requirementOperation;
1175         }
1176
1177         public void setRequirementOperation(RequirementOperation requirementOperation) {
1178                 this.requirementOperation = requirementOperation;
1179         }
1180
1181         public CapabilityOperation getCapabilityOperation() {
1182                 return capabilityOperation;
1183         }
1184
1185         public void setCapabilityOperation(CapabilityOperation capabilityOperation) {
1186                 this.capabilityOperation = capabilityOperation;
1187         }
1188
1189         public IArtifactOperation getArtifactOperation() {
1190                 return artifactOperation;
1191         }
1192
1193         public void setArtifactOperation(IArtifactOperation artifactOperation) {
1194                 this.artifactOperation = artifactOperation;
1195         }
1196
1197         public InterfaceLifecycleOperation getInterfaceLifecycleOperation() {
1198                 return interfaceLifecycleOperation;
1199         }
1200
1201         public void setInterfaceLifecycleOperation(InterfaceLifecycleOperation interfaceLifecycleOperation) {
1202                 this.interfaceLifecycleOperation = interfaceLifecycleOperation;
1203         }
1204
1205         public TitanGenericDao getTitanGenericDao() {
1206                 return titanGenericDao;
1207         }
1208
1209         public IElementOperation getElementOperation() {
1210                 return elementOperation;
1211         }
1212
1213         public void setElementOperation(IElementOperation elementOperation) {
1214                 this.elementOperation = elementOperation;
1215         }
1216
1217         /**
1218          * FOR TEST ONLY
1219          *
1220          * @param titanGenericDao
1221          */
1222         public void setTitanGenericDao(TitanGenericDao titanGenericDao) {
1223                 this.titanGenericDao = titanGenericDao;
1224         }
1225
1226         @Override
1227         public Either<List<Resource>, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract) {
1228
1229                 return getAllCertifiedResources(isAbstract, null);
1230
1231         }
1232
1233         @Override
1234         /**
1235          * Deletes the resource node, property nodes and relation to artifacts. MUST handle deletion of artifact from artifacts repository outside this method (in catalog-be)
1236          */
1237         public Either<Resource, StorageOperationStatus> deleteResource(String resourceId, boolean inTransaction) {
1238
1239                 Either<Resource, StorageOperationStatus> result = Either.right(StorageOperationStatus.GENERAL_ERROR);
1240                 try {
1241
1242                         Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
1243                         if (graphResult.isRight()) {
1244                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graphResult.right().value()));
1245                                 return result;
1246                         }
1247
1248                         TitanGraph titanGraph = graphResult.left().value();
1249                         Iterable<TitanVertex> vertecies = titanGraph.query().has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId).vertices();
1250                         Either<Resource, StorageOperationStatus> resourceEither = getResource(resourceId, true);
1251                         Resource resource = resourceEither.left().value();
1252                         if (vertecies != null && resourceEither.isLeft()) {
1253                                 Iterator<TitanVertex> iterator = vertecies.iterator();
1254                                 if (iterator != null && iterator.hasNext()) {
1255                                         Vertex rootVertex = iterator.next();
1256                                         TitanOperationStatus deleteChildrenNodes = graphDeleteUtil.deleteChildrenNodes(rootVertex, GraphEdgeLabels.PROPERTY);
1257                                         log.debug("After deleting properties nodes in the graph. status is {}", deleteChildrenNodes);
1258                                         if (deleteChildrenNodes != TitanOperationStatus.OK) {
1259                                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteChildrenNodes));
1260                                                 return result;
1261                                         }
1262                                         StorageOperationStatus removeInterfacesFromResource = removeInterfacesFromResource(resource);
1263                                         log.debug("After deleting interfaces nodes in the graph. status is {}", removeInterfacesFromResource);
1264                                         if (!removeInterfacesFromResource.equals(StorageOperationStatus.OK)) {
1265                                                 result = Either.right(removeInterfacesFromResource);
1266                                                 return result;
1267                                         }
1268                                         StorageOperationStatus removeArtifactsFromResource = removeArtifactsFromResource(resource);
1269                                         log.debug("After deleting artifacts nodes in the graph. status is {}", removeArtifactsFromResource);
1270                                         if (!removeArtifactsFromResource.equals(StorageOperationStatus.OK)) {
1271                                                 result = Either.right(removeArtifactsFromResource);
1272                                                 return result;
1273                                         }
1274                                         StorageOperationStatus removeCapabilitiesFromResource = removeCapabilitiesFromResource(resource);
1275                                         log.debug("After deleting capabilities nodes in the graph. status is {}", removeCapabilitiesFromResource);
1276                                         if (!removeCapabilitiesFromResource.equals(StorageOperationStatus.OK)) {
1277                                                 result = Either.right(removeCapabilitiesFromResource);
1278                                                 return result;
1279                                         }
1280
1281                                         StorageOperationStatus removeRequirementsFromResource = removeRequirementsFromResource(resource);
1282                                         log.debug("After deleting requirements nodes in the graph. status is {}", removeRequirementsFromResource);
1283                                         if (!removeRequirementsFromResource.equals(StorageOperationStatus.OK)) {
1284                                                 result = Either.right(removeRequirementsFromResource);
1285                                                 return result;
1286                                         }
1287
1288                                         StorageOperationStatus removeRIsFromResource = removeResourceInstanceFromResource(resource);
1289                                         log.debug("After deleting resource instance nodes in the graph. status is {}", removeRIsFromResource);
1290                                         if (!removeRIsFromResource.equals(StorageOperationStatus.OK)) {
1291                                                 result = Either.right(removeRIsFromResource);
1292                                                 return result;
1293                                         }
1294
1295                                         StorageOperationStatus removeAttributesFromResource = removeAttributesFromResource(resource);
1296                                         log.debug("After deleting requirements nodes in the graph. status is {}", removeRequirementsFromResource);
1297                                         if (removeAttributesFromResource != StorageOperationStatus.OK) {
1298                                                 result = Either.right(removeAttributesFromResource);
1299                                                 return result;
1300                                         }
1301
1302                                         StorageOperationStatus removeInputsFromResource = removeInputsFromComponent(NodeTypeEnum.Resource, resource);
1303                                         log.debug("After deleting requirements nodes in the graph. status is {}", removeInputsFromResource);
1304                                         if (removeInputsFromResource != StorageOperationStatus.OK) {
1305                                                 result = Either.right(removeInputsFromResource);
1306                                                 return result;
1307                                         }
1308
1309                                         StorageOperationStatus removeAdditionalInformationFromResource = super.deleteAdditionalInformation(NodeTypeEnum.Resource, resource.getUniqueId());
1310                                         log.debug("After deleting additional information node in the graph. status is {}", removeAdditionalInformationFromResource);
1311                                         if (!removeAdditionalInformationFromResource.equals(StorageOperationStatus.OK)) {
1312                                                 result = Either.right(removeAdditionalInformationFromResource);
1313                                                 return result;
1314                                         }
1315
1316                                         StorageOperationStatus removeGroupsFromResource = super.deleteGroups(NodeTypeEnum.Resource, resource.getUniqueId());
1317                                         log.debug("After deleting group nodes in the graph. status is {}", removeGroupsFromResource);
1318                                         if (!removeGroupsFromResource.equals(StorageOperationStatus.OK)) {
1319                                                 result = Either.right(removeGroupsFromResource);
1320                                                 return result;
1321                                         }
1322
1323                                         rootVertex.remove();
1324
1325                                 } else {
1326                                         result = Either.right(StorageOperationStatus.NOT_FOUND);
1327                                         return result;
1328                                 }
1329                         } else {
1330                                 result = Either.right(StorageOperationStatus.NOT_FOUND);
1331                                 return result;
1332                         }
1333
1334                         result = Either.left(resource);
1335                         return result;
1336                 } finally {
1337                         if (false == inTransaction) {
1338                                 if (result == null || result.isRight()) {
1339                                         log.error("deleteResource operation : Going to execute rollback on graph.");
1340                                         titanGenericDao.rollback();
1341                                 } else {
1342                                         log.debug("deleteResource operation : Going to execute commit on graph.");
1343                                         titanGenericDao.commit();
1344                                 }
1345                         }
1346                 }
1347
1348         }
1349
1350         private StorageOperationStatus removeAttributesFromResource(Resource resource) {
1351                 Either<Map<String, PropertyDefinition>, StorageOperationStatus> deleteAllAttributeAssociatedToNode = attributeOperation.deleteAllAttributeAssociatedToNode(NodeTypeEnum.Resource, resource.getUniqueId());
1352                 return deleteAllAttributeAssociatedToNode.isRight() ? deleteAllAttributeAssociatedToNode.right().value() : StorageOperationStatus.OK;
1353         }
1354
1355         private StorageOperationStatus removeArtifactsFromResource(Resource resource) {
1356
1357                 String resourceId = resource.getUniqueId();
1358                 Map<String, ArtifactDefinition> allArtifacts = new HashMap<String, ArtifactDefinition>();
1359                 if (resource.getArtifacts() != null) {
1360                         allArtifacts.putAll(resource.getArtifacts());
1361                 }
1362                 if (resource.getDeploymentArtifacts() != null) {
1363                         allArtifacts.putAll(resource.getDeploymentArtifacts());
1364                 }
1365                 if (allArtifacts != null) {
1366                         for (Entry<String, ArtifactDefinition> entry : allArtifacts.entrySet()) {
1367
1368                                 ArtifactDefinition artifactDefinition = entry.getValue();
1369                                 Either<ArtifactDefinition, StorageOperationStatus> removeArifactFromResource = artifactOperation.removeArifactFromResource(resourceId, artifactDefinition.getUniqueId(), NodeTypeEnum.Resource, true, true);
1370                                 if (removeArifactFromResource.isRight()) {
1371                                         return removeArifactFromResource.right().value();
1372                                 }
1373                         }
1374                 }
1375                 return StorageOperationStatus.OK;
1376         }
1377
1378         private StorageOperationStatus removeInterfacesFromResource(Resource resource) {
1379
1380                 String resourceId = resource.getUniqueId();
1381                 // delete only interfaces of this resource (not interfaces derived)
1382                 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource = interfaceLifecycleOperation.getAllInterfacesOfResource(resourceId, false, true);
1383                 if (allInterfacesOfResource.isRight()) {
1384                         log.error("failed to get interfaces for resource {}. status is {}", resourceId, allInterfacesOfResource.right().value());
1385                         return allInterfacesOfResource.right().value();
1386                 }
1387                 Map<String, InterfaceDefinition> interfaces = allInterfacesOfResource.left().value();
1388                 if (interfaces != null) {
1389                         for (Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {
1390                                 Boolean isAbstract = resource.isAbstract();
1391
1392                                 InterfaceDefinition interfaceDefinition = entry.getValue();
1393                                 // esofer - in case the resource is abstract, we deleting only
1394                                 // the edge to the interface.
1395                                 if (isAbstract != null && true == isAbstract.booleanValue()) {
1396                                         log.debug("Going to dissociate resource {} from interface {}", resourceId, interfaceDefinition.getUniqueId());
1397                                         UniqueIdData uniqueIdData = new UniqueIdData(NodeTypeEnum.Resource, resourceId);
1398                                         Either<InterfaceDefinition, StorageOperationStatus> dissociateInterfaceFromNode = interfaceLifecycleOperation.dissociateInterfaceFromNode(uniqueIdData, interfaceDefinition);
1399                                         if (dissociateInterfaceFromNode.isRight()) {
1400                                                 log.error("failed to dissociate resource {} from interface {}. status is {}", resourceId, interfaceDefinition.getUniqueId(), dissociateInterfaceFromNode.right().value());
1401                                                 return dissociateInterfaceFromNode.right().value();
1402                                         }
1403                                 } else {
1404                                         Either<InterfaceDefinition, StorageOperationStatus> deleteInterfaceOfResourceOnGraph = interfaceLifecycleOperation.deleteInterfaceOfResourceOnGraph(resourceId, interfaceDefinition, true);
1405                                         if (deleteInterfaceOfResourceOnGraph.isRight()) {
1406                                                 return deleteInterfaceOfResourceOnGraph.right().value();
1407                                         }
1408                                 }
1409                         }
1410                 }
1411                 return StorageOperationStatus.OK;
1412         }
1413
1414         private StorageOperationStatus removeCapabilitiesFromResource(Resource resource) {
1415
1416                 String resourceId = resource.getUniqueId();
1417
1418                 Either<Map<String, CapabilityDefinition>, StorageOperationStatus> deleteAllRes = capabilityOperation.deleteAllCapabilities(resourceId, true);
1419                 if (deleteAllRes.isRight()) {
1420                         StorageOperationStatus status = deleteAllRes.right().value();
1421                         if (status == StorageOperationStatus.NOT_FOUND) {
1422                                 return StorageOperationStatus.OK;
1423                         }
1424                         return status;
1425                 }
1426
1427                 return StorageOperationStatus.OK;
1428
1429         }
1430
1431         private StorageOperationStatus removeRequirementsFromResource(Resource resource) {
1432
1433                 String resourceId = resource.getUniqueId();
1434
1435                 Either<Map<String, RequirementDefinition>, StorageOperationStatus> deleteAllRes = requirementOperation.deleteAllRequirements(resourceId, true);
1436
1437                 if (deleteAllRes.isRight()) {
1438                         StorageOperationStatus status = deleteAllRes.right().value();
1439                         if (status == StorageOperationStatus.NOT_FOUND) {
1440                                 return StorageOperationStatus.OK;
1441                         }
1442                         return status;
1443                 }
1444
1445                 return StorageOperationStatus.OK;
1446
1447         }
1448
1449         private StorageOperationStatus removeResourceInstanceFromResource(Resource resource) {
1450                 String resourceId = resource.getUniqueId();
1451
1452                 Either<List<ComponentInstance>, StorageOperationStatus> deleteAllResourceInstancesRes = componentInstanceOperation.deleteAllComponentInstances(resourceId, NodeTypeEnum.Resource, true);
1453                 if (deleteAllResourceInstancesRes.isRight()) {
1454                         StorageOperationStatus status = deleteAllResourceInstancesRes.right().value();
1455                         if (status == StorageOperationStatus.NOT_FOUND) {
1456                                 return StorageOperationStatus.OK;
1457                         }
1458                         return status;
1459                 }
1460                 return StorageOperationStatus.OK;
1461         }
1462
1463         @Override
1464         public Either<Resource, StorageOperationStatus> updateResource(Resource resource, boolean inTransaction) {
1465                 return (Either<Resource, StorageOperationStatus>) updateComponent(resource, inTransaction, titanGenericDao, resource.getClass(), NodeTypeEnum.Resource);
1466
1467         }
1468
1469         @Override
1470         protected <T extends Component> StorageOperationStatus updateDerived(Component component, Component currentComponent, ComponentMetadataData updatedResourceData, Class<T> clazz) {
1471                 Resource resource = (Resource) component;
1472                 Resource currentResource = (Resource) currentComponent;
1473                 if (resource.getDerivedFrom() != null) {// meaning derived from changed
1474
1475                         Either<List<ResourceMetadataData>, StorageOperationStatus> findDerivedResourcesOld = findDerivedResources(currentResource);
1476                         if (findDerivedResourcesOld.isRight()) {
1477                                 log.debug("Couldn't find derived resource {} for current resource in the graph", currentResource.getDerivedFrom().get(0));
1478                                 return findDerivedResourcesOld.right().value();
1479                         }
1480
1481                         List<ResourceMetadataData> oldDerived = findDerivedResourcesOld.left().value();
1482                         if (oldDerived.isEmpty()) {
1483                                 log.debug("Derived from list fetched from DB for current resource is empty");
1484                                 return StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND;
1485                         }
1486
1487                         Either<List<ResourceMetadataData>, StorageOperationStatus> findDerivedResourcesNew = findDerivedResources((Resource) resource);
1488                         if (findDerivedResourcesNew.isRight()) {
1489                                 log.debug("Couldn't find derived resource {} for update resource in the graph", resource.getDerivedFrom().get(0));
1490                                 return findDerivedResourcesNew.right().value();
1491                         }
1492
1493                         List<ResourceMetadataData> newDerived = findDerivedResourcesNew.left().value();
1494                         if (newDerived.isEmpty()) {
1495                                 log.debug("Derived from list fetched from DB for updated resource is empty");
1496                                 return StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND;
1497                         }
1498
1499                         Either<Boolean, TitanOperationStatus> reassociateDerivedFrom = reassociateDerivedFrom((ResourceMetadataData) updatedResourceData, oldDerived, newDerived);
1500                         if (reassociateDerivedFrom.isRight()) {
1501                                 log.debug("Couldn't change derived from for the resoure");
1502                                 return DaoStatusConverter.convertTitanStatusToStorageStatus(reassociateDerivedFrom.right().value());
1503                         }
1504                 }
1505                 return StorageOperationStatus.OK;
1506         }
1507
1508         private Either<Boolean, TitanOperationStatus> reassociateDerivedFrom(ResourceMetadataData resourceData, List<ResourceMetadataData> oldDerived, List<ResourceMetadataData> newDerived) {
1509                 ResourceMetadataData oldDerivedNode = oldDerived.get(0);
1510                 log.debug("Dissociating resource {} from old parent resource {}", resourceData.getUniqueId(), oldDerivedNode.getUniqueId());
1511                 Either<GraphRelation, TitanOperationStatus> deleteRelation = titanGenericDao.deleteRelation(resourceData, oldDerivedNode, GraphEdgeLabels.DERIVED_FROM);
1512                 if (deleteRelation.isRight()) {
1513                         log.debug("Failed to dissociate resource {} from old parent resource {}", resourceData.getUniqueId(), oldDerivedNode.getUniqueId());
1514                         return Either.right(deleteRelation.right().value());
1515                 }
1516                 ResourceMetadataData newDerivedNode = newDerived.get(0);
1517                 log.debug("Associating resource {} with new parent resource {}", resourceData.getUniqueId(), newDerivedNode.getUniqueId());
1518                 Either<GraphRelation, TitanOperationStatus> addRelation = titanGenericDao.createRelation(resourceData, newDerivedNode, GraphEdgeLabels.DERIVED_FROM, null);
1519                 if (addRelation.isRight()) {
1520                         log.debug("Failed to associate resource {} with new parent resource {}", resourceData.getUniqueId(), newDerivedNode.getUniqueId());
1521                         return Either.right(addRelation.right().value());
1522                 }
1523
1524                 return Either.left(true);
1525         }
1526
1527         private StorageOperationStatus moveCategoryEdge(Resource resource, ResourceMetadataData resourceData, CategoryDefinition newCategory) {
1528
1529                 StorageOperationStatus result = StorageOperationStatus.OK;
1530
1531                 GraphRelation categoryRelation = new GraphRelation();
1532                 categoryRelation.setType(GraphEdgeLabels.CATEGORY.getProperty());
1533                 RelationEndPoint relationEndPoint = new RelationEndPoint(NodeTypeEnum.Resource, UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resource.getUniqueId());
1534                 categoryRelation.setFrom(relationEndPoint);
1535                 Either<GraphRelation, TitanOperationStatus> deleteOutgoingRelation = titanGenericDao.deleteOutgoingRelation(categoryRelation);
1536                 if (deleteOutgoingRelation.isRight()) {
1537                         log.error("Failed to delete category from resource {}. Edge type is {}", resourceData.getUniqueId(), GraphEdgeLabels.CATEGORY);
1538                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(deleteOutgoingRelation.right().value());
1539                         return result;
1540                 }
1541
1542                 log.debug("After removing edge from graph {}", deleteOutgoingRelation);
1543
1544                 return assosiateMetadataToCategory(resource, resourceData);
1545         }
1546
1547         private StorageOperationStatus moveLastModifierEdge(Resource resource, ResourceMetadataData resourceData, UserData modifierUserData) {
1548
1549                 StorageOperationStatus result = StorageOperationStatus.OK;
1550
1551                 GraphRelation lastModifierRelation = new GraphRelation();
1552                 lastModifierRelation.setType(GraphEdgeLabels.LAST_MODIFIER.getProperty());
1553                 RelationEndPoint relationEndPoint = new RelationEndPoint(NodeTypeEnum.Resource, UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resource.getUniqueId());
1554                 lastModifierRelation.setTo(relationEndPoint);
1555                 Either<GraphRelation, TitanOperationStatus> deleteIncomingRelation = titanGenericDao.deleteIncomingRelation(lastModifierRelation);
1556                 if (deleteIncomingRelation.isRight()) {
1557                         log.error("Failed to delete user from resource {}. Edge type is {}", resourceData.getUniqueId(),GraphEdgeLabels.LAST_MODIFIER);
1558                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(deleteIncomingRelation.right().value());
1559                         return result;
1560                 }
1561
1562                 Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(modifierUserData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null);
1563                 log.debug("After associating user {} to resource {}. Edge type is {}", modifierUserData, resourceData.getUniqueId(), GraphEdgeLabels.LAST_MODIFIER);
1564                 if (createRelation.isRight()) {
1565                         log.error("Failed to associate user {} to resource {}. Edge type is {}", modifierUserData, resourceData.getUniqueId(), GraphEdgeLabels.LAST_MODIFIER);
1566                         result = DaoStatusConverter.convertTitanStatusToStorageStatus(createRelation.right().value());
1567                         return result;
1568                 }
1569
1570                 return result;
1571         }
1572
1573         private Either<ResourceMetadataData, TitanOperationStatus> findResource(String resourceId) {
1574
1575                 String key = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource);
1576                 Either<ResourceMetadataData, TitanOperationStatus> findResource = titanGenericDao.getNode(key, resourceId, ResourceMetadataData.class);
1577
1578                 return findResource;
1579         }
1580
1581         private StorageOperationStatus setArtifactFromGraph(String uniqueId, Resource resource) {
1582                 StorageOperationStatus result = StorageOperationStatus.OK;
1583                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = artifactOperation.getArtifacts(uniqueId, NodeTypeEnum.Resource, true);
1584                 if (artifacts.isRight()) {
1585                         result = artifacts.right().value();
1586                 } else {
1587                         createSpecificArtifactList(resource, artifacts.left().value());
1588                 }
1589                 return result;
1590         }
1591
1592         @Override
1593         public <T extends Component> Either<T, StorageOperationStatus> getComponent(String id, Class<T> clazz) {
1594
1595                 Either<Resource, StorageOperationStatus> component = getResource(id);
1596                 if (component.isRight()) {
1597                         return Either.right(component.right().value());
1598                 }
1599                 return Either.left(clazz.cast(component.left().value()));
1600         }
1601
1602         @Override
1603         public Either<Boolean, StorageOperationStatus> validateResourceNameExists(String resourceName, ResourceTypeEnum resourceType) {
1604                 if (resourceType != null) {
1605                         Map<String, Object> properties = new HashMap<String, Object>();
1606                         properties.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
1607                         if (resourceType.equals(ResourceTypeEnum.VF)) {
1608                                 return validateResourceNameUniqueness(resourceName, properties, null, titanGenericDao);
1609                         } else {
1610                                 return validateResourceNameUniqueness(resourceName, null, properties, titanGenericDao);
1611                         }
1612
1613                 } else {
1614                         return validateResourceNameUniqueness(resourceName, null, null, titanGenericDao);
1615                 }
1616
1617         }
1618
1619         public Either<Boolean, StorageOperationStatus> validateToscaResourceNameExists(String templateName) {
1620                 return validateToscaResourceNameUniqueness(templateName, titanGenericDao);
1621         }
1622
1623         //Tal G for US815447
1624         public Either<Boolean, StorageOperationStatus> validateToscaResourceNameExtends(String templateNameCurrent, String templateNameExtends) {
1625
1626                 String currentTemplateNameChecked = templateNameExtends;
1627
1628                 while(currentTemplateNameChecked != null && !currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)){
1629                         Either<Resource, StorageOperationStatus> latestByToscaResourceName = getLatestByToscaResourceName(currentTemplateNameChecked, true);
1630
1631                         if(latestByToscaResourceName.isRight()){
1632                                 return latestByToscaResourceName.right().value() == StorageOperationStatus.NOT_FOUND ? Either.left(false) : Either.right(latestByToscaResourceName.right().value());
1633                         }
1634
1635                         Resource value = latestByToscaResourceName.left().value();
1636
1637                         if(value.getDerivedFrom() != null){
1638                                 currentTemplateNameChecked = value.getDerivedFrom().get(0);
1639                         } else {
1640                                 currentTemplateNameChecked = null;
1641                         }
1642                 }
1643
1644                 return (currentTemplateNameChecked != null && currentTemplateNameChecked.equalsIgnoreCase(templateNameCurrent)) ? Either.left(true) : Either.left(false);
1645         }
1646
1647         public Either<List<ArtifactDefinition>, StorageOperationStatus> getAdditionalArtifacts(String resourceId, boolean recursively, boolean inTransaction) {
1648                 List<ArtifactDefinition> artifacts = new ArrayList<>();
1649
1650                 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfacesOfResource = interfaceLifecycleOperation.getAllInterfacesOfResource(resourceId, false, true);
1651                 if (interfacesOfResource.isRight()) {
1652                         log.error("failed to get all resource interfaces. resource id={}. status ={}", resourceId, interfacesOfResource.right().value());
1653                         return Either.right(interfacesOfResource.right().value());
1654                 }
1655
1656                 Map<String, InterfaceDefinition> interfaces = interfacesOfResource.left().value();
1657                 if (interfaces != null && !interfaces.isEmpty()) {
1658                         for (Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {
1659
1660                                 InterfaceDefinition interfaceDefinition = entry.getValue();
1661                                 Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
1662                                 if (operations != null && !operations.isEmpty()) {
1663                                         for (Entry<String, Operation> opEntry : operations.entrySet()) {
1664
1665                                                 Operation operation = opEntry.getValue();
1666                                                 ArtifactDefinition artifactDefinition = operation.getImplementationArtifact();
1667                                                 if (artifactDefinition != null) {
1668                                                         artifacts.add(artifactDefinition);
1669                                                 }
1670                                         }
1671                                 }
1672                         }
1673                 }
1674                 return Either.left(artifacts);
1675         }
1676
1677         @SuppressWarnings("unchecked")
1678         public Either<List<Resource>, StorageOperationStatus> getFollowed(String userId, Set<LifecycleStateEnum> lifecycleStates, Set<LifecycleStateEnum> lastStateStates, boolean inTransaction) {
1679                 return (Either<List<Resource>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getFollowedComponent(userId, lifecycleStates, lastStateStates, inTransaction, titanGenericDao, NodeTypeEnum.Resource);
1680         }
1681
1682         @SuppressWarnings("unchecked")
1683         @Override
1684         public <T> Either<T, StorageOperationStatus> getComponent(String id, boolean inTransaction) {
1685                 return (Either<T, StorageOperationStatus>) getResource(id, inTransaction);
1686         }
1687
1688         // @Override
1689         // public <T> Either<T, StorageOperationStatus> getComponent_tx(String id,
1690         // boolean inTransaction) {
1691         // return (Either<T, StorageOperationStatus>) getResource_tx(id,
1692         // inTransaction);
1693         // }
1694
1695         private Optional<ImmutablePair<SubCategoryData, GraphEdge>> validateCategoryHierarcy(List<ImmutablePair<SubCategoryData, GraphEdge>> childNodes, String subCategoryName) {
1696                 Predicate<ImmutablePair<SubCategoryData, GraphEdge>> matchName = p -> p.getLeft().getSubCategoryDataDefinition().getName().equals(subCategoryName);
1697                 return childNodes.stream().filter(matchName).findAny();
1698         }
1699
1700         private Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, StorageOperationStatus> getAllSubCategories(String categoryName) {
1701                 Either<CategoryData, StorageOperationStatus> categoryResult = elementOperation.getNewCategoryData(categoryName, NodeTypeEnum.ResourceNewCategory, CategoryData.class);
1702                 if (categoryResult.isRight()) {
1703                         return Either.right(categoryResult.right().value());
1704                 }
1705                 CategoryData categoryData = categoryResult.left().value();
1706
1707                 Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceNewCategory), (String) categoryData.getUniqueId(),
1708                                 GraphEdgeLabels.SUB_CATEGORY, NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
1709                 if (childrenNodes.isRight()) {
1710                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childrenNodes.right().value()));
1711                 }
1712                 return Either.left(childrenNodes.left().value());
1713         }
1714
1715         @Override
1716         public <T> Either<List<T>, StorageOperationStatus> getFilteredComponents(Map<FilterKeyEnum, String> filters, boolean inTransaction) {
1717
1718                 String subCategoryName = filters.get(FilterKeyEnum.SUB_CATEGORY);
1719                 String categoryName = filters.get(FilterKeyEnum.CATEGORY);
1720                 ResourceTypeEnum resourceType = ResourceTypeEnum.getType( filters.get(FilterKeyEnum.RESOURCE_TYPE));
1721                 Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, StorageOperationStatus> subcategories = null;
1722                 Optional<ImmutablePair<SubCategoryData, GraphEdge>> subCategoryData;
1723
1724                 if (categoryName != null) {
1725                         subcategories = getAllSubCategories(categoryName);
1726                         if (subcategories.isRight()) {
1727                                 filters.remove(FilterKeyEnum.SUB_CATEGORY);
1728                                 return Either.right(subcategories.right().value());
1729                         }
1730                 }
1731                 if (subCategoryName != null) { // primary filter
1732                         if (categoryName != null) {
1733                                 subCategoryData = validateCategoryHierarcy(subcategories.left().value(), subCategoryName);
1734                                 if (!subCategoryData.isPresent()) {
1735                                         return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1736                                 }
1737                                 return fetchByCategoryOrSubCategoryUid((String) subCategoryData.get().getLeft().getUniqueId(), NodeTypeEnum.ResourceSubcategory, GraphEdgeLabels.SUB_CATEGORY.getProperty(), NodeTypeEnum.Resource, inTransaction,
1738                                                 ResourceMetadataData.class, resourceType);
1739                         }
1740
1741                         return fetchByCategoryOrSubCategoryName(subCategoryName, NodeTypeEnum.ResourceSubcategory, GraphEdgeLabels.SUB_CATEGORY.getProperty(), NodeTypeEnum.Resource, inTransaction, ResourceMetadataData.class, resourceType);
1742                 }
1743                 if(subcategories != null){
1744                         return fetchByMainCategory(subcategories.left().value(), inTransaction, resourceType);
1745                 }
1746                 return fetchByResourceType(NodeTypeEnum.Resource, filters.get(FilterKeyEnum.RESOURCE_TYPE), ResourceMetadataData.class, inTransaction);
1747         }
1748
1749         @SuppressWarnings("unchecked")
1750         private <T, S extends ComponentMetadataData> Either<List<T>, StorageOperationStatus> fetchByResourceType(NodeTypeEnum nodeType, String resourceType,
1751                         Class<S> clazz, boolean inTransaction) {
1752                 List<T> components = null;
1753                 TitanOperationStatus status;
1754                 Wrapper<StorageOperationStatus> statusWrapper = new Wrapper<>();
1755                 Either<List<T>, StorageOperationStatus> result;
1756                 try {
1757                         Map<String, Object> props = new HashMap<>();
1758                         props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), resourceType);
1759                         props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
1760                         Either<List<S>, TitanOperationStatus> getResources = titanGenericDao.getByCriteria(nodeType, props, clazz);
1761                         if (getResources.isRight()) {
1762                                 status = getResources.right().value();
1763                                 if(status != TitanOperationStatus.NOT_FOUND){
1764                                         statusWrapper.setInnerElement(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
1765                                 }else{
1766                                         components = new ArrayList<>();
1767                                 }
1768                         }else{
1769                                 components = getResources.left().value().stream().
1770                                 map(c->(T)convertComponentMetadataDataToComponent(c)).collect(Collectors.toList());
1771                         }
1772                         if(!statusWrapper.isEmpty()){
1773                                 result = Either.right(statusWrapper.getInnerElement());
1774                         }else{
1775                                 result = Either.left(components);
1776                         }
1777                         return result;
1778                 } finally {
1779                         if (!inTransaction) {
1780                                 titanGenericDao.commit();
1781                         }
1782                 }
1783         }
1784
1785         private <T> Either<List<T>, StorageOperationStatus> fetchByMainCategory(List<ImmutablePair<SubCategoryData, GraphEdge>> subcategories, boolean inTransaction, ResourceTypeEnum resourceType) {
1786                 List<T> components = new ArrayList<>();
1787
1788                 for (ImmutablePair<SubCategoryData, GraphEdge> subCategory : subcategories) {
1789                         Either<List<T>, StorageOperationStatus> fetched = fetchByCategoryOrSubCategoryUid((String) subCategory.getLeft().getUniqueId(), NodeTypeEnum.ResourceSubcategory, GraphEdgeLabels.SUB_CATEGORY.getProperty(), NodeTypeEnum.Resource,
1790                                         inTransaction, ResourceMetadataData.class, resourceType);
1791                         if (fetched.isRight()) {
1792                                 // return fetched;
1793                                 continue;
1794                         }
1795                         components.addAll(fetched.left().value());
1796                 }
1797                 return Either.left(components);
1798         }
1799
1800         @Override
1801         public <T> Either<T, StorageOperationStatus> getLightComponent(String id, boolean inTransaction) {
1802                 return getLightComponent(id, NodeTypeEnum.Resource, inTransaction);
1803         }
1804
1805         // will be implement later
1806         @Override
1807         protected ComponentMetadataData getMetaDataFromComponent(Component component) {
1808                 return getResourceMetaDataFromResource((Resource) component);
1809         }
1810
1811         @Override
1812         public Either<Set<Resource>, StorageOperationStatus> getCatalogData(Map<String, Object> propertiesToMatch, boolean inTransaction) {
1813                 return getComponentCatalogData(NodeTypeEnum.Resource, propertiesToMatch, Resource.class, ResourceMetadataData.class, inTransaction);
1814         }
1815
1816         @Override
1817         public Either<List<Resource>, StorageOperationStatus> getAllDerivedResources(Resource resource) {
1818                 try {
1819                         Either<List<ImmutablePair<ResourceMetadataData, GraphEdge>>, TitanOperationStatus> childrenNodes = getDerivingChildren(resource);
1820                         return childrenNodes.either((childrenPairs) -> convertToResources(PairUtils.leftSequence(childrenPairs)),
1821                                                                                 (status) -> Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status)));
1822                 } finally {
1823                         titanGenericDao.commit();
1824                 }
1825         }
1826
1827         @Override
1828         public Either<List<Resource>, StorageOperationStatus> getRootResources() {
1829                 Map<String, Object> rootToscaResource = new HashMap<>();
1830                 rootToscaResource.put(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), Resource.ROOT_RESOURCE);
1831                 return getResourceListByCriteria(rootToscaResource, false);
1832         }
1833
1834         @Override
1835         public Either<List<Resource>, StorageOperationStatus> getVFResources() {
1836                 Map<String, Object> rootToscaResource = new HashMap<>();
1837                 rootToscaResource.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF);
1838                 return getResourceListByCriteria(rootToscaResource, false);
1839         }
1840
1841         private Either<List<ImmutablePair<ResourceMetadataData, GraphEdge>>, TitanOperationStatus> getDerivingChildren(Resource resource) {
1842                 return titanGenericDao.getParentNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resource.getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource, ResourceMetadataData.class);
1843         }
1844
1845         private Either<List<Resource>, StorageOperationStatus> convertToResources(List<ResourceMetadataData> resourcesMetaData) {
1846                 List<Resource> resources = new ArrayList<>();
1847                 for (ResourceMetadataData resourceMetadataData : resourcesMetaData) {
1848                         String uniqueId = resourceMetadataData.getMetadataDataDefinition().getUniqueId();
1849                         Either<Resource, StorageOperationStatus> resource = this.getResource(uniqueId);
1850                         if (resource.isRight()) {
1851                                 StorageOperationStatus status = resource.right().value();
1852                                 log.error("Failed to fetch resource {} . status is {}", uniqueId, status);
1853                                 return Either.right(status);
1854                         }
1855                         resources.add(resource.left().value());
1856                 }
1857                 return Either.left(resources);
1858         }
1859
1860         protected TitanOperationStatus findResourcesPathRecursively(String resourceId, List<ResourceMetadataData> resourcesPathList) {
1861
1862                 Either<ResourceMetadataData, TitanOperationStatus> nodeRes = this.titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, ResourceMetadataData.class);
1863
1864                 if (nodeRes.isRight()) {
1865                         TitanOperationStatus status = nodeRes.right().value();
1866                         log.error("Failed to fetch resource {} . status is {}", resourceId, status);
1867                         return status;
1868                 }
1869
1870                 ResourceMetadataData resourceData = nodeRes.left().value();
1871                 resourcesPathList.add(resourceData);
1872                 Either<ImmutablePair<ResourceMetadataData, GraphEdge>, TitanOperationStatus> parentResourceRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM,
1873                                 NodeTypeEnum.Resource, ResourceMetadataData.class);
1874
1875                 while (parentResourceRes.isLeft()) {
1876
1877                         ImmutablePair<ResourceMetadataData, GraphEdge> value = parentResourceRes.left().value();
1878                         ResourceMetadataData parentResourceData = value.getKey();
1879
1880                         resourcesPathList.add(parentResourceData);
1881
1882                         parentResourceRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), parentResourceData.getMetadataDataDefinition().getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
1883                                         ResourceMetadataData.class);
1884                 }
1885
1886                 TitanOperationStatus operationStatus = parentResourceRes.right().value();
1887
1888                 if (operationStatus != TitanOperationStatus.NOT_FOUND) {
1889                         return operationStatus;
1890                 } else {
1891                         return TitanOperationStatus.OK;
1892                 }
1893
1894         }
1895
1896         @SuppressWarnings("unchecked")
1897         @Override
1898         public <T> Either<T, StorageOperationStatus> updateComponent(T component, boolean inTransaction) {
1899                 return (Either<T, StorageOperationStatus>) updateResource((Resource) component, inTransaction);
1900         }
1901
1902         @SuppressWarnings("unchecked")
1903         @Override
1904         public Either<Component, StorageOperationStatus> deleteComponent(String id, boolean inTransaction) {
1905                 return (Either<Component, StorageOperationStatus>) (Either<?, StorageOperationStatus>) deleteResource(id, inTransaction);
1906         }
1907
1908         @Override
1909         public Either<Resource, StorageOperationStatus> getLatestByToscaResourceName(String toscaResourceName, boolean inTransaction) {
1910                 return getLatestByName(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), toscaResourceName, inTransaction);
1911
1912         }
1913
1914         @Override
1915         public Either<Resource, StorageOperationStatus> getLatestByName(String resourceName, boolean inTransaction) {
1916                 return getLatestByName(GraphPropertiesDictionary.NAME.getProperty(), resourceName, inTransaction);
1917
1918         }
1919
1920         private Either<Resource, StorageOperationStatus> getLatestByName(String property, String resourceName, boolean inTransaction) {
1921                 Either<Resource, StorageOperationStatus> result = null;
1922                 try {
1923                         Map<String, Object> props = new HashMap<String, Object>();
1924                         props.put(property, resourceName);
1925                         props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
1926
1927                         Either<List<ResourceMetadataData>, TitanOperationStatus> highestResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
1928                         if (highestResources.isRight()) {
1929                                 TitanOperationStatus status = highestResources.right().value();
1930                                 log.debug("failed to find resource with name {}. status={} ", resourceName, status);
1931                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
1932                                 return result;
1933                         }
1934
1935                         List<ResourceMetadataData> resources = highestResources.left().value();
1936                         double version = 0.0;
1937                         ResourceMetadataData highestResource = null;
1938                         for (ResourceMetadataData resource : resources) {
1939                                 double resourceVersion = Double.parseDouble(resource.getMetadataDataDefinition().getVersion());
1940                                 if (resourceVersion > version) {
1941                                         version = resourceVersion;
1942                                         highestResource = resource;
1943                                 }
1944                         }
1945                         result = getResource(highestResource.getMetadataDataDefinition().getUniqueId(), true);
1946                         return result;
1947
1948                 } finally {
1949                         if (false == inTransaction) {
1950                                 if (result == null || result.isRight()) {
1951                                         log.error("getLatestByName operation : Going to execute rollback on graph.");
1952                                         titanGenericDao.rollback();
1953                                 } else {
1954                                         log.debug("getLatestByName operation : Going to execute commit on graph.");
1955                                         titanGenericDao.commit();
1956                                 }
1957                         }
1958
1959                 }
1960         }
1961
1962         @SuppressWarnings("unchecked")
1963         @Override
1964         public Either<List<Resource>, StorageOperationStatus> getTesterFollowed(String userId, Set<LifecycleStateEnum> lifecycleStates, boolean inTransaction) {
1965                 return (Either<List<Resource>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getTesterFollowedComponent(userId, lifecycleStates, inTransaction, NodeTypeEnum.Resource);
1966         }
1967
1968         @Override
1969         public Either<List<Resource>, StorageOperationStatus> getResourceCatalogData(boolean inTransaction) {
1970                 return getResourceCatalogData(inTransaction, null);
1971         }
1972
1973         private Either<List<Resource>, StorageOperationStatus> getResourceCatalogData(boolean inTransaction, Map<String, Object> otherToMatch) {
1974
1975                 long start = System.currentTimeMillis();
1976
1977                 long startFetchAllStates = System.currentTimeMillis();
1978                 Map<String, Object> propertiesToMatchHigest = new HashMap<>();
1979                 propertiesToMatchHigest.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
1980                 propertiesToMatchHigest.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false);
1981                 Either<List<ResourceMetadataData>, TitanOperationStatus> allHighestStates = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatchHigest, ResourceMetadataData.class);
1982                 if (allHighestStates.isRight() && allHighestStates.right().value() != TitanOperationStatus.NOT_FOUND) {
1983                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(allHighestStates.right().value()));
1984                 }
1985
1986                 if (allHighestStates.isRight()) {
1987                         return Either.left(new ArrayList<>());
1988                 }
1989                 List<ResourceMetadataData> list = allHighestStates.left().value();
1990
1991                 List<ResourceMetadataData> certified = new ArrayList<>();
1992                 List<ResourceMetadataData> noncertified = new ArrayList<>();
1993                 for (ResourceMetadataData reData : list) {
1994                         if (reData.getMetadataDataDefinition().getState().equals(LifecycleStateEnum.CERTIFIED.name())) {
1995                                 certified.add(reData);
1996                         } else {
1997                                 noncertified.add(reData);
1998                         }
1999                 }
2000
2001                 long endFetchAll = System.currentTimeMillis();
2002                 log.debug("Fetch catalog resources all states: certified {}, noncertified {}", certified.size(), noncertified.size());
2003                 log.debug("Fetch catalog resources all states from graph took {} ms", endFetchAll - startFetchAllStates);
2004
2005                 try {
2006                         List<ResourceMetadataData> notCertifiedHighest = noncertified;
2007                         List<ResourceMetadataData> certifiedHighestList = certified;
2008
2009                         HashMap<String, String> VFNames = new HashMap<>();
2010                         HashMap<String, String> VFCNames = new HashMap<>();
2011                         for (ResourceMetadataData data : notCertifiedHighest) {
2012                                 String serviceName = data.getMetadataDataDefinition().getName();
2013                                 if (((ResourceMetadataDataDefinition) data.getMetadataDataDefinition()).getResourceType().equals(ResourceTypeEnum.VF)) {
2014                                         VFNames.put(serviceName, serviceName);
2015                                 } else {
2016                                         VFCNames.put(serviceName, serviceName);
2017                                 }
2018                         }
2019
2020                         for (ResourceMetadataData data : certifiedHighestList) {
2021                                 String serviceName = data.getMetadataDataDefinition().getName();
2022                                 if (((ResourceMetadataDataDefinition) data.getMetadataDataDefinition()).getResourceType().equals(ResourceTypeEnum.VF)) {
2023                                         if (!VFNames.containsKey(serviceName)) {
2024                                                 notCertifiedHighest.add(data);
2025                                         }
2026                                 } else {
2027                                         if (!VFCNames.containsKey(serviceName)) {
2028                                                 notCertifiedHighest.add(data);
2029                                         }
2030                                 }
2031                         }
2032
2033                         long endFetchAllFromGraph = System.currentTimeMillis();
2034                         log.debug("Fetch all catalog resources metadata from graph took {} ms", endFetchAllFromGraph - start);
2035
2036                         long startFetchAllFromCache = System.currentTimeMillis();
2037
2038                         List<Resource> result = new ArrayList<>();
2039
2040                         Map<String, Long> components = notCertifiedHighest.stream().collect(Collectors.toMap(p -> p.getMetadataDataDefinition().getUniqueId(), p -> p.getMetadataDataDefinition().getLastUpdateDate()));
2041
2042                         Either<ImmutablePair<List<Component>, Set<String>>, ActionStatus> componentsForCatalog = componentCache.getComponentsForCatalog(components, ComponentTypeEnum.RESOURCE);
2043                         if (componentsForCatalog.isLeft()) {
2044                                 ImmutablePair<List<Component>, Set<String>> immutablePair = componentsForCatalog.left().value();
2045                                 List<Component> foundComponents = immutablePair.getLeft();
2046                                 if (foundComponents != null) {
2047                                         foundComponents.forEach(p -> result.add((Resource) p));
2048                                         log.debug("The number of resources added to catalog from cache is {}", foundComponents.size());
2049
2050                                         List<String> foundComponentsUid = foundComponents.stream().map(p -> p.getUniqueId()).collect(Collectors.toList());
2051                                         notCertifiedHighest = notCertifiedHighest.stream().filter(p -> false == foundComponentsUid.contains(p.getUniqueId())).collect(Collectors.toList());
2052                                 }
2053                                 Set<String> nonCachedComponents = immutablePair.getRight();
2054                                 int numberNonCached = nonCachedComponents == null ? 0 : nonCachedComponents.size();
2055                                 log.debug("The number of left resources for catalog is {}", numberNonCached);
2056
2057                         }
2058
2059                         long endFetchAllFromCache = System.currentTimeMillis();
2060                         log.debug("Fetch all catalog resources metadata from cache took {} ms", (endFetchAllFromCache - startFetchAllFromCache));
2061
2062                         long startFetchFromGraph = System.currentTimeMillis();
2063                         log.debug("The number of resources needed to be fetch as light component is {}", notCertifiedHighest.size());
2064                         for (ResourceMetadataData data : notCertifiedHighest) {
2065                                 String uniqueId = data.getMetadataDataDefinition().getUniqueId();
2066                                 log.trace("Fetch catalog resource non cached {} {}", uniqueId, data.getMetadataDataDefinition().getName());
2067                                 Either<Resource, StorageOperationStatus> component = getLightComponent(uniqueId, inTransaction);
2068                                 if (component.isRight()) {
2069                                         log.debug("Failed to get Service for id =  {}  error : {} skip resource", data.getUniqueId(), component.right().value());
2070                                 } else {
2071                                         result.add(component.left().value());
2072                                 }
2073                         }
2074                         long endFetchFromGraph = System.currentTimeMillis();
2075                         log.debug("Fetch catalog resources from graph took {} ms", (endFetchFromGraph - startFetchFromGraph));
2076
2077                         return Either.left(result);
2078
2079                 } finally {
2080                         long end = System.currentTimeMillis();
2081                         log.debug("Fetch all catalog resources took {} ms", end - start);
2082                         if (false == inTransaction) {
2083                                 titanGenericDao.commit();
2084                         }
2085                 }
2086         }
2087
2088         public Either<List<Resource>, StorageOperationStatus> getResourceCatalogDataVFLatestCertifiedAndNonCertified(boolean inTransaction) {
2089                 Map<String, Object> propertiesToMatch = new HashMap<>();
2090                 propertiesToMatch.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
2091
2092                 return getResourceCatalogDataLatestCertifiedAndNonCertified(inTransaction, propertiesToMatch);
2093         }
2094
2095         public Either<List<Resource>, StorageOperationStatus> getResourceCatalogDataLatestCertifiedAndNonCertified(boolean inTransaction, Map<String, Object> otherToMatch) {
2096                 Map<String, Object> propertiesToMatch = new HashMap<>();
2097
2098                 if (otherToMatch != null) {
2099                         propertiesToMatch.putAll(otherToMatch);
2100                 }
2101
2102                 propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
2103
2104                 Either<List<ResourceMetadataData>, TitanOperationStatus> lastVersionNodes = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
2105
2106                 List<Resource> result = new ArrayList<>();
2107
2108                 if (lastVersionNodes.isRight() && lastVersionNodes.right().value() != TitanOperationStatus.NOT_FOUND) {
2109                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(lastVersionNodes.right().value()));
2110                 }
2111
2112                 List<ResourceMetadataData> listOfHighest;
2113
2114                 if (lastVersionNodes.isLeft()) {
2115                         listOfHighest = lastVersionNodes.left().value();
2116                 } else {
2117                         return Either.left(result);
2118                 }
2119
2120                 for (ResourceMetadataData data : listOfHighest) {
2121                         Either<Resource, StorageOperationStatus> component = getLightComponent(data.getMetadataDataDefinition().getUniqueId(), inTransaction);
2122                         if (component.isRight()) {
2123                                 log.debug("Failed to get Service for id =  {} error : {} skip resource", data.getUniqueId(), component.right().value());
2124                         } else {
2125                                 result.add(component.left().value());
2126                         }
2127                 }
2128                 return Either.left(result);
2129         }
2130
2131         private Either<List<Resource>, StorageOperationStatus> getResourceListByCriteria(Map<String, Object> props, boolean inTransaction) {
2132
2133                 props.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName());
2134
2135                 Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
2136
2137                 if (byCriteria.isRight()) {
2138                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value()));
2139                 }
2140                 List<Resource> resources = new ArrayList<>();
2141                 List<ResourceMetadataData> resourcesDataList = byCriteria.left().value();
2142                 for (ResourceMetadataData data : resourcesDataList) {
2143                         buildResource(inTransaction, resources, data);
2144                 }
2145                 return Either.left(resources);
2146         }
2147
2148         private void buildResource(boolean inTransaction, List<Resource> resources, ResourceMetadataData data) {
2149                 Either<Resource, StorageOperationStatus> resource = getResource(data.getMetadataDataDefinition().getUniqueId(), inTransaction);
2150                 if (resource.isLeft()) {
2151             resources.add(resource.left().value());
2152         } else {
2153             log.debug("Failed to fetch resource for name = {} and id = {}", data.getUniqueId(), data.getMetadataDataDefinition().getName());
2154         }
2155         }
2156
2157         public Either<List<Resource>, StorageOperationStatus> getResourceListByUuid(String uuid, boolean inTransaction) {
2158                 return getLatestResourceByUuid(uuid, false, inTransaction);
2159         }
2160
2161         public Either<List<Resource>, StorageOperationStatus> getLatestResourceByUuid(String uuid, boolean inTransaction) {
2162                 return getLatestResourceByUuid(uuid, true, inTransaction);
2163         }
2164
2165         private Either<List<Resource>, StorageOperationStatus> getLatestResourceByUuid(String uuid, boolean isLatest, boolean inTransaction) {
2166                 Map<String, Object> props = new HashMap<String, Object>();
2167                 if (isLatest) {
2168                         props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), isLatest);
2169                 }
2170                 props.put(GraphPropertiesDictionary.UUID.getProperty(), uuid);
2171                 return getResourceListByCriteria(props, inTransaction);
2172         }
2173
2174         public Either<List<Resource>, StorageOperationStatus> getResourceListBySystemName(String systemName, boolean inTransaction) {
2175                 Map<String, Object> props = new HashMap<String, Object>();
2176                 props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), systemName);
2177                 return getResourceListByCriteria(props, inTransaction);
2178         }
2179
2180         public Either<List<Resource>, StorageOperationStatus> getResourceListByToscaName(String toscaName, boolean inTransaction) {
2181                 Map<String, Object> props = new HashMap<String, Object>();
2182                 props.put(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), toscaName);
2183                 return getResourceListByCriteria(props, inTransaction);
2184         }
2185
2186         public Either<List<Resource>, StorageOperationStatus> getResourceByNameAndVersion(String name, String version, boolean inTransaction) {
2187                 return getByNamesAndVersion(GraphPropertiesDictionary.NAME.getProperty(), name, version, null, inTransaction);
2188         }
2189
2190         @Override
2191         public Either<List<Resource>, StorageOperationStatus> getResourceByNameAndVersion(String name, String version) {
2192                 return getResourceByNameAndVersion(name, version, false);
2193         }
2194
2195         protected Either<List<Resource>, StorageOperationStatus> getByNamesAndVersion(String nameKey, String nameValue, String version, Map<String, Object> additionalParams, boolean inTransaction) {
2196                 Map<String, Object> props = new HashMap<String, Object>();
2197                 props.put(nameKey, nameValue);
2198                 props.put(GraphPropertiesDictionary.VERSION.getProperty(), version);
2199                 props.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName());
2200                 if (additionalParams != null && !additionalParams.isEmpty()) {
2201                         props.putAll(additionalParams);
2202                 }
2203
2204                 Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
2205                 List<Resource> resourcesList = new ArrayList<Resource>();
2206                 if (byCriteria.isRight()) {
2207                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value()));
2208                 }
2209                 List<ResourceMetadataData> dataList = byCriteria.left().value();
2210                 if (dataList != null && !dataList.isEmpty()) {
2211                         for (ResourceMetadataData resourceData : dataList) {
2212                                 // ResourceMetadataData resourceData = dataList.get(0);
2213                                 Either<Resource, StorageOperationStatus> resource = getResource(resourceData.getMetadataDataDefinition().getUniqueId(), inTransaction);
2214                                 if (resource.isRight()) {
2215                                         log.debug("Failed to fetch resource for name = {} and id = {}", resourceData.getMetadataDataDefinition().getName(), resourceData.getUniqueId());
2216                                         return Either.right(resource.right().value());
2217                                 }
2218                                 resourcesList.add(resource.left().value());
2219                         }
2220                         // return resource;
2221                         return Either.left(resourcesList);
2222                 } else {
2223                         return Either.right(StorageOperationStatus.NOT_FOUND);
2224                 }
2225         }
2226
2227         @Override
2228         protected <T> Either<T, StorageOperationStatus> getComponentByNameAndVersion(String name, String version, Map<String, Object> additionalParams, boolean inTransaction) {
2229                 return (Either<T, StorageOperationStatus>) getResourceBySystemNameAndVersion(name, version, additionalParams, inTransaction);
2230         }
2231
2232         @Override
2233         public Either<Resource, StorageOperationStatus> getResourceBySystemNameAndVersion(String name, String version, Map<String, Object> additionalParams, boolean inTransaction) {
2234                 Either<List<Resource>, StorageOperationStatus> byNamesAndVersion = getByNamesAndVersion(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), ValidationUtils.normaliseComponentName(name), version, additionalParams, inTransaction);
2235                 if (byNamesAndVersion.isRight()) {
2236                         return Either.right(byNamesAndVersion.right().value());
2237                 }
2238                 List<Resource> resourcesList = byNamesAndVersion.left().value();
2239                 if (resourcesList.size() > 1) {
2240                         log.debug("More that one instance of resource for name = {} and version = {}", name, version);
2241                         return Either.right(StorageOperationStatus.GENERAL_ERROR);
2242                 }
2243                 return Either.left(resourcesList.get(0));
2244         }
2245
2246         private TitanOperationStatus setAllVersions(Resource resource) {
2247                 Either<Map<String, String>, TitanOperationStatus> res = getVersionList(NodeTypeEnum.Resource, resource.getVersion(), resource, ResourceMetadataData.class);
2248                 if (res.isRight()) {
2249                         return res.right().value();
2250                 }
2251                 resource.setAllVersions(res.left().value());
2252                 return TitanOperationStatus.OK;
2253         }
2254
2255         @Override
2256         protected <T extends GraphNode> Either<Map<String, String>, TitanOperationStatus> getVersionList(NodeTypeEnum type, String version, Component component, Class<T> clazz) {
2257                 Map<String, Object> props = new HashMap<String, Object>();
2258                 Map<String, Object> hasNotProps = new HashMap<String, Object>();
2259
2260                 if (version.startsWith("0")) {
2261                         props.put(GraphPropertiesDictionary.UUID.getProperty(), component.getUUID());
2262                 } else {
2263                         props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), component.getSystemName());
2264                         props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ((Resource) component).getResourceType().name());
2265                 }
2266                 hasNotProps.put(GraphPropertiesDictionary.IS_DELETED.getProperty(), true);
2267                 Either<List<T>, TitanOperationStatus> result = titanGenericDao.getByCriteria(type, props, hasNotProps, clazz);
2268
2269                 Map<String, String> versionMap = new HashMap<String, String>();
2270                 if (result.isRight()) {
2271                         if (!result.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
2272                                 return Either.right(result.right().value());
2273                         }
2274
2275                 } else {
2276                         List<ResourceMetadataData> components = (List<ResourceMetadataData>) result.left().value();
2277                         for (ResourceMetadataData data : components) {
2278                                 versionMap.put(data.getMetadataDataDefinition().getVersion(), (String) data.getUniqueId());
2279                         }
2280                 }
2281
2282                 return Either.left(versionMap);
2283         }
2284
2285         /**
2286          * update only the resource object itself without tag, derived from or any other neighbours.
2287          *
2288          * @param resource
2289          * @param inTransaction
2290          * @return
2291          */
2292         protected Either<Resource, StorageOperationStatus> updateResourceMetadata(Resource resource, boolean inTransaction) {
2293
2294                 Either<Resource, StorageOperationStatus> result = null;
2295
2296                 try {
2297
2298                         log.debug("In updateResource. received resource = {}", (resource == null ? null : resource.toString()));
2299                         if (resource == null) {
2300                                 log.error("Resource object is null");
2301                                 result = Either.right(StorageOperationStatus.BAD_REQUEST);
2302                                 return result;
2303                         }
2304
2305                         ResourceMetadataData resourceData = new ResourceMetadataData();
2306                         resourceData.getMetadataDataDefinition().setUniqueId(resource.getUniqueId());
2307                         resourceData.getMetadataDataDefinition().setHighestVersion(resource.isHighestVersion());
2308                         log.debug("After converting resource to ResourceData. ResourceData = {}", resourceData);
2309
2310                         if (resourceData.getUniqueId() == null) {
2311                                 log.error("Resource id is missing in the request.");
2312                                 return Either.right(StorageOperationStatus.BAD_REQUEST);
2313                         }
2314
2315                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(resourceData, ResourceMetadataData.class);
2316
2317                         if (updateNode.isRight()) {
2318                                 log.error("Failed to update resource {}. status is {}", resource.getUniqueId(), updateNode.right().value());
2319                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value()));
2320                                 return result;
2321                         }
2322
2323                         Either<Resource, StorageOperationStatus> updatedResource = getResource(resource.getUniqueId(), true);
2324                         if (updatedResource.isRight()) {
2325                                 log.error("Resource id is missing in the request. status is {}", updatedResource.right().value());
2326                                 result = Either.right(StorageOperationStatus.BAD_REQUEST);
2327                                 return result;
2328                         }
2329
2330                         Resource updatedResourceValue = updatedResource.left().value();
2331                         result = Either.left(updatedResourceValue);
2332
2333                         if (log.isDebugEnabled()) {
2334                                 String json = prettyJson.toJson(result.left().value());
2335                                 log.debug("Resource retrieved after update is {}", json);
2336                         }
2337
2338                         return result;
2339
2340                 } finally {
2341                         if (false == inTransaction) {
2342                                 if (result == null || result.isRight()) {
2343                                         log.error("Going to execute rollback on graph.");
2344                                         titanGenericDao.rollback();
2345                                 } else {
2346                                         log.debug("Going to execute commit on graph.");
2347                                         titanGenericDao.commit();
2348                                 }
2349                         }
2350                 }
2351
2352         }
2353
2354         @Override
2355         public Either<List<Resource>, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract, Boolean isHighest) {
2356
2357                 try {
2358                         List<Resource> result = new ArrayList<>();
2359                         Map<String, Object> propertiesToMatch = new HashMap<>();
2360                         propertiesToMatch.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), isAbstract);
2361                         propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
2362
2363                         if (isHighest != null) {
2364                                 propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), isHighest.booleanValue());
2365                         }
2366
2367                         Either<List<ResourceMetadataData>, TitanOperationStatus> resourceNodes = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
2368
2369                         titanGenericDao.commit();
2370                         if (resourceNodes.isRight()) {
2371                                 // in case of NOT_FOUND from Titan client return to UI empty
2372                                 // list
2373                                 if (resourceNodes.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
2374                                         return Either.left(result);
2375                                 } else {
2376                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(resourceNodes.right().value()));
2377                                 }
2378                         } else {
2379                                 List<ResourceMetadataData> resourceDataList = resourceNodes.left().value();
2380                                 for (ResourceMetadataData resourceData : resourceDataList) {
2381                                         Either<Resource, StorageOperationStatus> resource = getResource(resourceData.getMetadataDataDefinition().getUniqueId());
2382                                         if (resource.isRight()) {
2383                                                 log.debug("Failed to fetch resource for id = {} error is {}", resourceData.getUniqueId(), resource.right().value());
2384                                                 return Either.right(resource.right().value());
2385                                         }
2386                                         result.add(resource.left().value());
2387                                 }
2388                                 return Either.left(result);
2389                         }
2390                 } finally {
2391                         titanGenericDao.commit();
2392                 }
2393
2394         }
2395
2396         public Either<Resource, StorageOperationStatus> getLatestCertifiedByToscaResourceName(String toscaResourceName, boolean inTransaction) {
2397                 return getLatestCertifiedByCriteria(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), toscaResourceName, inTransaction);
2398
2399         }
2400
2401         public Either<Resource, StorageOperationStatus> getLatestCertifiedByCriteria(String property, String resourceName, boolean inTransaction) {
2402                 Either<Resource, StorageOperationStatus> result = null;
2403                 try {
2404                         Map<String, Object> props = new HashMap<String, Object>();
2405                         props.put(property, resourceName);
2406                         props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
2407                         props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
2408
2409                         Either<List<ResourceMetadataData>, TitanOperationStatus> highestResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
2410                         if (highestResources.isRight()) {
2411                                 TitanOperationStatus status = highestResources.right().value();
2412                                 log.debug("failed to find resource with name {}. status={} ", resourceName, status);
2413                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2414                                 return result;
2415                         }
2416
2417                         List<ResourceMetadataData> resources = highestResources.left().value();
2418                         double version = 0.0;
2419                         ResourceMetadataData highestResource = null;
2420                         for (ResourceMetadataData resource : resources) {
2421                                 double resourceVersion = Double.parseDouble(resource.getMetadataDataDefinition().getVersion());
2422                                 if (resourceVersion > version) {
2423                                         version = resourceVersion;
2424                                         highestResource = resource;
2425                                 }
2426                         }
2427                         result = getResource(highestResource.getMetadataDataDefinition().getUniqueId(), true);
2428                         return result;
2429
2430                 } finally {
2431                         if (false == inTransaction) {
2432                                 if (result == null || result.isRight()) {
2433                                         log.error("getLatestByName operation : Going to execute rollback on graph.");
2434                                         titanGenericDao.rollback();
2435                                 } else {
2436                                         log.debug("getLatestByName operation : Going to execute commit on graph.");
2437                                         titanGenericDao.commit();
2438                                 }
2439                         }
2440
2441                 }
2442         }
2443
2444         public Either<List<Resource>, StorageOperationStatus> findLastCertifiedResourceByName(Resource resource) {
2445
2446                 Map<String, Object> props = new HashMap<String, Object>();
2447                 props.put(GraphPropertiesDictionary.NAME.getProperty(), resource.getName());
2448                 props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
2449                 return getResourceListByCriteria(props, false);
2450
2451         }
2452
2453         public Either<List<Resource>, StorageOperationStatus> findLastCertifiedResourceByUUID(Resource resource) {
2454                 Map<String, Object> props = new HashMap<String, Object>();
2455                 props.put(GraphPropertiesDictionary.UUID.getProperty(), resource.getUUID());
2456                 props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
2457                 return getResourceListByCriteria(props, false);
2458
2459         }
2460
2461         @Override
2462         public boolean isComponentExist(String resourceId) {
2463                 return isComponentExist(resourceId, NodeTypeEnum.Resource);
2464         }
2465
2466         @Override
2467         public <T> Either<T, StorageOperationStatus> cloneComponent(T other, String version, LifecycleStateEnum targetLifecycle, boolean inTransaction) {
2468                 return (Either<T, StorageOperationStatus>) cloneResource((Resource) other, version, targetLifecycle, inTransaction);
2469         }
2470
2471         @Override
2472         public Either<Integer, StorageOperationStatus> increaseAndGetComponentInstanceCounter(String componentId, boolean inTransaction) {
2473                 return increaseAndGetComponentInstanceCounter(componentId, NodeTypeEnum.Resource, inTransaction);
2474         }
2475
2476         private Either<Resource, StorageOperationStatus> cloneResource(Resource other, String version, boolean inTransaction) {
2477                 return cloneResource(other, version, null, inTransaction);
2478         }
2479
2480         private Either<Resource, StorageOperationStatus> cloneResource(Resource other, String version, LifecycleStateEnum targetLifecycle, boolean inTransaction) {
2481                 Either<Resource, StorageOperationStatus> result = null;
2482
2483                 try {
2484                         String origRsourceId = other.getUniqueId();
2485
2486                         StorageOperationStatus overrideStatus = overrideRecursiveMembers(other, origRsourceId);
2487                         if (!overrideStatus.equals(StorageOperationStatus.OK)) {
2488                                 return Either.right(overrideStatus);
2489                         }
2490                         other.setVersion(version);
2491                         other.setUniqueId(null);
2492
2493                         List<InputDefinition> inputs = other.getInputs();
2494                         Map<String, List<ComponentInstanceProperty>> inputsPropMap = new HashMap<String, List<ComponentInstanceProperty>>();
2495
2496                         if(inputs != null){
2497                                 for(InputDefinition input: inputs){
2498
2499                                         Either<List<ComponentInstanceProperty>, TitanOperationStatus> inputPropStatus  = inputOperation.getComponentInstancePropertiesByInputId(input.getUniqueId());
2500                                         if(inputPropStatus.isLeft()){
2501                                                 if(inputPropStatus.left().value() != null)
2502                                                         inputsPropMap.put(input.getName(), inputPropStatus.left().value());
2503
2504                                         }
2505
2506
2507                                 }
2508                         }
2509
2510                         Either<Resource, StorageOperationStatus> createResourceMD = createResource(other, inTransaction);
2511                         if (createResourceMD.isRight()) {
2512                                 StorageOperationStatus status = createResourceMD.right().value();
2513                                 log.error("failed to clone resource. status= {}", status);
2514                                 result = Either.right(status);
2515                                 return result;
2516                         }
2517                         Resource resource = createResourceMD.left().value();
2518                         Either<TitanVertex, TitanOperationStatus> metadataVertexEither = titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resource.getUniqueId());
2519                         if (metadataVertexEither.isRight()) {
2520                                 TitanOperationStatus error = metadataVertexEither.right().value();
2521                                 log.debug("Failed to fetch vertex of metadata {} error {}", resource.getUniqueId(), error);
2522                                 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
2523                                 return result;
2524                         }
2525
2526                         TitanVertex metadataVertex = metadataVertexEither.left().value();
2527                         Either<ImmutablePair<List<ComponentInstance>, Map<String, String>>, StorageOperationStatus> cloneInstances = componentInstanceOperation.cloneAllComponentInstancesFromContainerComponent(origRsourceId, resource.getUniqueId(),
2528                                         NodeTypeEnum.Resource, NodeTypeEnum.Resource, targetLifecycle, metadataVertex, other, resource, inputsPropMap);
2529                         if (cloneInstances.isRight()) {
2530                                 result = Either.right(cloneInstances.right().value());
2531                                 return result;
2532                         }
2533
2534                         Either<Integer, StorageOperationStatus> counterStatus = getComponentInstanceCoutner(origRsourceId, NodeTypeEnum.Resource);
2535                         if (counterStatus.isRight()) {
2536                                 StorageOperationStatus status = counterStatus.right().value();
2537                                 log.error("failed to get resource instance counter on service {}. status={}", origRsourceId, counterStatus);
2538                                 result = Either.right(status);
2539                                 return result;
2540                         }
2541
2542                         Either<Integer, StorageOperationStatus> setResourceInstanceCounter = setComponentInstanceCounter(resource.getUniqueId(), NodeTypeEnum.Resource, counterStatus.left().value(), true);
2543                         if (setResourceInstanceCounter.isRight()) {
2544                                 StorageOperationStatus status = setResourceInstanceCounter.right().value();
2545                                 log.error("failed to set resource instance counter on service {}. status={}", resource.getUniqueId(), status);
2546                                 result = Either.right(status);
2547                                 return result;
2548                         }
2549
2550                         Either<List<GroupDefinition>, StorageOperationStatus> clonedGroups = cloneGroups(other, resource, cloneInstances.left().value(), true);
2551                         if (clonedGroups.isRight()) {
2552                                 StorageOperationStatus status = clonedGroups.right().value();
2553                                 if (status != StorageOperationStatus.OK) {
2554                                         result = Either.right(status);
2555                                         return result;
2556                                 }
2557                         }
2558
2559                         result = this.getResource(resource.getUniqueId(), true);
2560                         if (result.isRight()) {
2561                                 log.error("Cannot get full service from the graph. status is {}", result.right().value());
2562                                 return Either.right(result.right().value());
2563                         }
2564
2565                         return result;
2566                 } finally {
2567                         if (false == inTransaction) {
2568                                 if (result == null || result.isRight()) {
2569                                         log.debug("Going to execute rollback on graph.");
2570                                         titanGenericDao.rollback();
2571                                 } else {
2572                                         log.debug("Going to execute commit on graph.");
2573                                         titanGenericDao.commit();
2574                                 }
2575                         }
2576                 }
2577         }
2578
2579         private StorageOperationStatus overrideRecursiveMembers(Resource resource, String prevId) {
2580                 // override requirements to copy only resource's requirements and not
2581                 // derived requirements
2582                 Either<Map<String, List<RequirementDefinition>>, StorageOperationStatus> requirementsOfResourceOnly = getRequirementOperation().getAllRequirementsOfResourceOnly(prevId, true);
2583                 if (requirementsOfResourceOnly.isRight()) {
2584                         log.error("failed to get requirements of resource. resourceId {} status is {}", prevId, requirementsOfResourceOnly.right().value());
2585                         return requirementsOfResourceOnly.right().value();
2586                 }
2587                 resource.setRequirements(requirementsOfResourceOnly.left().value());
2588
2589                 // override capabilities to copy only resource's requirements and not
2590                 // derived requirements
2591                 Either<Map<String, List<CapabilityDefinition>>, StorageOperationStatus> capabilitiesOfResourceOnly = getResourceCapabilitiesMap(prevId);
2592
2593                 resource.setCapabilities(capabilitiesOfResourceOnly.left().value());
2594
2595                 // override interfaces to copy only resource's interfaces and not
2596                 // derived interfaces
2597                 Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfacesOfResourceOnly = getInterfaceLifecycleOperation().getAllInterfacesOfResource(prevId, false, true);
2598                 if (interfacesOfResourceOnly.isRight()) {
2599                         log.error("failed to get interfaces of resource. resourceId {} status is {}", prevId, interfacesOfResourceOnly.right().value());
2600                         return interfacesOfResourceOnly.right().value();
2601                 }
2602                 resource.setInterfaces(interfacesOfResourceOnly.left().value());
2603
2604                 List<PropertyDefinition> attributes = new ArrayList<>();
2605                 TitanOperationStatus status = attributeOperation.findNodeNonInheretedAttribues(prevId, NodeTypeEnum.Resource, attributes);
2606                 if (status != TitanOperationStatus.OK) {
2607                         return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
2608                 } else {
2609                         resource.setAttributes(attributes);
2610                 }
2611
2612                 // override properties to copy only resource's properties and not
2613                 // derived properties
2614                 Either<Map<String, PropertyDefinition>, TitanOperationStatus> propertiesOfResourceOnly = getPropertyOperation().findPropertiesOfNode(NodeTypeEnum.Resource, prevId);
2615
2616                 List<PropertyDefinition> resourceProperties = null;
2617                 if (propertiesOfResourceOnly.isRight()) {
2618                         TitanOperationStatus titanStatus = propertiesOfResourceOnly.right().value();
2619                         if (titanStatus != TitanOperationStatus.NOT_FOUND) {
2620                                 log.error("failed to get properties of resource. resourceId {} status is {}", prevId, propertiesOfResourceOnly.right().value());
2621                                 return DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus);
2622                         }
2623                 } else {
2624                         Map<String, PropertyDefinition> propertiesMap = propertiesOfResourceOnly.left().value();
2625                         if (propertiesMap != null) {
2626                                 resourceProperties = new ArrayList<PropertyDefinition>();
2627                                 resourceProperties.addAll(propertiesMap.values());
2628                         }
2629                 }
2630                 resource.setProperties(resourceProperties);
2631
2632                 return StorageOperationStatus.OK;
2633         }
2634
2635         private Either<Map<String, List<CapabilityDefinition>>, StorageOperationStatus> getResourceCapabilitiesMap(String prevId) {
2636
2637                 Either<Map<String, CapabilityDefinition>, StorageOperationStatus> capabilitiesOfResourceOnly = getCapabilityOperation().getAllCapabilitiesOfResource(prevId, false, true);
2638                 if (capabilitiesOfResourceOnly.isRight()) {
2639                         log.error("failed to get capabilities of resource. resourceId {} status is {}", prevId, capabilitiesOfResourceOnly.right().value());
2640                         return Either.right(capabilitiesOfResourceOnly.right().value());
2641                 }
2642                 Map<String, List<CapabilityDefinition>> capabilityMap = getCapabilityOperation().convertCapabilityMap(capabilitiesOfResourceOnly.left().value(), null, null);
2643                 return Either.left(capabilityMap);
2644         }
2645
2646         @Override
2647         protected StorageOperationStatus validateCategories(Component currentComponent, Component component, ComponentMetadataData componentData, NodeTypeEnum type) {
2648                 StorageOperationStatus status = StorageOperationStatus.OK;
2649                 List<CategoryDefinition> newCategoryList = component.getCategories();
2650                 CategoryDefinition newCategory = newCategoryList.get(0);
2651                 CategoryDefinition currentCategory = currentComponent.getCategories().get(0);
2652                 boolean categoryWasChanged = false;
2653
2654                 if (newCategory.getName() != null && false == newCategory.getName().equals(currentCategory.getName())) {
2655                         // the category was changed
2656                         categoryWasChanged = true;
2657                 } else {
2658                         // the sub-category was changed
2659                         SubCategoryDefinition currSubcategory = currentCategory.getSubcategories().get(0);
2660                         SubCategoryDefinition newSubcategory = newCategory.getSubcategories().get(0);
2661                         if (newSubcategory.getName() != null && false == newSubcategory.getName().equals(currSubcategory.getName())) {
2662                                 log.debug("Going to update the category of the resource from {} to {}", currentCategory, newCategory);
2663                                 categoryWasChanged = true;
2664                         }
2665                 }
2666                 if (categoryWasChanged) {
2667                         status = moveCategoryEdge((Resource) component, (ResourceMetadataData) componentData, newCategory);
2668                         log.debug("Going to update the category of the resource from {} to {}. status is {}", currentCategory, newCategory, status);
2669                 }
2670                 return status;
2671         }
2672
2673         @Override
2674         public Resource getDefaultComponent() {
2675                 return new Resource();
2676         }
2677
2678         @Override
2679         public Either<Component, StorageOperationStatus> getMetadataComponent(String id, boolean inTransaction) {
2680                 return getMetadataComponent(id, NodeTypeEnum.Resource, inTransaction);
2681         }
2682
2683         @Override
2684         Component convertComponentMetadataDataToComponent(ComponentMetadataData componentMetadataData) {
2685                 return convertResourceDataToResource((ResourceMetadataData) componentMetadataData);
2686         }
2687
2688         @Override
2689         public Either<Boolean, StorageOperationStatus> validateComponentNameExists(String componentName) {
2690                 return validateComponentNameUniqueness(componentName, titanGenericDao, NodeTypeEnum.Resource);
2691         }
2692
2693         @Override
2694         public Either<Component, StorageOperationStatus> markComponentToDelete(Component componentToDelete, boolean inTransaction) {
2695                 return internalMarkComponentToDelete(componentToDelete, inTransaction);
2696         }
2697
2698         @Override
2699         public Either<Boolean, StorageOperationStatus> isComponentInUse(String componentId) {
2700                 return isResourceInUse(componentId);
2701         }
2702
2703         @Override
2704         public Either<List<String>, StorageOperationStatus> getAllComponentsMarkedForDeletion() {
2705                 return getAllResourcesMarkedForDeletion();
2706         }
2707
2708         @Override
2709         public Either<List<String>, StorageOperationStatus> getAllResourcesMarkedForDeletion() {
2710                 return getAllComponentsMarkedForDeletion(NodeTypeEnum.Resource);
2711         }
2712
2713         @Override
2714         public Either<Boolean, StorageOperationStatus> isResourceInUse(String resourceToDelete) {
2715                 return isComponentInUse(resourceToDelete, NodeTypeEnum.Resource);
2716         }
2717
2718         public Either<List<GroupDefinition>, StorageOperationStatus> cloneGroups(Resource resource, Resource newResource, ImmutablePair<List<ComponentInstance>, Map<String, String>> cloneInstances, boolean inTransaction) {
2719
2720                 Either<List<GroupDefinition>, StorageOperationStatus> result = null;
2721
2722                 if (resource.getGroups() == null) {
2723                         return Either.right(StorageOperationStatus.OK);
2724                 }
2725
2726                 Either<List<GroupDefinition>, StorageOperationStatus> prepareGroupsForCloning = groupOperation.prepareGroupsForCloning(resource, cloneInstances);
2727                 if (prepareGroupsForCloning.isRight()) {
2728                         StorageOperationStatus status = prepareGroupsForCloning.right().value();
2729                         if (status != StorageOperationStatus.OK) {
2730                                 BeEcompErrorManager.getInstance().logInternalFlowError("CloneResource", "Failed to prepare groups for cloning", ErrorSeverity.ERROR);
2731                         }
2732                         result = Either.right(status);
2733                         return result;
2734                 } else {
2735                         List<GroupDefinition> groupsToCreate = prepareGroupsForCloning.left().value();
2736                         if (groupsToCreate != null && false == groupsToCreate.isEmpty()) {
2737                                 Either<List<GroupDefinition>, StorageOperationStatus> addGroups = groupOperation.addGroups(NodeTypeEnum.Resource, newResource.getUniqueId(), groupsToCreate, inTransaction);
2738                                 if (addGroups.isRight()) {
2739                                         BeEcompErrorManager.getInstance().logInternalFlowError("CloneResource", "Failed to clone groups", ErrorSeverity.ERROR);
2740                                         result = Either.right(addGroups.right().value());
2741                                         return result;
2742                                 }
2743
2744                                 return Either.left(addGroups.left().value());
2745                         } else {
2746                                 return Either.right(StorageOperationStatus.OK);
2747                         }
2748                 }
2749         }
2750
2751         public Either<Resource, StorageOperationStatus> getLatestResourceByCsarOrName(String csarUUID, String systemName) {
2752                 Map<String, Object> props = new HashMap<>();
2753                 props.put(GraphPropertiesDictionary.CSAR_UUID.getProperty(), csarUUID);
2754                 props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
2755                 ResourceMetadataData resourceMetadataData = null;
2756                 List<ResourceMetadataData> resourceMetadataDataList = null;
2757                 Either<List<ResourceMetadataData>, TitanOperationStatus> byCsar = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
2758                 if (byCsar.isRight()) {
2759                         if (TitanOperationStatus.NOT_FOUND == byCsar.right().value()) {
2760                                 //Fix Defect DE256036
2761                                 if( StringUtils.isEmpty(systemName)){
2762                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.NOT_FOUND));
2763                                 }
2764
2765                                 props.clear();
2766                                 props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
2767                                 props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), systemName);
2768                                 Either<List<ResourceMetadataData>, TitanOperationStatus> bySystemname = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
2769                                 if (bySystemname.isRight()) {
2770                                         log.debug("getLatestResourceByCsarOrName - Failed to find by system name {}  error {} ", systemName, bySystemname.right().value());
2771                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(bySystemname.right().value()));
2772                                 }
2773                                 if (bySystemname.left().value().size() > 2) {
2774                                         log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) must return only 2 latest version, but was returned - {}", bySystemname.left().value().size());
2775                                         return Either.right(StorageOperationStatus.GENERAL_ERROR);
2776                                 }
2777                                 resourceMetadataDataList = bySystemname.left().value();
2778                                 if (resourceMetadataDataList.size() == 1) {
2779                                         resourceMetadataData = resourceMetadataDataList.get(0);
2780                                 } else {
2781                                         for (ResourceMetadataData curResource : resourceMetadataDataList) {
2782                                                 if (!curResource.getMetadataDataDefinition().getState().equals("CERTIFIED")) {
2783                                                         resourceMetadataData = curResource;
2784                                                         break;
2785                                                 }
2786                                         }
2787                                 }
2788                                 if (resourceMetadataData == null) {
2789                                         log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) returned 2 latest CERTIFIED versions");
2790                                         return Either.right(StorageOperationStatus.GENERAL_ERROR);
2791                                 }
2792                                 if (resourceMetadataData.getMetadataDataDefinition().getCsarUUID() != null && !resourceMetadataData.getMetadataDataDefinition().getCsarUUID().equals(csarUUID)) {
2793                                         log.debug("getLatestResourceByCsarOrName - same system name {} but different csarUUID. exist {} and new {} ", systemName, resourceMetadataData.getMetadataDataDefinition().getCsarUUID(), csarUUID);
2794                                         // correct error will be returned from create flow. with all
2795                                         // correct audit records!!!!!
2796                                         return Either.right(StorageOperationStatus.NOT_FOUND);
2797                                 }
2798                                 Either<Resource, StorageOperationStatus> resource = getResource((String) resourceMetadataData.getUniqueId());
2799                                 return resource;
2800                         }
2801                 } else {
2802                         resourceMetadataDataList = byCsar.left().value();
2803                         if (resourceMetadataDataList.size() > 2) {
2804                                 log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) must return only 2 latest version, but was returned - {}", byCsar.left().value().size());
2805                                 return Either.right(StorageOperationStatus.GENERAL_ERROR);
2806                         }
2807                         if (resourceMetadataDataList.size() == 1) {
2808                                 resourceMetadataData = resourceMetadataDataList.get(0);
2809                         } else {
2810                                 for (ResourceMetadataData curResource : resourceMetadataDataList) {
2811                                         if (!curResource.getMetadataDataDefinition().getState().equals("CERTIFIED")) {
2812                                                 resourceMetadataData = curResource;
2813                                                 break;
2814                                         }
2815                                 }
2816                         }
2817                         if (resourceMetadataData == null) {
2818                                 log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) returned 2 latest CERTIFIED versions");
2819                                 return Either.right(StorageOperationStatus.GENERAL_ERROR);
2820                         }
2821                         Either<Resource, StorageOperationStatus> resource = getResource((String) resourceMetadataData.getMetadataDataDefinition().getUniqueId());
2822                         return resource;
2823                 }
2824                 return null;
2825         }
2826
2827         public Either<List<ResourceMetadataData>, StorageOperationStatus> validateCsarUuidUniqueness(String csarUUID) {
2828
2829                 Map<String, Object> props = new HashMap<>();
2830                 props.put(GraphPropertiesDictionary.CSAR_UUID.getProperty(), csarUUID);
2831
2832                 Either<List<ResourceMetadataData>, TitanOperationStatus> byCsar = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
2833                 if (byCsar.isRight()) {
2834                         if (TitanOperationStatus.NOT_FOUND.equals(byCsar.right().value())) {
2835                                 return Either.left(null);
2836                         } else {
2837                                 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCsar.right().value()));
2838                         }
2839                 }
2840                 return Either.left(byCsar.left().value());
2841         }
2842
2843         public Either<Resource, StorageOperationStatus> getResource(String uniqueId, ComponentParametersView componentParametersView, boolean inTransaction) {
2844
2845                 Resource resource = null;
2846                 try {
2847
2848                         NodeTypeEnum resourceNodeType = NodeTypeEnum.Resource;
2849                         NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource;
2850
2851                         Either<ResourceMetadataData, StorageOperationStatus> componentByLabelAndId = getComponentByLabelAndId(uniqueId, resourceNodeType, ResourceMetadataData.class);
2852                         if (componentByLabelAndId.isRight()) {
2853                                 return Either.right(componentByLabelAndId.right().value());
2854                         }
2855                         ResourceMetadataData resourceData = componentByLabelAndId.left().value();
2856
2857                         // Try to fetch resource from the cache. The resource will be
2858                         // fetched only if the time on the cache equals to
2859                         // the time on the graph.
2860                         Either<Resource, ActionStatus> componentFromCacheIfUpToDate = this.getComponentFromCacheIfUpToDate(uniqueId, resourceData, componentParametersView, Resource.class, ComponentTypeEnum.RESOURCE);
2861                         if (componentFromCacheIfUpToDate.isLeft()) {
2862                                 Resource cachedResource = componentFromCacheIfUpToDate.left().value();
2863                                 log.debug("Resource {} with uid {} was fetched from cache.", cachedResource.getName(), cachedResource.getUniqueId());
2864                                 return Either.left(cachedResource);
2865                         }
2866
2867                         resource = convertResourceDataToResource(resourceData);
2868
2869                         TitanOperationStatus status = null;
2870                         if (false == componentParametersView.isIgnoreUsers()) {
2871                                 status = setResourceCreatorFromGraph(resource, uniqueId);
2872                                 if (status != TitanOperationStatus.OK) {
2873                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2874                                 }
2875
2876                                 status = setResourceLastModifierFromGraph(resource, uniqueId);
2877                                 if (status != TitanOperationStatus.OK) {
2878                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2879                                 }
2880                         }
2881
2882                         if (false == componentParametersView.isIgnoreProperties()) {
2883                                 status = setResourcePropertiesFromGraph(uniqueId, resource);
2884                                 if (status != TitanOperationStatus.OK) {
2885                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2886                                 }
2887                         }
2888
2889                         if (false == componentParametersView.isIgnoreAttributesFrom()) {
2890                                 status = setResourceAttributesFromGraph(uniqueId, resource);
2891                                 if (status != TitanOperationStatus.OK) {
2892                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2893                                 }
2894                         }
2895
2896                         if (false == componentParametersView.isIgnoreDerivedFrom()) {
2897                                 status = setResourceDerivedFromGraph(uniqueId, resource);
2898                                 if (status != TitanOperationStatus.OK) {
2899                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2900                                 }
2901                         }
2902
2903                         if (false == componentParametersView.isIgnoreCategories()) {
2904                                 status = setComponentCategoriesFromGraph(resource);
2905                                 if (status != TitanOperationStatus.OK) {
2906                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2907                                 }
2908                         }
2909
2910                         // Since capabilities and requirements and instances properties are
2911                         // based on component instances, then we must fetch the instances.
2912                         if (false == componentParametersView.isIgnoreComponentInstances() || false == componentParametersView.isIgnoreComponentInstancesProperties() || false == componentParametersView.isIgnoreComponentInstancesInputs()
2913                                         || false == componentParametersView.isIgnoreCapabilities() || false == componentParametersView.isIgnoreRequirements()) {
2914
2915                                 status = setComponentInstancesFromGraph(uniqueId, resource, resourceNodeType, compInstNodeType);
2916                                 if (status != TitanOperationStatus.OK) {
2917                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2918
2919                                 }
2920                         }
2921
2922                         if (false == componentParametersView.isIgnoreRequirements()) {
2923                                 StorageOperationStatus setRequirementsStatus = setResourceRequirementsFromGraph(uniqueId, resource, true);
2924                                 if (setRequirementsStatus != StorageOperationStatus.OK) {
2925                                         log.error("Failed to set requirement of resource {}. status is {}", uniqueId, setRequirementsStatus);
2926                                         return Either.right(setRequirementsStatus);
2927                                 }
2928                         }
2929
2930                         if (false == componentParametersView.isIgnoreInputs()) {
2931                                 status = setComponentInputsFromGraph(uniqueId, resource, true);
2932                                 if (status != TitanOperationStatus.OK) {
2933                                         log.error("Failed to set inputs of resource {}. status is {}", uniqueId, status);
2934                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2935                                 }
2936
2937                         }
2938
2939                         StorageOperationStatus storageStatus = null;
2940                         if (false == componentParametersView.isIgnoreCapabilities()) {
2941                                 storageStatus = setResourceCapabilitiesFromGraph(uniqueId, resource);
2942                                 if (storageStatus != StorageOperationStatus.OK) {
2943                                         return Either.right(storageStatus);
2944                                 }
2945                         }
2946
2947                         if (false == componentParametersView.isIgnoreArtifacts()) {
2948                                 storageStatus = setArtifactFromGraph(uniqueId, resource);
2949                                 if (storageStatus != StorageOperationStatus.OK) {
2950                                         return Either.right(storageStatus);
2951                                 }
2952                         }
2953                         if (false == componentParametersView.isIgnoreComponentInstancesAttributesFrom()) {
2954                                 status = setComponentInstancesAttributesFromGraph(uniqueId, resource);
2955                                 if (status != TitanOperationStatus.OK) {
2956                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2957
2958                                 }
2959                         }
2960
2961                         if (false == componentParametersView.isIgnoreComponentInstancesProperties()) {
2962                                 status = setComponentInstancesPropertiesFromGraph(resource);
2963                                 if (status != TitanOperationStatus.OK) {
2964                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2965
2966                                 }
2967                         }
2968
2969                         if (false == componentParametersView.isIgnoreComponentInstancesInputs()) {
2970                                 status = setComponentInstancesInputsFromGraph(uniqueId, resource);
2971                                 if (status != TitanOperationStatus.OK) {
2972                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2973
2974                                 }
2975                         }
2976
2977                         if (false == componentParametersView.isIgnoreInterfaces()) {
2978                                 storageStatus = setResourceInterfacesFromGraph(uniqueId, resource);
2979                                 if (storageStatus != StorageOperationStatus.OK) {
2980                                         return Either.right(storageStatus);
2981                                 }
2982                         }
2983
2984                         if (false == componentParametersView.isIgnoreAdditionalInformation()) {
2985                                 storageStatus = setResourceAdditionalInformationFromGraph(uniqueId, resource);
2986                                 if (storageStatus != StorageOperationStatus.OK) {
2987                                         return Either.right(storageStatus);
2988                                 }
2989                         }
2990
2991                         if (false == componentParametersView.isIgnoreAllVersions()) {
2992                                 status = setAllVersions(resource);
2993                                 if (status != TitanOperationStatus.OK) {
2994                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
2995                                 }
2996                         }
2997
2998                         if (false == componentParametersView.isIgnoreGroups()) {
2999                                 status = setGroupsFromGraph(uniqueId, resource, NodeTypeEnum.Resource);
3000                                 if (status != TitanOperationStatus.OK) {
3001                                         return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
3002                                 }
3003                         }
3004
3005                         if (true == componentParametersView.isIgnoreComponentInstances()) {
3006                                 resource.setComponentInstances(null);
3007                                 resource.setComponentInstancesRelations(null);
3008                         }
3009
3010                 } finally {
3011                         if (false == inTransaction) {
3012                                 titanGenericDao.commit();
3013                         }
3014                 }
3015
3016                 return Either.left(resource);
3017
3018         }
3019
3020         @SuppressWarnings("unchecked")
3021         @Override
3022         public <T> Either<T, StorageOperationStatus> getComponent(String id, ComponentParametersView componentParametersView, boolean inTrasnaction) {
3023
3024                 Either<Resource, StorageOperationStatus> component = getResource(id, componentParametersView, inTrasnaction);
3025                 if (component.isRight()) {
3026                         return Either.right(component.right().value());
3027                 }
3028                 return (Either<T, StorageOperationStatus>) component;
3029         }
3030
3031         // @Override
3032         public Either<Resource, StorageOperationStatus> updateResource(Resource resource, boolean inTransaction, ComponentParametersView filterResultView) {
3033                 return (Either<Resource, StorageOperationStatus>) updateComponentFilterResult(resource, inTransaction, titanGenericDao, resource.getClass(), NodeTypeEnum.Resource, filterResultView);
3034         }
3035
3036         @Override
3037         protected <T> Either<T, StorageOperationStatus> updateComponentFilterResult(T component, boolean inTransaction, ComponentParametersView filterResultView) {
3038                 return (Either<T, StorageOperationStatus>) updateResource((Resource) component, inTransaction, filterResultView);
3039         }
3040 }