path: root/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ArtifactsOperations.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.jsonjanusgraph.operations;

import fj.data.Either;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.tuple.ImmutableTriple;
import org.apache.commons.lang3.tuple.Triple;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.model.HeatParameterDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
import org.openecomp.sdc.common.api.ArtifactTypeEnum;
import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.slf4j.MDC;

import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

@org.springframework.stereotype.Component("artifacts-operations")

public class ArtifactsOperations extends BaseOperation {
    private static final String FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR = "failed to fetch {} for tosca element with id {}, error {}";
	private static final Logger log = Logger.getLogger(ArtifactsOperations.class.getName());

    public Either<ArtifactDefinition, StorageOperationStatus> addArifactToComponent(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type, boolean failIfExist, String instanceId) {

        String artifactId = artifactInfo.getUniqueId();
        if (artifactId == null && artifactInfo.getEsId() != null) {
            artifactId = artifactInfo.getEsId();
        }
        Either<ArtifactDataDefinition, StorageOperationStatus> status = updateArtifactOnGraph(parentId, artifactInfo, type, artifactId, instanceId, false, false);
        if (status.isRight()) {

            log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), parentId, status.right().value());
            BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value()));
            return Either.right(status.right().value());
        } else {

            ArtifactDataDefinition artifactData = status.left().value();

            ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData);
            log.debug("The returned ArtifactDefintion is {}", artifactDefResult);
            return Either.left(artifactDefResult);
        }

    }

    public Either<ArtifactDefinition, StorageOperationStatus> updateArtifactOnResource(ArtifactDefinition artifactInfo, String id, String artifactId, NodeTypeEnum type, String instanceId) {

        Either<ArtifactDataDefinition, StorageOperationStatus> status = updateArtifactOnGraph(id, artifactInfo, type, artifactId, instanceId, true, false);
        if (status.isRight()) {

            log.debug("Failed to update artifact {} of {} {}. status is {}", artifactInfo.getArtifactName(), type.getName(), id, status.right().value());
            BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("Update Artifact", artifactInfo.getArtifactName(), String.valueOf(status.right().value()));
            return Either.right(status.right().value());
        } else {

            ArtifactDataDefinition artifactData = status.left().value();

            ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(artifactInfo, artifactData);
            log.debug("The returned ArtifactDefintion is {}", artifactDefResult);
            return Either.left(artifactDefResult);
        }
    }

    public Either<Boolean, StorageOperationStatus> isCloneNeeded(String parentId, ArtifactDefinition artifactInfo, NodeTypeEnum type) {
        ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();

        Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type);
        EdgeLabelEnum edgeLabelEnum = triple.getLeft();
        return super.isCloneNeeded(parentId, edgeLabelEnum);
    }

    public Either<ArtifactDefinition, StorageOperationStatus> getArtifactById(String parentId, String id) {
        return getArtifactById(parentId, id, null, null);
    }

    public Either<ArtifactDefinition, StorageOperationStatus> getArtifactById(String parentId, String id, ComponentTypeEnum componentType, String containerId) {
        Either<ArtifactDefinition, StorageOperationStatus> result = null;
        ArtifactDataDefinition foundArtifact = null;
        if (componentType != null && componentType == ComponentTypeEnum.RESOURCE_INSTANCE) {
            foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
            if (foundArtifact == null) {
                foundArtifact = getInstanceArtifactByLabelAndId(parentId, id, containerId, EdgeLabelEnum.INSTANCE_ARTIFACTS);
            }
        }
        if (foundArtifact == null) {
            foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
        }
        if (foundArtifact == null) {
            foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.TOSCA_ARTIFACTS);
        }

        if (foundArtifact == null) {
            foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.ARTIFACTS);
        }

        if (foundArtifact == null) {
            foundArtifact = getArtifactByLabelAndId(parentId, id, EdgeLabelEnum.SERVICE_API_ARTIFACTS);
        }
		if (foundArtifact == null) {
			foundArtifact = findInterfaceArtifact(parentId, id);

		}

        if (foundArtifact == null) {
            result = Either.right(StorageOperationStatus.NOT_FOUND);
            return result;
        }

        ArtifactDefinition artifactDefResult = convertArtifactDataToArtifactDefinition(null, foundArtifact);
        return Either.left(artifactDefResult);

    }
	private ArtifactDataDefinition findInterfaceArtifact(String parentId, String id) {
		Either<Map<String, InterfaceDefinition>, JanusGraphOperationStatus> dataFromGraph = getDataFromGraph(parentId, EdgeLabelEnum.INTERFACE);
		if (dataFromGraph.isRight()){
			log.debug("failed to fetch interfaces {} for tosca element with id {}, error {}", id, parentId ,dataFromGraph.right().value());
			return null;
		}

		Map<String, InterfaceDefinition> interfaceDefinitionMap = dataFromGraph.left().value();
		if(interfaceDefinitionMap == null) {
			return null;
		}
		Collection<InterfaceDefinition> interfaces = interfaceDefinitionMap.values();
		if (interfaces == null){
			return null;
		}
		for (InterfaceDataDefinition interfaceDataDefinition : interfaces){
			Map<String, OperationDataDefinition> operationsMap = interfaceDataDefinition.getOperations();
			if (operationsMap == null) {
				return null;
			}
			ArtifactDataDefinition implementationArtifact = getArtifactDataDefinition(id, operationsMap);
			if (implementationArtifact != null)
				return implementationArtifact;
		}
		return null;
	}

	private ArtifactDataDefinition getArtifactDataDefinition(String id,
			Map<String, OperationDataDefinition> operationsMap) {
		for(OperationDataDefinition operationDataDefinition : operationsMap.values()){
			ArtifactDataDefinition implementationArtifact = operationDataDefinition.getImplementation();
			if(implementationArtifact != null){
				String uniqueId = implementationArtifact.getUniqueId();
				if (id.equals(uniqueId)) {
					return  implementationArtifact;
				}
			}
		}
		return null;
	}


    public Either<ArtifactDefinition, StorageOperationStatus> removeArifactFromResource(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
        Either<ArtifactDefinition, StorageOperationStatus> status = removeArtifactOnGraph(id, artifactId, type, deleteMandatoryArtifact);

        if (status.isRight()) {

            log.debug("Failed to delete artifact {} of resource {}", artifactId, id);

            BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("Delete Artifact", artifactId, String.valueOf(status.right().value()));
            return Either.right(status.right().value());
        } else {

            return Either.left(status.left().value());
        }
    }

    public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType, ArtifactGroupTypeEnum groupType, String instanceId) {

        Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, parentType);
        EdgeLabelEnum edgeLabelEnum = triple.getLeft();

        Either<Map<String, ArtifactDefinition>, JanusGraphOperationStatus> foundArtifact = null;
        Map<String, ArtifactDefinition> resMap = new HashMap<>();
        foundArtifact = getArtifactByLabel(parentId, instanceId, edgeLabelEnum);
        if (foundArtifact.isRight()) {
            log.debug("Failed to find artifact in component {} with label {} ", parentId, edgeLabelEnum);
            return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(foundArtifact.right().value()));
        }

        resMap.putAll(foundArtifact.left().value());

        return Either.left(resMap);
    }

    /**
     * @param parentId   the id of the instance container
     * @param instanceId the id of the instance of which to return its artifacts
     * @return instance and instance deployment artifacts mapped by artifact label name
     */
    public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getAllInstanceArtifacts(String parentId, String instanceId) {
        Map<String, ArtifactDataDefinition> resMap = new HashMap<>();
        Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> instArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INSTANCE_ARTIFACTS);
        if (instArtifacts.isRight()) {
            return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(instArtifacts.right().value()));
        }
        Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> deployInstArtifacts = getInstanceArtifactsByLabel(parentId, instanceId, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
        if (deployInstArtifacts.isRight()) {
            return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deployInstArtifacts.right().value()));
        }
        resMap.putAll(instArtifacts.left().value());
        resMap.putAll(deployInstArtifacts.left().value());
        return Either.left(convertArtifactMapToArtifactDefinitionMap(resMap));
    }

    public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId) {

        Either<Map<String, ArtifactDefinition>, JanusGraphOperationStatus> foundArtifact = null;
        Map<String, ArtifactDefinition> resMap = new HashMap<>();
        foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.ARTIFACTS);
        if (foundArtifact.isLeft()) {
            resMap.putAll(foundArtifact.left().value());

        }
        foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
        if (foundArtifact.isLeft()) {
            resMap.putAll(foundArtifact.left().value());

        }
        foundArtifact = getArtifactByLabel(parentId, null, EdgeLabelEnum.TOSCA_ARTIFACTS);
        if (foundArtifact.isLeft()) {
            resMap.putAll(foundArtifact.left().value());

        }

        return Either.left(resMap);

    }

    public Either<ArtifactDefinition, StorageOperationStatus> removeArtifactOnGraph(String id, String artifactId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {

        Either<ArtifactDefinition, StorageOperationStatus> artifactData = this.getArtifactById(id, artifactId);
        if (artifactData.isRight()) {
            log.debug("Failed to find artifact in component {} with id {} ", id, artifactId);
            return Either.right(artifactData.right().value());
        }
        ArtifactDataDefinition artifactDefinition = artifactData.left().value();
        boolean isMandatory = false;
        if ((artifactDefinition.getMandatory() || artifactDefinition.getServiceApi()) && !deleteMandatoryArtifact) {
            // return Either.left(artifactData.left().value());
            isMandatory = true;
        }

        Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactDefinition.getArtifactGroupType(), type);
        EdgeLabelEnum edgeLabelEnum = triple.getLeft();
        VertexTypeEnum vertexTypeEnum = triple.getRight();

        if (!isMandatory) {
            StorageOperationStatus status = deleteToscaDataElement(id, edgeLabelEnum, vertexTypeEnum, artifactDefinition.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL);
            if (status != StorageOperationStatus.OK)
                return Either.right(status);
        }

        return Either.left(artifactData.left().value());

    }

    public void updateUUID(ArtifactDataDefinition artifactData, String oldChecksum, String oldVesrion, boolean isUpdate, EdgeLabelEnum edgeLabel) {
        if (oldVesrion == null || oldVesrion.isEmpty())
            oldVesrion = "0";

        String currentChecksum = artifactData.getArtifactChecksum();

        if (isUpdate) {
            ArtifactTypeEnum type = ArtifactTypeEnum.findType(artifactData.getArtifactType());
            switch (type) {
                case HEAT_ENV:
                    if (edgeLabel == EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS) {
                        generateUUID(artifactData, oldVesrion);
                    } else {
                        updateVersionAndDate(artifactData, oldVesrion);
                    }
                    break;
                case HEAT:
                case HEAT_NET:
                case HEAT_VOL:
                    generateUUID(artifactData, oldVesrion);
                    break;
                default:
                    if (oldChecksum == null || oldChecksum.isEmpty()) {
                        if (currentChecksum != null) {
                            generateUUID(artifactData, oldVesrion);
                        }
                    } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) {
                        generateUUID(artifactData, oldVesrion);
                    }
                    break;
            }
        } else {
            if (oldChecksum == null || oldChecksum.isEmpty()) {
                if (currentChecksum != null) {
                    generateUUID(artifactData, oldVesrion);
                }
            } else if ((currentChecksum != null && !currentChecksum.isEmpty()) && !oldChecksum.equals(currentChecksum)) {
                generateUUID(artifactData, oldVesrion);
            }
        }
    }

    // @TODO add implementation

    public Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getArtifacts(String parentId, NodeTypeEnum parentType) {
        return null;
    }

    public Either<ArtifactDefinition, StorageOperationStatus> addHeatEnvArtifact(ArtifactDefinition artifactHeatEnv, ArtifactDefinition artifactHeat, String componentId, NodeTypeEnum parentType, boolean failIfExist, String instanceId) {
        artifactHeatEnv.setGeneratedFromId(artifactHeat.getUniqueId());
        return addArifactToComponent(artifactHeatEnv, componentId, parentType, failIfExist, instanceId);
    }

    public Either<ArtifactDefinition, StorageOperationStatus> getHeatArtifactByHeatEnvId(String parentId, ArtifactDefinition heatEnv, NodeTypeEnum parentType, String containerId, ComponentTypeEnum componentType) {
        String id = heatEnv.getGeneratedFromId();
        ComponentTypeEnum compType;
        switch (parentType) {
            case ResourceInstance:
                compType = ComponentTypeEnum.RESOURCE_INSTANCE;
                break;
            default:
                compType = componentType;
        }
        return getArtifactById(parentId, id, compType, containerId);
    }

    public Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvArtifact(String id, ArtifactDefinition artifactEnvInfo, String artifactId, String newArtifactId, NodeTypeEnum type, String instanceId) {

        Either<Map<String, ArtifactDefinition>, JanusGraphOperationStatus> artifactsEither = getArtifactByLabel(id, instanceId, EdgeLabelEnum.DEPLOYMENT_ARTIFACTS);
        if (artifactsEither.isRight()) {
            log.debug("Failed to find artifacts in component {} with id {} ", id, artifactsEither.right().value());
            return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(artifactsEither.right().value()));
        }

        Map<String, ArtifactDefinition> artifacts = artifactsEither.left().value();
        List<ArtifactDefinition> envList = artifacts.values().stream().filter(a -> a.getGeneratedFromId() != null && a.getGeneratedFromId().equals(artifactId)).collect(Collectors.toList());
        if (envList != null && !envList.isEmpty()) {
            envList.forEach(a -> {
                a.setGeneratedFromId(newArtifactId);
                updateArtifactOnResource(a, id, a.getUniqueId(), type, instanceId);

            });

        }
        return Either.left(artifactEnvInfo);
    }

    public Either<ArtifactDefinition, StorageOperationStatus> updateHeatEnvPlaceholder(ArtifactDefinition artifactInfo, String parentId, NodeTypeEnum type) {
		return updateArtifactOnResource(artifactInfo, parentId, artifactInfo.getUniqueId(), type, null);
    }


    ///////////////////////////////////////////// private methods ////////////////////////////////////////////////////

    protected ArtifactDefinition convertArtifactDataToArtifactDefinition(ArtifactDefinition artifactInfo, ArtifactDataDefinition artifactDefResult) {
        log.debug("The object returned after create property is {}", artifactDefResult);

        ArtifactDefinition propertyDefResult = new ArtifactDefinition(artifactDefResult);
        if (artifactInfo != null)
            propertyDefResult.setPayload(artifactInfo.getPayloadData());

        List<HeatParameterDefinition> parameters = new ArrayList<>();
        /*
         * StorageOperationStatus heatParametersOfNode = heatParametersOperation.getHeatParametersOfNode(NodeTypeEnum.ArtifactRef, artifactDefResult.getUniqueId().toString(), parameters); if ((heatParametersOfNode.equals(StorageOperationStatus.OK))
         * && !parameters.isEmpty()) { propertyDefResult.setHeatParameters(parameters); }
         */
        return propertyDefResult;
    }

    private ArtifactDataDefinition getInstanceArtifactByLabelAndId(String parentId, String id, String containerId, EdgeLabelEnum edgeLabelEnum) {
        ArtifactDataDefinition foundArtifact = null;
        Either<Map<String, MapArtifactDataDefinition>, JanusGraphOperationStatus> artifactsEither = getDataFromGraph(containerId, edgeLabelEnum);
        if (artifactsEither.isRight()) {
            log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, containerId, artifactsEither.right().value());
            return null;
        }

        Map<String, MapArtifactDataDefinition> artifacts = artifactsEither.left().value();

        MapArtifactDataDefinition artifactsPerInstance = artifacts.get(parentId);
        if (artifactsPerInstance == null) {
            log.debug("failed to fetch artifacts for instance {} in tosca element with id {}, error {}", parentId, containerId, artifactsEither.right().value());
            return null;
        }
        Optional<ArtifactDataDefinition> op = artifactsPerInstance.getMapToscaDataDefinition().values().stream().filter(p -> p.getUniqueId().equals(id)).findAny();
        if (op.isPresent()) {
            foundArtifact = op.get();
        }
        return foundArtifact;
    }

    private ArtifactDataDefinition getArtifactByLabelAndId(String parentId, String id, EdgeLabelEnum edgeLabelEnum) {
        ArtifactDataDefinition foundArtifact = null;
        Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> artifactsEither = getDataFromGraph(parentId, edgeLabelEnum);
        if (artifactsEither.isRight()) {
            log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, artifactsEither.right().value());
            return null;
        }

        Map<String, ArtifactDataDefinition> artifacts = artifactsEither.left().value();
        Optional<ArtifactDataDefinition> op = artifacts.values().stream().filter(p -> p.getUniqueId().equals(id)).findAny();
        if (op.isPresent()) {
            foundArtifact = op.get();
        }
        return foundArtifact;
    }

    private Either<Map<String, ArtifactDefinition>, JanusGraphOperationStatus> getArtifactByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
        Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> artifactsEither = getArtifactsDataByLabel(parentId, instanceId, edgeLabelEnum);
        if (artifactsEither.isRight()) {
            log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, artifactsEither.right().value());
            return Either.right(artifactsEither.right().value());
        }
        Map<String, ArtifactDataDefinition> artifactDataMap = artifactsEither.left().value();
        return Either.left(convertArtifactMapToArtifactDefinitionMap(artifactDataMap));
    }

    private Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> getArtifactsDataByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
        return edgeLabelEnum.isInstanceArtifactsLabel() ? getInstanceArtifactsByLabel(parentId, instanceId, edgeLabelEnum) : getDataFromGraph(parentId, edgeLabelEnum);
    }

    private Map<String, ArtifactDefinition> convertArtifactMapToArtifactDefinitionMap(Map<String, ArtifactDataDefinition> artifactDataMap) {
        Map<String, ArtifactDefinition> artMap = new HashMap<>();
        if (artifactDataMap != null && !artifactDataMap.isEmpty()) {
            artMap = artifactDataMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> convertArtifactDataToArtifactDefinition(null, e.getValue())));
        }
        return artMap;
    }

    private Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> getInstanceArtifactsByLabel(String parentId, String instanceId, EdgeLabelEnum edgeLabelEnum) {
        Either<Map<String, MapArtifactDataDefinition>, JanusGraphOperationStatus> resultEither = getDataFromGraph(parentId, edgeLabelEnum);
        if (resultEither.isRight()) {
            log.debug(FAILED_TO_FETCH_FOR_TOSCA_ELEMENT_WITH_ID_ERROR, edgeLabelEnum, parentId, resultEither.right().value());
            return Either.right(resultEither.right().value());
        }
        Map<String, MapArtifactDataDefinition> mapArtifacts = resultEither.left().value();
        MapArtifactDataDefinition artifactPerInstance = mapArtifacts.get(instanceId);
        return artifactPerInstance != null ? Either.left(artifactPerInstance.getMapToscaDataDefinition()) : Either.left(new HashMap<>());
    }

    private Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> getEdgeLabelEnumFromArtifactGroupType(ArtifactGroupTypeEnum groupType, NodeTypeEnum nodeType) {
        EdgeLabelEnum edgeLabelEnum;
        VertexTypeEnum vertexTypeEnum;
        Boolean isDeepElement = false;
        /*
         * if (nodeType == NodeTypeEnum.ResourceInstance) { edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS; vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS; isDeepElement = true; } else {
         */
        switch (groupType) {
            case TOSCA:
                edgeLabelEnum = EdgeLabelEnum.TOSCA_ARTIFACTS;
                vertexTypeEnum = VertexTypeEnum.TOSCA_ARTIFACTS;
                break;
            case DEPLOYMENT:
                if (nodeType == NodeTypeEnum.ResourceInstance) {
                    edgeLabelEnum = EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS;
                    vertexTypeEnum = VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS;
                    isDeepElement = true;
                } else {
                    edgeLabelEnum = EdgeLabelEnum.DEPLOYMENT_ARTIFACTS;
                    vertexTypeEnum = VertexTypeEnum.DEPLOYMENT_ARTIFACTS;
                }
                break;
            case SERVICE_API:
                edgeLabelEnum = EdgeLabelEnum.SERVICE_API_ARTIFACTS;
                vertexTypeEnum = VertexTypeEnum.SERVICE_API_ARTIFACTS;
                break;
            default:
                if (nodeType == NodeTypeEnum.ResourceInstance) {
                    edgeLabelEnum = EdgeLabelEnum.INSTANCE_ARTIFACTS;
                    vertexTypeEnum = VertexTypeEnum.INSTANCE_ARTIFACTS;
                    isDeepElement = true;
                } else {
                    edgeLabelEnum = EdgeLabelEnum.ARTIFACTS;
                    vertexTypeEnum = VertexTypeEnum.ARTIFACTS;
                }
                break;
        }
        // }
        return new ImmutableTriple<>(edgeLabelEnum, isDeepElement, vertexTypeEnum);

    }

    public Either<ArtifactDataDefinition, StorageOperationStatus> updateArtifactOnGraph(String componentId, ArtifactDefinition artifactInfo, NodeTypeEnum type, String artifactId, String instanceId, boolean isUpdate, boolean isDeletePlaceholder) {
        Either<ArtifactDataDefinition, StorageOperationStatus> res = null;
        ArtifactDataDefinition artifactToUpdate = new ArtifactDataDefinition(artifactInfo);
        ArtifactGroupTypeEnum groupType = artifactInfo.getArtifactGroupType();

        Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(groupType, type);
        EdgeLabelEnum edgeLabelEnum = triple.getLeft();
        VertexTypeEnum vertexTypeEnum = triple.getRight();

        Either<Boolean, StorageOperationStatus> isNeedToCloneEither = isCloneNeeded(componentId, edgeLabelEnum);
        if (isNeedToCloneEither.isRight()) {
            log.debug("Failed check is clone needed {}", componentId);
            return Either.right(isNeedToCloneEither.right().value());

        }
        boolean isNeedToClone = isNeedToCloneEither.left().value();

        if (artifactId == null || isNeedToClone) {
            String uniqueId;
            if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
                uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel());
            } else {
                uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel());
            }
            artifactToUpdate.setUniqueId(uniqueId);
            if (!isDeletePlaceholder)
                artifactToUpdate.setEsId(uniqueId);
        } else
            artifactToUpdate.setUniqueId(artifactId);

        Map<String, ArtifactDataDefinition> artifacts = new HashMap<>();
        Map<String, MapArtifactDataDefinition> artifactInst = null;
        if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {

            Either<Map<String, ArtifactDataDefinition>, JanusGraphOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum);

            if (artifactsEither.isLeft() && artifactsEither.left().value() != null && !artifactsEither.left().value().isEmpty()) {
                artifacts = artifactsEither.left().value();
                if (isNeedToClone && artifacts != null) {
                    artifacts.values().stream().forEach(a -> a.setDuplicated(Boolean.TRUE));
                }
            }
        } else {

            Either<Map<String, MapArtifactDataDefinition>, JanusGraphOperationStatus> artifactsEither = this.getDataFromGraph(componentId, edgeLabelEnum);
            if (artifactsEither.isLeft()) {
                artifactInst = artifactsEither.left().value();
                if (isNeedToClone && artifactInst != null) {
                    artifactInst.values().forEach(ma -> ma.getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE)));
                }
                MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId);
                if (artifatcsOnInstance != null) {
                    artifacts = artifatcsOnInstance.getMapToscaDataDefinition();
                }
            }
        }
        String oldChecksum = null;
        String oldVersion = null;
        if (artifacts != null && artifacts.containsKey(artifactInfo.getArtifactLabel())) {
            ArtifactDataDefinition oldArtifactData = artifacts.get(artifactInfo.getArtifactLabel());
            oldChecksum = oldArtifactData.getArtifactChecksum();
            oldVersion = oldArtifactData.getArtifactVersion();
            //duplicated flag didn't receive from UI, take from DB
            artifactToUpdate.setDuplicated(oldArtifactData.getDuplicated());

            if (isNeedToClone)
                artifactToUpdate.setDuplicated(Boolean.FALSE);
            else {
                if (artifactToUpdate.getDuplicated()) {
                    String uniqueId = "";
                    if(type != NodeTypeEnum.ResourceInstance)
                        uniqueId = UniqueIdBuilder.buildPropertyUniqueId(componentId, artifactToUpdate.getArtifactLabel());
                    else
                        uniqueId = UniqueIdBuilder.buildInstanceArtifactUniqueId(componentId, instanceId, artifactToUpdate.getArtifactLabel());

                    artifactToUpdate.setUniqueId(uniqueId);
                    if (!isDeletePlaceholder)
                        artifactToUpdate.setEsId(uniqueId);
                    artifactToUpdate.setDuplicated(Boolean.FALSE);
                }
            }
        }
        updateUUID(artifactToUpdate, oldChecksum, oldVersion, isUpdate, edgeLabelEnum);

        if (artifactInfo.getPayloadData() == null) {
            if (!artifactToUpdate.getMandatory() || artifactToUpdate.getEsId() != null) {
                artifactToUpdate.setEsId(artifactToUpdate.getUniqueId());
            }
        } else {
            if (artifactToUpdate.getEsId() == null) {
                artifactToUpdate.setEsId(artifactToUpdate.getUniqueId());
            }
        }

        StorageOperationStatus status = StorageOperationStatus.OK;
        if (edgeLabelEnum != EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS && edgeLabelEnum != EdgeLabelEnum.INSTANCE_ARTIFACTS) {
            List<ArtifactDataDefinition> toscaDataList = new ArrayList<>();
            toscaDataList.add(artifactToUpdate);

            if (isNeedToClone && artifacts != null) {
                artifacts.values().stream().filter(a -> !a.getArtifactLabel().equals(artifactToUpdate.getArtifactLabel())).forEach(toscaDataList::add);
            }
            status = updateToscaDataOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, JsonPresentationFields.ARTIFACT_LABEL);
        } else {
            List<ArtifactDataDefinition> toscaDataList = new ArrayList<>();
            toscaDataList.add(artifactToUpdate);
            List<String> pathKeys = new ArrayList<>();
            pathKeys.add(instanceId);
            if (isNeedToClone) {
                MapArtifactDataDefinition artifatcsOnInstance = artifactInst.get(instanceId);
                if (artifatcsOnInstance != null) {
                    artifacts = artifatcsOnInstance.getMapToscaDataDefinition();
                    artifacts.put(artifactToUpdate.getArtifactLabel(), artifactToUpdate);
                }

                for (Entry<String, MapArtifactDataDefinition> e : artifactInst.entrySet()) {
                    List<ArtifactDataDefinition> toscaDataListPerInst = e.getValue().getMapToscaDataDefinition().values().stream().collect(Collectors.toList());
                    List<String> pathKeysPerInst = new ArrayList<>();
                    pathKeysPerInst.add(e.getKey());
                    status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataListPerInst, pathKeysPerInst, JsonPresentationFields.ARTIFACT_LABEL);
                    if (status != StorageOperationStatus.OK) {
                        log.debug("Failed to update atifacts group for instance {} in component {} edge type {} error {}", instanceId, componentId, edgeLabelEnum, status);
                        res = Either.right(status);
                        break;
                    }
                }
            } else {
                status = updateToscaDataDeepElementsOfToscaElement(componentId, edgeLabelEnum, vertexTypeEnum, toscaDataList, pathKeys, JsonPresentationFields.ARTIFACT_LABEL);
            }
        }
        if (status == StorageOperationStatus.OK)
            res = Either.left(artifactToUpdate);
        else
            res = Either.right(status);
        return res;
    }

    public void generateUUID(ArtifactDataDefinition artifactData, String oldVesrion) {

        UUID uuid = UUID.randomUUID();
        artifactData.setArtifactUUID(uuid.toString());
        MDC.put("serviceInstanceID", uuid.toString());
        updateVersionAndDate(artifactData, oldVesrion);
    }

    private void updateVersionAndDate(ArtifactDataDefinition artifactData, String oldVesrion) {
        if (artifactData.getArtifactChecksum() != null) {
            long time = System.currentTimeMillis();
            artifactData.setPayloadUpdateDate(time);
        }
        int newVersion = new Integer(oldVesrion).intValue();
        newVersion++;
        artifactData.setArtifactVersion(String.valueOf(newVersion));
    }

    public Either<ArtifactDataDefinition, StorageOperationStatus> removeArtifactOnGraph(ArtifactDefinition artifactFromGraph, String componentId, String instanceId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {

        Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactFromGraph.getArtifactGroupType(), type);
        EdgeLabelEnum edgeLabelEnum = triple.getLeft();
        VertexTypeEnum vertexTypeEnum = triple.getRight();

        if (deleteMandatoryArtifact || !(artifactFromGraph.getMandatory() || artifactFromGraph.getServiceApi())) {
            StorageOperationStatus status;
            if (triple.getMiddle()) {
                List<String> pathKeys = new ArrayList<>();
                pathKeys.add(instanceId);
                status = deleteToscaDataDeepElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), pathKeys, JsonPresentationFields.ARTIFACT_LABEL);
            } else {
                status = deleteToscaDataElement(componentId, edgeLabelEnum, vertexTypeEnum, artifactFromGraph.getArtifactLabel(), JsonPresentationFields.ARTIFACT_LABEL);
            }
            if (status != StorageOperationStatus.OK)
                return Either.right(status);
        }
        return Either.left(artifactFromGraph);

    }

    public Either<ArtifactDataDefinition, StorageOperationStatus> deleteArtifactWithCloningOnGraph(String componentId, ArtifactDefinition artifactToDelete, NodeTypeEnum type, String instanceId, boolean deleteMandatoryArtifact) {

        Either<ArtifactDataDefinition, StorageOperationStatus> result = null;
        Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactToDelete.getArtifactGroupType(), type);
        EdgeLabelEnum edgeLabel = triple.getLeft();
        VertexTypeEnum vertexLabel = triple.getRight();

        Boolean deleteElement = deleteMandatoryArtifact || !(artifactToDelete.getMandatory() || artifactToDelete.getServiceApi());
        Map<String, ToscaDataDefinition> artifacts = null;
        GraphVertex parentVertex = null;
        Either<Map<String, ToscaDataDefinition>, JanusGraphOperationStatus> getArtifactsRes = null;

        Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes = janusGraphDao
            .getVertexById(componentId, JsonParseFlagEnum.NoParse);
        if (getToscaElementRes.isRight()) {
            CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to get tosca element {} upon getting tosca data from graph. Status is {}. ", componentId, getToscaElementRes.right().value());
            result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementRes.right().value()));
        }
        if (result == null) {
            parentVertex = getToscaElementRes.left().value();
            getArtifactsRes = this.getDataFromGraph(parentVertex, edgeLabel);
            if (getArtifactsRes.isRight()) {
                result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getArtifactsRes.right().value()));
            }
        }
        if (result == null) {
            artifacts = getArtifactsRes.left().value();
            if (triple.getMiddle()) {
                artifacts.values().forEach(ma -> ((MapArtifactDataDefinition) ma).getMapToscaDataDefinition().values().forEach(a -> a.setDuplicated(Boolean.TRUE)));
                MapArtifactDataDefinition artifatcsOnInstance = (MapArtifactDataDefinition) artifacts.get(instanceId);
                if (artifatcsOnInstance != null && deleteElement) {
                    artifatcsOnInstance.getMapToscaDataDefinition().remove(artifactToDelete.getArtifactLabel());
                }
            } else {
                if (deleteElement) {
                    artifacts.remove(artifactToDelete.getArtifactLabel());
                }
                artifacts.values().stream().forEach(a -> ((ArtifactDataDefinition) a).setDuplicated(Boolean.TRUE));
            }
            artifactToDelete.setDuplicated(Boolean.TRUE);
        }
        if (artifacts != null) {
            JanusGraphOperationStatus
                status = janusGraphDao.deleteEdgeByDirection(parentVertex, Direction.OUT, edgeLabel);
            if (status != JanusGraphOperationStatus.OK) {
                result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
            } else if (MapUtils.isNotEmpty(artifacts)) {
                Either<GraphVertex, StorageOperationStatus> associateResult = associateElementToData(parentVertex, vertexLabel, edgeLabel, artifacts);
                if (associateResult.isRight()) {
                    result = Either.right(associateResult.right().value());
                }
            }
        }
        if (result == null) {
            result = Either.left(artifactToDelete);
        }
        return result;
    }

}