* ============LICENSE_START=======================================================
* org.onap.aai
* ================================================================================
- * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright © 2017-18 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.
* See the License for the specific language governing permissions and
* limitations under the License.
* ============LICENSE_END=========================================================
- *
- * ECOMP is a trademark and service mark of AT&T Intellectual Property.
*/
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;
import org.onap.aai.edges.enums.EdgeType;
-import org.onap.aai.setup.Version;
+import org.onap.aai.setup.SchemaVersion;
import com.jayway.jsonpath.Filter;
import com.jayway.jsonpath.Predicate;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import static com.jayway.jsonpath.Criteria.where;
*/
public class EdgeRuleQuery {
private Filter filter;
- private Version v;
+ 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 {
//required
private String nodeB = null;
private String label = null;
private EdgeType type = null;
- private Version version = Version.getLatest(); //default
+ private AAIDirection direction = null;
+ private boolean isPrivate = false;
+ private SchemaVersion version = null;
public Builder(String nodeA) {
this.nodeA = nodeA;
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 type;
}
- public Builder version(Version version) {
+
+ 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;
}
- private Version getVersion() {
- return version;
+
+ public Builder setPrivate(boolean isPrivate){
+ this.isPrivate = isPrivate;
+ return this;
+ }
+
+ public boolean isPrivate(){
+ return isPrivate;
+ }
+
+ private Optional<SchemaVersion> getSchemaVersion() {
+ return Optional.ofNullable(version);
}
public EdgeRuleQuery build() {
}
private EdgeRuleQuery(Builder builder) {
- this.v = builder.getVersion();
+ 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<>();
- criteriaFromTo.add(buildToFromPart(builder.getFirstNodeType(), builder.getSecondNodeType()));
+ //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<>();
- criteriaToFrom.add(buildToFromPart(builder.getSecondNodeType(), builder.getFirstNodeType()));
-
-
-
+ //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);
criteriaFromTo.add(typePred);
criteriaToFrom.add(typePred);
}
-
+ Predicate privatePredicate = where("private").is(String.valueOf(isPrivate));
+ if(isPrivate){
+ criteriaFromTo.add(privatePredicate);
+ criteriaToFrom.add(privatePredicate);
+ }
- this.filter = filter(criteriaFromTo).or(filter(criteriaToFrom));
+ 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) {
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 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 Version getVersion() {
+ public Optional<SchemaVersion> getVersion() {
return this.v;
}
} else {
sb.append("any");
}
-
- sb.append(", for version: ").append(v.toString()).append(".");
- return sb.toString();
+
+ sb.append(", isPrivate: ");
+ sb.append(isPrivate);
+
+ if(v.isPresent()){
+ sb.append(", for version: ").append(v.get().toString()).append(".");
+ }
+ return sb.toString();
}
}
+
+
Code Review / aai / aai-common.git / blobdiff