path: root/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ResourceOperation.java

/*-
 * ============LICENSE_START=======================================================
 * SDC
 * ================================================================================
 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */

package org.openecomp.sdc.be.model.operations.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
import org.openecomp.sdc.be.dao.graph.datatype.RelationEndPoint;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.FilterKeyEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.model.AttributeDefinition;
import org.openecomp.sdc.be.model.CapabilityDefinition;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
import org.openecomp.sdc.be.model.ComponentInstanceProperty;
import org.openecomp.sdc.be.model.ComponentParametersView;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.GroupDefinition;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.LifecycleStateEnum;
import org.openecomp.sdc.be.model.Operation;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.RequirementDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
import org.openecomp.sdc.be.model.cache.ComponentCache;
import org.openecomp.sdc.be.model.category.CategoryDefinition;
import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
import org.openecomp.sdc.be.model.operations.api.IAdditionalInformationOperation;
import org.openecomp.sdc.be.model.operations.api.IArtifactOperation;
import org.openecomp.sdc.be.model.operations.api.IAttributeOperation;
import org.openecomp.sdc.be.model.operations.api.IElementOperation;
import org.openecomp.sdc.be.model.operations.api.IResourceOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.utils.GraphDeleteUtil;
import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
import org.openecomp.sdc.be.resources.data.TagData;
import org.openecomp.sdc.be.resources.data.UniqueIdData;
import org.openecomp.sdc.be.resources.data.UserData;
import org.openecomp.sdc.be.resources.data.category.CategoryData;
import org.openecomp.sdc.be.resources.data.category.SubCategoryData;
import org.openecomp.sdc.common.util.ValidationUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.thinkaurelius.titan.core.TitanGraph;
import com.thinkaurelius.titan.core.TitanVertex;

import fj.data.Either;

@org.springframework.stereotype.Component("resource-operation")
public class ResourceOperation extends ComponentOperation implements IResourceOperation {

	public ResourceOperation() {
		super();
	}

	private static Logger log = LoggerFactory.getLogger(ResourceOperation.class.getName());

	@javax.annotation.Resource
	private PropertyOperation propertyOperation;

	@javax.annotation.Resource
	private IAttributeOperation attributeOperation;

	@javax.annotation.Resource
	private RequirementOperation requirementOperation;

	@javax.annotation.Resource
	private CapabilityOperation capabilityOperation;

	@javax.annotation.Resource
	private InterfaceLifecycleOperation interfaceLifecycleOperation;

	@javax.annotation.Resource
	private IElementOperation elementOperation;

	@javax.annotation.Resource
	private IAdditionalInformationOperation addioAdditionalInformationOperation;

	@javax.annotation.Resource
	private GroupOperation groupOperation;

	@javax.annotation.Resource
	private ComponentCache componentCache;

	private Gson prettyJson = new GsonBuilder().setPrettyPrinting().create();

	private GraphDeleteUtil graphDeleteUtil = new GraphDeleteUtil();

	private static Pattern uuidNewVersion = Pattern.compile("^\\d{1,}.1");
	private static Pattern uuidNormativeNewVersion = Pattern.compile("^\\d{1,}.0");

	@Override
	public Either<Resource, StorageOperationStatus> createResource(Resource resource) {
		return createResource(resource, false);
	}

	@Override
	public Either<Resource, StorageOperationStatus> createResource(Resource resource, boolean inTransaction) {

		Either<Resource, StorageOperationStatus> result = null;

		try {
			generateUUID(resource);

			ResourceMetadataData resourceData = getResourceMetaDataFromResource(resource);
			String resourceUniqueId = resource.getUniqueId();
			if (resourceUniqueId == null) {
				resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId();
				resourceData.getMetadataDataDefinition().setUniqueId(resourceUniqueId);
			}
			resourceData.getMetadataDataDefinition().setHighestVersion(true);

			String userId = resource.getCreatorUserId();

			Either<TitanVertex, TitanOperationStatus> findUser = findUserVertex(userId);

			if (findUser.isRight()) {
				TitanOperationStatus status = findUser.right().value();
				log.error("Cannot find user " + userId + " in the graph. status is " + status);
				return sendError(status, StorageOperationStatus.USER_NOT_FOUND);
			}

			TitanVertex creatorVertex = findUser.left().value();
			TitanVertex updaterVertex = creatorVertex;

			String updaterUserId = resource.getLastUpdaterUserId();
			if (updaterUserId != null && !updaterUserId.equals(userId)) {
				findUser = findUserVertex(updaterUserId);
				if (findUser.isRight()) {
					TitanOperationStatus status = findUser.right().value();
					log.error("Cannot find user " + userId + " in the graph. status is " + status);
					return sendError(status, StorageOperationStatus.USER_NOT_FOUND);
				} else {
					updaterVertex = findUser.left().value();
				}
			}

			// get derived from resources
			List<ResourceMetadataData> derivedResources = null;
			Either<List<ResourceMetadataData>, StorageOperationStatus> derivedResourcesResult = findDerivedResources(resource);
			if (derivedResourcesResult.isRight()) {
				result = Either.right(derivedResourcesResult.right().value());
				return result;
			} else {
				derivedResources = derivedResourcesResult.left().value();
			}

			List<String> tags = resource.getTags();
			if (tags != null && false == tags.isEmpty()) {
				Either<List<TagData>, StorageOperationStatus> tagsResult = createNewTagsList(tags);
				if (tagsResult.isRight()) {
					result = Either.right(tagsResult.right().value());
					return result;
				}
				List<TagData> tagsToCreate = tagsResult.left().value();
				StorageOperationStatus status = createTagNodesOnGraph(tagsToCreate);
				if (!status.equals(StorageOperationStatus.OK)) {
					result = Either.right(status);
					return result;
				}
			}

			Either<TitanVertex, TitanOperationStatus> createdVertex = titanGenericDao.createNode(resourceData);
			if (createdVertex.isRight()) {
				TitanOperationStatus status = createdVertex.right().value();
				log.error("Error returned after creating resource data node {}. status returned is ", resourceData, status);
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				return result;
			}
			TitanVertex metadataVertex = createdVertex.left().value();

			TitanOperationStatus associateMetadata = associateMetadataToResource(resourceData, creatorVertex, updaterVertex, derivedResources, metadataVertex);
			if (associateMetadata != TitanOperationStatus.OK) {
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateMetadata));
				return result;
			}
			StorageOperationStatus associateCategory = assosiateMetadataToCategory(resource, resourceData);
			if (associateCategory != StorageOperationStatus.OK) {
				result = Either.right(associateCategory);
				return result;
			}

			TitanOperationStatus associateProperties = associatePropertiesToResource(metadataVertex, resourceUniqueId, resource.getProperties());
			if (associateProperties != TitanOperationStatus.OK) {
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateProperties));
				return result;
			}

			TitanOperationStatus associateAttributes = associateAttributesToResource(metadataVertex, resource.getAttributes(), resourceUniqueId);
			if (associateAttributes != TitanOperationStatus.OK) {
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateAttributes));
				return result;
			}

			TitanOperationStatus associateInputs = associateInputsToComponent(metadataVertex, resourceUniqueId, resource.getInputs());
			if (associateInputs != TitanOperationStatus.OK) {
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(associateInputs));
				return result;
			}

			StorageOperationStatus associateRequirements = associateRequirementsToResource(metadataVertex, resourceUniqueId, resource.getRequirements());
			if (associateRequirements != StorageOperationStatus.OK) {
				result = Either.right(associateRequirements);
				return result;
			}

			StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(metadataVertex, resourceUniqueId, resource.getCapabilities());
			if (associateCapabilities != StorageOperationStatus.OK) {
				result = Either.right(associateCapabilities);
				return result;
			}

			StorageOperationStatus associateInterfaces = associateInterfacesToResource(resourceData, resource.getInterfaces(), metadataVertex);
			if (associateInterfaces != StorageOperationStatus.OK) {
				result = Either.right(associateInterfaces);
				return result;
			}

			Map<String, ArtifactDefinition> resourceArtifacts = resource.getArtifacts();
			Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
			Map<String, ArtifactDefinition> toscaArtifacts = resource.getToscaArtifacts();
			if (resourceArtifacts != null) {
				if (deploymentArtifacts != null) {
					resourceArtifacts.putAll(deploymentArtifacts);
				}
			} else {
				resourceArtifacts = deploymentArtifacts;
			}
			if (toscaArtifacts != null) {
				if (resourceArtifacts != null) {
					resourceArtifacts.putAll(toscaArtifacts);
				} else {
					resourceArtifacts = toscaArtifacts;
				}
			}

			StorageOperationStatus associateArtifacts = associateArtifactsToResource(metadataVertex, resourceUniqueId, resourceArtifacts);
			if (associateArtifacts != StorageOperationStatus.OK) {
				result = Either.right(associateArtifacts);
				return result;
			}

			List<AdditionalInformationDefinition> additionalInformation = resource.getAdditionalInformation();
			StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(metadataVertex, resourceUniqueId, additionalInformation);
			if (addAdditionalInformation != StorageOperationStatus.OK) {
				result = Either.right(addAdditionalInformation);
				return result;
			}

			result = this.getResource(resourceUniqueId, true);
			if (result.isRight()) {
				log.error("Cannot get full resource from the graph. status is " + result.right().value());
				return Either.right(result.right().value());
			}

			if (log.isDebugEnabled()) {
				String json = prettyJson.toJson(result.left().value());
				log.debug("Resource retrieved is " + json);
			}

			return result;

		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.error("Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}
		}
	}

	private StorageOperationStatus assosiateMetadataToCategory(Resource resource, ResourceMetadataData resourceData) {
		// get category
		String categoryName = resource.getCategories().get(0).getName();
		String subcategoryName = resource.getCategories().get(0).getSubcategories().get(0).getName();

		CategoryData categoryData = null;
		Either<CategoryData, StorageOperationStatus> categoryResult = elementOperation.getNewCategoryData(categoryName, NodeTypeEnum.ResourceNewCategory, CategoryData.class);
		if (categoryResult.isRight()) {
			StorageOperationStatus status = categoryResult.right().value();
			log.error("Cannot find category " + categoryName + " in the graph. status is " + status);
			return categoryResult.right().value();
		}
		categoryData = categoryResult.left().value();
		if (categoryData != null) {
			Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceNewCategory), (String) categoryData.getUniqueId(),
					GraphEdgeLabels.SUB_CATEGORY, NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
			if (childrenNodes.isRight()) {
				log.debug("Faield to fetch sub categories for  resource category" + categoryData.getCategoryDataDefinition().getName());
				return DaoStatusConverter.convertTitanStatusToStorageStatus(childrenNodes.right().value());
			}
			for (ImmutablePair<SubCategoryData, GraphEdge> pair : childrenNodes.left().value()) {
				SubCategoryData subcategoryData = pair.left;
				if (subcategoryData.getSubCategoryDataDefinition().getName().equals(subcategoryName)) {
					Either<GraphRelation, TitanOperationStatus> result = titanGenericDao.createRelation(resourceData, subcategoryData, GraphEdgeLabels.CATEGORY, null);
					log.debug("After associating resource " + resourceData.getUniqueId() + " to subcategory " + subcategoryData + ". Edge type is " + GraphEdgeLabels.CATEGORY);
					if (result.isRight()) {
						log.error("Faield to associate resource " + resourceData.getUniqueId() + " to category " + categoryData + ". Edge type is " + GraphEdgeLabels.CATEGORY);
						return DaoStatusConverter.convertTitanStatusToStorageStatus(result.right().value());
					}

				}
			}
		}
		return StorageOperationStatus.OK;
	}

	private StorageOperationStatus addAdditionalInformationToResource(TitanVertex metadataVertex, String resourceUniqueId, List<AdditionalInformationDefinition> additionalInformation) {

		StorageOperationStatus result = null;
		if (additionalInformation == null || true == additionalInformation.isEmpty()) {
			result = super.addAdditionalInformation(NodeTypeEnum.Resource, resourceUniqueId, null, metadataVertex);
		} else {
			if (additionalInformation.size() == 1) {
				result = super.addAdditionalInformation(NodeTypeEnum.Resource, resourceUniqueId, additionalInformation.get(0));
			} else {
				result = StorageOperationStatus.BAD_REQUEST;
				log.info("Cannot create resource with more than one additional information object. The number of received object is {}", additionalInformation.size());
			}
		}
		return result;
	}

	private void generateUUID(Resource resource) {
		String prevUUID = resource.getUUID();
		String version = resource.getVersion();
		if ((prevUUID == null && uuidNormativeNewVersion.matcher(version).matches()) || uuidNewVersion.matcher(version).matches()) {
			UUID uuid = UUID.randomUUID();
			resource.setUUID(uuid.toString());
			MDC.put("serviceInstanceID", uuid.toString());
		}
	}

	@Override
	public Either<Resource, StorageOperationStatus> overrideResource(Resource resource, Resource resourceSaved, boolean inTransaction) {
		Either<Resource, StorageOperationStatus> result = null;
		try {
			String resourceId = resourceSaved.getUniqueId();

			// override interfaces to copy only resource's interfaces and not
			// derived interfaces
			Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfacesOfResourceOnly = interfaceLifecycleOperation.getAllInterfacesOfResource(resourceSaved.getUniqueId(), false, true);
			if (interfacesOfResourceOnly.isRight()) {
				log.error("failed to get interfaces of resource. resourceId {} status is {}", resourceId, interfacesOfResourceOnly.right().value());
				result = Either.right(interfacesOfResourceOnly.right().value());
				return result;
			}
			resource.setInterfaces(interfacesOfResourceOnly.left().value());
			resource.setArtifacts(resourceSaved.getArtifacts());
			resource.setDeploymentArtifacts(resourceSaved.getDeploymentArtifacts());
			resource.setGroups(resourceSaved.getGroups());
			resource.setInputs(null);
			resource.setLastUpdateDate(null);
			resource.setHighestVersion(true);

			// delete former resource
			Either<Resource, StorageOperationStatus> deleteResource = deleteResource(resourceId, true);
			if (deleteResource.isRight()) {
				log.error("failed to delete old resource with id {}. status = {}", resourceId, deleteResource.right().value());
				result = deleteResource;
				return result;
			}

			Either<Resource, StorageOperationStatus> createResource = createResource(resource, true);
			if (createResource.isRight()) {
				log.error("failed to create new version of resource {} status = {}", resourceId, createResource.right().value());
				result = createResource;
				return result;
			}
			Resource newResource = createResource.left().value();

			Either<List<GroupDefinition>, StorageOperationStatus> cloneGroupEither = cloneGroups(resource, newResource, null, inTransaction);
			if (cloneGroupEither.isLeft()) {
				newResource.setGroups(cloneGroupEither.left().value());
			} else if (cloneGroupEither.right().value() != StorageOperationStatus.OK) {
				log.error("failed to clone group of resource {} status = {}", resourceId, cloneGroupEither.right().value());
				result = Either.right(cloneGroupEither.right().value());
				return result;
			}

			result = Either.left(newResource);
			return result;
		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.error("Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}
		}

	}

	private StorageOperationStatus associateCapabilitiesToResource(TitanVertex metadataVertex, String resourceIda, Map<String, List<CapabilityDefinition>> capabilities) {
		StorageOperationStatus addCapabilityToResource = null;
		if (capabilities != null) {
			for (Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) {

				List<CapabilityDefinition> capDefinition = entry.getValue();
				for (CapabilityDefinition item : capDefinition) {
					addCapabilityToResource = capabilityOperation.addCapability(metadataVertex, resourceIda, item.getName(), item, true);
					if (!addCapabilityToResource.equals(StorageOperationStatus.OK)) {
						return addCapabilityToResource;
					}

				}
			}

		}
		return StorageOperationStatus.OK;
	}

	private StorageOperationStatus associateRequirementsToResource(TitanVertex metadataVertex, String resourceId, Map<String, List<RequirementDefinition>> requirements) {

		if (requirements != null) {
			for (Entry<String, List<RequirementDefinition>> entry : requirements.entrySet()) {

				List<RequirementDefinition> reqDefinition = entry.getValue();
				for (RequirementDefinition item : reqDefinition) {
					StorageOperationStatus addRequirementToResource = requirementOperation.addRequirementToResource(metadataVertex, item.getName(), item, resourceId, true);

					if (!addRequirementToResource.equals(StorageOperationStatus.OK)) {
						return addRequirementToResource;
					}
				}
			}
		}
		return StorageOperationStatus.OK;
	}

	private StorageOperationStatus associateArtifactsToResource(TitanVertex metadataVertex, String resourceId, Map<String, ArtifactDefinition> artifacts) {

		StorageOperationStatus status = StorageOperationStatus.OK;
		if (artifacts != null) {
			for (Entry<String, ArtifactDefinition> entry : artifacts.entrySet()) {

				ArtifactDefinition artifactDefinition = entry.getValue();
				status = artifactOperation.addArifactToComponent(artifactDefinition, resourceId, NodeTypeEnum.Resource, false, metadataVertex);

				if (!status.equals(StorageOperationStatus.OK)) {
					return status;
				}
			}
		}
		return status;

	}

	private StorageOperationStatus associateInterfacesToResource(ResourceMetadataData resourceData, Map<String, InterfaceDefinition> interfaces, TitanVertex metadataVertex) {

		if (interfaces != null) {
			for (Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {

				InterfaceDefinition interfaceDefinition = entry.getValue();
				StorageOperationStatus status;
				if (((ResourceMetadataDataDefinition) resourceData.getMetadataDataDefinition()).isAbstract()) {
					status = interfaceLifecycleOperation.associateInterfaceToNode(resourceData, interfaceDefinition, metadataVertex);
				} else {
					status = interfaceLifecycleOperation.createInterfaceOnResource(interfaceDefinition, resourceData.getMetadataDataDefinition().getUniqueId(), interfaceDefinition.getType(), false, true, metadataVertex);
				}

				if (!status.equals(StorageOperationStatus.OK)) {
					return status;
				}
			}
		}
		return StorageOperationStatus.OK;

	}

	private Either<Resource, StorageOperationStatus> sendError(TitanOperationStatus status, StorageOperationStatus statusIfNotFound) {
		Either<Resource, StorageOperationStatus> result;
		if (status == TitanOperationStatus.NOT_FOUND) {
			result = Either.right(statusIfNotFound);
			return result;
		} else {
			result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
			return result;
		}
	}

	private TitanOperationStatus associatePropertiesToResource(TitanVertex metadatVertex, String resourceId, List<PropertyDefinition> properties) {

		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = applicationDataTypeCache.getAll();
		if (allDataTypes.isRight()) {
			TitanOperationStatus status = allDataTypes.right().value();
			log.debug("Cannot find any data type. Status is {}.", status);
			return status;
		}

		Map<String, PropertyDefinition> convertedProperties = new HashMap<>();

		if (properties != null) {
			for (PropertyDefinition propertyDefinition : properties) {
				convertedProperties.put(propertyDefinition.getName(), propertyDefinition);
			}
			TitanOperationStatus operationStatus = propertyOperation.addPropertiesToGraph(metadatVertex, convertedProperties, allDataTypes.left().value(), resourceId);
			return operationStatus;
		}

		return TitanOperationStatus.OK;

	}

	private TitanOperationStatus associateAttributesToResource(TitanVertex metadataVertex, List<AttributeDefinition> attributes, String resourceId) {
		TitanOperationStatus operationStatus = TitanOperationStatus.OK;

		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = applicationDataTypeCache.getAll();
		if (allDataTypes.isRight()) {
			TitanOperationStatus status = allDataTypes.right().value();
			log.debug("Cannot find any data type. Status is {}.", status);
			return status;
		}

		if (attributes != null) {
			Map<String, AttributeDefinition> convertedAttributes = attributes.stream().collect(Collectors.toMap(e -> e.getName(), e -> e));
			operationStatus = attributeOperation.addAttributesToGraph(metadataVertex, convertedAttributes, resourceId, allDataTypes.left().value());
		}
		return operationStatus;
	}

	private TitanOperationStatus associateMetadataToResource(ResourceMetadataData resourceData, TitanVertex creatorVertex, TitanVertex updaterVertex, List<ResourceMetadataData> derivedResources, TitanVertex metadataVertex) {

		Map<String, Object> props = new HashMap<String, Object>();
		props.put(GraphPropertiesDictionary.STATE.getProperty(), resourceData.getMetadataDataDefinition().getState());

		TitanOperationStatus result = titanGenericDao.createEdge(updaterVertex, metadataVertex, GraphEdgeLabels.STATE, props);
		log.debug("After associating user {} to resource {}. Edge type is {}", updaterVertex, resourceData.getUniqueId(), GraphEdgeLabels.STATE);
		if (!result.equals(TitanOperationStatus.OK)) {
			return result;
		}
		result = titanGenericDao.createEdge(updaterVertex, metadataVertex, GraphEdgeLabels.LAST_MODIFIER, null);
		log.debug("After associating user {}  to resource {}. Edge type is {}", updaterVertex, resourceData.getUniqueId(), GraphEdgeLabels.LAST_MODIFIER);
		if (!result.equals(TitanOperationStatus.OK)) {
			log.error("Failed to associate user {}  to resource {}. Edge type is {}", updaterVertex, resourceData.getUniqueId(), GraphEdgeLabels.LAST_MODIFIER);
			return result;
		}

		result = titanGenericDao.createEdge(creatorVertex, metadataVertex, GraphEdgeLabels.CREATOR, null);
		log.debug("After associating user {} to resource {}. Edge type is {} ", creatorVertex, resourceData.getUniqueId(), GraphEdgeLabels.CREATOR);
		if (!result.equals(TitanOperationStatus.OK)) {
			log.error("Failed to associate user {} to resource {}. Edge type is {} ", creatorVertex, resourceData.getUniqueId(), GraphEdgeLabels.CREATOR);
			return result;
		}
		// TODO Evg : need to change too..
		if (derivedResources != null) {
			for (ResourceMetadataData derivedResource : derivedResources) {
				log.debug("After associating resource " + resourceData.getUniqueId() + " to parent resource " + derivedResource.getUniqueId() + ". Edge type is " + GraphEdgeLabels.DERIVED_FROM);
				Either<GraphRelation, TitanOperationStatus> createRelationResult = titanGenericDao.createRelation(resourceData, derivedResource, GraphEdgeLabels.DERIVED_FROM, null);
				if (createRelationResult.isRight()) {
					log.error("Failed to associate resource {} to derived ", resourceData.getUniqueId());
					return createRelationResult.right().value();
				}
			}
		}

		return TitanOperationStatus.OK;
	}

	public Either<List<ResourceMetadataData>, StorageOperationStatus> findDerivedResources(Resource resource) {

		List<ResourceMetadataData> derivedResources = new ArrayList<ResourceMetadataData>();
		List<String> derivedFromResources = resource.getDerivedFrom();
		if (derivedFromResources != null && false == derivedFromResources.isEmpty()) {

			for (String parentResource : derivedFromResources) {

				Map<String, Object> propertiesToMatch = new HashMap<String, Object>();
				propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
				// propertiesToMatch.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(),
				// true);
				propertiesToMatch.put(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), parentResource);
				propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);

				Either<List<ResourceMetadataData>, TitanOperationStatus> getParentResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
				List<ResourceMetadataData> resources = null;
				if (getParentResources.isRight()) {
					/*
					 * log.debug( "Cannot find parent resource by tosca resource name" + parentResource + " in the graph. Try to find by name"); Map<String, Object> propertiesWithResourceNameToMatch = new HashMap<String, Object>();
					 * propertiesWithResourceNameToMatch.put( GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name()); propertiesWithResourceNameToMatch.put( GraphPropertiesDictionary.NAME.getProperty(), parentResource);
					 * propertiesWithResourceNameToMatch.put( GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty( ), true);
					 * 
					 * getParentResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesWithResourceNameToMatch, ResourceData.class); if (getParentResources.isRight()) { log.error(
					 * "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();
					 * 
					 * }
					 */
					log.error("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();
					if (resources == null || resources.size() == 0) {
						log.error("Cannot find parent resource by tosc name" + parentResource + " in the graph. resources size is empty");
						return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
					} else {
						if (resources.size() > 1) {
							log.error("Multiple parent resources called " + parentResource + " found in the graph.");
							return Either.right(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND);
						}
						ResourceMetadataData parentResourceData = resources.get(0);
						derivedResources.add(parentResourceData);
					}

				}

			}
		}
		return Either.left(derivedResources);
	}

	private ResourceMetadataData getResourceMetaDataFromResource(Resource resource) {
		ResourceMetadataData resourceData = new ResourceMetadataData((ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
		if (resource.getNormalizedName() == null || resource.getNormalizedName().isEmpty()) {
			resourceData.getMetadataDataDefinition().setNormalizedName(ValidationUtils.normaliseComponentName(resource.getName()));
		}
		if (resource.getSystemName() == null || resource.getSystemName().isEmpty()) {
			resourceData.getMetadataDataDefinition().setSystemName(ValidationUtils.convertToSystemName(resource.getName()));
		}

		LifecycleStateEnum lifecycleStateEnum = resource.getLifecycleState();
		if (lifecycleStateEnum == null) {
			resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
		}
		long currentDate = System.currentTimeMillis();
		if (resource.getCreationDate() == null) {
			resourceData.getMetadataDataDefinition().setCreationDate(currentDate);
		}
		resourceData.getMetadataDataDefinition().setLastUpdateDate(currentDate);

		return resourceData;
	}

	private ResourceMetadataData getResourceMetaDataForUpdate(Resource resource) {
		// PA - please note: if you add here any fields, make sure they are
		// validated (if needed)
		// at ResourceBusinessLogic.validateResourceFieldsBeforeUpdate() and
		// tested at ResourceBusinessLogicTest.
		ResourceMetadataData resourceData = getResourceMetaDataFromResource(resource);
		// resourceData.setLastUpdateDate(System.currentTimeMillis());
		// resourceData.setHighestVersion(resource.isHighestVersion());
		// resourceData.setNormalizedName(resource.getNormalizedName());
		// resourceData.setResourceType(resource.getResourceType().name());

		return resourceData;
	}

	public Either<Resource, StorageOperationStatus> getResource(String uniqueId) {
		return getResource(uniqueId, false);
	}

	public Either<Resource, StorageOperationStatus> getResource(String uniqueId, boolean inTransaction) {
		ComponentParametersView componentParametersView = new ComponentParametersView();
		return getResource(uniqueId, componentParametersView, inTransaction);
	}

	// public Either<Resource, StorageOperationStatus> getResource(String
	// uniqueId, boolean inTransaction) {
	//
	// Resource resource = null;
	// try {
	//
	// NodeTypeEnum resourceNodeType = NodeTypeEnum.Resource;
	// NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource;
	//
	// Either<ResourceMetadataData, StorageOperationStatus>
	// componentByLabelAndId = getComponentByLabelAndId(uniqueId,
	// resourceNodeType, ResourceMetadataData.class);
	// if (componentByLabelAndId.isRight()) {
	// return Either.right(componentByLabelAndId.right().value());
	// }
	// ResourceMetadataData resourceData = componentByLabelAndId.left().value();
	// resource = convertResourceDataToResource(resourceData);
	//
	// TitanOperationStatus status = setResourceCreatorFromGraph(resource,
	// uniqueId);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourceLastModifierFromGraph(resource, uniqueId);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourcePropertiesFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourceAttributesFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourceDerivedFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setComponentCategoriesFromGraph(resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setComponentInstancesFromGraph(uniqueId, resource,
	// resourceNodeType, compInstNodeType);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	//
	// }
	//
	// StorageOperationStatus setRequirementsStatus =
	// setResourceRequirementsFromGraph(uniqueId, resource, true);
	// if (setRequirementsStatus != StorageOperationStatus.OK) {
	// log.error("Failed to set requirement of resource " + uniqueId + ". status
	// is " + setRequirementsStatus);
	// return Either.right(setRequirementsStatus);
	// }
	//
	// StorageOperationStatus storageStatus =
	// setResourceCapabilitiesFromGraph(uniqueId, resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	//
	// storageStatus = setArtifactFromGraph(uniqueId, resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	//
	// status = setComponentInstancesAttributesFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	//
	// }
	//
	// status = setComponentInstancesPropertiesFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	//
	// }
	//
	// storageStatus = setResourceInterfacesFromGraph(uniqueId, resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	//
	// storageStatus = setResourceAdditionalInformationFromGraph(uniqueId,
	// resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	// status = setAllVersions(resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setGroupsFromGraph(uniqueId, resource, NodeTypeEnum.Resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// } finally {
	// if (false == inTransaction) {
	// titanGenericDao.commit();
	// }
	// }
	//
	// return Either.left(resource);
	// }

	private TitanOperationStatus setComponentInstancesAttributesFromGraph(String uniqueId, Resource component) {
		Map<String, List<ComponentInstanceAttribute>> resourceInstancesAttributes = new HashMap<>();
		TitanOperationStatus status = TitanOperationStatus.OK;
		List<ComponentInstance> componentInstances = component.getComponentInstances();
		if (componentInstances != null) {
			for (ComponentInstance resourceInstance : componentInstances) {
				Either<List<ComponentInstanceAttribute>, TitanOperationStatus> eitherRIAttributes = attributeOperation.getAllAttributesOfResourceInstance(resourceInstance);
				if (eitherRIAttributes.isRight()) {
					status = eitherRIAttributes.right().value();
					break;
				} else {
					resourceInstancesAttributes.put(resourceInstance.getUniqueId(), eitherRIAttributes.left().value());
				}
			}

			component.setComponentInstancesAttributes(resourceInstancesAttributes);
		}

		return status;

	}

	// public Either<Resource, StorageOperationStatus> getResource_tx(String
	// uniqueId, boolean inTransaction) {
	//
	// Resource resource = null;
	// try {
	//
	// NodeTypeEnum resourceNodeType = NodeTypeEnum.Resource;
	// NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource;
	//
	// Either<ResourceMetadataData, StorageOperationStatus>
	// componentByLabelAndId = getComponentByLabelAndId_tx(uniqueId,
	// resourceNodeType, ResourceMetadataData.class);
	// if (componentByLabelAndId.isRight()) {
	// return Either.right(componentByLabelAndId.right().value());
	// }
	// ResourceMetadataData resourceData = componentByLabelAndId.left().value();
	// resource = convertResourceDataToResource(resourceData);
	//
	// TitanOperationStatus status = setResourceCreatorFromGraph(resource,
	// uniqueId);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourceLastModifierFromGraph(resource, uniqueId);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourcePropertiesFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setResourceDerivedFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setComponentCategoriesFromGraph(resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// status = setComponentInstancesFromGraph(uniqueId, resource,
	// resourceNodeType, compInstNodeType);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	//
	// }
	//
	// StorageOperationStatus setRequirementsStatus =
	// setResourceRequirementsFromGraph(uniqueId, resource, true);
	// if (setRequirementsStatus != StorageOperationStatus.OK) {
	// log.error("Failed to set requirement of resource " + uniqueId + ". status
	// is " + setRequirementsStatus);
	// return Either.right(setRequirementsStatus);
	// }
	//
	// StorageOperationStatus storageStatus =
	// setResourceCapabilitiesFromGraph(uniqueId, resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	//
	// storageStatus = setArtifactFromGraph(uniqueId, resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	//
	// status = setComponentInstancesPropertiesFromGraph(uniqueId, resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	//
	// }
	//
	// storageStatus = setResourceInterfacesFromGraph(uniqueId, resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	//
	// storageStatus = setResourceAdditionalInformationFromGraph(uniqueId,
	// resource);
	// if (storageStatus != StorageOperationStatus.OK) {
	// return Either.right(storageStatus);
	// }
	// status = setAllVersions(resource);
	// if (status != TitanOperationStatus.OK) {
	// return
	// Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
	// }
	//
	// } finally {
	// if (false == inTransaction) {
	// titanGenericDao.commit();
	// }
	// }
	//
	// return Either.left(resource);
	// }

	private StorageOperationStatus setResourceAdditionalInformationFromGraph(String uniqueId, Resource resource) {

		List<AdditionalInformationDefinition> additionalInformation = new ArrayList<>();

		Either<AdditionalInformationDefinition, StorageOperationStatus> either = additionalInformationOperation.getAllAdditionalInformationParameters(NodeTypeEnum.Resource, uniqueId, true, true);

		if (either.isRight()) {
			StorageOperationStatus status = either.right().value();
			if (status == StorageOperationStatus.NOT_FOUND) {
				return StorageOperationStatus.OK;
			}
			return status;
		}

		AdditionalInformationDefinition additionalInformationDefinition = either.left().value();
		additionalInformation.add(additionalInformationDefinition);

		resource.setAdditionalInformation(additionalInformation);

		return StorageOperationStatus.OK;

	}

	private StorageOperationStatus setResourceInterfacesFromGraph(String uniqueId, Resource resource) {

		Either<Map<String, InterfaceDefinition>, StorageOperationStatus> statusRes = interfaceLifecycleOperation.getAllInterfacesOfResource(uniqueId, true, true);
		if (statusRes.isRight()) {
			return statusRes.right().value();
		}
		Map<String, InterfaceDefinition> value = statusRes.left().value();

		resource.setInterfaces(value);

		return StorageOperationStatus.OK;
	}

	private StorageOperationStatus setResourceCapabilitiesFromGraph(String uniqueId, Resource resource) {
		StorageOperationStatus retStatus;
		Either<Map<String, CapabilityDefinition>, StorageOperationStatus> result = capabilityOperation.getAllCapabilitiesOfResource(uniqueId, true, true);
		if (result.isRight()) {
			StorageOperationStatus status = result.right().value();
			if (status != StorageOperationStatus.NOT_FOUND) {
				retStatus = status;
			} else {
				retStatus = StorageOperationStatus.OK;
			}
		} else {
			Map<String, CapabilityDefinition> capabilities = result.left().value();
			if (capabilities == null || capabilities.isEmpty()) {
				Either<Map<String, List<CapabilityDefinition>>, TitanOperationStatus> eitherCapabilities = super.getCapabilities(resource, NodeTypeEnum.Resource, true);
				if (eitherCapabilities.isLeft()) {
					retStatus = StorageOperationStatus.OK;
					Map<String, List<CapabilityDefinition>> calculatedCapabilities = eitherCapabilities.left().value();
					resource.setCapabilities(calculatedCapabilities);
				} else {
					retStatus = StorageOperationStatus.GENERAL_ERROR;
				}

			} else {
				retStatus = StorageOperationStatus.OK;
				resource.setCapabilities(capabilityOperation.convertCapabilityMap(capabilities, null, null));
			}

		}
		return retStatus;

	}

	public Either<Map<String, List<CapabilityDefinition>>, TitanOperationStatus> getCapabilities(org.openecomp.sdc.be.model.Component component, NodeTypeEnum componentTypeEnum, boolean inTransaction) {

		try {
			Either<Map<String, CapabilityDefinition>, StorageOperationStatus> result = capabilityOperation.getAllCapabilitiesOfResource(component.getUniqueId(), true, true);
			if (result.isRight() || result.left().value().isEmpty()) {
				final Either<Map<String, List<CapabilityDefinition>>, TitanOperationStatus> eitherCapabilities = super.getCapabilities(component, componentTypeEnum, inTransaction);
				return eitherCapabilities;
			} else {
				return Either.left(capabilityOperation.convertCapabilityMap(result.left().value(), null, null));
			}
		} finally {
			if (inTransaction == false) {
				titanGenericDao.commit();
			}
		}
	}

	public Either<Map<String, List<RequirementDefinition>>, TitanOperationStatus> getRequirements(org.openecomp.sdc.be.model.Component component, NodeTypeEnum componentTypeEnum, boolean inTransaction) {
		try {
			Either<Map<String, RequirementDefinition>, StorageOperationStatus> result = requirementOperation.getAllResourceRequirements(component.getUniqueId(), true);
			if (result.isRight() || result.left().value().isEmpty()) {
				final Either<Map<String, List<RequirementDefinition>>, TitanOperationStatus> eitherCapabilities = super.getRequirements(component, componentTypeEnum, true);
				return eitherCapabilities;
			} else {
				return Either.left(requirementOperation.convertRequirementMap(result.left().value(), null, null));
			}
		} finally {
			if (inTransaction == false) {
				titanGenericDao.commit();
			}
		}

	}

	private StorageOperationStatus setResourceRequirementsFromGraph(String uniqueId, Resource resource, boolean inTransaction) {
		StorageOperationStatus retStatus;
		Either<Map<String, RequirementDefinition>, StorageOperationStatus> result = requirementOperation.getAllResourceRequirements(uniqueId, inTransaction);
		;
		if (result.isRight()) {
			StorageOperationStatus status = result.right().value();
			if (status != StorageOperationStatus.NOT_FOUND) {
				retStatus = status;
			} else {
				retStatus = StorageOperationStatus.OK;
			}
		} else {
			Map<String, RequirementDefinition> requirements = result.left().value();
			if (requirements == null || requirements.isEmpty()) {
				Either<Map<String, List<RequirementDefinition>>, TitanOperationStatus> eitherCapabilities = super.getRequirements(resource, NodeTypeEnum.Resource, true);
				if (eitherCapabilities.isLeft()) {
					retStatus = StorageOperationStatus.OK;
					Map<String, List<RequirementDefinition>> calculatedCapabilities = eitherCapabilities.left().value();
					resource.setRequirements(calculatedCapabilities);
				} else {
					retStatus = StorageOperationStatus.GENERAL_ERROR;
				}

			} else {
				retStatus = StorageOperationStatus.OK;
				resource.setRequirements(requirementOperation.convertRequirementMap(requirements, null, null));
			}

		}
		return retStatus;
	}

	private TitanOperationStatus setResourcePropertiesFromGraph(String uniqueId, Resource resource) {

		List<PropertyDefinition> properties = new ArrayList<>();
		TitanOperationStatus status = propertyOperation.findAllResourcePropertiesRecursively(uniqueId, properties);
		if (status == TitanOperationStatus.OK) {
			resource.setProperties(properties);
		}

		return status;

	}

	private TitanOperationStatus setResourceAttributesFromGraph(String uniqueId, Resource resource) {

		List<AttributeDefinition> attributes = new ArrayList<>();
		TitanOperationStatus status = attributeOperation.findAllResourceAttributesRecursively(uniqueId, attributes);
		if (status == TitanOperationStatus.OK) {
			resource.setAttributes(attributes);
		}

		return status;

	}

	private TitanOperationStatus setResourceDerivedFromGraph(String uniqueId, Resource resource) {
		List<String> derivedFromList = new ArrayList<String>();

		TitanOperationStatus listFromGraphStatus = fillResourceDerivedListFromGraph(uniqueId, derivedFromList);
		if (!TitanOperationStatus.OK.equals(listFromGraphStatus)) {
			return listFromGraphStatus;
		}

		if (false == derivedFromList.isEmpty()) {
			if (derivedFromList.size() > 1) {
				List<String> lastDerivedFrom = new ArrayList<String>();
				lastDerivedFrom.add(derivedFromList.get(1));
				resource.setDerivedFrom(lastDerivedFrom);
				resource.setDerivedList(derivedFromList);
			} else {
				resource.setDerivedFrom(null);
				resource.setDerivedList(derivedFromList);
			}

		}

		return TitanOperationStatus.OK;
	}

	public TitanOperationStatus fillResourceDerivedListFromGraph(String uniqueId, List<String> derivedFromList) {
		// Either<List<ImmutablePair<ResourceMetadataData, GraphEdge>>,
		// TitanOperationStatus> childrenNodes =
		// titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource),
		// uniqueId, GraphEdgeLabels.DERIVED_FROM,
		// NodeTypeEnum.Resource, ResourceMetadataData.class);
		//
		// if (childrenNodes.isRight() && (childrenNodes.right().value() !=
		// TitanOperationStatus.NOT_FOUND)) {
		// return childrenNodes.right().value();
		// } else if (childrenNodes.isLeft()) {
		//
		// List<ImmutablePair<ResourceMetadataData, GraphEdge>> pairList =
		// childrenNodes.left().value();
		// for (ImmutablePair<ResourceMetadataData, GraphEdge> pair : pairList)
		// {
		// derivedFromList.add(pair.left.getMetadataDataDefinition().getName());
		// return
		// fillResourceDerivedListFromGraph(pair.left.getMetadataDataDefinition().getUniqueId(),
		// derivedFromList);
		// }
		// }
		List<ResourceMetadataData> derivedData = new ArrayList<ResourceMetadataData>();
		TitanOperationStatus findResourcesPathRecursively = findResourcesPathRecursively(uniqueId, derivedData);
		if (!findResourcesPathRecursively.equals(TitanOperationStatus.OK)) {
			return findResourcesPathRecursively;
		}
		derivedData.forEach(resourceData -> derivedFromList.add(((ResourceMetadataDataDefinition) resourceData.getMetadataDataDefinition()).getToscaResourceName()));
		return TitanOperationStatus.OK;
	}

	private TitanOperationStatus setResourceLastModifierFromGraph(Resource resource, String resourceId) {

		Either<ImmutablePair<UserData, GraphEdge>, TitanOperationStatus> parentNode = titanGenericDao.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.LAST_MODIFIER, NodeTypeEnum.User,
				UserData.class);
		if (parentNode.isRight()) {
			return parentNode.right().value();
		}

		ImmutablePair<UserData, GraphEdge> value = parentNode.left().value();
		if (log.isDebugEnabled())
			log.debug("Found parent node {}", value);
		UserData userData = value.getKey();

		if (log.isDebugEnabled()) {
			log.debug("Build resource : set last modifier userId to {}", userData.getUserId());
		}

		String fullName = buildFullName(userData);
		if (log.isDebugEnabled())
			log.debug("Build resource : set last modifier full name to {}", fullName);
		resource.setLastUpdaterUserId(userData.getUserId());
		resource.setLastUpdaterFullName(fullName);

		return TitanOperationStatus.OK;
	}

	private TitanOperationStatus setResourceCreatorFromGraph(Resource resource, String resourceId) {

		Either<ImmutablePair<UserData, GraphEdge>, TitanOperationStatus> parentNode = titanGenericDao.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.CREATOR, NodeTypeEnum.User, UserData.class);
		if (parentNode.isRight()) {
			log.debug("Failed to find the creator of resource {}", resourceId);
			return parentNode.right().value();
		}

		ImmutablePair<UserData, GraphEdge> value = parentNode.left().value();
		if (log.isDebugEnabled())
			log.debug("Found parent node {}", value);
		UserData userData = value.getKey();
		if (log.isDebugEnabled()) {
			log.debug("Build resource : set creator userId to {}", userData.getUserId());
		}
		String fullName = buildFullName(userData);
		if (log.isDebugEnabled())
			log.debug("Build resource : set creator full name to {}", fullName);
		resource.setCreatorUserId(userData.getUserId());
		resource.setCreatorFullName(fullName);

		return TitanOperationStatus.OK;
	}

	@Override
	TitanOperationStatus setComponentCategoriesFromGraph(Component resource) {
		String uniqueId = resource.getUniqueId();
		Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> parentNode = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), uniqueId, GraphEdgeLabels.CATEGORY,
				NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
		if (parentNode.isRight()) {
			return parentNode.right().value();
		}

		List<ImmutablePair<SubCategoryData, GraphEdge>> listValue = parentNode.left().value();
		log.debug("Result after looking for subcategory nodes pointed by resource {}. status is {}", uniqueId, listValue);
		if (listValue.size() > 1) {
			log.error("Multiple edges foud between resource {} to subcategory nodes.", uniqueId);
		}
		ImmutablePair<SubCategoryData, GraphEdge> value = listValue.get(0);
		log.debug("Found parent node {}", value);

		SubCategoryData subcategoryData = value.getKey();

		Either<ImmutablePair<CategoryData, GraphEdge>, TitanOperationStatus> categoryNode = titanGenericDao.getParentNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceSubcategory), (String) subcategoryData.getUniqueId(),
				GraphEdgeLabels.SUB_CATEGORY, NodeTypeEnum.ResourceNewCategory, CategoryData.class);
		if (categoryNode.isRight()) {
			return categoryNode.right().value();
		}

		CategoryData categoryData = categoryNode.left().value().left;
		CategoryDefinition catDef = new CategoryDefinition(categoryData.getCategoryDataDefinition());
		SubCategoryDefinition subcatDef = new SubCategoryDefinition(subcategoryData.getSubCategoryDataDefinition());

		resource.addCategory(catDef, subcatDef);
		return TitanOperationStatus.OK;
	}

	public String buildFullName(UserData userData) {

		String fullName = userData.getFirstName();
		if (fullName == null) {
			fullName = "";
		} else {
			fullName = fullName + " ";
		}
		String lastName = userData.getLastName();
		if (lastName != null) {
			fullName += lastName;
		}
		return fullName;
	}

	private Resource convertResourceDataToResource(ResourceMetadataData resourceData) {

		ResourceMetadataDefinition resourceMetadataDataDefinition = new ResourceMetadataDefinition((ResourceMetadataDataDefinition) resourceData.getMetadataDataDefinition());

		Resource resource = new Resource(resourceMetadataDataDefinition);

		return resource;
	}

	@Override
	public Either<Resource, StorageOperationStatus> deleteResource(String resourceId) {
		return deleteResource(resourceId, false);
	}

	@Override
	public Either<Resource, StorageOperationStatus> updateResource(Resource resource) {

		return updateResource(resource, false);

	}

	@Override
	public Either<Integer, StorageOperationStatus> getNumberOfResourcesByName(String resourceName) {

		Map<String, Object> propertiesToMatch = new HashMap<String, Object>();
		propertiesToMatch.put(GraphPropertiesDictionary.NAME.getProperty(), resourceName);

		Either<List<ResourceMetadataData>, TitanOperationStatus> getParentResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
		log.debug("result after searching for resources called " + resourceName + " is " + getParentResources);
		if (getParentResources.isRight()) {
			TitanOperationStatus titanStatus = getParentResources.right().value();
			if (titanStatus == TitanOperationStatus.NOT_FOUND) {
				log.debug("Number of returned resources is 0.");
				return Either.left(0);
			}
			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus));
		} else {
			List<ResourceMetadataData> value = getParentResources.left().value();
			int numberOFResources = (value == null ? 0 : value.size());
			log.debug("The number of resources returned after searching for resource called " + resourceName + " is " + numberOFResources);
			return Either.left(numberOFResources);
		}
	}

	public PropertyOperation getPropertyOperation() {
		return propertyOperation;
	}

	public void setPropertyOperation(PropertyOperation propertyOperation) {
		this.propertyOperation = propertyOperation;
	}

	public RequirementOperation getRequirementOperation() {
		return requirementOperation;
	}

	public void setRequirementOperation(RequirementOperation requirementOperation) {
		this.requirementOperation = requirementOperation;
	}

	public CapabilityOperation getCapabilityOperation() {
		return capabilityOperation;
	}

	public void setCapabilityOperation(CapabilityOperation capabilityOperation) {
		this.capabilityOperation = capabilityOperation;
	}

	public IArtifactOperation getArtifactOperation() {
		return artifactOperation;
	}

	public void setArtifactOperation(IArtifactOperation artifactOperation) {
		this.artifactOperation = artifactOperation;
	}

	public InterfaceLifecycleOperation getInterfaceLifecycleOperation() {
		return interfaceLifecycleOperation;
	}

	public void setInterfaceLifecycleOperation(InterfaceLifecycleOperation interfaceLifecycleOperation) {
		this.interfaceLifecycleOperation = interfaceLifecycleOperation;
	}

	public TitanGenericDao getTitanGenericDao() {
		return titanGenericDao;
	}

	public IElementOperation getElementOperation() {
		return elementOperation;
	}

	public void setElementOperation(IElementOperation elementOperation) {
		this.elementOperation = elementOperation;
	}

	/**
	 * FOR TEST ONLY
	 * 
	 * @param titanGenericDao
	 */
	public void setTitanGenericDao(TitanGenericDao titanGenericDao) {
		this.titanGenericDao = titanGenericDao;
	}

	@Override
	public Either<List<Resource>, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract) {

		return getAllCertifiedResources(isAbstract, null);

	}

	@Override
	/**
	 * Deletes the resource node, property nodes and relation to artifacts. MUST handle deletion of artifact from artifacts repository outside this method (in catalog-be)
	 */
	public Either<Resource, StorageOperationStatus> deleteResource(String resourceId, boolean inTransaction) {

		Either<Resource, StorageOperationStatus> result = Either.right(StorageOperationStatus.GENERAL_ERROR);
		try {

			Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
			if (graphResult.isRight()) {
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(graphResult.right().value()));
				return result;
			}

			TitanGraph titanGraph = graphResult.left().value();
			Iterable<TitanVertex> vertecies = titanGraph.query().has(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId).vertices();
			Either<Resource, StorageOperationStatus> resourceEither = getResource(resourceId, true);
			Resource resource = resourceEither.left().value();
			if (vertecies != null && resourceEither.isLeft()) {
				Iterator<TitanVertex> iterator = vertecies.iterator();
				if (iterator != null && iterator.hasNext()) {
					Vertex rootVertex = iterator.next();
					TitanOperationStatus deleteChildrenNodes = graphDeleteUtil.deleteChildrenNodes(rootVertex, GraphEdgeLabels.PROPERTY);
					log.debug("After deleting properties nodes in the graph. status is " + deleteChildrenNodes);
					if (deleteChildrenNodes != TitanOperationStatus.OK) {
						result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteChildrenNodes));
						return result;
					}
					StorageOperationStatus removeInterfacesFromResource = removeInterfacesFromResource(resource);
					log.debug("After deleting interfaces nodes in the graph. status is " + removeInterfacesFromResource);
					if (!removeInterfacesFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeInterfacesFromResource);
						return result;
					}
					StorageOperationStatus removeArtifactsFromResource = removeArtifactsFromResource(resource);
					log.debug("After deleting artifacts nodes in the graph. status is " + removeArtifactsFromResource);
					if (!removeArtifactsFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeArtifactsFromResource);
						return result;
					}
					StorageOperationStatus removeCapabilitiesFromResource = removeCapabilitiesFromResource(resource);
					log.debug("After deleting capabilities nodes in the graph. status is " + removeCapabilitiesFromResource);
					if (!removeCapabilitiesFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeCapabilitiesFromResource);
						return result;
					}

					StorageOperationStatus removeRequirementsFromResource = removeRequirementsFromResource(resource);
					log.debug("After deleting requirements nodes in the graph. status is " + removeRequirementsFromResource);
					if (!removeRequirementsFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeRequirementsFromResource);
						return result;
					}

					StorageOperationStatus removeRIsFromResource = removeResourceInstanceFromResource(resource);
					log.debug("After deleting resource instance nodes in the graph. status is " + removeRIsFromResource);
					if (!removeRIsFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeRIsFromResource);
						return result;
					}

					StorageOperationStatus removeAttributesFromResource = removeAttributesFromResource(resource);
					log.debug("After deleting requirements nodes in the graph. status is " + removeRequirementsFromResource);
					if (removeAttributesFromResource != StorageOperationStatus.OK) {
						result = Either.right(removeAttributesFromResource);
						return result;
					}

					StorageOperationStatus removeInputsFromResource = removeInputsFromComponent(NodeTypeEnum.Resource, resource);
					log.debug("After deleting requirements nodes in the graph. status is " + removeInputsFromResource);
					if (removeInputsFromResource != StorageOperationStatus.OK) {
						result = Either.right(removeInputsFromResource);
						return result;
					}

					StorageOperationStatus removeAdditionalInformationFromResource = super.deleteAdditionalInformation(NodeTypeEnum.Resource, resource.getUniqueId());
					log.debug("After deleting additional information node in the graph. status is " + removeAdditionalInformationFromResource);
					if (!removeAdditionalInformationFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeAdditionalInformationFromResource);
						return result;
					}

					StorageOperationStatus removeGroupsFromResource = super.deleteGroups(NodeTypeEnum.Resource, resource.getUniqueId());
					log.debug("After deleting group nodes in the graph. status is " + removeGroupsFromResource);
					if (!removeGroupsFromResource.equals(StorageOperationStatus.OK)) {
						result = Either.right(removeGroupsFromResource);
						return result;
					}

					rootVertex.remove();

				} else {
					result = Either.right(StorageOperationStatus.NOT_FOUND);
					return result;
				}
			} else {
				result = Either.right(StorageOperationStatus.NOT_FOUND);
				return result;
			}

			result = Either.left(resource);
			return result;
		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.error("deleteResource operation : Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("deleteResource operation : Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}
		}

	}

	private StorageOperationStatus removeAttributesFromResource(Resource resource) {
		Either<Map<String, AttributeDefinition>, StorageOperationStatus> deleteAllAttributeAssociatedToNode = attributeOperation.deleteAllAttributeAssociatedToNode(NodeTypeEnum.Resource, resource.getUniqueId());
		return deleteAllAttributeAssociatedToNode.isRight() ? deleteAllAttributeAssociatedToNode.right().value() : StorageOperationStatus.OK;
	}

	private StorageOperationStatus removeArtifactsFromResource(Resource resource) {

		String resourceId = resource.getUniqueId();
		Map<String, ArtifactDefinition> allArtifacts = new HashMap<String, ArtifactDefinition>();
		if (resource.getArtifacts() != null) {
			allArtifacts.putAll(resource.getArtifacts());
		}
		if (resource.getDeploymentArtifacts() != null) {
			allArtifacts.putAll(resource.getDeploymentArtifacts());
		}
		if (allArtifacts != null) {
			for (Entry<String, ArtifactDefinition> entry : allArtifacts.entrySet()) {

				ArtifactDefinition artifactDefinition = entry.getValue();
				Either<ArtifactDefinition, StorageOperationStatus> removeArifactFromResource = artifactOperation.removeArifactFromResource(resourceId, artifactDefinition.getUniqueId(), NodeTypeEnum.Resource, true, true);
				if (removeArifactFromResource.isRight()) {
					return removeArifactFromResource.right().value();
				}
			}
		}
		return StorageOperationStatus.OK;
	}

	private StorageOperationStatus removeInterfacesFromResource(Resource resource) {

		String resourceId = resource.getUniqueId();
		// delete only interfaces of this resource (not interfaces derived)
		Either<Map<String, InterfaceDefinition>, StorageOperationStatus> allInterfacesOfResource = interfaceLifecycleOperation.getAllInterfacesOfResource(resourceId, false, true);
		if (allInterfacesOfResource.isRight()) {
			log.error("failed to get interfaces for resource {}. status is {}", resourceId, allInterfacesOfResource.right().value());
			return allInterfacesOfResource.right().value();
		}
		Map<String, InterfaceDefinition> interfaces = allInterfacesOfResource.left().value();
		if (interfaces != null) {
			for (Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {
				Boolean isAbstract = resource.isAbstract();

				InterfaceDefinition interfaceDefinition = entry.getValue();
				// esofer - in case the resource is abstract, we deleting only
				// the edge to the interface.
				if (isAbstract != null && true == isAbstract.booleanValue()) {
					log.debug("Going to dissociate resource {} from interface {}", resourceId, interfaceDefinition.getUniqueId());
					UniqueIdData uniqueIdData = new UniqueIdData(NodeTypeEnum.Resource, resourceId);
					Either<InterfaceDefinition, StorageOperationStatus> dissociateInterfaceFromNode = interfaceLifecycleOperation.dissociateInterfaceFromNode(uniqueIdData, interfaceDefinition);
					if (dissociateInterfaceFromNode.isRight()) {
						log.error("failed to dissociate resource {} from interface {}. status is {}", resourceId, interfaceDefinition.getUniqueId(), dissociateInterfaceFromNode.right().value());
						return dissociateInterfaceFromNode.right().value();
					}
				} else {
					Either<InterfaceDefinition, StorageOperationStatus> deleteInterfaceOfResourceOnGraph = interfaceLifecycleOperation.deleteInterfaceOfResourceOnGraph(resourceId, interfaceDefinition, true);
					if (deleteInterfaceOfResourceOnGraph.isRight()) {
						return deleteInterfaceOfResourceOnGraph.right().value();
					}
				}
			}
		}
		return StorageOperationStatus.OK;
	}

	private StorageOperationStatus removeCapabilitiesFromResource(Resource resource) {

		String resourceId = resource.getUniqueId();

		Either<Map<String, CapabilityDefinition>, StorageOperationStatus> deleteAllRes = capabilityOperation.deleteAllCapabilities(resourceId, true);
		if (deleteAllRes.isRight()) {
			StorageOperationStatus status = deleteAllRes.right().value();
			if (status == StorageOperationStatus.NOT_FOUND) {
				return StorageOperationStatus.OK;
			}
			return status;
		}

		return StorageOperationStatus.OK;

	}

	private StorageOperationStatus removeRequirementsFromResource(Resource resource) {

		String resourceId = resource.getUniqueId();

		Either<Map<String, RequirementDefinition>, StorageOperationStatus> deleteAllRes = requirementOperation.deleteAllRequirements(resourceId, true);

		if (deleteAllRes.isRight()) {
			StorageOperationStatus status = deleteAllRes.right().value();
			if (status == StorageOperationStatus.NOT_FOUND) {
				return StorageOperationStatus.OK;
			}
			return status;
		}

		return StorageOperationStatus.OK;

	}

	private StorageOperationStatus removeResourceInstanceFromResource(Resource resource) {
		String resourceId = resource.getUniqueId();

		Either<List<ComponentInstance>, StorageOperationStatus> deleteAllResourceInstancesRes = componentInstanceOperation.deleteAllComponentInstances(resourceId, NodeTypeEnum.Resource, true);
		if (deleteAllResourceInstancesRes.isRight()) {
			StorageOperationStatus status = deleteAllResourceInstancesRes.right().value();
			if (status == StorageOperationStatus.NOT_FOUND) {
				return StorageOperationStatus.OK;
			}
			return status;
		}
		return StorageOperationStatus.OK;
	}

	@Override
	public Either<Resource, StorageOperationStatus> updateResource(Resource resource, boolean inTransaction) {
		return (Either<Resource, StorageOperationStatus>) updateComponent(resource, inTransaction, titanGenericDao, resource.getClass(), NodeTypeEnum.Resource);

	}

	@Override
	protected <T extends Component> StorageOperationStatus updateDerived(Component component, Component currentComponent, ComponentMetadataData updatedResourceData, Class<T> clazz) {
		Resource resource = (Resource) component;
		Resource currentResource = (Resource) currentComponent;
		if (resource.getDerivedFrom() != null) {// meaning derived from changed

			Either<List<ResourceMetadataData>, StorageOperationStatus> findDerivedResourcesOld = findDerivedResources(currentResource);
			if (findDerivedResourcesOld.isRight()) {
				log.debug("Couldn't find derived resource {} for current resource in the graph", currentResource.getDerivedFrom().get(0));
				return findDerivedResourcesOld.right().value();
			}

			List<ResourceMetadataData> oldDerived = findDerivedResourcesOld.left().value();
			if (oldDerived.isEmpty()) {
				log.debug("Derived from list fetched from DB for current resource is empty");
				return StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND;
			}

			Either<List<ResourceMetadataData>, StorageOperationStatus> findDerivedResourcesNew = findDerivedResources((Resource) resource);
			if (findDerivedResourcesNew.isRight()) {
				log.debug("Couldn't find derived resource {} for update resource in the graph", resource.getDerivedFrom().get(0));
				return findDerivedResourcesNew.right().value();
			}

			List<ResourceMetadataData> newDerived = findDerivedResourcesNew.left().value();
			if (newDerived.isEmpty()) {
				log.debug("Derived from list fetched from DB for updated resource is empty");
				return StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND;
			}

			Either<Boolean, TitanOperationStatus> reassociateDerivedFrom = reassociateDerivedFrom((ResourceMetadataData) updatedResourceData, oldDerived, newDerived);
			if (reassociateDerivedFrom.isRight()) {
				log.debug("Couldn't change derived from for the resoure");
				return DaoStatusConverter.convertTitanStatusToStorageStatus(reassociateDerivedFrom.right().value());
			}
		}
		return StorageOperationStatus.OK;
	}

	private Either<Boolean, TitanOperationStatus> reassociateDerivedFrom(ResourceMetadataData resourceData, List<ResourceMetadataData> oldDerived, List<ResourceMetadataData> newDerived) {
		ResourceMetadataData oldDerivedNode = oldDerived.get(0);
		log.debug("Dissociating resource {} from old parent resource {}", resourceData.getUniqueId(), oldDerivedNode.getUniqueId());
		Either<GraphRelation, TitanOperationStatus> deleteRelation = titanGenericDao.deleteRelation(resourceData, oldDerivedNode, GraphEdgeLabels.DERIVED_FROM);
		if (deleteRelation.isRight()) {
			log.debug("Failed to dissociate resource {} from old parent resource {}", resourceData.getUniqueId(), oldDerivedNode.getUniqueId());
			return Either.right(deleteRelation.right().value());
		}
		ResourceMetadataData newDerivedNode = newDerived.get(0);
		log.debug("Associating resource {} with new parent resource {}", resourceData.getUniqueId(), newDerivedNode.getUniqueId());
		Either<GraphRelation, TitanOperationStatus> addRelation = titanGenericDao.createRelation(resourceData, newDerivedNode, GraphEdgeLabels.DERIVED_FROM, null);
		if (addRelation.isRight()) {
			log.debug("Failed to associate resource {} with new parent resource {}", resourceData.getUniqueId(), newDerivedNode.getUniqueId());
			return Either.right(addRelation.right().value());
		}

		return Either.left(true);
	}

	private StorageOperationStatus moveCategoryEdge(Resource resource, ResourceMetadataData resourceData, CategoryDefinition newCategory) {

		StorageOperationStatus result = StorageOperationStatus.OK;

		GraphRelation categoryRelation = new GraphRelation();
		categoryRelation.setType(GraphEdgeLabels.CATEGORY.getProperty());
		RelationEndPoint relationEndPoint = new RelationEndPoint(NodeTypeEnum.Resource, UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resource.getUniqueId());
		categoryRelation.setFrom(relationEndPoint);
		Either<GraphRelation, TitanOperationStatus> deleteOutgoingRelation = titanGenericDao.deleteOutgoingRelation(categoryRelation);
		if (deleteOutgoingRelation.isRight()) {
			log.error("Failed to delete category from resource " + resourceData.getUniqueId() + ". Edge type is " + GraphEdgeLabels.CATEGORY);
			result = DaoStatusConverter.convertTitanStatusToStorageStatus(deleteOutgoingRelation.right().value());
			return result;
		}

		log.debug("After removing edge from graph " + deleteOutgoingRelation);

		return assosiateMetadataToCategory(resource, resourceData);
	}

	private StorageOperationStatus moveLastModifierEdge(Resource resource, ResourceMetadataData resourceData, UserData modifierUserData) {

		StorageOperationStatus result = StorageOperationStatus.OK;

		GraphRelation lastModifierRelation = new GraphRelation();
		lastModifierRelation.setType(GraphEdgeLabels.LAST_MODIFIER.getProperty());
		RelationEndPoint relationEndPoint = new RelationEndPoint(NodeTypeEnum.Resource, UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resource.getUniqueId());
		lastModifierRelation.setTo(relationEndPoint);
		Either<GraphRelation, TitanOperationStatus> deleteIncomingRelation = titanGenericDao.deleteIncomingRelation(lastModifierRelation);
		if (deleteIncomingRelation.isRight()) {
			log.error("Failed to delete user from resource " + resourceData.getUniqueId() + ". Edge type is " + GraphEdgeLabels.LAST_MODIFIER);
			result = DaoStatusConverter.convertTitanStatusToStorageStatus(deleteIncomingRelation.right().value());
			return result;
		}

		Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(modifierUserData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null);
		log.debug("After associating user " + modifierUserData + " to resource " + resourceData.getUniqueId() + ". Edge type is " + GraphEdgeLabels.LAST_MODIFIER);
		if (createRelation.isRight()) {
			log.error("Failed to associate user " + modifierUserData + " to resource " + resourceData.getUniqueId() + ". Edge type is " + GraphEdgeLabels.LAST_MODIFIER);
			result = DaoStatusConverter.convertTitanStatusToStorageStatus(createRelation.right().value());
			return result;
		}

		return result;
	}

	private Either<ResourceMetadataData, TitanOperationStatus> findResource(String resourceId) {

		String key = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource);
		Either<ResourceMetadataData, TitanOperationStatus> findResource = titanGenericDao.getNode(key, resourceId, ResourceMetadataData.class);

		return findResource;
	}

	private StorageOperationStatus setArtifactFromGraph(String uniqueId, Resource resource) {
		StorageOperationStatus result = StorageOperationStatus.OK;
		Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifacts = artifactOperation.getArtifacts(uniqueId, NodeTypeEnum.Resource, true);
		if (artifacts.isRight()) {
			result = artifacts.right().value();
		} else {
			createSpecificArtifactList(resource, artifacts.left().value());
		}
		return result;
	}

	@Override
	public <T extends Component> Either<T, StorageOperationStatus> getComponent(String id, Class<T> clazz) {

		Either<Resource, StorageOperationStatus> component = getResource(id);
		if (component.isRight()) {
			return Either.right(component.right().value());
		}
		return Either.left(clazz.cast(component.left().value()));
	}

	@Override
	public Either<Boolean, StorageOperationStatus> validateResourceNameExists(String resourceName, ResourceTypeEnum resourceType) {
		if (resourceType != null) {
			Map<String, Object> properties = new HashMap<String, Object>();
			properties.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());
			if (resourceType.equals(ResourceTypeEnum.VF)) {
				return validateResourceNameUniqueness(resourceName, properties, null, titanGenericDao);
			} else {
				return validateResourceNameUniqueness(resourceName, null, properties, titanGenericDao);
			}

		} else {
			return validateResourceNameUniqueness(resourceName, null, null, titanGenericDao);
		}

	}

	public Either<Boolean, StorageOperationStatus> validateToscaResourceNameExists(String templateName) {
		return validateToscaResourceNameUniqueness(templateName, titanGenericDao);
	}

	public Either<List<ArtifactDefinition>, StorageOperationStatus> getAdditionalArtifacts(String resourceId, boolean recursively, boolean inTransaction) {
		List<ArtifactDefinition> artifacts = new ArrayList<>();

		Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfacesOfResource = interfaceLifecycleOperation.getAllInterfacesOfResource(resourceId, false, true);
		if (interfacesOfResource.isRight()) {
			log.error("failed to get all resource interfaces. resource id={}. status ={}", resourceId, interfacesOfResource.right().value());
			return Either.right(interfacesOfResource.right().value());
		}

		Map<String, InterfaceDefinition> interfaces = interfacesOfResource.left().value();
		if (interfaces != null && !interfaces.isEmpty()) {
			for (Entry<String, InterfaceDefinition> entry : interfaces.entrySet()) {

				InterfaceDefinition interfaceDefinition = entry.getValue();
				Map<String, Operation> operations = interfaceDefinition.getOperations();
				if (operations != null && !operations.isEmpty()) {
					for (Entry<String, Operation> opEntry : operations.entrySet()) {

						Operation operation = opEntry.getValue();
						ArtifactDefinition artifactDefinition = operation.getImplementation();
						if (artifactDefinition != null) {
							artifacts.add(artifactDefinition);
						}
					}
				}
			}
		}
		return Either.left(artifacts);
	}

	@SuppressWarnings("unchecked")
	public Either<List<Resource>, StorageOperationStatus> getFollowed(String userId, Set<LifecycleStateEnum> lifecycleStates, Set<LifecycleStateEnum> lastStateStates, boolean inTransaction) {
		return (Either<List<Resource>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getFollowedComponent(userId, lifecycleStates, lastStateStates, inTransaction, titanGenericDao, NodeTypeEnum.Resource);
	}

	@SuppressWarnings("unchecked")
	@Override
	public <T> Either<T, StorageOperationStatus> getComponent(String id, boolean inTransaction) {
		return (Either<T, StorageOperationStatus>) getResource(id, inTransaction);
	}

	private Optional<ImmutablePair<SubCategoryData, GraphEdge>> validateCategoryHierarcy(List<ImmutablePair<SubCategoryData, GraphEdge>> childNodes, String subCategoryName) {
		Predicate<ImmutablePair<SubCategoryData, GraphEdge>> matchName = p -> p.getLeft().getSubCategoryDataDefinition().getName().equals(subCategoryName);
		return childNodes.stream().filter(matchName).findAny();
	}

	private Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, StorageOperationStatus> getAllSubCategories(String categoryName) {
		Either<CategoryData, StorageOperationStatus> categoryResult = elementOperation.getNewCategoryData(categoryName, NodeTypeEnum.ResourceNewCategory, CategoryData.class);
		if (categoryResult.isRight()) {
			return Either.right(categoryResult.right().value());
		}
		CategoryData categoryData = categoryResult.left().value();

		Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceNewCategory), (String) categoryData.getUniqueId(),
				GraphEdgeLabels.SUB_CATEGORY, NodeTypeEnum.ResourceSubcategory, SubCategoryData.class);
		if (childrenNodes.isRight()) {
			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childrenNodes.right().value()));
		}
		return Either.left(childrenNodes.left().value());
	}

	@Override
	public <T> Either<List<T>, StorageOperationStatus> getFilteredComponents(Map<FilterKeyEnum, String> filters, boolean inTransaction) {

		String subCategoryName = filters.get(FilterKeyEnum.SUB_CATEGORY);
		String categoryName = filters.get(FilterKeyEnum.CATEGORY);
		Either<List<ImmutablePair<SubCategoryData, GraphEdge>>, StorageOperationStatus> subcategories = null;
		Optional<ImmutablePair<SubCategoryData, GraphEdge>> subCategoryData = null;

		if (categoryName != null) {
			subcategories = getAllSubCategories(categoryName);
			if (subcategories.isRight()) {
				filters.remove(FilterKeyEnum.SUB_CATEGORY);
				return Either.right(subcategories.right().value());
			}
		}
		if (subCategoryName != null) { // primary filter
			if (categoryName != null) {
				subCategoryData = validateCategoryHierarcy(subcategories.left().value(), subCategoryName);
				if (!subCategoryData.isPresent()) {
					return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
				}
				return fetchByCategoryOrSubCategoryUid((String) subCategoryData.get().getLeft().getUniqueId(), NodeTypeEnum.ResourceSubcategory, GraphEdgeLabels.SUB_CATEGORY.getProperty(), NodeTypeEnum.Resource, inTransaction,
						ResourceMetadataData.class);
			}

			return fetchByCategoryOrSubCategoryName(subCategoryName, NodeTypeEnum.ResourceSubcategory, GraphEdgeLabels.SUB_CATEGORY.getProperty(), NodeTypeEnum.Resource, inTransaction, ResourceMetadataData.class);
		}
		return fetchByMainCategory(subcategories.left().value(), inTransaction);
	}

	private <T> Either<List<T>, StorageOperationStatus> fetchByMainCategory(List<ImmutablePair<SubCategoryData, GraphEdge>> subcategories, boolean inTransaction) {
		List<T> components = new ArrayList<>();

		for (ImmutablePair<SubCategoryData, GraphEdge> subCategory : subcategories) {
			Either<List<T>, StorageOperationStatus> fetched = fetchByCategoryOrSubCategoryUid((String) subCategory.getLeft().getUniqueId(), NodeTypeEnum.ResourceSubcategory, GraphEdgeLabels.SUB_CATEGORY.getProperty(), NodeTypeEnum.Resource,
					inTransaction, ResourceMetadataData.class);
			if (fetched.isRight()) {
				// return fetched;
				continue;
			}
			components.addAll(fetched.left().value());
		}
		return Either.left(components);
	}

	@Override
	public <T> Either<T, StorageOperationStatus> getLightComponent(String id, boolean inTransaction) {
		return getLightComponent(id, NodeTypeEnum.Resource, inTransaction);
	}

	// will be implement later
	@Override
	protected ComponentMetadataData getMetaDataFromComponent(Component component) {
		return getResourceMetaDataFromResource((Resource) component);
	}

	@Override
	public Either<Set<Resource>, StorageOperationStatus> getCatalogData(Map<String, Object> propertiesToMatch, boolean inTransaction) {
		return getComponentCatalogData(NodeTypeEnum.Resource, propertiesToMatch, Resource.class, ResourceMetadataData.class, inTransaction);
	}

	protected TitanOperationStatus findResourcesPathRecursively(String resourceId, List<ResourceMetadataData> resourcesPathList) {

		Either<ResourceMetadataData, TitanOperationStatus> nodeRes = this.titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, ResourceMetadataData.class);

		if (nodeRes.isRight()) {
			TitanOperationStatus status = nodeRes.right().value();
			log.error("Failed to fetch resource {} . status is {}", resourceId, status);
			return status;
		}

		ResourceMetadataData resourceData = nodeRes.left().value();
		resourcesPathList.add(resourceData);
		Either<ImmutablePair<ResourceMetadataData, GraphEdge>, TitanOperationStatus> parentResourceRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM,
				NodeTypeEnum.Resource, ResourceMetadataData.class);

		while (parentResourceRes.isLeft()) {

			ImmutablePair<ResourceMetadataData, GraphEdge> value = parentResourceRes.left().value();
			ResourceMetadataData parentResourceData = value.getKey();

			resourcesPathList.add(parentResourceData);

			parentResourceRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), parentResourceData.getMetadataDataDefinition().getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
					ResourceMetadataData.class);
		}

		TitanOperationStatus operationStatus = parentResourceRes.right().value();

		if (operationStatus != TitanOperationStatus.NOT_FOUND) {
			return operationStatus;
		} else {
			return TitanOperationStatus.OK;
		}

	}

	@SuppressWarnings("unchecked")
	@Override
	public <T> Either<T, StorageOperationStatus> updateComponent(T component, boolean inTransaction) {
		return (Either<T, StorageOperationStatus>) updateResource((Resource) component, inTransaction);
	}

	@SuppressWarnings("unchecked")
	@Override
	public Either<Component, StorageOperationStatus> deleteComponent(String id, boolean inTransaction) {
		return (Either<Component, StorageOperationStatus>) (Either<?, StorageOperationStatus>) deleteResource(id, inTransaction);
	}

	@Override
	public Either<Resource, StorageOperationStatus> getLatestByToscaResourceName(String toscaResourceName, boolean inTransaction) {
		return getLatestByName(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), toscaResourceName, inTransaction);

	}

	@Override
	public Either<Resource, StorageOperationStatus> getLatestByName(String resourceName, boolean inTransaction) {
		return getLatestByName(GraphPropertiesDictionary.NAME.getProperty(), resourceName, inTransaction);

	}

	private Either<Resource, StorageOperationStatus> getLatestByName(String property, String resourceName, boolean inTransaction) {
		Either<Resource, StorageOperationStatus> result = null;
		try {
			Map<String, Object> props = new HashMap<String, Object>();
			props.put(property, resourceName);
			props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);

			Either<List<ResourceMetadataData>, TitanOperationStatus> highestResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
			if (highestResources.isRight()) {
				TitanOperationStatus status = highestResources.right().value();
				log.debug("failed to find resource with name {}. status={} ", resourceName, status);
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				return result;
			}

			List<ResourceMetadataData> resources = highestResources.left().value();
			double version = 0.0;
			ResourceMetadataData highestResource = null;
			for (ResourceMetadataData resource : resources) {
				double resourceVersion = Double.parseDouble(resource.getMetadataDataDefinition().getVersion());
				if (resourceVersion > version) {
					version = resourceVersion;
					highestResource = resource;
				}
			}
			result = getResource(highestResource.getMetadataDataDefinition().getUniqueId(), true);
			return result;

		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.error("getLatestByName operation : Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("getLatestByName operation : Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}

		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public Either<List<Resource>, StorageOperationStatus> getTesterFollowed(String userId, Set<LifecycleStateEnum> lifecycleStates, boolean inTransaction) {
		return (Either<List<Resource>, StorageOperationStatus>) (Either<?, StorageOperationStatus>) getTesterFollowedComponent(userId, lifecycleStates, inTransaction, NodeTypeEnum.Resource);
	}

	@Override
	public Either<List<Resource>, StorageOperationStatus> getResourceCatalogData(boolean inTransaction) {
		return getResourceCatalogData(inTransaction, null);
	}

	private Either<List<Resource>, StorageOperationStatus> getResourceCatalogData(boolean inTransaction, Map<String, Object> otherToMatch) {

		long start = System.currentTimeMillis();

		long startFetchAllStates = System.currentTimeMillis();
		Map<String, Object> propertiesToMatchHigest = new HashMap<>();
		propertiesToMatchHigest.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
		propertiesToMatchHigest.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false);
		Either<List<ResourceMetadataData>, TitanOperationStatus> allHighestStates = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatchHigest, ResourceMetadataData.class);
		if (allHighestStates.isRight() && allHighestStates.right().value() != TitanOperationStatus.NOT_FOUND) {
			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(allHighestStates.right().value()));
		}

		if (allHighestStates.isRight()) {
			return Either.left(new ArrayList<>());
		}
		List<ResourceMetadataData> list = allHighestStates.left().value();

		List<ResourceMetadataData> certified = new ArrayList<>();
		List<ResourceMetadataData> noncertified = new ArrayList<>();
		for (ResourceMetadataData reData : list) {
			if (reData.getMetadataDataDefinition().getState().equals(LifecycleStateEnum.CERTIFIED.name())) {
				certified.add(reData);
			} else {
				noncertified.add(reData);
			}
		}

		long endFetchAll = System.currentTimeMillis();
		log.debug("Fetch catalog resources all states: certified {}, noncertified {}", certified.size(), noncertified.size());
		log.debug("Fetch catalog resources all states from graph took {} ms", endFetchAll - startFetchAllStates);

		try {
			List<ResourceMetadataData> notCertifiedHighest = noncertified;
			List<ResourceMetadataData> certifiedHighestList = certified;

			HashMap<String, String> VFNames = new HashMap<>();
			HashMap<String, String> VFCNames = new HashMap<>();
			for (ResourceMetadataData data : notCertifiedHighest) {
				String serviceName = data.getMetadataDataDefinition().getName();
				if (((ResourceMetadataDataDefinition) data.getMetadataDataDefinition()).getResourceType().equals(ResourceTypeEnum.VF)) {
					VFNames.put(serviceName, serviceName);
				} else {
					VFCNames.put(serviceName, serviceName);
				}
			}

			for (ResourceMetadataData data : certifiedHighestList) {
				String serviceName = data.getMetadataDataDefinition().getName();
				if (((ResourceMetadataDataDefinition) data.getMetadataDataDefinition()).getResourceType().equals(ResourceTypeEnum.VF)) {
					if (!VFNames.containsKey(serviceName)) {
						notCertifiedHighest.add(data);
					}
				} else {
					if (!VFCNames.containsKey(serviceName)) {
						notCertifiedHighest.add(data);
					}
				}
			}

			long endFetchAllFromGraph = System.currentTimeMillis();
			log.debug("Fetch all catalog resources metadata from graph took {} ms", endFetchAllFromGraph - start);

			long startFetchAllFromCache = System.currentTimeMillis();

			List<Resource> result = new ArrayList<>();

			Map<String, Long> components = notCertifiedHighest.stream().collect(Collectors.toMap(p -> p.getMetadataDataDefinition().getUniqueId(), p -> p.getMetadataDataDefinition().getLastUpdateDate()));

			Either<ImmutablePair<List<Component>, Set<String>>, ActionStatus> componentsForCatalog = componentCache.getComponentsForCatalog(components, ComponentTypeEnum.RESOURCE);
			if (componentsForCatalog.isLeft()) {
				ImmutablePair<List<Component>, Set<String>> immutablePair = componentsForCatalog.left().value();
				List<Component> foundComponents = immutablePair.getLeft();
				if (foundComponents != null) {
					foundComponents.forEach(p -> result.add((Resource) p));
					log.debug("The number of resources added to catalog from cache is {}", foundComponents.size());

					List<String> foundComponentsUid = foundComponents.stream().map(p -> p.getUniqueId()).collect(Collectors.toList());
					notCertifiedHighest = notCertifiedHighest.stream().filter(p -> false == foundComponentsUid.contains(p.getUniqueId())).collect(Collectors.toList());
				}
				Set<String> nonCachedComponents = immutablePair.getRight();
				int numberNonCached = nonCachedComponents == null ? 0 : nonCachedComponents.size();
				log.debug("The number of left resources for catalog is {}", numberNonCached);

			}

			long endFetchAllFromCache = System.currentTimeMillis();
			log.debug("Fetch all catalog resources metadata from cache took " + (endFetchAllFromCache - startFetchAllFromCache) + " ms");

			long startFetchFromGraph = System.currentTimeMillis();
			log.debug("The number of resources needed to be fetch as light component is {}", notCertifiedHighest.size());
			for (ResourceMetadataData data : notCertifiedHighest) {
				String uniqueId = data.getMetadataDataDefinition().getUniqueId();
				log.trace("Fetch catalog resource non cached {} {}", uniqueId, data.getMetadataDataDefinition().getName());
				Either<Resource, StorageOperationStatus> component = getLightComponent(uniqueId, inTransaction);
				if (component.isRight()) {
					log.debug("Failed to get Service for id =  " + data.getUniqueId() + "  error : " + component.right().value() + " skip resource");
				} else {
					result.add(component.left().value());
				}
			}
			long endFetchFromGraph = System.currentTimeMillis();
			log.debug("Fetch catalog resources from graph took " + (endFetchFromGraph - startFetchFromGraph) + " ms");

			return Either.left(result);

		} finally {
			long end = System.currentTimeMillis();
			log.debug("Fetch all catalog resources took {} ms", end - start);
			if (false == inTransaction) {
				titanGenericDao.commit();
			}
		}
	}

	public Either<List<Resource>, StorageOperationStatus> getResourceCatalogDataVFLatestCertifiedAndNonCertified(boolean inTransaction) {
		Map<String, Object> propertiesToMatch = new HashMap<>();
		propertiesToMatch.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ResourceTypeEnum.VF.name());

		return getResourceCatalogDataLatestCertifiedAndNonCertified(inTransaction, propertiesToMatch);
	}

	private Either<List<Resource>, StorageOperationStatus> getResourceCatalogDataLatestCertifiedAndNonCertified(boolean inTransaction, Map<String, Object> otherToMatch) {
		Map<String, Object> propertiesToMatch = new HashMap<>();

		if (otherToMatch != null) {
			propertiesToMatch.putAll(otherToMatch);
		}

		propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);

		Either<List<ResourceMetadataData>, TitanOperationStatus> lastVersionNodes = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);

		List<Resource> result = new ArrayList<>();

		if (lastVersionNodes.isRight() && lastVersionNodes.right().value() != TitanOperationStatus.NOT_FOUND) {
			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(lastVersionNodes.right().value()));
		}

		List<ResourceMetadataData> listOfHighest;

		if (lastVersionNodes.isLeft()) {
			listOfHighest = lastVersionNodes.left().value();
		} else {
			return Either.left(result);
		}

		for (ResourceMetadataData data : listOfHighest) {
			Either<Resource, StorageOperationStatus> component = getLightComponent(data.getMetadataDataDefinition().getUniqueId(), inTransaction);
			if (component.isRight()) {
				log.debug("Failed to get Service for id =  " + data.getUniqueId() + "  error : " + component.right().value() + " skip resource");
			} else {
				result.add(component.left().value());
			}
		}
		return Either.left(result);
	}

	private Either<List<Resource>, StorageOperationStatus> getResourceListByCriteria(Map<String, Object> props, boolean inTransaction) {

		props.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName());

		Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);

		if (byCriteria.isRight()) {
			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value()));
		}
		List<Resource> resources = new ArrayList<Resource>();
		List<ResourceMetadataData> resourcesDataList = byCriteria.left().value();
		for (ResourceMetadataData data : resourcesDataList) {
			Either<Resource, StorageOperationStatus> resource = getResource(data.getMetadataDataDefinition().getUniqueId(), inTransaction);
			if (resource.isLeft()) {
				resources.add(resource.left().value());
			} else {
				log.debug("Failed to fetch resource for name = " + data.getMetadataDataDefinition().getName() + "  and id = " + data.getUniqueId());
			}
		}
		return Either.left(resources);
	}

	public Either<List<Resource>, StorageOperationStatus> getResourceListByUuid(String uuid, boolean inTransaction) {
		return getLatestResourceByUuid(uuid, false, inTransaction);
	}

	public Either<List<Resource>, StorageOperationStatus> getLatestResourceByUuid(String uuid, boolean inTransaction) {
		return getLatestResourceByUuid(uuid, true, inTransaction);
	}

	private Either<List<Resource>, StorageOperationStatus> getLatestResourceByUuid(String uuid, boolean isLatest, boolean inTransaction) {
		Map<String, Object> props = new HashMap<String, Object>();
		if (isLatest) {
			props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), isLatest);
		}
		props.put(GraphPropertiesDictionary.UUID.getProperty(), uuid);
		return getResourceListByCriteria(props, inTransaction);
	}

	public Either<List<Resource>, StorageOperationStatus> getResourceListBySystemName(String systemName, boolean inTransaction) {
		Map<String, Object> props = new HashMap<String, Object>();
		props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), systemName);
		return getResourceListByCriteria(props, inTransaction);
	}

	public Either<List<Resource>, StorageOperationStatus> getResourceListByToscaName(String toscaName, boolean inTransaction) {
		Map<String, Object> props = new HashMap<String, Object>();
		props.put(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), toscaName);
		return getResourceListByCriteria(props, inTransaction);
	}

	public Either<List<Resource>, StorageOperationStatus> getResourceByNameAndVersion(String name, String version, boolean inTransaction) {
		return getByNamesAndVersion(GraphPropertiesDictionary.NAME.getProperty(), name, version, null, inTransaction);
	}

	@Override
	public Either<List<Resource>, StorageOperationStatus> getResourceByNameAndVersion(String name, String version) {
		return getResourceByNameAndVersion(name, version, false);
	}

	protected Either<List<Resource>, StorageOperationStatus> getByNamesAndVersion(String nameKey, String nameValue, String version, Map<String, Object> additionalParams, boolean inTransaction) {
		Map<String, Object> props = new HashMap<String, Object>();
		props.put(nameKey, nameValue);
		props.put(GraphPropertiesDictionary.VERSION.getProperty(), version);
		props.put(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.Resource.getName());
		if (additionalParams != null && !additionalParams.isEmpty()) {
			props.putAll(additionalParams);
		}

		Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
		List<Resource> resourcesList = new ArrayList<Resource>();
		if (byCriteria.isRight()) {
			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value()));
		}
		List<ResourceMetadataData> dataList = byCriteria.left().value();
		if (dataList != null && !dataList.isEmpty()) {
			// if (dataList.size() > 1) {
			// log.debug("More that one instance of resource for name =" +
			// nameValue + " and version = " + version);
			// return Either.right(StorageOperationStatus.GENERAL_ERROR);
			// }
			for (ResourceMetadataData resourceData : dataList) {
				// ResourceMetadataData resourceData = dataList.get(0);
				Either<Resource, StorageOperationStatus> resource = getResource(resourceData.getMetadataDataDefinition().getUniqueId(), inTransaction);
				if (resource.isRight()) {
					log.debug("Failed to fetch resource for name = " + resourceData.getMetadataDataDefinition().getName() + "  and id = " + resourceData.getUniqueId());
					return Either.right(resource.right().value());
				}
				resourcesList.add(resource.left().value());
			}
			// return resource;
			return Either.left(resourcesList);
		} else {
			return Either.right(StorageOperationStatus.NOT_FOUND);
		}
	}

	@Override
	protected <T> Either<T, StorageOperationStatus> getComponentByNameAndVersion(String name, String version, Map<String, Object> additionalParams, boolean inTransaction) {
		return (Either<T, StorageOperationStatus>) getResourceBySystemNameAndVersion(name, version, additionalParams, inTransaction);
	}

	@Override
	public Either<Resource, StorageOperationStatus> getResourceBySystemNameAndVersion(String name, String version, Map<String, Object> additionalParams, boolean inTransaction) {
		Either<List<Resource>, StorageOperationStatus> byNamesAndVersion = getByNamesAndVersion(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), ValidationUtils.normaliseComponentName(name), version, additionalParams, inTransaction);
		if (byNamesAndVersion.isRight()) {
			return Either.right(byNamesAndVersion.right().value());
		}
		List<Resource> resourcesList = byNamesAndVersion.left().value();
		if (resourcesList.size() > 1) {
			log.debug("More that one instance of resource for name =" + name + " and version = " + version);
			return Either.right(StorageOperationStatus.GENERAL_ERROR);
		}
		return Either.left(resourcesList.get(0));
	}

	private TitanOperationStatus setAllVersions(Resource resource) {
		Either<Map<String, String>, TitanOperationStatus> res = getVersionList(NodeTypeEnum.Resource, resource.getVersion(), resource, ResourceMetadataData.class);
		if (res.isRight()) {
			return res.right().value();
		}
		resource.setAllVersions(res.left().value());
		return TitanOperationStatus.OK;
	}

	@Override
	protected <T extends GraphNode> Either<Map<String, String>, TitanOperationStatus> getVersionList(NodeTypeEnum type, String version, Component component, Class<T> clazz) {
		Map<String, Object> props = new HashMap<String, Object>();
		Map<String, Object> hasNotProps = new HashMap<String, Object>();

		if (version.startsWith("0")) {
			props.put(GraphPropertiesDictionary.UUID.getProperty(), component.getUUID());
		} else {
			props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), component.getSystemName());
			props.put(GraphPropertiesDictionary.RESOURCE_TYPE.getProperty(), ((Resource) component).getResourceType().name());
		}
		hasNotProps.put(GraphPropertiesDictionary.IS_DELETED.getProperty(), true);
		Either<List<T>, TitanOperationStatus> result = titanGenericDao.getByCriteria(type, props, hasNotProps, clazz);

		Map<String, String> versionMap = new HashMap<String, String>();
		if (result.isRight()) {
			if (!result.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
				return Either.right(result.right().value());
			}

		} else {
			List<ResourceMetadataData> components = (List<ResourceMetadataData>) result.left().value();
			for (ResourceMetadataData data : components) {
				versionMap.put(data.getMetadataDataDefinition().getVersion(), (String) data.getUniqueId());
			}
		}

		return Either.left(versionMap);
	}

	/**
	 * update only the resource object itself without tag, derived from or any other neighbours.
	 * 
	 * @param resource
	 * @param inTransaction
	 * @return
	 */
	protected Either<Resource, StorageOperationStatus> updateResourceMetadata(Resource resource, boolean inTransaction) {

		Either<Resource, StorageOperationStatus> result = null;

		try {

			log.debug("In updateResource. received resource = " + (resource == null ? null : resource.toString()));
			if (resource == null) {
				log.error("Resource object is null");
				result = Either.right(StorageOperationStatus.BAD_REQUEST);
				return result;
			}

			ResourceMetadataData resourceData = new ResourceMetadataData();
			resourceData.getMetadataDataDefinition().setUniqueId(resource.getUniqueId());
			resourceData.getMetadataDataDefinition().setHighestVersion(resource.isHighestVersion());
			log.debug("After converting resource to ResourceData. ResourceData = " + resourceData);

			if (resourceData.getUniqueId() == null) {
				log.error("Resource id is missing in the request.");
				return Either.right(StorageOperationStatus.BAD_REQUEST);
			}

			Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(resourceData, ResourceMetadataData.class);

			if (updateNode.isRight()) {
				log.error("Failed to update resource " + resource.getUniqueId() + ". status is " + updateNode.right().value());
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value()));
				return result;
			}

			Either<Resource, StorageOperationStatus> updatedResource = getResource(resource.getUniqueId(), true);
			if (updatedResource.isRight()) {
				log.error("Resource id is missing in the request. status is " + updatedResource.right().value());
				result = Either.right(StorageOperationStatus.BAD_REQUEST);
				return result;
			}

			Resource updatedResourceValue = updatedResource.left().value();
			result = Either.left(updatedResourceValue);

			if (log.isDebugEnabled()) {
				String json = prettyJson.toJson(result.left().value());
				log.debug("Resource retrieved after update is " + json);
			}

			return result;

		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.error("Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}
		}

	}

	@Override
	public Either<List<Resource>, StorageOperationStatus> getAllCertifiedResources(boolean isAbstract, Boolean isHighest) {

		try {
			List<Resource> result = new ArrayList<>();
			Map<String, Object> propertiesToMatch = new HashMap<>();
			propertiesToMatch.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), isAbstract);
			propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());

			if (isHighest != null) {
				propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), isHighest.booleanValue());
			}

			Either<List<ResourceMetadataData>, TitanOperationStatus> resourceNodes = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);

			titanGenericDao.commit();
			if (resourceNodes.isRight()) {
				// in case of NOT_FOUND from Titan client return to UI empty
				// list
				if (resourceNodes.right().value().equals(TitanOperationStatus.NOT_FOUND)) {
					return Either.left(result);
				} else {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(resourceNodes.right().value()));
				}
			} else {
				List<ResourceMetadataData> resourceDataList = resourceNodes.left().value();
				for (ResourceMetadataData resourceData : resourceDataList) {
					Either<Resource, StorageOperationStatus> resource = getResource(resourceData.getMetadataDataDefinition().getUniqueId());
					if (resource.isRight()) {
						log.debug("Failed to fetch resource for id = " + resourceData.getUniqueId() + "  error is " + resource.right().value());
						return Either.right(resource.right().value());
					}
					result.add(resource.left().value());
				}
				return Either.left(result);
			}
		} finally {
			titanGenericDao.commit();
		}

	}

	public Either<Resource, StorageOperationStatus> getLatestCertifiedByToscaResourceName(String toscaResourceName, boolean inTransaction) {
		return getLatestCertifiedByCriteria(GraphPropertiesDictionary.TOSCA_RESOURCE_NAME.getProperty(), toscaResourceName, inTransaction);

	}

	public Either<Resource, StorageOperationStatus> getLatestCertifiedByCriteria(String property, String resourceName, boolean inTransaction) {
		Either<Resource, StorageOperationStatus> result = null;
		try {
			Map<String, Object> props = new HashMap<String, Object>();
			props.put(property, resourceName);
			props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
			props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());

			Either<List<ResourceMetadataData>, TitanOperationStatus> highestResources = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
			if (highestResources.isRight()) {
				TitanOperationStatus status = highestResources.right().value();
				log.debug("failed to find resource with name {}. status={} ", resourceName, status);
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				return result;
			}

			List<ResourceMetadataData> resources = highestResources.left().value();
			double version = 0.0;
			ResourceMetadataData highestResource = null;
			for (ResourceMetadataData resource : resources) {
				double resourceVersion = Double.parseDouble(resource.getMetadataDataDefinition().getVersion());
				if (resourceVersion > version) {
					version = resourceVersion;
					highestResource = resource;
				}
			}
			result = getResource(highestResource.getMetadataDataDefinition().getUniqueId(), true);
			return result;

		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.error("getLatestByName operation : Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("getLatestByName operation : Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}

		}
	}

	public Either<List<Resource>, StorageOperationStatus> findLastCertifiedResourceByName(Resource resource) {

		Map<String, Object> props = new HashMap<String, Object>();
		props.put(GraphPropertiesDictionary.NAME.getProperty(), resource.getName());
		props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
		return getResourceListByCriteria(props, false);

	}

	public Either<List<Resource>, StorageOperationStatus> findLastCertifiedResourceByUUID(Resource resource) {
		Map<String, Object> props = new HashMap<String, Object>();
		props.put(GraphPropertiesDictionary.UUID.getProperty(), resource.getUUID());
		props.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
		return getResourceListByCriteria(props, false);

	}

	@Override
	public boolean isComponentExist(String resourceId) {
		return isComponentExist(resourceId, NodeTypeEnum.Resource);
	}

	@Override
	public <T> Either<T, StorageOperationStatus> cloneComponent(T other, String version, LifecycleStateEnum targetLifecycle, boolean inTransaction) {
		return (Either<T, StorageOperationStatus>) cloneResource((Resource) other, version, targetLifecycle, inTransaction);
	}

	@Override
	public Either<Integer, StorageOperationStatus> increaseAndGetComponentInstanceCounter(String componentId, boolean inTransaction) {
		return increaseAndGetComponentInstanceCounter(componentId, NodeTypeEnum.Resource, inTransaction);
	}

	private Either<Resource, StorageOperationStatus> cloneResource(Resource other, String version, boolean inTransaction) {
		return cloneResource(other, version, null, inTransaction);
	}

	private Either<Resource, StorageOperationStatus> cloneResource(Resource other, String version, LifecycleStateEnum targetLifecycle, boolean inTransaction) {
		Either<Resource, StorageOperationStatus> result = null;

		try {
			String origRsourceId = other.getUniqueId();

			StorageOperationStatus overrideStatus = overrideRecursiveMembers(other, origRsourceId);
			if (!overrideStatus.equals(StorageOperationStatus.OK)) {
				return Either.right(overrideStatus);
			}
			other.setVersion(version);
			other.setUniqueId(null);

			List<InputDefinition> inputs = other.getInputs();
			Map<String, List<ComponentInstanceProperty>> inputsPropMap = new HashMap<String, List<ComponentInstanceProperty>>();

			if (inputs != null) {
				for (InputDefinition input : inputs) {

					Either<List<ComponentInstanceProperty>, TitanOperationStatus> inputPropStatus = inputOperation.getComponentInstancePropertiesByInputId(input.getUniqueId());
					if (inputPropStatus.isLeft()) {
						if (inputPropStatus.left().value() != null)
							inputsPropMap.put(input.getName(), inputPropStatus.left().value());

					}

				}
			}

			Either<Resource, StorageOperationStatus> createResourceMD = createResource(other, inTransaction);
			if (createResourceMD.isRight()) {
				StorageOperationStatus status = createResourceMD.right().value();
				log.error("failed to clone resource. status= {}", status);
				result = Either.right(status);
				return result;
			}
			Resource resource = createResourceMD.left().value();
			Either<TitanVertex, TitanOperationStatus> metadataVertexEither = titanGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resource.getUniqueId());
			if (metadataVertexEither.isRight()) {
				TitanOperationStatus error = metadataVertexEither.right().value();
				log.debug("Failed to fetch vertex of metadata {} error {}", resource.getUniqueId(), error);
				result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
				return result;
			}

			TitanVertex metadataVertex = metadataVertexEither.left().value();
			Either<ImmutablePair<List<ComponentInstance>, Map<String, String>>, StorageOperationStatus> cloneInstances = componentInstanceOperation.cloneAllComponentInstancesFromContainerComponent(origRsourceId, resource.getUniqueId(),
					NodeTypeEnum.Resource, NodeTypeEnum.Resource, targetLifecycle, metadataVertex, other, resource, inputsPropMap);
			if (cloneInstances.isRight()) {
				result = Either.right(cloneInstances.right().value());
				return result;
			}

			Either<Integer, StorageOperationStatus> counterStatus = getComponentInstanceCoutner(origRsourceId, NodeTypeEnum.Resource);
			if (counterStatus.isRight()) {
				StorageOperationStatus status = counterStatus.right().value();
				log.error("failed to get resource instance counter on service {}. status={}", origRsourceId, counterStatus);
				result = Either.right(status);
				return result;
			}

			Either<Integer, StorageOperationStatus> setResourceInstanceCounter = setComponentInstanceCounter(resource.getUniqueId(), NodeTypeEnum.Resource, counterStatus.left().value(), true);
			if (setResourceInstanceCounter.isRight()) {
				StorageOperationStatus status = setResourceInstanceCounter.right().value();
				log.error("failed to set resource instance counter on service {}. status={}", resource.getUniqueId(), status);
				result = Either.right(status);
				return result;
			}

			Either<List<GroupDefinition>, StorageOperationStatus> clonedGroups = cloneGroups(other, resource, cloneInstances.left().value(), true);
			if (clonedGroups.isRight()) {
				StorageOperationStatus status = clonedGroups.right().value();
				if (status != StorageOperationStatus.OK) {
					result = Either.right(status);
					return result;
				}
			}

			result = this.getResource(resource.getUniqueId(), true);
			if (result.isRight()) {
				log.error("Cannot get full service from the graph. status is " + result.right().value());
				return Either.right(result.right().value());
			}

			if (log.isDebugEnabled()) {
				String json = prettyJson.toJson(result.left().value());
				// log.debug("Resource retrieved is {}", json);
			}

			return result;
		} finally {
			if (false == inTransaction) {
				if (result == null || result.isRight()) {
					log.debug("Going to execute rollback on graph.");
					titanGenericDao.rollback();
				} else {
					log.debug("Going to execute commit on graph.");
					titanGenericDao.commit();
				}
			}
		}
	}

	private StorageOperationStatus overrideRecursiveMembers(Resource resource, String prevId) {
		// override requirements to copy only resource's requirements and not
		// derived requirements
		Either<Map<String, List<RequirementDefinition>>, StorageOperationStatus> requirementsOfResourceOnly = getRequirementOperation().getAllRequirementsOfResourceOnly(prevId, true);
		if (requirementsOfResourceOnly.isRight()) {
			log.error("failed to get requirements of resource. resourceId {} status is {}", prevId, requirementsOfResourceOnly.right().value());
			return requirementsOfResourceOnly.right().value();
		}
		resource.setRequirements(requirementsOfResourceOnly.left().value());

		// override capabilities to copy only resource's requirements and not
		// derived requirements
		Either<Map<String, List<CapabilityDefinition>>, StorageOperationStatus> capabilitiesOfResourceOnly = getResourceCapabilitiesMap(prevId);

		resource.setCapabilities(capabilitiesOfResourceOnly.left().value());

		// override interfaces to copy only resource's interfaces and not
		// derived interfaces
		Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfacesOfResourceOnly = getInterfaceLifecycleOperation().getAllInterfacesOfResource(prevId, false, true);
		if (interfacesOfResourceOnly.isRight()) {
			log.error("failed to get interfaces of resource. resourceId {} status is {}", prevId, interfacesOfResourceOnly.right().value());
			return interfacesOfResourceOnly.right().value();
		}
		resource.setInterfaces(interfacesOfResourceOnly.left().value());

		List<AttributeDefinition> attributes = new ArrayList<>();
		TitanOperationStatus status = attributeOperation.findNodeNonInheretedAttribues(prevId, NodeTypeEnum.Resource, attributes);
		if (status != TitanOperationStatus.OK) {
			return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
		} else {
			resource.setAttributes(attributes);
		}

		// override properties to copy only resource's properties and not
		// derived properties
		Either<Map<String, PropertyDefinition>, TitanOperationStatus> propertiesOfResourceOnly = getPropertyOperation().findPropertiesOfNode(NodeTypeEnum.Resource, prevId);

		List<PropertyDefinition> resourceProperties = null;
		if (propertiesOfResourceOnly.isRight()) {
			TitanOperationStatus titanStatus = propertiesOfResourceOnly.right().value();
			if (titanStatus != TitanOperationStatus.NOT_FOUND) {
				log.error("failed to get properties of resource. resourceId {} status is {}", prevId, propertiesOfResourceOnly.right().value());
				return DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus);
			}
		} else {
			Map<String, PropertyDefinition> propertiesMap = propertiesOfResourceOnly.left().value();
			if (propertiesMap != null) {
				resourceProperties = new ArrayList<PropertyDefinition>();
				resourceProperties.addAll(propertiesMap.values());
			}
		}
		resource.setProperties(resourceProperties);

		return StorageOperationStatus.OK;
	}

	private Either<Map<String, List<CapabilityDefinition>>, StorageOperationStatus> getResourceCapabilitiesMap(String prevId) {

		Either<Map<String, CapabilityDefinition>, StorageOperationStatus> capabilitiesOfResourceOnly = getCapabilityOperation().getAllCapabilitiesOfResource(prevId, false, true);
		if (capabilitiesOfResourceOnly.isRight()) {
			log.error("failed to get capabilities of resource. resourceId {} status is {}", prevId, capabilitiesOfResourceOnly.right().value());
			return Either.right(capabilitiesOfResourceOnly.right().value());
		}
		Map<String, List<CapabilityDefinition>> capabilityMap = getCapabilityOperation().convertCapabilityMap(capabilitiesOfResourceOnly.left().value(), null, null);
		return Either.left(capabilityMap);
	}

	@Override
	protected StorageOperationStatus validateCategories(Component currentComponent, Component component, ComponentMetadataData componentData, NodeTypeEnum type) {
		StorageOperationStatus status = StorageOperationStatus.OK;
		List<CategoryDefinition> newCategoryList = component.getCategories();
		CategoryDefinition newCategory = newCategoryList.get(0);
		CategoryDefinition currentCategory = currentComponent.getCategories().get(0);
		boolean categoryWasChanged = false;

		if (newCategory.getName() != null && false == newCategory.getName().equals(currentCategory.getName())) {
			// the category was changed
			categoryWasChanged = true;
		} else {
			// the sub-category was changed
			SubCategoryDefinition currSubcategory = currentCategory.getSubcategories().get(0);
			SubCategoryDefinition newSubcategory = newCategory.getSubcategories().get(0);
			if (newSubcategory.getName() != null && false == newSubcategory.getName().equals(currSubcategory.getName())) {
				log.debug("Going to update the category of the resource from " + currentCategory + " to " + newCategory);
				categoryWasChanged = true;
			}
		}
		if (categoryWasChanged) {
			status = moveCategoryEdge((Resource) component, (ResourceMetadataData) componentData, newCategory);
			log.debug("Going to update the category of the resource from " + currentCategory + " to " + newCategory + ". status is " + status);
		}
		return status;
	}

	@Override
	public Resource getDefaultComponent() {
		return new Resource();
	}

	@Override
	public Either<Component, StorageOperationStatus> getMetadataComponent(String id, boolean inTransaction) {
		return getMetadataComponent(id, NodeTypeEnum.Resource, inTransaction);
	}

	@Override
	Component convertComponentMetadataDataToComponent(ComponentMetadataData componentMetadataData) {
		return convertResourceDataToResource((ResourceMetadataData) componentMetadataData);
	}

	@Override
	public Either<Boolean, StorageOperationStatus> validateComponentNameExists(String componentName) {
		return validateComponentNameUniqueness(componentName, titanGenericDao, NodeTypeEnum.Resource);
	}

	@Override
	public Either<Component, StorageOperationStatus> markComponentToDelete(Component componentToDelete, boolean inTransaction) {
		return internalMarkComponentToDelete(componentToDelete, inTransaction);
	}

	@Override
	public Either<Boolean, StorageOperationStatus> isComponentInUse(String componentId) {
		return isResourceInUse(componentId);
	}

	@Override
	public Either<List<String>, StorageOperationStatus> getAllComponentsMarkedForDeletion() {
		return getAllResourcesMarkedForDeletion();
	}

	@Override
	public Either<List<String>, StorageOperationStatus> getAllResourcesMarkedForDeletion() {
		return getAllComponentsMarkedForDeletion(NodeTypeEnum.Resource);
	}

	@Override
	public Either<Boolean, StorageOperationStatus> isResourceInUse(String resourceToDelete) {
		return isComponentInUse(resourceToDelete, NodeTypeEnum.Resource);
	}

	public Either<List<GroupDefinition>, StorageOperationStatus> cloneGroups(Resource resource, Resource newResource, ImmutablePair<List<ComponentInstance>, Map<String, String>> cloneInstances, boolean inTransaction) {

		Either<List<GroupDefinition>, StorageOperationStatus> result = null;

		if (resource.getGroups() == null) {
			return Either.right(StorageOperationStatus.OK);
		}

		Either<List<GroupDefinition>, StorageOperationStatus> prepareGroupsForCloning = groupOperation.prepareGroupsForCloning(resource, cloneInstances);
		if (prepareGroupsForCloning.isRight()) {
			StorageOperationStatus status = prepareGroupsForCloning.right().value();
			if (status != StorageOperationStatus.OK) {
				BeEcompErrorManager.getInstance().logInternalFlowError("CloneResource", "Failed to prepare groups for cloning", ErrorSeverity.ERROR);
			}
			result = Either.right(status);
			return result;
		} else {
			List<GroupDefinition> groupsToCreate = prepareGroupsForCloning.left().value();
			if (groupsToCreate != null && false == groupsToCreate.isEmpty()) {
				Either<List<GroupDefinition>, StorageOperationStatus> addGroups = groupOperation.addGroups(NodeTypeEnum.Resource, newResource.getUniqueId(), groupsToCreate, inTransaction);
				if (addGroups.isRight()) {
					BeEcompErrorManager.getInstance().logInternalFlowError("CloneResource", "Failed to clone groups", ErrorSeverity.ERROR);
					result = Either.right(addGroups.right().value());
					return result;
				}

				return Either.left(addGroups.left().value());
			} else {
				return Either.right(StorageOperationStatus.OK);
			}
		}
	}

	public Either<Resource, StorageOperationStatus> getLatestResourceByCsarOrName(String csarUUID, String systemName) {
		Map<String, Object> props = new HashMap<>();
		props.put(GraphPropertiesDictionary.CSAR_UUID.getProperty(), csarUUID);
		props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
		ResourceMetadataData resourceMetadataData = null;
		List<ResourceMetadataData> resourceMetadataDataList = null;
		Either<List<ResourceMetadataData>, TitanOperationStatus> byCsar = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
		if (byCsar.isRight()) {
			if (TitanOperationStatus.NOT_FOUND.equals(byCsar.right().value())) {
				props.clear();
				props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), true);
				props.put(GraphPropertiesDictionary.SYSTEM_NAME.getProperty(), systemName);
				Either<List<ResourceMetadataData>, TitanOperationStatus> bySystemname = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
				if (bySystemname.isRight()) {
					log.debug("getLatestResourceByCsarOrName - Failed to find by system name {}  error {} ", systemName, bySystemname.right().value());
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(bySystemname.right().value()));
				}
				if (bySystemname.left().value().size() > 2) {
					log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) must return only 2 latest version, but was returned - " + bySystemname.left().value().size());
					return Either.right(StorageOperationStatus.GENERAL_ERROR);
				}
				resourceMetadataDataList = bySystemname.left().value();
				if (resourceMetadataDataList.size() == 1) {
					resourceMetadataData = resourceMetadataDataList.get(0);
				} else {
					for (ResourceMetadataData curResource : resourceMetadataDataList) {
						if (!curResource.getMetadataDataDefinition().getState().equals("CERTIFIED")) {
							resourceMetadataData = curResource;
							break;
						}
					}
				}
				if (resourceMetadataData == null) {
					log.debug("getLatestResourceByCsarOrName - getByCriteria(by system name) returned 2 latest CERTIFIED versions");
					return Either.right(StorageOperationStatus.GENERAL_ERROR);
				}
				if (resourceMetadataData.getMetadataDataDefinition().getCsarUUID() != null && !resourceMetadataData.getMetadataDataDefinition().getCsarUUID().equals(csarUUID)) {
					log.debug("getLatestResourceByCsarOrName - same system name {} but different csarUUID. exist {} and new {} ", systemName, resourceMetadataData.getMetadataDataDefinition().getCsarUUID(), csarUUID);
					// correct error will be returned from create flow. with all
					// correct audit records!!!!!
					return Either.right(StorageOperationStatus.NOT_FOUND);
				}
				Either<Resource, StorageOperationStatus> resource = getResource((String) resourceMetadataData.getUniqueId());
				return resource;
			}
		} else {
			resourceMetadataDataList = byCsar.left().value();
			if (resourceMetadataDataList.size() > 2) {
				log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) must return only 2 latest version, but was returned - " + byCsar.left().value().size());
				return Either.right(StorageOperationStatus.GENERAL_ERROR);
			}
			if (resourceMetadataDataList.size() == 1) {
				resourceMetadataData = resourceMetadataDataList.get(0);
			} else {
				for (ResourceMetadataData curResource : resourceMetadataDataList) {
					if (!curResource.getMetadataDataDefinition().getState().equals("CERTIFIED")) {
						resourceMetadataData = curResource;
						break;
					}
				}
			}
			if (resourceMetadataData == null) {
				log.debug("getLatestResourceByCsarOrName - getByCriteria(by csar) returned 2 latest CERTIFIED versions");
				return Either.right(StorageOperationStatus.GENERAL_ERROR);
			}
			Either<Resource, StorageOperationStatus> resource = getResource((String) resourceMetadataData.getMetadataDataDefinition().getUniqueId());
			return resource;
		}
		return null;
	}

	public Either<List<ResourceMetadataData>, StorageOperationStatus> validateCsarUuidUniqueness(String csarUUID) {

		Map<String, Object> props = new HashMap<>();
		props.put(GraphPropertiesDictionary.CSAR_UUID.getProperty(), csarUUID);

		Either<List<ResourceMetadataData>, TitanOperationStatus> byCsar = titanGenericDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class);
		if (byCsar.isRight()) {
			if (TitanOperationStatus.NOT_FOUND.equals(byCsar.right().value())) {
				return Either.left(null);
			} else {
				return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCsar.right().value()));
			}
		}
		return Either.left(byCsar.left().value());
	}

	private Either<Resource, StorageOperationStatus> getResource(String uniqueId, ComponentParametersView componentParametersView, boolean inTransaction) {

		Resource resource = null;
		try {

			NodeTypeEnum resourceNodeType = NodeTypeEnum.Resource;
			NodeTypeEnum compInstNodeType = NodeTypeEnum.Resource;

			Either<ResourceMetadataData, StorageOperationStatus> componentByLabelAndId = getComponentByLabelAndId(uniqueId, resourceNodeType, ResourceMetadataData.class);
			if (componentByLabelAndId.isRight()) {
				return Either.right(componentByLabelAndId.right().value());
			}
			ResourceMetadataData resourceData = componentByLabelAndId.left().value();

			// Try to fetch resource from the cache. The resource will be
			// fetched only if the time on the cache equals to
			// the time on the graph.
			Either<Resource, ActionStatus> componentFromCacheIfUpToDate = this.getComponentFromCacheIfUpToDate(uniqueId, resourceData, componentParametersView, Resource.class, ComponentTypeEnum.RESOURCE);
			if (componentFromCacheIfUpToDate.isLeft()) {
				Resource cachedResource = componentFromCacheIfUpToDate.left().value();
				log.debug("Resource {} with uid {} was fetched from cache.", cachedResource.getName(), cachedResource.getUniqueId());
				return Either.left(cachedResource);
			}

			resource = convertResourceDataToResource(resourceData);

			TitanOperationStatus status = null;
			if (false == componentParametersView.isIgnoreUsers()) {
				status = setResourceCreatorFromGraph(resource, uniqueId);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}

				status = setResourceLastModifierFromGraph(resource, uniqueId);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			if (false == componentParametersView.isIgnoreProperties()) {
				status = setResourcePropertiesFromGraph(uniqueId, resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			if (false == componentParametersView.isIgnoreAttributesFrom()) {
				status = setResourceAttributesFromGraph(uniqueId, resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			if (false == componentParametersView.isIgnoreDerivedFrom()) {
				status = setResourceDerivedFromGraph(uniqueId, resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			if (false == componentParametersView.isIgnoreCategories()) {
				status = setComponentCategoriesFromGraph(resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			// Since capabilities and requirements and instances properties are
			// based on component instances, then we must fetch the instances.
			if (false == componentParametersView.isIgnoreComponentInstances() || false == componentParametersView.isIgnoreComponentInstancesProperties() || false == componentParametersView.isIgnoreComponentInstancesInputs()
					|| false == componentParametersView.isIgnoreCapabilities() || false == componentParametersView.isIgnoreRequirements()) {

				status = setComponentInstancesFromGraph(uniqueId, resource, resourceNodeType, compInstNodeType);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));

				}
			}

			if (false == componentParametersView.isIgnoreRequirements()) {
				StorageOperationStatus setRequirementsStatus = setResourceRequirementsFromGraph(uniqueId, resource, true);
				if (setRequirementsStatus != StorageOperationStatus.OK) {
					log.error("Failed to set requirement of resource " + uniqueId + ". status is " + setRequirementsStatus);
					return Either.right(setRequirementsStatus);
				}
			}

			if (false == componentParametersView.isIgnoreInputs()) {
				status = setComponentInputsFromGraph(uniqueId, resource, true);
				if (status != TitanOperationStatus.OK) {
					log.error("Failed to set inputs of resource " + uniqueId + ". status is " + status);
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}

			}

			StorageOperationStatus storageStatus = null;
			if (false == componentParametersView.isIgnoreCapabilities()) {
				storageStatus = setResourceCapabilitiesFromGraph(uniqueId, resource);
				if (storageStatus != StorageOperationStatus.OK) {
					return Either.right(storageStatus);
				}
			}

			if (false == componentParametersView.isIgnoreArtifacts()) {
				storageStatus = setArtifactFromGraph(uniqueId, resource);
				if (storageStatus != StorageOperationStatus.OK) {
					return Either.right(storageStatus);
				}
			}
			if (false == componentParametersView.isIgnoreComponentInstancesAttributesFrom()) {
				status = setComponentInstancesAttributesFromGraph(uniqueId, resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));

				}
			}

			if (false == componentParametersView.isIgnoreComponentInstancesProperties()) {
				status = setComponentInstancesPropertiesFromGraph(uniqueId, resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));

				}
			}

			if (false == componentParametersView.isIgnoreComponentInstancesInputs()) {
				status = setComponentInstancesInputsFromGraph(uniqueId, resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));

				}
			}

			if (false == componentParametersView.isIgnoreInterfaces()) {
				storageStatus = setResourceInterfacesFromGraph(uniqueId, resource);
				if (storageStatus != StorageOperationStatus.OK) {
					return Either.right(storageStatus);
				}
			}

			if (false == componentParametersView.isIgnoreAdditionalInformation()) {
				storageStatus = setResourceAdditionalInformationFromGraph(uniqueId, resource);
				if (storageStatus != StorageOperationStatus.OK) {
					return Either.right(storageStatus);
				}
			}

			if (false == componentParametersView.isIgnoreAllVersions()) {
				status = setAllVersions(resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			if (false == componentParametersView.isIgnoreGroups()) {
				status = setGroupsFromGraph(uniqueId, resource, NodeTypeEnum.Resource);
				if (status != TitanOperationStatus.OK) {
					return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
				}
			}

			if (true == componentParametersView.isIgnoreComponentInstances()) {
				resource.setComponentInstances(null);
				resource.setComponentInstancesRelations(null);
			}

		} finally {
			if (false == inTransaction) {
				titanGenericDao.commit();
			}
		}

		return Either.left(resource);

	}

	@SuppressWarnings("unchecked")
	@Override
	public <T> Either<T, StorageOperationStatus> getComponent(String id, ComponentParametersView componentParametersView, boolean inTrasnaction) {

		Either<Resource, StorageOperationStatus> component = getResource(id, componentParametersView, inTrasnaction);
		if (component.isRight()) {
			return Either.right(component.right().value());
		}
		return (Either<T, StorageOperationStatus>) component;
	}

	// @Override
	public Either<Resource, StorageOperationStatus> updateResource(Resource resource, boolean inTransaction, ComponentParametersView filterResultView) {
		return (Either<Resource, StorageOperationStatus>) updateComponentFilterResult(resource, inTransaction, titanGenericDao, resource.getClass(), NodeTypeEnum.Resource, filterResultView);
	}

	@Override
	protected <T> Either<T, StorageOperationStatus> updateComponentFilterResult(T component, boolean inTransaction, ComponentParametersView filterResultView) {
		return (Either<T, StorageOperationStatus>) updateResource((Resource) component, inTransaction, filterResultView);
	}
}