fix capabilities

Change-Id: Iff0448a083627b881affcacbf12b5fb5baebe294
Issue-Id: SDC-533
Signed-off-by: Michael Lando <ml636r@att.com>

3 files changed, 207 insertions, 40 deletions

diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java
index d986d77450..e530144fe0 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTypeOperation.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.be.model.jsontitan.operations;
 
 import fj.data.Either;
+import java.util.stream.Collectors;
 
 import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.apache.tinkerpop.gremlin.structure.Edge;
@@ -58,8 +59,10 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.regex.Pattern;
 
 @org.springframework.stereotype.Component("node-type-operation")
@@ -757,25 +760,49 @@ public class NodeTypeOperation extends ToscaElementOperation {
 					return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
 				}
 				// must be only one
-				GraphVertex newDerived = getParentResources.left().value().get(0);
-				derivedResources.add(newDerived);
-				StorageOperationStatus updateStatus = updateDataFromNewDerived(derivedResources, nodeTypeV, (NodeType)toscaElementToUpdate);
-				if (updateStatus != StorageOperationStatus.OK) {
-					CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update data for {} from new derived {} ", nodeTypeV.getUniqueId(), newDerived.getUniqueId(), updateStatus);
-					return updateStatus;
-				}
+				GraphVertex newDerivedV = getParentResources.left().value().get(0);
+				return updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, newDerivedV, false);
+			}
+		}
+		return StorageOperationStatus.OK;
+	}
 
-				Either<Edge, TitanOperationStatus> deleteEdge = titanDao.deleteEdge(nodeTypeV, firstDerivedInChain, EdgeLabelEnum.DERIVED_FROM);
-				if (deleteEdge.isRight()) {
-					TitanOperationStatus deleteError = deleteEdge.right().value();
-					log.debug("Failed to disassociate element {} from derived {} , error {}", nodeTypeV.getUniqueId(), firstDerivedInChain.getUniqueId(), deleteError);
-					return DaoStatusConverter.convertTitanStatusToStorageStatus(deleteError);
-				}
+	/**
+	 * 
+	 * @param toscaElementToUpdate
+	 * @param nodeTypeV
+	 * @param preDerivedV
+	 * @param newDerivedV
+	 * @param mergeValues
+	 * @return
+	 */
+	protected <T extends ToscaElement> StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV, GraphVertex preDerivedV, GraphVertex newDerivedV, boolean mergeValues) {
+		Set<String> preDerivedChainIdList = new HashSet();
+		preDerivedChainIdList.add(preDerivedV.getUniqueId());
+		Either<GraphVertex, TitanOperationStatus> childVertex = titanDao.getChildVertex(preDerivedV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
+		while (childVertex.isLeft()) {
+			GraphVertex currentChield = childVertex.left().value();
+			preDerivedChainIdList.add(currentChield.getUniqueId());
+			childVertex = titanDao.getChildVertex(currentChield, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
+		}
 
-				titanDao.createEdge(nodeTypeV, newDerived, EdgeLabelEnum.DERIVED_FROM, new HashMap<>());
-			}
+		List<GraphVertex> derivedResources = new ArrayList<>();
+		derivedResources.add(newDerivedV);
+		StorageOperationStatus updateStatus = updateDataFromNewDerived(derivedResources, nodeTypeV, (NodeType) toscaElementToUpdate, mergeValues, preDerivedChainIdList);
+		if (updateStatus != StorageOperationStatus.OK) {
+			CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update data for {} from new derived {} ", nodeTypeV.getUniqueId(), newDerivedV.getUniqueId(), updateStatus);
+			return updateStatus;
+		}
+
+		Either<Edge, TitanOperationStatus> deleteEdge = titanDao.deleteEdge(nodeTypeV, preDerivedV, EdgeLabelEnum.DERIVED_FROM);
+		if (deleteEdge.isRight()) {
+			TitanOperationStatus deleteError = deleteEdge.right().value();
+			log.debug("Failed to disassociate element {} from derived {} , error {}", nodeTypeV.getUniqueId(), preDerivedV.getUniqueId(), deleteError);
+			return DaoStatusConverter.convertTitanStatusToStorageStatus(deleteError);
 		}
 
+		titanDao.createEdge(nodeTypeV, newDerivedV, EdgeLabelEnum.DERIVED_FROM, new HashMap<>());
+
 		return StorageOperationStatus.OK;
 	}
 	
@@ -800,20 +827,20 @@ public class NodeTypeOperation extends ToscaElementOperation {
 
 	}
 
-	private StorageOperationStatus updateDataFromNewDerived(List<GraphVertex> newDerived, GraphVertex nodeTypeV, NodeType nodeToUpdate) {    
+	private StorageOperationStatus updateDataFromNewDerived(List<GraphVertex> newDerived, GraphVertex nodeTypeV, NodeType nodeToUpdate, boolean mergeValues, Set<String> preDerivedChainIdList) {
 		EnumSet<EdgeLabelEnum> edgeLabels = EnumSet.of(EdgeLabelEnum.CAPABILITIES, EdgeLabelEnum.REQUIREMENTS, EdgeLabelEnum.PROPERTIES, EdgeLabelEnum.ATTRIBUTES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.ADDITIONAL_INFORMATION);
 		StorageOperationStatus status = null;
-		for (EdgeLabelEnum edge : edgeLabels){
-			status = updateDataByType(newDerived, nodeTypeV, edge, nodeToUpdate);
+		for (EdgeLabelEnum edge : edgeLabels) {
+			status = updateDataByType(newDerived, nodeTypeV, edge, nodeToUpdate, mergeValues, preDerivedChainIdList);
 			if (status != StorageOperationStatus.OK) {
 				break;
 			}
 		}
 		return status;
-		
+
 	}
 
-	private <T extends ToscaDataDefinition> StorageOperationStatus updateDataByType(List<GraphVertex> newDerivedList, GraphVertex nodeTypeV, EdgeLabelEnum label, NodeType nodeElement) {
+	private <T extends ToscaDataDefinition> StorageOperationStatus updateDataByType(List<GraphVertex> newDerivedList, GraphVertex nodeTypeV, EdgeLabelEnum label, NodeType nodeElement, boolean mergeValues, Set<String> preDerivedChainIdList) {
 		log.debug("Update data from derived for element {} type {}", nodeTypeV.getUniqueId(), label);
 		Either<GraphVertex, TitanOperationStatus> dataFromGraph = getDataVertex(nodeTypeV, label);
 		if (dataFromGraph.isRight()) {
@@ -824,9 +851,23 @@ public class NodeTypeOperation extends ToscaElementOperation {
 		GraphVertex dataV = dataFromGraph.left().value();
 
 		Map<String, T> mapFromGraph = (Map<String, T>) dataV.getJson();
-		mapFromGraph.entrySet().removeIf(e -> e.getValue().getOwnerId() != null);
+		Map<String, T> valuesFrmPrev = null;
+		if (isSimpleHierarchy(label)) {
+			if (mergeValues) {
+				valuesFrmPrev = mapFromGraph.entrySet().stream().filter(e -> e.getValue().getOwnerId() != null).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+			}
+			mapFromGraph.entrySet().removeIf(e -> preDerivedChainIdList.contains(e.getValue().getOwnerId()));
+		} else {
+			final Map<String, T> valuesFrmPrevFinal = new HashMap<>();
+			mapFromGraph.entrySet().stream().forEach(e -> {
+				T value = e.getValue();
+				value = ToscaDataDefinition.removeAndCollectByOwnerId(value, preDerivedChainIdList);
+				valuesFrmPrevFinal.put(e.getKey(), value);
+			});
+			valuesFrmPrev = valuesFrmPrevFinal;
+			mapFromGraph.entrySet().removeIf(e->e.getValue().isEmpty());
+		}
 
-		
 		Either<Map<String, T>, StorageOperationStatus> dataFromDerived = getDataFromDerived(newDerivedList, label);
 		if (dataFromDerived.isRight()) {
 			return dataFromDerived.right().value();
@@ -845,10 +886,74 @@ public class NodeTypeOperation extends ToscaElementOperation {
 		}
 		return StorageOperationStatus.OK;
 	}
+	
+		private boolean isSimpleHierarchy(EdgeLabelEnum label) {
+		switch (label) {
+		case PROPERTIES:
+		case ATTRIBUTES:
+		case ADDITIONAL_INFORMATION:
+		case ARTIFACTS:
+		case GROUPS:
+		case INPUTS:
+			return true;
+		default:
+			return false;
+		}
+	}
 
+	
 	@Override
 	public <T extends ToscaElement> void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) {
 		fillMetadata(elementV, (NodeType) toscaElementToUpdate);
 	}
 
+	public Either<ToscaElement, StorageOperationStatus> shouldUpdateDerivedVersion(ToscaElement toscaElementToUpdate, GraphVertex nodeTypeV) {
+		NodeType nodeType = (NodeType) toscaElementToUpdate;
+
+		Either<GraphVertex, TitanOperationStatus> childVertex = titanDao.getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
+		if (childVertex.isRight()) {
+			TitanOperationStatus getchildError = childVertex.right().value();
+			if (getchildError == TitanOperationStatus.NOT_FOUND) {
+				log.debug("derived resource for element {} not found", nodeTypeV.getUniqueId());
+				return Either.right(StorageOperationStatus.OK);
+			}
+
+			log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchildError);
+			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getchildError));
+		}
+		GraphVertex firstDerivedInChain = childVertex.left().value();
+
+		String currentVersion = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.VERSION);
+
+		Map<GraphPropertyEnum, Object> props = new HashMap<>();
+		props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, nodeType.getDerivedFrom().get(0));
+		props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
+		props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
+
+		Map<GraphPropertyEnum, Object> propsHasNot = new HashMap<>();
+		propsHasNot.put(GraphPropertyEnum.IS_DELETED, true);
+		Either<List<GraphVertex>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(VertexTypeEnum.NODE_TYPE, props, propsHasNot, JsonParseFlagEnum.NoParse);
+		if (byCriteria.isRight()) {
+			log.debug("Failed to fetch derived by props {} error {}", props, byCriteria.right().value());
+			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value()));
+		}
+		List<GraphVertex> lastDerived = byCriteria.left().value();
+		// now supported only one derived!!! Change in future!(Evg)
+		GraphVertex derivedFromHighest = lastDerived.get(0);
+		String highestVersion = (String) derivedFromHighest.getMetadataProperty(GraphPropertyEnum.VERSION);
+		if (!highestVersion.equals(currentVersion)) {
+
+			// need to update to latest version of derived from
+			StorageOperationStatus updateDerived = updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, derivedFromHighest, true);
+
+			if (updateDerived != StorageOperationStatus.OK) {
+				log.debug("Failed to update {} to highest derived {} from error {}", nodeTypeV.getUniqueId(), derivedFromHighest.getUniqueId(), updateDerived);
+				return Either.right(updateDerived);
+			}
+			return getToscaElement(nodeTypeV.getUniqueId(), new ComponentParametersView());
+		}
+		// no version changes
+		return Either.right(StorageOperationStatus.OK);
+	}
+
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java
index b11036df49..394231938a 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java
@@ -275,8 +275,11 @@ public class ToscaOperationFacade {
 
     public <T extends Component> Either<T, StorageOperationStatus> getLatestByToscaResourceName(String toscaResourceName) {
         return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
-
     }
+    
+	public <T extends Component> Either<T, StorageOperationStatus> getFullLatestComponentByToscaResourceName(String toscaResourceName) {
+		return getLatestByName(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName, JsonParseFlagEnum.ParseAll);
+	}
 
     public <T extends Component> Either<T, StorageOperationStatus> getLatestByName(String resourceName) {
         return getLatestByName(GraphPropertyEnum.NAME, resourceName);
@@ -536,6 +539,39 @@ public class ToscaOperationFacade {
         return getToscaElementByOperation(highestResource);
     }
 
+	private <T extends Component> Either<T, StorageOperationStatus> getLatestByName(GraphPropertyEnum property, String nodeName, JsonParseFlagEnum parseFlag) {
+		Either<T, StorageOperationStatus> result;
+
+		Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
+		Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
+
+		propertiesToMatch.put(property, nodeName);
+		propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
+
+		propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
+
+		Either<List<GraphVertex>, TitanOperationStatus> highestResources = titanDao.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, parseFlag);
+		if (highestResources.isRight()) {
+			TitanOperationStatus status = highestResources.right().value();
+			log.debug("failed to find resource with name {}. status={} ", nodeName, status);
+			result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+			return result;
+		}
+
+		List<GraphVertex> resources = highestResources.left().value();
+		double version = 0.0;
+		GraphVertex highestResource = null;
+		for (GraphVertex vertex : resources) {
+			Object versionObj = vertex.getMetadataProperty(GraphPropertyEnum.VERSION);
+			double resourceVersion = Double.valueOf((String) versionObj);
+			if (resourceVersion > version) {
+				version = resourceVersion;
+				highestResource = vertex;
+			}
+		}
+		return getToscaElementByOperation(highestResource);
+	}
+
     public <T extends Component> Either<List<T>, StorageOperationStatus> getBySystemName(ComponentTypeEnum componentType, String systemName) {
 
         Either<List<T>, StorageOperationStatus> result = null;
@@ -2216,4 +2252,28 @@ public class ToscaOperationFacade {
 		return status;
 	}
 
+	public Either<Component, StorageOperationStatus> shouldUpgradeToLatestDerived(Resource clonedResource) {
+		String componentId = clonedResource.getUniqueId();
+		Either<GraphVertex, TitanOperationStatus> getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
+		if (getVertexEither.isRight()) {
+			log.debug("Couldn't fetch component with and unique id {}, error: {}", componentId, getVertexEither.right().value());
+			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()));
+
+		}
+		GraphVertex nodeTypeV = getVertexEither.left().value();
+		
+		ToscaElement toscaElementToUpdate = ModelConverter.convertToToscaElement(clonedResource);
+
+		Either<ToscaElement, StorageOperationStatus> shouldUpdateDerivedVersion = nodeTypeOperation.shouldUpdateDerivedVersion(toscaElementToUpdate, nodeTypeV);
+		if ( shouldUpdateDerivedVersion.isRight() && StorageOperationStatus.OK != shouldUpdateDerivedVersion.right().value() ){
+			log.debug("Failed to update derived version for node type {} derived {}, error: {}", componentId, clonedResource.getDerivedFrom().get(0), shouldUpdateDerivedVersion.right().value());
+			return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value()));
+		}
+		if ( shouldUpdateDerivedVersion.isLeft() ){
+			return Either.left(ModelConverter.convertFromToscaElement(shouldUpdateDerivedVersion.left().value()));
+		}
+		return Either.left(clonedResource);
+	}
+
+
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java
index 03a5f41d55..973b0ce069 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java
@@ -94,6 +94,22 @@ public class ModelConverter {
 			return null;
 		}
 	}
+	
+	public static boolean isAtomicComponent(Component component) {
+		ComponentTypeEnum componentType = component.getComponentType();
+		if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
+			return false;
+		}
+		Resource resource = (Resource) component;
+		ResourceTypeEnum resType = resource.getResourceType();
+		return isAtomicComponent(resType);
+	}
+	
+	public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
+		if (resourceType == null || resourceType == ResourceTypeEnum.VF || resourceType == ResourceTypeEnum.PNF || resourceType == ResourceTypeEnum.CVFC)
+			return false;
+		return true;
+	}
 
 	// **********************************************************
 	public static VertexTypeEnum getVertexType(Component component) {
@@ -117,11 +133,7 @@ public class ModelConverter {
 		return vertexType;
 	}
 
-	public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
-		if (resourceType == null || resourceType == ResourceTypeEnum.VF || resourceType == ResourceTypeEnum.PNF || resourceType == ResourceTypeEnum.CVFC)
-			return false;
-		return true;
-	}
+	
 
 	private static Service convertToService(ToscaElement toscaElement) {
 		Service service = new Service();
@@ -303,6 +315,7 @@ public class ModelConverter {
 
 		relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
 		relationshipPair.setCapabilityUid(relation.getCapabilityId());
+		relationshipPair.setCapability(relation.getCapability());
 		relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
 		relationshipPair.setRequirementUid(relation.getRequirementId());
 		relationshipPair.setRequirement(relation.getRequirement());
@@ -991,18 +1004,7 @@ public class ModelConverter {
 		toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
 	}
 
-	public static boolean isAtomicComponent(Component component) {
-		ComponentTypeEnum componentType = component.getComponentType();
-		if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
-			return false;
-		}
-		Resource resource = (Resource) component;
-		ResourceTypeEnum resType = resource.getResourceType();
-		if (resType == ResourceTypeEnum.VFC || resType == ResourceTypeEnum.VFCMT || resType == ResourceTypeEnum.VL || resType == ResourceTypeEnum.CP || resType == ResourceTypeEnum.ABSTRACT) {
-			return true;
-		}
-		return false;
-	}
+	
 
 	private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {