New endpoints to auto populate edge properties.

New endpoints created to allow v11 endpoints to have their properties
automatically set based on db edge rules.

Issue-Id: AAI-60

Change-Id: I9b41f654fa9924b1dcb863aca369725a763b3691
Signed-off-by: gfraboni <gino.fraboni@amdocs.com>

6 files changed, 591 insertions, 0 deletions

diff --git a/src/main/java/org/openecomp/crud/dao/GraphDao.java b/src/main/java/org/openecomp/crud/dao/GraphDao.java
index 20b568c..c714249 100644
--- a/src/main/java/org/openecomp/crud/dao/GraphDao.java
+++ b/src/main/java/org/openecomp/crud/dao/GraphDao.java
@@ -32,6 +32,8 @@ import java.util.Map;
 
 public interface GraphDao {
 
+  public Vertex getVertex(String id) throws CrudException;
+
   public Vertex getVertex(String id, String type) throws CrudException;
 
   /**
diff --git a/src/main/java/org/openecomp/crud/dao/champ/ChampDao.java b/src/main/java/org/openecomp/crud/dao/champ/ChampDao.java
index 5e9d10a..31bc9ab 100644
--- a/src/main/java/org/openecomp/crud/dao/champ/ChampDao.java
+++ b/src/main/java/org/openecomp/crud/dao/champ/ChampDao.java
@@ -96,6 +96,40 @@ public class ChampDao implements GraphDao {
   }
 
   @Override
+  public Vertex getVertex(String id) throws CrudException {
+    
+    try {
+      
+      if (logger.isDebugEnabled()) {
+        logger.debug("getVertex with id: " + id);
+      }
+      
+      long idAsLong = Long.parseLong(id);
+      
+      Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
+      
+      String nodeType = org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName();
+      if(retrievedVertex.isPresent() && 
+         retrievedVertex.get().getProperties().get(nodeType)!=null) {
+        return vertexFromChampObject(retrievedVertex.get(), 
+                                     retrievedVertex.get().getProperties().get(nodeType).toString());
+      } else {
+
+        // We didn't find a vertex with the supplied id, so just throw an
+        // exception.
+        throw new CrudException("No vertex with id " + id + " found in graph",
+                                javax.ws.rs.core.Response.Status.NOT_FOUND);
+      }
+      
+    } catch (ChampUnmarshallingException | ChampTransactionException e) {
+
+      // Something went wrong - throw an exception.
+      throw new CrudException(e.getMessage(),
+                              javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+    }
+  }
+  
+  @Override
   public Vertex getVertex(String id, String type) throws CrudException {
 
     try {
diff --git a/src/main/java/org/openecomp/crud/service/AaiResourceService.java b/src/main/java/org/openecomp/crud/service/AaiResourceService.java
new file mode 100644
index 0000000..b8ac158
--- /dev/null
+++ b/src/main/java/org/openecomp/crud/service/AaiResourceService.java
@@ -0,0 +1,533 @@
+/**

+ * ============LICENSE_START=======================================================

+ * Gizmo

+ * ================================================================================

+ * Copyright © 2017 AT&T Intellectual Property.

+ * Copyright © 2017 Amdocs

+ * 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.

+ * You may obtain a copy of the License at

+ *

+ *    http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * 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.openecomp.crud.service;

+

+import java.security.cert.X509Certificate;

+import java.util.AbstractMap;

+import java.util.HashSet;

+import java.util.Map;

+import java.util.Map.Entry;

+import java.util.Set;

+

+import javax.security.auth.x500.X500Principal;

+import javax.servlet.http.HttpServletRequest;

+import javax.ws.rs.Consumes;

+import javax.ws.rs.Encoded;

+import javax.ws.rs.POST;

+import javax.ws.rs.PUT;

+import javax.ws.rs.Path;

+import javax.ws.rs.PathParam;

+import javax.ws.rs.Produces;

+import javax.ws.rs.core.Context;

+import javax.ws.rs.core.HttpHeaders;

+import javax.ws.rs.core.MediaType;

+import javax.ws.rs.core.Response;

+import javax.ws.rs.core.UriInfo;

+import javax.ws.rs.core.Response.Status;

+

+import org.openecomp.aai.exceptions.AAIException;

+import org.openecomp.aai.serialization.db.EdgeProperty;

+import org.openecomp.aai.serialization.db.EdgeRule;

+import org.openecomp.aai.serialization.db.EdgeRules;

+import org.openecomp.aai.serialization.db.EdgeType;

+import org.openecomp.auth.Auth;

+import org.openecomp.cl.api.Logger;

+import org.openecomp.cl.eelf.LoggerFactory;

+import org.openecomp.crud.exception.CrudException;

+import org.openecomp.crud.logging.CrudServiceMsgs;

+import org.openecomp.crud.logging.LoggingUtil;

+import org.openecomp.crud.service.CrudRestService.Action;

+import org.openecomp.crud.util.CrudServiceConstants;

+import org.openecomp.schema.RelationshipSchemaLoader;

+import org.openecomp.schema.RelationshipSchemaValidator;

+import org.slf4j.MDC;

+

+import com.google.gson.Gson;

+import com.google.gson.JsonElement;

+import com.google.gson.JsonPrimitive;

+

+

+/**

+ * This defines a set of REST endpoints which allow clients to create or update graph edges

+ * where the edge rules defined by the A&AI will be invoked to automatically populate the

+ * defined edge properties.

+ */

+public class AaiResourceService {

+

+  private String mediaType = MediaType.APPLICATION_JSON;

+  public static final String HTTP_PATCH_METHOD_OVERRIDE = "X-HTTP-Method-Override";

+  

+  private Auth auth;

+  CrudGraphDataService crudGraphDataService;

+  Gson gson = new Gson();

+  

+  private Logger logger      = LoggerFactory.getInstance().getLogger(AaiResourceService.class.getName());

+  private Logger auditLogger = LoggerFactory.getInstance().getAuditLogger(AaiResourceService.class.getName());

+ 

+  public AaiResourceService() {}

+  

+  /**

+   * Creates a new instance of the AaiResourceService.

+   * 

+   * @param crudGraphDataService - Service used for interacting with the graph.

+   * 

+   * @throws Exception

+   */

+  public AaiResourceService(CrudGraphDataService crudGraphDataService) throws Exception {

+    this.crudGraphDataService = crudGraphDataService;

+    this.auth                 = new Auth(CrudServiceConstants.CRD_AUTH_FILE);

+  }

+  

+  /**

+   * Perform any one-time initialization required when starting the service.

+   */

+  public void startup() {

+    

+    if(logger.isDebugEnabled()) {

+      logger.debug("AaiResourceService started!");

+    }

+  }

+  

+  

+  /**

+   * Creates a new relationship in the graph, automatically populating the edge

+   * properties based on the A&AI edge rules.

+   * 

+   * @param content - Json structure describing the relationship to create.

+   * @param type    - Relationship type supplied as a URI parameter.

+   * @param uri     - Http request uri

+   * @param headers - Http request headers

+   * @param uriInfo - Http URI info field

+   * @param req     - Http request structure.

+   * 

+   * @return - Standard HTTP response.

+   */

+  @POST

+  @Path("/relationships/{type}/")

+  @Consumes({MediaType.APPLICATION_JSON})

+  @Produces({MediaType.APPLICATION_JSON})

+  public Response createRelationship(String content, 

+                                     @PathParam("type") String type, 

+                                     @PathParam("uri") @Encoded String uri,

+                                     @Context HttpHeaders headers, 

+                                     @Context UriInfo uriInfo,

+                                     @Context HttpServletRequest req) {

+    

+    LoggingUtil.initMdcContext(req, headers);

+

+    if(logger.isDebugEnabled()) {

+      logger.debug("Incoming request..." + content);

+    }

+    

+    Response response = null;

+

+    if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {

+      

+      try {

+        

+        // Extract the edge payload from the request.

+        EdgePayload payload = EdgePayload.fromJson(content);   

+        

+        // Do some basic validation on the payload.

+        if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {

+          throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);

+        }

+        if (payload.getId() != null) {

+          throw new CrudException("ID specified , use Http PUT to update Edge", Status.BAD_REQUEST);

+        }

+        if (payload.getType() != null && !payload.getType().equals(type)) {

+          throw new CrudException("Edge Type mismatch", Status.BAD_REQUEST);

+        }

+        

+        // Apply the edge rules to our edge.

+        payload = applyEdgeRulesToPayload(payload);

+        

+        if(logger.isDebugEnabled()) {

+          logger.debug("Creating AAI edge using version " + RelationshipSchemaLoader.getLatestSchemaVersion() );

+        }

+        

+        // Now, create our edge in the graph store.

+        String result = crudGraphDataService.addEdge(RelationshipSchemaLoader.getLatestSchemaVersion(), type, payload);

+        response = Response.status(Status.CREATED).entity(result).type(mediaType).build();

+        

+      } catch (CrudException e) {

+

+        response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();

+      }   

+    }

+    

+    LoggingUtil.logRestRequest(logger, auditLogger, req, response);

+    return response;

+  }

+  

+  

+  /**

+   * Creates a new relationship in the graph, automatically populating the edge

+   * properties based on the A&AI edge rules.

+   * 

+   * @param content - Json structure describing the relationship to create.

+   * @param uri     - Http request uri

+   * @param headers - Http request headers

+   * @param uriInfo - Http URI info field

+   * @param req     - Http request structure.

+   * 

+   * @return - Standard HTTP response.

+   *    

+   */

+  @POST

+  @Path("/relationships/")

+  @Consumes({MediaType.APPLICATION_JSON})

+  @Produces({MediaType.APPLICATION_JSON})

+  public Response createRelationship(String content, 

+                                     @PathParam("uri") @Encoded String uri, 

+                                     @Context HttpHeaders headers,

+                                     @Context UriInfo uriInfo, 

+                                     @Context HttpServletRequest req) {

+

+    LoggingUtil.initMdcContext(req, headers);

+

+    logger.debug("Incoming request..." + content);

+    Response response = null;

+

+    if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {

+

+      try {

+        

+        // Extract the edge payload from the request.

+        EdgePayload payload = EdgePayload.fromJson(content);

+        

+        // Do some basic validation on the payload.

+        if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {

+          throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);

+        }

+        if (payload.getId() != null) {

+          throw new CrudException("ID specified , use Http PUT to update Edge", Status.BAD_REQUEST);

+        }

+        if (payload.getType() == null || payload.getType().isEmpty()) {

+          throw new CrudException("Missing Edge Type ", Status.BAD_REQUEST);

+        }

+        

+        // Apply the edge rules to our edge.

+        payload = applyEdgeRulesToPayload(payload);

+        

+        // Now, create our edge in the graph store.

+        String result = crudGraphDataService.addEdge(RelationshipSchemaLoader.getLatestSchemaVersion(), payload.getType(), payload);

+        response = Response.status(Status.CREATED).entity(result).type(mediaType).build();

+      

+      } catch (CrudException ce) {

+        response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();

+      } catch (Exception e) {

+        response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();

+      }

+    } else {

+      response = Response.status(Status.FORBIDDEN).entity(content)

+          .type(MediaType.APPLICATION_JSON).build();

+    }

+

+    LoggingUtil.logRestRequest(logger, auditLogger, req, response);

+    return response;

+  }

+

+  

+  

+  /**

+   * Upserts a relationship into the graph, automatically populating the edge properties

+   * based on the A&AI edge rules.  The behaviour is as follows:

+   * <p>

+   * <li>If no relationship with the supplied identifier already exists, then a new relationship 

+   * is created with that id.<br>

+   * <li>If a relationship with the supplied id DOES exist, then it is replaced with the supplied 

+   * content.

+   * 

+   * @param content - Json structure describing the relationship to create.

+   * @param type    - Relationship type supplied as a URI parameter.

+   * @param id      - Edge identifier.

+   * @param uri     - Http request uri

+   * @param headers - Http request headers

+   * @param uriInfo - Http URI info field

+   * @param req     - Http request structure.

+   * 

+   * @return - Standard HTTP response.

+   */

+  @PUT

+  @Path("/relationships/{type}/{id}")

+  @Consumes({MediaType.APPLICATION_JSON})

+  @Produces({MediaType.APPLICATION_JSON})

+  public Response upsertEdge(String content, 

+                             @PathParam("type") String type, 

+                             @PathParam("id") String id,

+                             @PathParam("uri") @Encoded String uri, 

+                             @Context HttpHeaders headers,

+                             @Context UriInfo uriInfo, 

+                             @Context HttpServletRequest req) {

+    LoggingUtil.initMdcContext(req, headers);

+

+    logger.debug("Incoming request..." + content);

+    Response response = null;

+

+    if (validateRequest(req, uri, content, Action.PUT, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {

+      

+      try {

+        

+        // Extract the edge payload from the request.

+        EdgePayload payload = EdgePayload.fromJson(content);

+        

+        // Do some basic validation on the payload.

+        if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {

+          throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);

+        }

+        if (payload.getId() != null && !payload.getId().equals(id)) {

+          throw new CrudException("ID Mismatch", Status.BAD_REQUEST);

+        }

+        

+        // Apply the edge rules to our edge.

+        payload = applyEdgeRulesToPayload(payload);

+        

+        String result;

+        if (headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE) != null &&

+            headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE).equalsIgnoreCase("PATCH")) {

+          result = crudGraphDataService.patchEdge(RelationshipSchemaLoader.getLatestSchemaVersion(), id, type, payload);

+        } else {

+

+          result = crudGraphDataService.updateEdge(RelationshipSchemaLoader.getLatestSchemaVersion(), id, type, payload);

+        }

+

+        response = Response.status(Status.OK).entity(result).type(mediaType).build();

+        

+      } catch (CrudException ce) {

+        response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();

+      } catch (Exception e) {

+        response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();

+      }

+      

+    } else {

+      

+      response = Response.status(Status.FORBIDDEN).entity(content)

+          .type(MediaType.APPLICATION_JSON).build();

+    }

+    

+    LoggingUtil.logRestRequest(logger, auditLogger, req, response);

+    return response;

+  }

+  

+  

+  /**

+   * Retrieves the properties defined in the edge rules for a relationship between the 

+   * supplied vertex types.

+   * 

+   * @param sourceVertexType - Type of source vertex for the relationship.

+   * @param targetVertexType - Type of target vertex for the relationship.

+   * 

+   * @return - The defined properties for the relationship type.

+   *  

+   * @throws CrudException

+   */

+  private Map<EdgeProperty, String> getEdgeRuleProperties(String sourceVertexType, String targetVertexType) throws CrudException {

+

+    if(logger.isDebugEnabled()) {

+      logger.debug("Lookup db edge rules for " + sourceVertexType + " -> " + targetVertexType);

+    }

+    

+    EdgeRules rules = EdgeRules.getInstance();

+    EdgeRule rule;

+    try {

+      

+      if(logger.isDebugEnabled()) {

+        logger.debug("Lookup by edge type TREE");

+      }

+      

+      // We have no way of knowing in advance whether our relationship is considered to

+      // be a tree or cousing relationship, so try looking it up as a tree type first.

+      rule = rules.getEdgeRule(EdgeType.TREE, sourceVertexType, targetVertexType);

+      

+    } catch (AAIException e) {

+      try {

+        

+        if(logger.isDebugEnabled()) {

+          logger.debug("Lookup by edge type COUSIN");

+        }

+        

+        // If we are here, then our lookup by 'tree' type failed, so try looking it up

+        // as a 'cousin' relationship.

+        rule = rules.getEdgeRule(EdgeType.COUSIN, sourceVertexType, targetVertexType);

+        

+      } catch (AAIException e1) {

+        

+        // If we're here then we failed to find edge rules for this relationship.  Time to

+        // give up...

+        throw new CrudException("No edge rules for " + sourceVertexType + " -> " + targetVertexType, Status.NOT_FOUND);

+      }

+    } catch (Exception e) {

+      

+      throw new CrudException("General failure getting edge rule properties - " + 

+                              e.getMessage(), Status.INTERNAL_SERVER_ERROR);

+    }

+    

+    return rule.getEdgeProperties();

+  }

+  

+  

+  /**

+   * This method takes an inbound edge request payload, looks up the edge rules for the

+   * sort of relationship defined in the payload, and automatically applies the defined

+   * edge properties to it.

+   * 

+   * @param payload - The original edge request payload

+   * 

+   * @return - An updated edge request payload, with the properties defined in the edge

+   *           rules automatically populated.

+   *           

+   * @throws CrudException

+   */

+  public EdgePayload applyEdgeRulesToPayload(EdgePayload payload) throws CrudException {

+    

+    // Extract the types for both the source and target vertices.

+    String srcType = RelationshipSchemaValidator.vertexTypeFromUri(payload.getSource());

+    String tgtType = RelationshipSchemaValidator.vertexTypeFromUri(payload.getTarget());

+

+      // Now, get the default properties for this edge based on the edge rules definition...

+      Map<EdgeProperty, String> props = getEdgeRuleProperties(srcType, tgtType);

+      

+      // ...and merge them with any custom properties provided in the request.

+      JsonElement mergedProperties = mergeProperties(payload.getProperties(), props);

+      payload.setProperties(mergedProperties);

+    

+    

+    if(logger.isDebugEnabled()) {

+      logger.debug("Edge properties after applying rules for '" + srcType + " -> " + tgtType + "': " + mergedProperties);

+    }

+    

+    return payload;

+  }

+  

+  

+  /**

+   * Given a set of edge properties extracted from an edge request payload and a set of properties

+   * taken from the db edge rules, this method merges them into one set of properties.

+   * <p>

+   * If the client has attempted to override the defined value for a property in the db edge rules

+   * then the request will be rejected as invalid.

+   * 

+   * @param propertiesFromRequest - Set of properties from the edge request.

+   * @param propertyDefaults      - Set of properties from the db edge rules.

+   * 

+   * @return - A merged set of properties.

+   * 

+   * @throws CrudException

+   */

+  public JsonElement mergeProperties(JsonElement propertiesFromRequest, Map<EdgeProperty, String> propertyDefaults) throws CrudException {

+        

+    // Convert the properties from the edge payload into something we can

+    // manipulate.

+    Set<Map.Entry<String, JsonElement>> properties = new HashSet<Map.Entry<String, JsonElement>>();

+    properties.addAll(propertiesFromRequest.getAsJsonObject().entrySet());

+    

+    Set<String> propertyKeys = new HashSet<String>();

+    for(Map.Entry<String, JsonElement> property : properties) {

+      propertyKeys.add(property.getKey());

+    }

+    

+    // Now, merge in the properties specified in the Db Edge Rules.

+    for(EdgeProperty defProperty : propertyDefaults.keySet()) {

+      

+      // If the edge rules property was explicitly specified by the

+      // client then we will reject the request...

+      if(!propertyKeys.contains(defProperty.toString())) {

+        properties.add(new AbstractMap.SimpleEntry<String, JsonElement>(defProperty.toString(),

+            (JsonElement)(new JsonPrimitive(propertyDefaults.get(defProperty)))));

+        

+      } else {

+        throw new CrudException("Property " + defProperty + " defined in db edge rules can not be overriden by the client.", 

+                                Status.BAD_REQUEST);

+      }    

+    }

+

+    Object[] propArray = properties.toArray();

+    StringBuilder sb = new StringBuilder();

+    sb.append("{");

+    boolean first=true;

+    for(int i=0; i<propArray.length; i++) {

+      

+      Map.Entry<String, JsonElement> entry = (Entry<String, JsonElement>) propArray[i];

+      if(!first) {

+        sb.append(",");

+      }

+      sb.append("\"").append(entry.getKey()).append("\"").append(":").append(entry.getValue());

+      first=false;

+    }

+    sb.append("}");

+    

+    // We're done.  Return the result as a JsonElement.

+    return gson.fromJson(sb.toString(), JsonElement.class);

+  }

+

+

+  /**

+   * Invokes authentication validation on an incoming HTTP request.

+   * 

+   * @param req                    - The HTTP request.

+   * @param uri                    - HTTP URI

+   * @param content                - Payload of the HTTP request.

+   * @param action                 - What HTTP action is being performed (GET/PUT/POST/PATCH/DELETE)

+   * @param authPolicyFunctionName - Policy function being invoked.

+   * 

+   * @return true  - if the request passes validation,

+   *         false - otherwise.

+   */

+  protected boolean validateRequest(HttpServletRequest req, 

+                                    String uri, 

+                                    String content,

+                                    Action action, 

+                                    String authPolicyFunctionName) {

+    try {

+      String cipherSuite = (String) req.getAttribute("javax.servlet.request.cipher_suite");

+      String authUser = null;

+      if (cipherSuite != null) {

+                

+        X509Certificate[] certChain = (X509Certificate[]) req.getAttribute("javax.servlet.request.X509Certificate");

+        X509Certificate clientCert = certChain[0];

+        X500Principal subjectDn = clientCert.getSubjectX500Principal();

+        authUser = subjectDn.toString();

+      }

+      

+      return this.auth.validateRequest(authUser.toLowerCase(), action.toString() + ":" + authPolicyFunctionName);

+      

+    } catch (Exception e) {

+      logResult(action, uri, e);

+      return false;

+    }

+  }

+  

+  protected void logResult(Action op, String uri, Exception e) {

+

+    logger.error(CrudServiceMsgs.EXCEPTION_DURING_METHOD_CALL, 

+                 op.toString(), 

+                 uri, 

+                 e.getStackTrace().toString());

+

+    // Clear the MDC context so that no other transaction inadvertently

+    // uses our transaction id.

+    MDC.clear();

+  }

+}

diff --git a/src/main/java/org/openecomp/crud/service/CrudGraphDataService.java b/src/main/java/org/openecomp/crud/service/CrudGraphDataService.java
index e6d6748..a8c0248 100644
--- a/src/main/java/org/openecomp/crud/service/CrudGraphDataService.java
+++ b/src/main/java/org/openecomp/crud/service/CrudGraphDataService.java
@@ -159,6 +159,10 @@ public class CrudGraphDataService {
 
   }
 
+  public Vertex getVertex(String id) throws CrudException {
+    return dao.getVertex(id);
+  }
+  
   public String getVertex(String version, String id, String type) throws CrudException {
     type = OxmModelValidator.resolveCollectionType(version, type);
     Vertex vertex = dao.getVertex(id, type);
diff --git a/src/main/java/org/openecomp/crud/util/CrudServiceUtil.java b/src/main/java/org/openecomp/crud/util/CrudServiceUtil.java
index 25e3de6..b88f20b 100644
--- a/src/main/java/org/openecomp/crud/util/CrudServiceUtil.java
+++ b/src/main/java/org/openecomp/crud/util/CrudServiceUtil.java
@@ -41,6 +41,13 @@ public class CrudServiceUtil {
       } else if (clazz.isAssignableFrom(Double.class)) {
         return Double.parseDouble(value);
       } else if (clazz.isAssignableFrom(Boolean.class)) {
+		  
+		// If the value is an IN/OUT direction, this gets seen as a boolean, so
+        // check for that first.
+        if (value.equals("OUT") || value.equals("IN")) {
+          return value;
+        }
+		
         if (!value.equals("true") && !value.equals("false")) {
           throw new CrudException("Invalid propertry value: " + value, Status.BAD_REQUEST);
         }
diff --git a/src/main/java/org/openecomp/schema/RelationshipSchemaValidator.java b/src/main/java/org/openecomp/schema/RelationshipSchemaValidator.java
index af20699..e2374be 100644
--- a/src/main/java/org/openecomp/schema/RelationshipSchemaValidator.java
+++ b/src/main/java/org/openecomp/schema/RelationshipSchemaValidator.java
@@ -338,4 +338,15 @@ public class RelationshipSchemaValidator {
     return modelEdgeBuilder.build();
   }
 
+    
+  public static String vertexTypeFromUri(String uri) throws CrudException {
+      
+    Matcher matcher = urlPattern.matcher(uri);
+
+    if (!matcher.matches()) {
+      throw new CrudException("Invalid Source/Target Urls", Status.BAD_REQUEST);
+    }
+
+    return matcher.group(2);
+  }
 }