aai-traversal/src/main/java/org/onap/aai/rest/dsl/DslListener.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *    http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.aai.rest.dsl;
  21
  22 import java.util.ArrayList;
  23 import java.util.HashMap;
  24 import java.util.Map;
  25 import java.util.List;
  26
  27 import org.antlr.v4.runtime.tree.TerminalNode;
  28
  29 import org.onap.aai.AAIDslParser;
  30 import org.onap.aai.serialization.db.EdgeRules;
  31 import org.onap.aai.AAIDslBaseListener;
  32
  33 import com.att.eelf.configuration.EELFLogger;
  34 import com.att.eelf.configuration.EELFManager;
  35
  36 /**
  37  * The Class DslListener.
  38  */
  39 public class DslListener extends AAIDslBaseListener {
  40
  41         private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(DslQueryProcessor.class);
  42         private final EdgeRules edgeRules = EdgeRules.getInstance();
  43
  44         protected List<String> list = null;
  45         //TODO Use StringBuilder to build the query than concat
  46         String query = "";
  47
  48         Map<Integer, String> unionMap = new HashMap<>();
  49         Map<String, String> flags = new HashMap<>();
  50
  51         String currentNode = "";
  52         String prevsNode = "";
  53         int commas = 0;
  54
  55         int unionKey = 0;
  56         int unionMembers = 0;
  57         boolean isUnionBeg = false;
  58         boolean isUnionTraversal = false;
  59
  60         boolean isTraversal = false;
  61         boolean isWhereTraversal = false;
  62         String whereTraversalNode = "";
  63
  64         String limitQuery = "";
  65         boolean isNot = false;
  66
  67         /**
  68          * Instantiates a new DslListener.
  69          */
  70
  71         public DslListener() {
  72                 list = new ArrayList<>();
  73         }
  74
  75         @Override
  76         public void enterAaiquery(AAIDslParser.AaiqueryContext ctx) {
  77                 query += "builder";
  78         }
  79
  80         @Override
  81         public void enterDslStatement(AAIDslParser.DslStatementContext ctx) {
  82                 // LOGGER.info("Statement Enter"+ctx.getText());
  83                 /*
  84                  * This block of code is entered for every query statement
  85                  */
  86                 if (isUnionBeg) {
  87                         isUnionBeg = false;
  88                         isUnionTraversal = true;
  89
  90                 } else if (unionMembers > 0) {
  91                         unionMembers--;
  92                         query += ",builder.newInstance()";
  93                         isUnionTraversal = true;
  94                 }
  95
  96         }
  97
  98         @Override
  99         public void exitDslStatement(AAIDslParser.DslStatementContext ctx) {
 100                 /*
 101                  * Nothing to be done here for now
 102                  * LOGGER.info("Statement Exit"+ctx.getText());
 103                  */
 104         }
 105
 106         @Override
 107         public void exitAaiquery(AAIDslParser.AaiqueryContext ctx) {
 108                 /*
 109                  * dedup is by default for all queries If the query has limit in it
 110                  * include this as well LOGGER.info("Statement Exit"+ctx.getText());
 111                  */
 112
 113                 query += ".cap('x').unfold().dedup()" + limitQuery;
 114         }
 115
 116         /*
 117          * TODO: The contexts are not inherited from a single parent in AAIDslParser
 118          * Need to find a way to do that
 119          */
 120         @Override
 121         public void enterSingleNodeStep(AAIDslParser.SingleNodeStepContext ctx) {
 122
 123                 prevsNode = currentNode;
 124                 currentNode = ctx.NODE().getText();
 125
 126                 this.generateQuery();
 127                 if (ctx.STORE() != null && ctx.STORE().getText().equals("*")) {
 128                         flags.put(currentNode, "store");
 129                 }
 130
 131         }
 132
 133         @Override
 134         public void enterSingleQueryStep(AAIDslParser.SingleQueryStepContext ctx) {
 135
 136                 prevsNode = currentNode;
 137                 currentNode = ctx.NODE().getText();
 138                 this.generateQuery();
 139
 140                 if (ctx.STORE() != null && ctx.STORE().getText().equals("*")) {
 141                         flags.put(currentNode, "store");
 142                 }
 143         }
 144
 145         @Override
 146         public void enterMultiQueryStep(AAIDslParser.MultiQueryStepContext ctx) {
 147
 148                 prevsNode = currentNode;
 149                 currentNode = ctx.NODE().getText();
 150                 this.generateQuery();
 151
 152                 if (ctx.STORE() != null && ctx.STORE().getText().equals("*")) {
 153                         flags.put(currentNode, "store");
 154                 }
 155
 156         }
 157
 158         /*
 159          * Generates the QueryBuilder syntax for the dsl query
 160          */
 161         private void generateQuery() {
 162                 String edgeType = "";
 163
 164                 if (isUnionTraversal || isTraversal || isWhereTraversal) {
 165                         String previousNode = prevsNode;
 166                         if (isUnionTraversal) {
 167                                 previousNode = unionMap.get(unionKey);
 168                                 isUnionTraversal = false;
 169                         }
 170
 171                         if (edgeRules.hasTreeEdgeRule(previousNode, currentNode)) {
 172                                 edgeType = "EdgeType.TREE";
 173                         }else if (edgeRules.hasCousinEdgeRule(previousNode, currentNode, "")) {
 174                                 edgeType = "EdgeType.COUSIN";
 175                         } else
 176                                 edgeType = "EdgeType.COUSIN";
 177
 178                         query += ".createEdgeTraversal(" + edgeType + ", '" + previousNode + "','" + currentNode + "')";
 179
 180                 }
 181
 182                 else
 183                         query += ".getVerticesByProperty('aai-node-type', '" + currentNode + "')";
 184         }
 185
 186         @Override
 187         public void exitSingleNodeStep(AAIDslParser.SingleNodeStepContext ctx) {
 188
 189                 generateExitStep();
 190         }
 191
 192         @Override
 193         public void exitSingleQueryStep(AAIDslParser.SingleQueryStepContext ctx) {
 194                 generateExitStep();
 195         }
 196
 197         @Override
 198         public void exitMultiQueryStep(AAIDslParser.MultiQueryStepContext ctx) {
 199                 generateExitStep();
 200
 201         }
 202
 203         private void generateExitStep() {
 204                 if (flags.containsKey(currentNode)) {
 205                         String storeFlag = flags.get(currentNode);
 206                         if (storeFlag != null && storeFlag.equals("store"))
 207                                 query += ".store('x')";
 208                         flags.remove(currentNode);
 209                 }
 210         }
 211
 212         @Override
 213         public void enterUnionQueryStep(AAIDslParser.UnionQueryStepContext ctx) {
 214                 isUnionBeg = true;
 215
 216                 unionKey++;
 217                 unionMap.put(unionKey, currentNode);
 218                 query += ".union(builder.newInstance()";
 219
 220                 List<TerminalNode> commaNodes = ctx.COMMA();
 221
 222                 for (TerminalNode node : commaNodes) {
 223                         unionMembers++;
 224                 }
 225         }
 226
 227         @Override
 228         public void exitUnionQueryStep(AAIDslParser.UnionQueryStepContext ctx) {
 229                 isUnionBeg = false;
 230                 unionMap.remove(unionKey);
 231
 232                 query += ")";
 233                 unionKey--;
 234
 235         }
 236
 237         @Override
 238         public void enterFilterTraverseStep(AAIDslParser.FilterTraverseStepContext ctx) {
 239                 isWhereTraversal = true;
 240                 whereTraversalNode = currentNode;
 241                 query += ".where(builder.newInstance()";
 242         }
 243
 244         @Override
 245         public void exitFilterTraverseStep(AAIDslParser.FilterTraverseStepContext ctx) {
 246                 query += ")";
 247                 isWhereTraversal = false;
 248                 currentNode = whereTraversalNode;
 249         }
 250
 251         @Override
 252         public void enterFilterStep(AAIDslParser.FilterStepContext ctx) {
 253                 if (ctx.NOT() != null && ctx.NOT().getText().equals("!"))
 254                         isNot = true;
 255
 256                 List<TerminalNode> nodes = ctx.KEY();
 257                 String key = ctx.KEY(0).getText();
 258
 259                 if (isNot) {
 260                         query += ".getVerticesExcludeByProperty(";
 261                         isNot = false;
 262                 } else
 263                         query += ".getVerticesByProperty(";
 264
 265                 if (nodes.size() == 2) {
 266                         query += key + "," + ctx.KEY(1).getText();
 267                         query += ")";
 268                 }
 269
 270                 if (nodes.size() > 2) {
 271
 272                         for (TerminalNode node : nodes) {
 273                                 if (node.getText().equals(key))
 274                                         continue;
 275
 276                                 query += key + "," + node.getText();
 277                                 query += ")";
 278                         }
 279
 280                 }
 281
 282         }
 283
 284         @Override
 285         public void exitFilterStep(AAIDslParser.FilterStepContext ctx) {
 286                 // For now do nothing
 287         }
 288
 289         @Override
 290         public void enterTraverseStep(AAIDslParser.TraverseStepContext ctx) {
 291                 isTraversal = true;
 292         }
 293
 294         @Override
 295         public void exitTraverseStep(AAIDslParser.TraverseStepContext ctx) {
 296                 isTraversal = false;
 297         }
 298
 299         @Override
 300         public void enterLimitStep(AAIDslParser.LimitStepContext ctx) {
 301                 String value = ctx.NODE().getText();
 302                 limitQuery += ".limit(" + value + ")";
 303         }
 304 }