1 files changed, 140 insertions, 136 deletions

diff --git a/aai-traversal/src/main/java/org/onap/aai/rest/dsl/DslListener.java b/aai-traversal/src/main/java/org/onap/aai/rest/dsl/DslListener.java
index a6be24c..8fd23cc 100644
--- a/aai-traversal/src/main/java/org/onap/aai/rest/dsl/DslListener.java
+++ b/aai-traversal/src/main/java/org/onap/aai/rest/dsl/DslListener.java
@@ -19,235 +19,239 @@
  */
 package org.onap.aai.rest.dsl;
 
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.List;
-
-import org.antlr.v4.runtime.tree.TerminalNode;
-
+import com.att.eelf.configuration.EELFLogger;
+import com.att.eelf.configuration.EELFManager;
+import com.google.common.collect.Lists;
+import org.onap.aai.AAIDslBaseListener;
 import org.onap.aai.AAIDslParser;
-import org.onap.aai.config.SpringContextAware;
-import org.onap.aai.edges.EdgeRuleQuery;
-import org.onap.aai.edges.enums.EdgeType;
+import org.onap.aai.edges.EdgeIngestor;
 import org.onap.aai.exceptions.AAIException;
-import org.onap.aai.introspection.Introspector;
 import org.onap.aai.introspection.Loader;
 import org.onap.aai.introspection.LoaderFactory;
 import org.onap.aai.introspection.ModelType;
-import org.onap.aai.logging.LogFormatTools;
-import org.onap.aai.setup.SchemaVersion;
 import org.onap.aai.setup.SchemaVersions;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.onap.aai.AAIDslBaseListener;
-import org.onap.aai.edges.EdgeIngestor;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * The Class DslListener.
  */
 public class DslListener extends AAIDslBaseListener {
 
-	private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(DslQueryProcessor.class);
+	private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(DslListener.class);
 
-	private final EdgeIngestor edgeRules;
+	boolean validationFlag = false;
+	EdgeIngestor edgeIngestor;
+	Loader loader;
 
-	DslContext context = null;
-	DslQueryBuilder dslBuilder = null;
+	private Deque<DslQueryBuilder> dslQueryBuilders = new LinkedList<>();
+	private Deque<String> traversedNodes = new LinkedList<>();
+	private Deque<List<String>> returnedNodes = new LinkedList<>();
+
+	List<String> traversedEdgeLabels = new LinkedList<>();
 
 	/**
 	 * Instantiates a new DslListener.
 	 */
 	@Autowired
 	public DslListener(EdgeIngestor edgeIngestor, SchemaVersions schemaVersions, LoaderFactory loaderFactory) {
-		this.edgeRules = edgeIngestor;
-		context = new DslContext();
+		this.loader = loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDefaultVersion());
+		this.edgeIngestor = edgeIngestor;
+	}
 
-		Loader loader = loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDefaultVersion());
-		dslBuilder = new DslQueryBuilder(edgeIngestor, loader);
+	public DslQueryBuilder builder() {
+		return dslQueryBuilders.peekFirst();
 	}
 
 	public String getQuery() throws AAIException {
+		//TODO Change the exception reporting
 		if (!getException().isEmpty()) {
 			LOGGER.error("Exception in the DSL Query" + getException());
 			throw new AAIException("AAI_6149", getException());
 		}
-		return dslBuilder.getQuery().toString();
+
+		return this.compile();
+	}
+
+	public String compile() {
+		List<String> queries = dslQueryBuilders.stream().map(dslQb -> dslQb.getQuery().toString()).collect(Collectors.toList());
+		return String.join("", Lists.reverse(queries));
 	}
 
 	public String getException() {
-		return dslBuilder.getQueryException().toString();
+		return builder().getQueryException().toString();
 	}
 
 	@Override
 	public void enterAaiquery(AAIDslParser.AaiqueryContext ctx) {
-		/*
-		 * This is my start-node, have some validations here
-		 */
-		context.setStartNodeFlag(true);
-		dslBuilder.start();
+		dslQueryBuilders.push(new DslQueryBuilder(edgeIngestor, loader));
 	}
 
 	@Override
-	public void exitAaiquery(AAIDslParser.AaiqueryContext ctx) {
-		dslBuilder.end(context);
+	public void enterStartStatement(AAIDslParser.StartStatementContext ctx) {
+		builder().start();
 	}
 
 	@Override
-	public void enterDslStatement(AAIDslParser.DslStatementContext ctx) {
-		if (context.isUnionStart()) {
-			dslBuilder.startUnion();
+	public void exitStartStatement(AAIDslParser.StartStatementContext ctx) {
+		builder().end();
+		if (!traversedNodes.isEmpty()) {
+			traversedNodes.removeFirst();
 		}
+
 	}
 
 	@Override
-	public void exitDslStatement(AAIDslParser.DslStatementContext ctx) {
-		if (context.isUnionQuery()) {
-			dslBuilder.comma(context);
-			context.setUnionStart(true);
-		}
+	public void exitLimit(AAIDslParser.LimitContext ctx) {
+		builder().limit(ctx.num().getText());
 	}
 
 	@Override
-	public void enterSingleNodeStep(AAIDslParser.SingleNodeStepContext ctx) {
-		try {
-			/*
-			 * Set the previous Node to current node and get the new current
-			 * node
-			 */
-			context.setPreviousNode(context.getCurrentNode());
-			context.setCurrentNode(ctx.NODE().getText());
-
-			if (context.isUnionQuery() || context.isTraversal() || context.isWhereQuery()) {
-				String oldPreviousNode = context.getPreviousNode();
-
-				if (context.isUnionStart()) {
-					String previousNode = context.getUnionStartNodes().peek();
-					context.setPreviousNode(previousNode);
-
-					context.setUnionStart(false);
-				}
+	public void enterNestedStatement(AAIDslParser.NestedStatementContext ctx) {
+		dslQueryBuilders.addFirst(new DslQueryBuilder(edgeIngestor, loader));
+		builder().startInstance();
+	}
 
-				dslBuilder.edgeQuery(context);
+	@Override
+	public void exitNestedStatement(AAIDslParser.NestedStatementContext ctx) {
+		int count = 1;
+		if(!ctx.traversal().isEmpty()) {
+			count += ctx.traversal().size() ;
+		}
+		//TODO so ugly
+		String resultNode = traversedNodes.peekFirst();
 
-				/*
-				 * Reset is required bcos for union queries im changing the
-				 * context
-				 */
-				context.setPreviousNode(oldPreviousNode);
+		if (!traversedNodes.isEmpty()) {
+			Stream<Integer> integers = Stream.iterate(0, i -> i + 1);
+			integers.limit(count)
+					.forEach(i -> traversedNodes.removeFirst());
+		}
+		List<String> resultNodes = returnedNodes.pop();
+		resultNodes.add(resultNode);
+		returnedNodes.addFirst(resultNodes);
+	}
 
-			}
+	@Override
+	public void enterComma(AAIDslParser.CommaContext ctx) {
+		builder().comma();
+	}
 
-			else {
-				dslBuilder.nodeQuery(context);
-			}
+	@Override
+	public void enterVertex(AAIDslParser.VertexContext ctx) {
 
-		} catch (AAIException e) {
-			LOGGER.info("AAIException in DslListener" + e.getMessage());
+		if (!traversedNodes.isEmpty()) {
+			builder().edgeQuery(traversedEdgeLabels, traversedNodes.peekFirst(), ctx.label().getText());
+		} else {
+			builder().nodeQuery(ctx.label().getText());
 		}
 
+		traversedNodes.addFirst(ctx.label().getText());
 	}
 
 	@Override
-	public void exitSingleNodeStep(AAIDslParser.SingleNodeStepContext ctx) {
-		if (context.isStartNode() && isValidationFlag()) {
-			try {
-				dslBuilder.validateFilter(context);
-			} catch (AAIException e) {
-				LOGGER.error("AAIException in DslListener" + LogFormatTools.getStackTop(e));
+	public void exitVertex(AAIDslParser.VertexContext ctx) {
+
+		/*TODO dont use context */
+		if (ctx.getParent() instanceof AAIDslParser.StartStatementContext && isValidationFlag()) {
+			List<String> allKeys = new ArrayList<>();
+
+			if (ctx.filter() != null) {
+				allKeys = ctx.filter().propertyFilter().stream().flatMap(
+						pf -> pf.key().stream()).map(
+						e -> e.getText().replaceAll("\'", "")).collect(Collectors.toList());
+
 			}
+			builder().validateFilter(ctx.label().getText(), allKeys);
 		}
-		context.setStartNodeFlag(false);
-		context.setCtx(ctx);
-		dslBuilder.store(context);
+		if (ctx.store() != null) {
+			builder().store();
+		}
+		traversedEdgeLabels = new ArrayList<>();
 	}
 
-	private void generateExitStep() {
 
+	@Override
+	public void enterUnionVertex(AAIDslParser.UnionVertexContext ctx) {
+		returnedNodes.addFirst(new ArrayList<>());
+		builder().union();
 	}
 
 	@Override
-	public void enterUnionQueryStep(AAIDslParser.UnionQueryStepContext ctx) {
-
-		Deque<String> unionStartNodes = context.getUnionStartNodes();
-		unionStartNodes.add(context.getCurrentNode());
-
-		context.setUnionStart(true);
-		/*
-		 * I may not need this
-		 */
-		context.setUnionQuery(true);
-		dslBuilder.union(context);
+	public void exitUnionVertex(AAIDslParser.UnionVertexContext ctx) {
+		String resultNode = returnedNodes.pop().get(0);
+		traversedNodes.addFirst(resultNode);
+		builder().endUnion();
+	}
 
+	@Override
+	public void enterWhereFilter(AAIDslParser.WhereFilterContext ctx) {
+		returnedNodes.addFirst(new ArrayList<>());
+		builder().where();
 	}
 
 	@Override
-	public void exitUnionQueryStep(AAIDslParser.UnionQueryStepContext ctx) {
-		context.setUnionStart(false);
-		context.setUnionQuery(false);
-		Deque<String> unionStartNodes = context.getUnionStartNodes();
-		if (unionStartNodes.peek() != null) {
-			unionStartNodes.pop();
+	public void exitWhereFilter(AAIDslParser.WhereFilterContext ctx) {
+		if(!returnedNodes.isEmpty()) {
+			returnedNodes.pop();
 		}
-
-		dslBuilder.endUnion(context);
-
+		builder().endWhere();
 	}
 
 	@Override
-	public void enterFilterTraverseStep(AAIDslParser.FilterTraverseStepContext ctx) {
-		context.setWhereQuery(true);
-		context.setWhereStartNode(context.getCurrentNode());
-		dslBuilder.where(context);
-
+	public void enterTraversal(AAIDslParser.TraversalContext ctx) {
 	}
 
 	@Override
-	public void exitFilterTraverseStep(AAIDslParser.FilterTraverseStepContext ctx) {
-		context.setWhereQuery(false);
-		context.setCurrentNode(context.getWhereStartNode());
-
-		dslBuilder.endWhere(context);
-
+	public void enterEdge(AAIDslParser.EdgeContext ctx) {
 	}
 
 	@Override
-	public void enterFilterStep(AAIDslParser.FilterStepContext ctx) {
+	public void enterEdgeFilter(AAIDslParser.EdgeFilterContext ctx) {
+		traversedEdgeLabels = ctx.key().stream().map(value -> value.getText()).collect(Collectors.toList());
 
-		context.setCtx(ctx);
-		dslBuilder.filter(context);
 	}
 
 	@Override
-	public void exitFilterStep(AAIDslParser.FilterStepContext ctx) {
-		// For now do nothing
-	}
+	public void enterFilter(AAIDslParser.FilterContext ctx) {
 
-	@Override
-	public void enterTraverseStep(AAIDslParser.TraverseStepContext ctx) {
-		context.setTraversal(true);
 	}
 
 	@Override
-	public void exitTraverseStep(AAIDslParser.TraverseStepContext ctx) {
-		context.setTraversal(false);
+	public void enterPropertyFilter(AAIDslParser.PropertyFilterContext ctx) {
+
+		List<AAIDslParser.KeyContext> valueList = ctx.key();
+		String filterKey = valueList.get(0).getText();
+
+		boolean isNot = ctx.not() != null && !ctx.not().isEmpty();
+		List<AAIDslParser.NumContext> numberValues = ctx.num();
+
+		/*
+		 * Add all String values
+		 */
+		List<String> values = valueList.stream().filter(value -> !filterKey.equals(value.getText()))
+				.map(value -> "'" + value.getText().replace("'", "") + "'").collect(Collectors.toList());
+		/*
+		 * Add all numeric values
+		 */
+		values.addAll(numberValues.stream().filter(value -> !filterKey.equals(value.getText()))
+				.map(value -> value.getText()).collect(Collectors.toList()));
+
+		builder().filter(isNot, traversedNodes.peekFirst(), filterKey, values);
+
 	}
 
-	@Override
-	public void enterLimitStep(AAIDslParser.LimitStepContext ctx) {
-		context.setCtx(ctx);
-		dslBuilder.limit(context);
+	public boolean isValidationFlag() {
+		return validationFlag;
 	}
-	
+
 	public void setValidationFlag(boolean validationFlag) {
-		this.context.setValidationFlag(validationFlag);
-	}
-	
-	public boolean isValidationFlag() {
-		return this.context.isValidationFlag();
+		this.validationFlag = validationFlag;
 	}
 
 }