src/main/java/org/openecomp/crud/service/CrudRestService.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * Gizmo
   4  * ================================================================================
   5  * Copyright © 2017 AT&T Intellectual Property.
   6  * Copyright © 2017 Amdocs
   7  * All rights reserved.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *    http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  *
  22  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  23  */
  24 package org.openecomp.crud.service;
  25
  26 import org.apache.cxf.jaxrs.ext.PATCH;
  27 import org.openecomp.auth.Auth;
  28 import org.openecomp.cl.api.Logger;
  29 import org.openecomp.cl.eelf.LoggerFactory;
  30 import org.openecomp.crud.exception.CrudException;
  31 import org.openecomp.crud.logging.CrudServiceMsgs;
  32 import org.openecomp.crud.logging.LoggingUtil;
  33 import org.openecomp.crud.util.CrudServiceConstants;
  34 import org.slf4j.MDC;
  35
  36 import java.security.cert.X509Certificate;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import javax.security.auth.x500.X500Principal;
  41 import javax.servlet.http.HttpServletRequest;
  42 import javax.ws.rs.Consumes;
  43 import javax.ws.rs.DELETE;
  44 import javax.ws.rs.Encoded;
  45 import javax.ws.rs.GET;
  46 import javax.ws.rs.POST;
  47 import javax.ws.rs.PUT;
  48 import javax.ws.rs.Path;
  49 import javax.ws.rs.PathParam;
  50 import javax.ws.rs.Produces;
  51 import javax.ws.rs.core.Context;
  52 import javax.ws.rs.core.HttpHeaders;
  53 import javax.ws.rs.core.MediaType;
  54 import javax.ws.rs.core.Response;
  55 import javax.ws.rs.core.Response.Status;
  56 import javax.ws.rs.core.UriInfo;
  57
  58 public class CrudRestService {
  59
  60   private CrudGraphDataService crudGraphDataService;
  61   Logger logger = LoggerFactory.getInstance().getLogger(CrudRestService.class.getName());
  62   Logger auditLogger = LoggerFactory.getInstance().getAuditLogger(CrudRestService.class.getName());
  63   private Auth auth;
  64
  65   private String mediaType = MediaType.APPLICATION_JSON;
  66   public static final String HTTP_PATCH_METHOD_OVERRIDE = "X-HTTP-Method-Override";
  67
  68   public CrudRestService(CrudGraphDataService crudGraphDataService) throws Exception {
  69     this.crudGraphDataService = crudGraphDataService;
  70     this.auth = new Auth(CrudServiceConstants.CRD_AUTH_FILE);
  71   }
  72
  73   public enum Action {
  74     POST, GET, PUT, DELETE, PATCH
  75   }
  76
  77   ;
  78
  79   public void startup() {
  80
  81   }
  82
  83   @GET
  84   @Path("/{version}/{type}/{id}")
  85   @Consumes({MediaType.APPLICATION_JSON})
  86   @Produces({MediaType.APPLICATION_JSON})
  87   public Response getVertex(String content, @PathParam("version") String version,
  88                             @PathParam("type") String type, @PathParam("id") String id,
  89                             @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
  90                             @Context UriInfo uriInfo, @Context HttpServletRequest req) {
  91     LoggingUtil.initMdcContext(req, headers);
  92
  93     logger.debug("Incoming request..." + content);
  94     Response response = null;
  95
  96     if (validateRequest(req, uri, content, Action.GET, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
  97
  98       try {
  99         String result = crudGraphDataService.getVertex(version, id, type);
 100         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 101       } catch (CrudException ce) {
 102         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 103       } catch (Exception e) {
 104         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 105       }
 106     } else {
 107       response = Response.status(Status.FORBIDDEN).entity(content)
 108           .type(MediaType.APPLICATION_JSON).build();
 109     }
 110
 111     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 112     return response;
 113   }
 114
 115   @GET
 116   @Path("/{version}/{type}/")
 117   @Consumes({MediaType.APPLICATION_JSON})
 118   @Produces({MediaType.APPLICATION_JSON})
 119   public Response getVertices(String content, @PathParam("version") String version,
 120                               @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
 121                               @Context HttpHeaders headers, @Context UriInfo uriInfo,
 122                               @Context HttpServletRequest req) {
 123
 124     LoggingUtil.initMdcContext(req, headers);
 125
 126     logger.debug("Incoming request..." + content);
 127     Response response = null;
 128     if (validateRequest(req, uri, content, Action.GET, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 129
 130       Map<String, String> filter = new HashMap<String, String>();
 131       for (Map.Entry<String, List<String>> e : uriInfo.getQueryParameters().entrySet()) {
 132         filter.put(e.getKey(), e.getValue().get(0));
 133       }
 134
 135       try {
 136         String result = crudGraphDataService.getVertices(version, type, filter);
 137         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 138       } catch (CrudException ce) {
 139         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 140       } catch (Exception e) {
 141         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 142       }
 143     } else {
 144       response = Response.status(Status.FORBIDDEN).entity(content)
 145           .type(MediaType.APPLICATION_JSON).build();
 146     }
 147
 148     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 149     return response;
 150   }
 151
 152   @GET
 153   @Path("/relationships/{version}/{type}/{id}")
 154   @Consumes({MediaType.APPLICATION_JSON})
 155   @Produces({MediaType.APPLICATION_JSON})
 156   public Response getEdge(String content, @PathParam("version") String version,
 157                           @PathParam("type") String type, @PathParam("id") String id,
 158                           @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 159                           @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 160     LoggingUtil.initMdcContext(req, headers);
 161
 162     logger.debug("Incoming request..." + content);
 163     Response response = null;
 164
 165     if (validateRequest(req, uri, content, Action.GET, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 166
 167       try {
 168
 169         String result = crudGraphDataService.getEdge(version, id, type);
 170         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 171       } catch (CrudException ce) {
 172         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 173       } catch (Exception e) {
 174         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 175       }
 176     } else {
 177       response = Response.status(Status.FORBIDDEN).entity(content)
 178           .type(MediaType.APPLICATION_JSON).build();
 179     }
 180
 181     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 182     return response;
 183   }
 184
 185   @GET
 186   @Path("/relationships/{version}/{type}/")
 187   @Consumes({MediaType.APPLICATION_JSON})
 188   @Produces({MediaType.APPLICATION_JSON})
 189   public Response getEdges(String content, @PathParam("version") String version,
 190                            @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
 191                            @Context HttpHeaders headers, @Context UriInfo uriInfo,
 192                            @Context HttpServletRequest req) {
 193
 194     LoggingUtil.initMdcContext(req, headers);
 195
 196     logger.debug("Incoming request..." + content);
 197     Response response = null;
 198
 199     if (validateRequest(req, uri, content, Action.GET, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 200
 201       Map<String, String> filter = new HashMap<String, String>();
 202       for (Map.Entry<String, List<String>> e : uriInfo.getQueryParameters().entrySet()) {
 203         filter.put(e.getKey(), e.getValue().get(0));
 204       }
 205
 206       try {
 207         String result = crudGraphDataService.getEdges(version, type, filter);
 208         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 209       } catch (CrudException ce) {
 210         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 211       } catch (Exception e) {
 212         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 213       }
 214     } else {
 215       response = Response.status(Status.FORBIDDEN).entity(content)
 216           .type(MediaType.APPLICATION_JSON).build();
 217
 218     }
 219
 220     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 221     return response;
 222   }
 223
 224   @PUT
 225   @Path("/relationships/{version}/{type}/")
 226   @Consumes({MediaType.APPLICATION_JSON})
 227   @Produces({MediaType.APPLICATION_JSON})
 228   public Response updateEdgeWithoutId(String content, @Context HttpHeaders headers, @Context HttpServletRequest req) {
 229
 230     LoggingUtil.initMdcContext(req, headers);
 231
 232     logger.debug("Incoming request..." + content);
 233     Response response = Response.status (Status.BAD_REQUEST).entity ("Cannot Update Edge Without Specifying Id in URL").build();
 234
 235     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 236     return response;
 237   }
 238
 239   @PUT
 240   @Path("/relationships/{version}/{type}/{id}")
 241   @Consumes({MediaType.APPLICATION_JSON})
 242   @Produces({MediaType.APPLICATION_JSON})
 243   public Response updateEdge(String content, @PathParam("version") String version,
 244                              @PathParam("type") String type, @PathParam("id") String id,
 245                              @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 246                              @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 247
 248     LoggingUtil.initMdcContext(req, headers);
 249
 250     logger.debug("Incoming request..." + content);
 251     Response response = null;
 252
 253     if (validateRequest(req, uri, content, Action.PUT, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 254
 255       try {
 256         EdgePayload payload = EdgePayload.fromJson(content);
 257         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 258           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 259         }
 260         if (payload.getId() != null && !payload.getId().equals(id)) {
 261           throw new CrudException("ID Mismatch", Status.BAD_REQUEST);
 262         }
 263         String result;
 264
 265         if (headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE) != null
 266             && headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE)
 267             .equalsIgnoreCase("PATCH")) {
 268           result = crudGraphDataService.patchEdge(version, id, type, payload);
 269         } else {
 270
 271           result = crudGraphDataService.updateEdge(version, id, type, payload);
 272         }
 273
 274         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 275       } catch (CrudException ce) {
 276         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 277       } catch (Exception e) {
 278         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 279       }
 280     } else {
 281       response = Response.status(Status.FORBIDDEN).entity(content)
 282           .type(MediaType.APPLICATION_JSON).build();
 283
 284     }
 285
 286     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 287     return response;
 288   }
 289
 290   @PATCH
 291   @Path("/relationships/{version}/{type}/{id}")
 292   @Consumes({"application/merge-patch+json"})
 293   @Produces({MediaType.APPLICATION_JSON})
 294   public Response patchEdge(String content, @PathParam("version") String version,
 295                             @PathParam("type") String type, @PathParam("id") String id,
 296                             @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 297                             @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 298
 299     LoggingUtil.initMdcContext(req, headers);
 300
 301     logger.debug("Incoming request..." + content);
 302     Response response = null;
 303     if (validateRequest(req, uri, content, Action.PATCH,
 304         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 305
 306       try {
 307         EdgePayload payload = EdgePayload.fromJson(content);
 308         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 309           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 310         }
 311         if (payload.getId() != null && !payload.getId().equals(id)) {
 312           throw new CrudException("ID Mismatch", Status.BAD_REQUEST);
 313         }
 314
 315         String result = crudGraphDataService.patchEdge(version, id, type, payload);
 316         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 317       } catch (CrudException ce) {
 318         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 319       } catch (Exception e) {
 320         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 321       }
 322     } else {
 323       response = Response.status(Status.FORBIDDEN).entity(content)
 324           .type(MediaType.APPLICATION_JSON).build();
 325     }
 326
 327     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 328     return response;
 329   }
 330
 331   @PUT
 332   @Path("/{version}/{type}/{id}")
 333   @Consumes({MediaType.APPLICATION_JSON})
 334   @Produces({MediaType.APPLICATION_JSON})
 335   public Response updateVertex(String content, @PathParam("version") String version,
 336                                @PathParam("type") String type, @PathParam("id") String id,
 337                                @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 338                                @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 339
 340     LoggingUtil.initMdcContext(req, headers);
 341
 342     logger.debug("Incoming request..." + content);
 343     Response response = null;
 344
 345     if (validateRequest(req, uri, content, Action.PUT, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 346
 347       try {
 348         VertexPayload payload = VertexPayload.fromJson(content);
 349         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 350           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 351         }
 352         if (payload.getId() != null && !payload.getId().equals(id)) {
 353           throw new CrudException("ID Mismatch", Status.BAD_REQUEST);
 354         }
 355         String result;
 356         if (headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE) != null
 357             && headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE)
 358             .equalsIgnoreCase("PATCH")) {
 359           result = crudGraphDataService.patchVertex(version, id, type, payload);
 360         } else {
 361
 362           result = crudGraphDataService.updateVertex(version, id, type, payload);
 363         }
 364         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 365       } catch (CrudException ce) {
 366         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 367       } catch (Exception e) {
 368         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 369       }
 370     } else {
 371       response = Response.status(Status.FORBIDDEN).entity(content)
 372           .type(MediaType.APPLICATION_JSON).build();
 373     }
 374
 375     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 376     return response;
 377   }
 378
 379   @PATCH
 380   @Path("/{version}/{type}/{id}")
 381   @Consumes({"application/merge-patch+json"})
 382   @Produces({MediaType.APPLICATION_JSON})
 383   public Response patchVertex(String content, @PathParam("version") String version,
 384                               @PathParam("type") String type, @PathParam("id") String id,
 385                               @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 386                               @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 387
 388     LoggingUtil.initMdcContext(req, headers);
 389
 390     logger.debug("Incoming request..." + content);
 391     Response response = null;
 392
 393     if (validateRequest(req, uri, content, Action.PATCH,
 394         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 395       try {
 396         VertexPayload payload = VertexPayload.fromJson(content);
 397         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 398           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 399         }
 400         if (payload.getId() != null && !payload.getId().equals(id)) {
 401           throw new CrudException("ID Mismatch", Status.BAD_REQUEST);
 402         }
 403
 404         String result = crudGraphDataService.patchVertex(version, id, type, payload);
 405         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 406       } catch (CrudException ce) {
 407         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 408       } catch (Exception e) {
 409         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 410       }
 411     } else {
 412       response = Response.status(Status.FORBIDDEN).entity(content)
 413           .type(MediaType.APPLICATION_JSON).build();
 414     }
 415
 416     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 417     return response;
 418   }
 419
 420   @POST
 421   @Path("/{version}/{type}/")
 422   @Consumes({MediaType.APPLICATION_JSON})
 423   @Produces({MediaType.APPLICATION_JSON})
 424   public Response addVertex(String content, @PathParam("version") String version,
 425                             @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
 426                             @Context HttpHeaders headers, @Context UriInfo uriInfo,
 427                             @Context HttpServletRequest req) {
 428
 429     LoggingUtil.initMdcContext(req, headers);
 430
 431     logger.debug("Incoming request..." + content);
 432     Response response = null;
 433
 434     if (validateRequest(req, uri, content, Action.POST,
 435         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 436
 437       try {
 438         VertexPayload payload = VertexPayload.fromJson(content);
 439         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 440           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 441         }
 442         if (payload.getId() != null) {
 443           throw new CrudException("ID specified , use Http PUT to update Vertex",
 444               Status.BAD_REQUEST);
 445         }
 446
 447         if (payload.getType() != null && !payload.getType().equals(type)) {
 448           throw new CrudException("Vertex Type mismatch", Status.BAD_REQUEST);
 449         }
 450
 451         String result = crudGraphDataService.addVertex(version, type, payload);
 452         response = Response.status(Status.CREATED).entity(result).type(mediaType).build();
 453       } catch (CrudException ce) {
 454         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 455       } catch (Exception e) {
 456         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 457       }
 458     } else {
 459       response = Response.status(Status.FORBIDDEN).entity(content)
 460           .type(MediaType.APPLICATION_JSON).build();
 461     }
 462
 463     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 464     return response;
 465   }
 466
 467   @POST
 468   @Path("/{version}/")
 469   @Consumes({MediaType.APPLICATION_JSON})
 470   @Produces({MediaType.APPLICATION_JSON})
 471   public Response addVertex(String content, @PathParam("version") String version,
 472                             @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 473                             @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 474
 475     LoggingUtil.initMdcContext(req, headers);
 476
 477     logger.debug("Incoming request..." + content);
 478     Response response = null;
 479
 480     if (validateRequest(req, uri, content, Action.POST,
 481         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 482       try {
 483
 484         VertexPayload payload = VertexPayload.fromJson(content);
 485         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 486           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 487         }
 488         if (payload.getId() != null) {
 489           throw new CrudException("ID specified , use Http PUT to update Vertex",
 490               Status.BAD_REQUEST);
 491         }
 492
 493         if (payload.getType() == null || payload.getType().isEmpty()) {
 494           throw new CrudException("Missing Vertex Type ", Status.BAD_REQUEST);
 495         }
 496         String result = crudGraphDataService.addVertex(version, payload.getType(), payload);
 497         response = Response.status(Status.CREATED).entity(result).type(mediaType).build();
 498       } catch (CrudException ce) {
 499         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 500       } catch (Exception e) {
 501         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 502       }
 503     } else {
 504       response = Response.status(Status.FORBIDDEN).entity(content)
 505           .type(MediaType.APPLICATION_JSON).build();
 506     }
 507
 508     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 509     return response;
 510   }
 511
 512   @POST
 513   @Path("/relationships/{version}/{type}/")
 514   @Consumes({MediaType.APPLICATION_JSON})
 515   @Produces({MediaType.APPLICATION_JSON})
 516   public Response addEdge(String content, @PathParam("version") String version,
 517                           @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
 518                           @Context HttpHeaders headers, @Context UriInfo uriInfo,
 519                           @Context HttpServletRequest req) {
 520
 521     LoggingUtil.initMdcContext(req, headers);
 522
 523     logger.debug("Incoming request..." + content);
 524     Response response = null;
 525
 526     if (validateRequest(req, uri, content, Action.POST,
 527         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 528
 529
 530       try {
 531         EdgePayload payload = EdgePayload.fromJson(content);
 532         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 533           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 534         }
 535         if (payload.getId() != null) {
 536           throw new CrudException("ID specified , use Http PUT to update Edge", Status.BAD_REQUEST);
 537         }
 538
 539         if (payload.getType() != null && !payload.getType().equals(type)) {
 540           throw new CrudException("Edge Type mismatch", Status.BAD_REQUEST);
 541         }
 542         String result = crudGraphDataService.addEdge(version, type, payload);
 543         response = Response.status(Status.CREATED).entity(result).type(mediaType).build();
 544       } catch (CrudException ce) {
 545         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 546       } catch (Exception e) {
 547         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 548       }
 549     } else {
 550       response = Response.status(Status.FORBIDDEN).entity(content)
 551           .type(MediaType.APPLICATION_JSON).build();
 552     }
 553
 554     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 555     return response;
 556   }
 557
 558   @POST
 559   @Path("/relationships/{version}/")
 560   @Consumes({MediaType.APPLICATION_JSON})
 561   @Produces({MediaType.APPLICATION_JSON})
 562   public Response addEdge(String content, @PathParam("version") String version,
 563                           @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 564                           @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 565
 566     LoggingUtil.initMdcContext(req, headers);
 567
 568     logger.debug("Incoming request..." + content);
 569     Response response = null;
 570
 571     if (validateRequest(req, uri, content, Action.POST,
 572         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 573
 574
 575       try {
 576         EdgePayload payload = EdgePayload.fromJson(content);
 577         if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
 578           throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
 579         }
 580         if (payload.getId() != null) {
 581           throw new CrudException("ID specified , use Http PUT to update Edge", Status.BAD_REQUEST);
 582         }
 583
 584         if (payload.getType() == null || payload.getType().isEmpty()) {
 585           throw new CrudException("Missing Edge Type ", Status.BAD_REQUEST);
 586         }
 587         String result = crudGraphDataService.addEdge(version, payload.getType(), payload);
 588
 589         response = Response.status(Status.CREATED).entity(result).type(mediaType).build();
 590       } catch (CrudException ce) {
 591         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 592       } catch (Exception e) {
 593         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 594       }
 595     } else {
 596       response = Response.status(Status.FORBIDDEN).entity(content)
 597           .type(MediaType.APPLICATION_JSON).build();
 598     }
 599
 600     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 601     return response;
 602   }
 603
 604   @DELETE
 605   @Path("/{version}/{type}/{id}")
 606   @Consumes({MediaType.APPLICATION_JSON})
 607   @Produces({MediaType.APPLICATION_JSON})
 608   public Response deleteVertex(String content, @PathParam("version") String version,
 609                                @PathParam("type") String type, @PathParam("id") String id,
 610                                @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 611                                @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 612
 613     LoggingUtil.initMdcContext(req, headers);
 614
 615     logger.debug("Incoming request..." + content);
 616     Response response = null;
 617
 618     if (validateRequest(req, uri, content, Action.DELETE,
 619         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 620
 621
 622       try {
 623         String result = crudGraphDataService.deleteVertex(version, id, type);
 624         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 625       } catch (CrudException ce) {
 626         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 627       } catch (Exception e) {
 628         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 629       }
 630     } else {
 631       response = Response.status(Status.FORBIDDEN).entity(content)
 632           .type(MediaType.APPLICATION_JSON).build();
 633     }
 634
 635     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 636     return response;
 637   }
 638
 639   @DELETE
 640   @Path("/relationships/{version}/{type}/")
 641   @Consumes({MediaType.APPLICATION_JSON})
 642   @Produces({MediaType.APPLICATION_JSON})
 643   public Response deleteEdgeWithouId(String content, @Context HttpHeaders headers, @Context HttpServletRequest req) {
 644
 645     LoggingUtil.initMdcContext(req, headers);
 646
 647     logger.debug("Incoming request..." + content);
 648     Response response = Response.status ( Status.BAD_REQUEST ).entity ( "Cannot Delete Edge Without Specifying Id in URL" ).build ();
 649     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 650     return response;
 651   }
 652
 653   @DELETE
 654   @Path("/relationships/{version}/{type}/{id}")
 655   @Consumes({MediaType.APPLICATION_JSON})
 656   @Produces({MediaType.APPLICATION_JSON})
 657   public Response deleteEdge(String content, @PathParam("version") String version,
 658                              @PathParam("type") String type, @PathParam("id") String id,
 659                              @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
 660                              @Context UriInfo uriInfo, @Context HttpServletRequest req) {
 661
 662     LoggingUtil.initMdcContext(req, headers);
 663
 664     logger.debug("Incoming request..." + content);
 665     Response response = null;
 666     if (validateRequest(req, uri, content, Action.DELETE,
 667         CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
 668
 669       try {
 670         String result = crudGraphDataService.deleteEdge(version, id, type);
 671         response = Response.status(Status.OK).entity(result).type(mediaType).build();
 672       } catch (CrudException ce) {
 673         response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
 674       } catch (Exception e) {
 675         response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
 676       }
 677     } else {
 678       response = Response.status(Status.FORBIDDEN).entity(content)
 679           .type(MediaType.APPLICATION_JSON).build();
 680     }
 681
 682     LoggingUtil.logRestRequest(logger, auditLogger, req, response);
 683     return response;
 684   }
 685
 686   protected boolean validateRequest(HttpServletRequest req, String uri, String content,
 687                                     Action action, String authPolicyFunctionName) {
 688     try {
 689       String cipherSuite = (String) req.getAttribute("javax.servlet.request.cipher_suite");
 690       String authUser = null;
 691       if (cipherSuite != null) {
 692         X509Certificate[] certChain = (X509Certificate[]) req
 693             .getAttribute("javax.servlet.request.X509Certificate");
 694         X509Certificate clientCert = certChain[0];
 695         X500Principal subjectDn = clientCert.getSubjectX500Principal();
 696         authUser = subjectDn.toString();
 697       }
 698       return this.auth.validateRequest(authUser.toLowerCase(), action.toString()
 699           + ":" + authPolicyFunctionName);
 700     } catch (Exception e) {
 701       logResult(action, uri, e);
 702       return false;
 703     }
 704   }
 705
 706   void logResult(Action op, String uri, Exception e) {
 707
 708     logger.error(CrudServiceMsgs.EXCEPTION_DURING_METHOD_CALL, op.toString(), uri,
 709         e.getStackTrace().toString());
 710
 711     // Clear the MDC context so that no other transaction inadvertently
 712     // uses our transaction id.
 713     MDC.clear();
 714   }
 715 }