Sonar fixes in EdgeRuleQuery.java

Change-Id: I46029a19b3f495bebdf714b26c72739355dda8e8
Issue-ID: AAI-1559
Signed-off-by: Mohamed Asgar Samiulla <sammoham@in.ibm.com>

1 files changed, 261 insertions, 256 deletions

diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/edges/EdgeRuleQuery.java b/aai-schema-ingest/src/main/java/org/onap/aai/edges/EdgeRuleQuery.java
index 828968a5..5801e816 100644
--- a/aai-schema-ingest/src/main/java/org/onap/aai/edges/EdgeRuleQuery.java
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/edges/EdgeRuleQuery.java
@@ -4,6 +4,8 @@
  * ================================================================================
  * Copyright © 2017-18 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
+ *  Modifications Copyright © 2018 IBM.
+ * ================================================================================
  * 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
@@ -21,7 +23,6 @@
 package org.onap.aai.edges;
 
 import org.apache.commons.lang.StringUtils;
-//import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.onap.aai.edges.enums.AAIDirection;
 import org.onap.aai.edges.enums.EdgeField;
 import org.onap.aai.edges.enums.EdgeProperty;
@@ -44,269 +45,273 @@ import static com.jayway.jsonpath.Criteria.where;
  *
  */
 public class EdgeRuleQuery {
-	private Filter filter;
-	private Optional<SchemaVersion> v;
-	private String nodeA;
-	private String nodeB;
-	private String label;
-	private AAIDirection direction;
-	private EdgeType type;
-	private boolean isPrivate;
+    private Filter filter;
+    private Optional<SchemaVersion> v;
+    private String nodeA;
+    private String nodeB;
+    private String label;
+    private AAIDirection direction;
+    private EdgeType type;
+    private boolean isPrivate;
+
+    public static class Builder {
+        private static final String TO_ONLY = "ToOnly";
+
+        private static final String FROM_ONLY = "FromOnly";
 
-	public static class Builder {
-		//required 
-		private String nodeA;
-		
-		//optional - null will translate to any value of the param
-		private String nodeB = null; 
-		private String label = null;
-		private EdgeType type = null;
-		private AAIDirection direction = null;
-		private boolean isPrivate = false;
-		private SchemaVersion version = null;
-		
-		public Builder(String nodeA) {
-			this.nodeA = nodeA;
-		}
-		
-		public Builder(String nodeA, String nodeB) {
-			this.nodeA = nodeA;
-			this.nodeB = nodeB;
-		}
-		
-		private String getFirstNodeType() {
-			return nodeA;
-		}
-		public Builder fromOnly() {
-			this.nodeB = "FromOnly";
-			return this;
-		}
-		
-		private String getSecondNodeType() {
-			return nodeB;
-		}
-		public Builder toOnly() {
-			//Allows this to be used with single parameter constructor Builder(String nodeA)
-			if(StringUtils.isEmpty(this.nodeB) && StringUtils.isNotEmpty(this.nodeA) ) {
-				this.nodeB=this.nodeA;
-			}
-			this.nodeA = "ToOnly";
-			return this;
-		}
-		
-		public Builder label(String label) {
-			this.label = label;
-			return this;
-		}
-		
-		private String getLabel() {
-			return label;
-		}
-		
-		public Builder edgeType(EdgeType type) {
-			this.type = type;
-			return this;
-		}
-		
-		private EdgeType getEdgeType() {
-			return type;
-		}
-		
+        //required 
+        private String nodeA;
+        
+        //optional - null will translate to any value of the param
+        private String nodeB = null; 
+        private String label = null;
+        private EdgeType type = null;
+        private AAIDirection direction = null;
+        private boolean isPrivate = false;
+        private SchemaVersion version = null;
+        
+        public Builder(String nodeA) {
+            this.nodeA = nodeA;
+        }
+        
+        public Builder(String nodeA, String nodeB) {
+            this.nodeA = nodeA;
+            this.nodeB = nodeB;
+        }
+        
+        private String getFirstNodeType() {
+            return nodeA;
+        }
+        public Builder fromOnly() {
+            this.nodeB = FROM_ONLY;
+            return this;
+        }
+        
+        private String getSecondNodeType() {
+            return nodeB;
+        }
+        public Builder toOnly() {
+            //Allows this to be used with single parameter constructor Builder(String nodeA)
+            if(StringUtils.isEmpty(this.nodeB) && StringUtils.isNotEmpty(this.nodeA) ) {
+                this.nodeB=this.nodeA;
+            }
+            this.nodeA = TO_ONLY;
+            return this;
+        }
+        
+        public Builder label(String label) {
+            this.label = label;
+            return this;
+        }
+        
+        private String getLabel() {
+            return label;
+        }
+        
+        public Builder edgeType(EdgeType type) {
+            this.type = type;
+            return this;
+        }
+        
+        private EdgeType getEdgeType() {
+            return type;
+        }
+        
 
-		public Builder direction(AAIDirection direction) {
-			this.direction = direction;
-			return this;
-		}
-		
-		private AAIDirection getDirection() {
-			return direction;
-		}
-				
-		public Builder version(SchemaVersion version) {
-			this.version = version;
-			return this;
-		}
+        public Builder direction(AAIDirection direction) {
+            this.direction = direction;
+            return this;
+        }
+        
+        private AAIDirection getDirection() {
+            return direction;
+        }
+                
+        public Builder version(SchemaVersion version) {
+            this.version = version;
+            return this;
+        }
 
-		public Builder setPrivate(boolean isPrivate){
-			this.isPrivate = isPrivate;
-			return this;
-		}
+        public Builder setPrivate(boolean isPrivate){
+            this.isPrivate = isPrivate;
+            return this;
+        }
 
-		public boolean isPrivate(){
-		    return isPrivate;
-		}
+        public boolean isPrivate(){
+            return isPrivate;
+        }
 
-		private Optional<SchemaVersion> getSchemaVersion() {
-			return Optional.ofNullable(version);
-		}
-		
-		public EdgeRuleQuery build() {
-			return new EdgeRuleQuery(this);
-		}
-	}
-	
-	private EdgeRuleQuery(Builder builder) {
-		this.v = builder.getSchemaVersion();
-		this.nodeA = builder.getFirstNodeType();
-		this.nodeB = builder.getSecondNodeType();
-		this.label = builder.getLabel();
-		this.type = builder.getEdgeType();
-		this.direction = builder.getDirection();
-		this.isPrivate = builder.isPrivate();
-		
-		//will cover from A to B case
-		List<Predicate> criteriaFromTo = new ArrayList<>();
-		//Special logic to allow for A to B case only
-		if(("FromOnly").equals(builder.getSecondNodeType())) {
-				criteriaFromTo.add(buildToFromPart(builder.getFirstNodeType(), null));
-		} else {
-			criteriaFromTo.add(buildToFromPart(builder.getFirstNodeType(), builder.getSecondNodeType()));
-		}
-		//will cover from B to A case - must be separate bc jsonpath won't let me OR predicates >:C
-		List<Predicate> criteriaToFrom = new ArrayList<>();
-		//Special logic to allow for B to A case only
-		if(("ToOnly").equals(builder.getFirstNodeType())) {
-			criteriaToFrom.add(buildToFromPart(null, builder.getSecondNodeType()));
-		} else {
-			criteriaToFrom.add(buildToFromPart(builder.getSecondNodeType(), builder.getFirstNodeType()));
-		}
-		if (builder.getLabel() != null) {
-			Predicate labelPred = addLabel(builder.getLabel());
-			criteriaFromTo.add(labelPred);
-			criteriaToFrom.add(labelPred);
-		}
-		
-		if (builder.getEdgeType() != null) {
-			Predicate typePred = addType(builder.getEdgeType());
-			criteriaFromTo.add(typePred);
-			criteriaToFrom.add(typePred);
-		}
-		Predicate privatePredicate = where("private").is(String.valueOf(isPrivate));
+        private Optional<SchemaVersion> getSchemaVersion() {
+            return Optional.ofNullable(version);
+        }
+        
+        public EdgeRuleQuery build() {
+            return new EdgeRuleQuery(this);
+        }
+    }
+    
+    private EdgeRuleQuery(Builder builder) {
+        this.v = builder.getSchemaVersion();
+        this.nodeA = builder.getFirstNodeType();
+        this.nodeB = builder.getSecondNodeType();
+        this.label = builder.getLabel();
+        this.type = builder.getEdgeType();
+        this.direction = builder.getDirection();
+        this.isPrivate = builder.isPrivate();
+        
+        //will cover from A to B case
+        List<Predicate> criteriaFromTo = new ArrayList<>();
+        //Special logic to allow for A to B case only
+        if(("FromOnly").equals(builder.getSecondNodeType())) {
+                criteriaFromTo.add(buildToFromPart(builder.getFirstNodeType(), null));
+        } else {
+            criteriaFromTo.add(buildToFromPart(builder.getFirstNodeType(), builder.getSecondNodeType()));
+        }
+        //will cover from B to A case - must be separate bc jsonpath won't let me OR predicates >:C
+        List<Predicate> criteriaToFrom = new ArrayList<>();
+        //Special logic to allow for B to A case only
+        if(("ToOnly").equals(builder.getFirstNodeType())) {
+            criteriaToFrom.add(buildToFromPart(null, builder.getSecondNodeType()));
+        } else {
+            criteriaToFrom.add(buildToFromPart(builder.getSecondNodeType(), builder.getFirstNodeType()));
+        }
+        if (builder.getLabel() != null) {
+            Predicate labelPred = addLabel(builder.getLabel());
+            criteriaFromTo.add(labelPred);
+            criteriaToFrom.add(labelPred);
+        }
+        
+        if (builder.getEdgeType() != null) {
+            Predicate typePred = addType(builder.getEdgeType());
+            criteriaFromTo.add(typePred);
+            criteriaToFrom.add(typePred);
+        }
+        Predicate privatePredicate = where("private").is(String.valueOf(isPrivate));
 
-		if(isPrivate){
-			criteriaFromTo.add(privatePredicate);
-			criteriaToFrom.add(privatePredicate);
-		}
-		
-		if (builder.getDirection() != null) {
-			Predicate directionPred = addDirection(builder.getDirection());
-			criteriaFromTo.add(directionPred);
-			criteriaToFrom.add(directionPred);
-		}
-		if(("ToOnly").equals(builder.getFirstNodeType())) {
-			this.filter = filter(criteriaToFrom);
-		} else if(("FromOnly").equals(builder.getSecondNodeType())) {
-			this.filter = filter(criteriaFromTo);
-		} else {
-			this.filter = filter(criteriaFromTo).or(filter(criteriaToFrom));
-		}
-	}
-	
-	private Predicate buildToFromPart(String from, String to) {
-		if (from == null && to == null) { //shouldn't ever happen though
-			throw new IllegalStateException("must have at least one node defined");
-		}
-		
-		Predicate p;
-		
-		if (to == null) {
-			p = where(EdgeField.FROM.toString()).is(from);
-		} else if (from == null) {
-			p = where(EdgeField.TO.toString()).is(to);
-		} else {
-			p = where(EdgeField.FROM.toString()).is(from).and(EdgeField.TO.toString()).is(to);
-		}
-		
-		return p;
-	}
-	
-	private Predicate addLabel(String label) {
-		return where(EdgeField.LABEL.toString()).is(label);
-	}
-	
-	private Predicate addType(EdgeType type) {
-		if (type == EdgeType.COUSIN) {
-			return where(EdgeProperty.CONTAINS.toString()).is(AAIDirection.NONE.toString());
-		} else { //equals TREE
-			return where(EdgeProperty.CONTAINS.toString()).ne(AAIDirection.NONE.toString());
-		}
-	}
-		
-	private Predicate addDirection(AAIDirection direction) {
-			if (direction == AAIDirection.OUT) {
-				return where(EdgeField.DIRECTION.toString()).in(AAIDirection.OUT.toString(), AAIDirection.BOTH.toString());
-			} else if (direction == AAIDirection.IN) {
-				return where(EdgeField.DIRECTION.toString()).in(AAIDirection.IN.toString(), AAIDirection.BOTH.toString());
-			} else if (direction == AAIDirection.BOTH) {
-				return where(EdgeField.DIRECTION.toString()).is(AAIDirection.BOTH.toString());
-			} else if (direction == AAIDirection.NONE) {
-				return where(EdgeField.DIRECTION.toString()).is(AAIDirection.NONE.toString());
-			}
-			return where(EdgeField.DIRECTION.toString()).is(AAIDirection.NONE.toString());
-	}
-	
-	/**
-	 * Provides the JsonPath filter for actually querying the edge rule schema files
-	 * @return Filter
-	 */
-	public Filter getFilter() {
-		return this.filter;
-	}
-	
-	/**
-	 * Gets the first node type given for the query.
-	 * 
-	 * ie, If you called Builder(A,B) this would return A,
-	 * if you called Builder(B,A), it would return B,
-	 * if you called Builder(A), it would return A.
-	 * 
-	 * This is to maintain backwards compatibility with the
-	 * EdgeRules API which flipped the direction of
-	 * the result EdgeRule to match the input directionality.
-	 * 
-	 * @return String first node type of the query
-	 */
-	public String getFromType() {
-		return this.nodeA;
-	}
-	
-	/**
-	 * So the Ingestor knows which version of the rules to search
-	 * @return the Version
-	 */
-	public Optional<SchemaVersion> getVersion() {
-		return this.v;
-	}
-	
-	@Override
-	public String toString() {
-		StringBuilder sb = new StringBuilder();
-		
-		sb.append("EdgeRuleQuery with filter params node type: ").append(nodeA);
-		
-		if (nodeB != null) {
-			sb.append(", node type: ").append(nodeB);
-		}
-		
-		if (label != null) {
-			sb.append(", label: ").append(label);
-		} 
-		
-		sb.append(", type: ");
-		if (type != null) {
-			sb.append(type.toString());
-		} else {
-			sb.append("any");
-		}
+        if(isPrivate){
+            criteriaFromTo.add(privatePredicate);
+            criteriaToFrom.add(privatePredicate);
+        }
+        
+        if (builder.getDirection() != null) {
+            Predicate directionPred = addDirection(builder.getDirection());
+            criteriaFromTo.add(directionPred);
+            criteriaToFrom.add(directionPred);
+        }
+        if(("ToOnly").equals(builder.getFirstNodeType())) {
+            this.filter = filter(criteriaToFrom);
+        } else if(("FromOnly").equals(builder.getSecondNodeType())) {
+            this.filter = filter(criteriaFromTo);
+        } else {
+            this.filter = filter(criteriaFromTo).or(filter(criteriaToFrom));
+        }
+    }
+    
+    private Predicate buildToFromPart(String from, String to) {
+        if (from == null && to == null) { //shouldn't ever happen though
+            throw new IllegalStateException("must have at least one node defined");
+        }
+        
+        Predicate p;
+        
+        if (to == null) {
+            p = where(EdgeField.FROM.toString()).is(from);
+        } else if (from == null) {
+            p = where(EdgeField.TO.toString()).is(to);
+        } else {
+            p = where(EdgeField.FROM.toString()).is(from).and(EdgeField.TO.toString()).is(to);
+        }
+        
+        return p;
+    }
+    
+    private Predicate addLabel(String label) {
+        return where(EdgeField.LABEL.toString()).is(label);
+    }
+    
+    private Predicate addType(EdgeType type) {
+        if (type == EdgeType.COUSIN) {
+            return where(EdgeProperty.CONTAINS.toString()).is(AAIDirection.NONE.toString());
+        } else { //equals TREE
+            return where(EdgeProperty.CONTAINS.toString()).ne(AAIDirection.NONE.toString());
+        }
+    }
+        
+    private Predicate addDirection(AAIDirection direction) {
+            if (direction == AAIDirection.OUT) {
+                return where(EdgeField.DIRECTION.toString()).in(AAIDirection.OUT.toString(), AAIDirection.BOTH.toString());
+            } else if (direction == AAIDirection.IN) {
+                return where(EdgeField.DIRECTION.toString()).in(AAIDirection.IN.toString(), AAIDirection.BOTH.toString());
+            } else if (direction == AAIDirection.BOTH) {
+                return where(EdgeField.DIRECTION.toString()).is(AAIDirection.BOTH.toString());
+            } else if (direction == AAIDirection.NONE) {
+                return where(EdgeField.DIRECTION.toString()).is(AAIDirection.NONE.toString());
+            }
+            return where(EdgeField.DIRECTION.toString()).is(AAIDirection.NONE.toString());
+    }
+    
+    /**
+     * Provides the JsonPath filter for actually querying the edge rule schema files
+     * @return Filter
+     */
+    public Filter getFilter() {
+        return this.filter;
+    }
+    
+    /**
+     * Gets the first node type given for the query.
+     * 
+     * ie, If you called Builder(A,B) this would return A,
+     * if you called Builder(B,A), it would return B,
+     * if you called Builder(A), it would return A.
+     * 
+     * This is to maintain backwards compatibility with the
+     * EdgeRules API which flipped the direction of
+     * the result EdgeRule to match the input directionality.
+     * 
+     * @return String first node type of the query
+     */
+    public String getFromType() {
+        return this.nodeA;
+    }
+    
+    /**
+     * So the Ingestor knows which version of the rules to search
+     * @return the Version
+     */
+    public Optional<SchemaVersion> getVersion() {
+        return this.v;
+    }
+    
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        
+        sb.append("EdgeRuleQuery with filter params node type: ").append(nodeA);
+        
+        if (nodeB != null) {
+            sb.append(", node type: ").append(nodeB);
+        }
+        
+        if (label != null) {
+            sb.append(", label: ").append(label);
+        } 
+        
+        sb.append(", type: ");
+        if (type != null) {
+            sb.append(type.toString());
+        } else {
+            sb.append("any");
+        }
 
-		sb.append(", isPrivate: ");
-		sb.append(isPrivate);
+        sb.append(", isPrivate: ");
+        sb.append(isPrivate);
 
-		if(v.isPresent()){
-			sb.append(", for version: ").append(v.get().toString()).append(".");
-		}
-		return sb.toString();
-	}
+        if(v.isPresent()){
+            sb.append(", for version: ").append(v.get().toString()).append(".");
+        }
+        return sb.toString();
+    }
 }