src/main/java/org/onap/aai/sa/rest/DocumentApi.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2017-2018 Amdocs
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *       http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21 package org.onap.aai.sa.rest;
  22
  23 import com.fasterxml.jackson.annotation.JsonInclude.Include;
  24 import com.fasterxml.jackson.core.JsonProcessingException;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import javax.servlet.http.HttpServletRequest;
  27 import javax.servlet.http.HttpServletResponse;
  28 import org.onap.aai.cl.api.LogFields;
  29 import org.onap.aai.cl.api.LogLine;
  30 import org.onap.aai.cl.api.Logger;
  31 import org.onap.aai.cl.eelf.LoggerFactory;
  32 import org.onap.aai.sa.searchdbabstraction.elasticsearch.dao.DocumentStoreDataEntityImpl;
  33 import org.onap.aai.sa.searchdbabstraction.elasticsearch.dao.DocumentStoreInterface;
  34 import org.onap.aai.sa.searchdbabstraction.entity.AggregationResults;
  35 import org.onap.aai.sa.searchdbabstraction.entity.DocumentOperationResult;
  36 import org.onap.aai.sa.searchdbabstraction.entity.SearchOperationResult;
  37 import org.onap.aai.sa.searchdbabstraction.logging.SearchDbMsgs;
  38 import org.onap.aai.sa.searchdbabstraction.searchapi.SearchStatement;
  39 import org.onap.aai.sa.searchdbabstraction.searchapi.SuggestionStatement;
  40 import org.springframework.http.HttpHeaders;
  41 import org.springframework.http.HttpStatus;
  42 import org.springframework.http.MediaType;
  43 import org.springframework.http.ResponseEntity;
  44
  45 public class DocumentApi {
  46     private static final String MSG_REQUEST_BODY = "Request Body: ";
  47     private static final String REQUEST_HEADER_RESOURCE_VERSION = "If-Match";
  48     private static final String RESPONSE_HEADER_RESOURCE_VERSION = "ETag";
  49     private static final String REQUEST_HEADER_ALLOW_IMPLICIT_INDEX_CREATION = "X-CreateIndex";
  50
  51     protected SearchServiceApi searchService = null;
  52
  53     private Logger logger = LoggerFactory.getInstance().getLogger(DocumentApi.class.getName());
  54     private Logger auditLogger = LoggerFactory.getInstance().getAuditLogger(DocumentApi.class.getName());
  55
  56     public DocumentApi(SearchServiceApi searchService) {
  57         this.searchService = searchService;
  58     }
  59
  60     public ResponseEntity<String> processPost(String content, HttpServletRequest request, HttpHeaders headers,
  61             HttpServletResponse httpResponse, String index, DocumentStoreInterface documentStore) {
  62
  63         // Initialize the MDC Context for logging purposes.
  64         ApiUtils.initMdcContext(request, headers);
  65
  66         try {
  67             ObjectMapper mapper = new ObjectMapper();
  68             mapper.setSerializationInclusion(Include.NON_EMPTY);
  69             if (content == null) {
  70                 return handleError(request, content, HttpStatus.BAD_REQUEST);
  71             }
  72
  73             boolean isValid;
  74             try {
  75                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.POST,
  76                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
  77             } catch (Exception e) {
  78                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "DocumentApi.processPost", e.getMessage());
  79                 return handleError(request, content, HttpStatus.FORBIDDEN);
  80             }
  81
  82             if (!isValid) {
  83                 return handleError(request, content, HttpStatus.FORBIDDEN);
  84             }
  85
  86             DocumentStoreDataEntityImpl document = new DocumentStoreDataEntityImpl();
  87             document.setContent(content);
  88
  89             DocumentOperationResult result =
  90                     documentStore.createDocument(index, document, implicitlyCreateIndex(headers));
  91             String output = null;
  92             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
  93                 output = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getDocument());
  94             } else {
  95                 output = result.getError() != null
  96                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
  97                         : result.getFailureCause();
  98             }
  99
 100             if (httpResponse != null) {
 101                 httpResponse.setHeader(RESPONSE_HEADER_RESOURCE_VERSION, result.getResultVersion());
 102             }
 103             ResponseEntity<String> response =
 104                     ResponseEntity.status(result.getResultCode()).contentType(MediaType.APPLICATION_JSON).body(output);
 105             logResult(request, HttpStatus.valueOf(response.getStatusCodeValue()));
 106             logResult(request, HttpStatus.valueOf(response.getStatusCodeValue()));
 107
 108             // Clear the MDC context so that no other transaction inadvertently
 109             // uses our transaction id.
 110             ApiUtils.clearMdcContext();
 111
 112             return response;
 113         } catch (Exception e) {
 114             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 115         }
 116     }
 117
 118     public ResponseEntity<String> processPut(String content, HttpServletRequest request, HttpHeaders headers,
 119             HttpServletResponse httpResponse, String index, String id, DocumentStoreInterface documentStore) {
 120
 121         // Initialize the MDC Context for logging purposes.
 122         ApiUtils.initMdcContext(request, headers);
 123
 124         try {
 125             ObjectMapper mapper = new ObjectMapper();
 126             mapper.setSerializationInclusion(Include.NON_EMPTY);
 127             if (content == null) {
 128                 return handleError(request, content, HttpStatus.BAD_REQUEST);
 129             }
 130
 131             boolean isValid;
 132             try {
 133                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.PUT,
 134                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
 135             } catch (Exception e) {
 136                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "DocumentApi.processPut", e.getMessage());
 137                 return handleError(request, content, HttpStatus.FORBIDDEN);
 138             }
 139
 140             if (!isValid) {
 141                 return handleError(request, content, HttpStatus.FORBIDDEN);
 142             }
 143
 144             String resourceVersion = headers.getFirst(REQUEST_HEADER_RESOURCE_VERSION);
 145
 146             DocumentStoreDataEntityImpl document = new DocumentStoreDataEntityImpl();
 147             document.setId(id);
 148             document.setContent(content);
 149             document.setVersion(resourceVersion);
 150
 151             DocumentOperationResult result = null;
 152             if (resourceVersion == null) {
 153                 result = documentStore.createDocument(index, document, implicitlyCreateIndex(headers));
 154             } else {
 155                 result = documentStore.updateDocument(index, document, implicitlyCreateIndex(headers));
 156             }
 157
 158             String output = null;
 159             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
 160                 output = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getDocument());
 161             } else {
 162                 output = result.getError() != null
 163                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
 164                         : result.getFailureCause();
 165             }
 166             if (httpResponse != null) {
 167                 httpResponse.setHeader(RESPONSE_HEADER_RESOURCE_VERSION, result.getResultVersion());
 168             }
 169             ResponseEntity<String> response =
 170                     ResponseEntity.status(result.getResultCode()).contentType(MediaType.APPLICATION_JSON).body(output);
 171             logResult(request, HttpStatus.valueOf(response.getStatusCodeValue()));
 172
 173             // Clear the MDC context so that no other transaction inadvertently
 174             // uses our transaction id.
 175             ApiUtils.clearMdcContext();
 176
 177             return response;
 178         } catch (Exception e) {
 179             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 180         }
 181     }
 182
 183     public ResponseEntity<String> processDelete(String content, HttpServletRequest request, HttpHeaders headers,
 184             HttpServletResponse httpResponse, String index, String id, DocumentStoreInterface documentStore) {
 185
 186         // Initialize the MDC Context for logging purposes.
 187         ApiUtils.initMdcContext(request, headers);
 188
 189         try {
 190             ObjectMapper mapper = new ObjectMapper();
 191             mapper.setSerializationInclusion(Include.NON_EMPTY);
 192             boolean isValid;
 193             try {
 194                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.DELETE,
 195                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
 196             } catch (Exception e) {
 197                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "DocumentApi.processDelete", e.getMessage());
 198                 return handleError(request, content, HttpStatus.FORBIDDEN);
 199             }
 200
 201             if (!isValid) {
 202                 return handleError(request, content, HttpStatus.FORBIDDEN);
 203             }
 204
 205             String resourceVersion = headers.getFirst(REQUEST_HEADER_RESOURCE_VERSION);
 206             if (resourceVersion == null || resourceVersion.isEmpty()) {
 207                 return handleError(request, "Request header 'If-Match' missing", HttpStatus.BAD_REQUEST);
 208             }
 209
 210             DocumentStoreDataEntityImpl document = new DocumentStoreDataEntityImpl();
 211             document.setId(id);
 212             document.setVersion(resourceVersion);
 213
 214             DocumentOperationResult result = documentStore.deleteDocument(index, document);
 215             String output = null;
 216             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
 217                 output = result.getError() != null
 218                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
 219                         : result.getFailureCause();
 220             }
 221
 222             if (httpResponse != null) {
 223                 httpResponse.setHeader(RESPONSE_HEADER_RESOURCE_VERSION, result.getResultVersion());
 224             }
 225             ResponseEntity<String> response;
 226             if (output == null) {
 227                 response = ResponseEntity.status(result.getResultCode()).build();
 228             } else {
 229                 response = ResponseEntity.status(result.getResultCode()).contentType(MediaType.APPLICATION_JSON)
 230                         .body(output);
 231             }
 232
 233             logResult(request, HttpStatus.valueOf(response.getStatusCodeValue()));
 234
 235             // Clear the MDC context so that no other transaction inadvertently
 236             // uses our transaction id.
 237             ApiUtils.clearMdcContext();
 238
 239             return response;
 240         } catch (Exception e) {
 241             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 242         }
 243     }
 244
 245     public ResponseEntity<String> processGet(String content, HttpServletRequest request, HttpHeaders headers,
 246             HttpServletResponse httpResponse, String index, String id, DocumentStoreInterface documentStore) {
 247
 248         // Initialize the MDC Context for logging purposes.
 249         ApiUtils.initMdcContext(request, headers);
 250
 251         try {
 252             ObjectMapper mapper = new ObjectMapper();
 253             mapper.setSerializationInclusion(Include.NON_EMPTY);
 254             boolean isValid;
 255             try {
 256                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.GET,
 257                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
 258             } catch (Exception e) {
 259                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "DocumentApi.processGet", e.getMessage());
 260                 return handleError(request, content, HttpStatus.FORBIDDEN);
 261             }
 262
 263             if (!isValid) {
 264                 return handleError(request, content, HttpStatus.FORBIDDEN);
 265             }
 266
 267             String resourceVersion = headers.getFirst(REQUEST_HEADER_RESOURCE_VERSION);
 268
 269             DocumentStoreDataEntityImpl document = new DocumentStoreDataEntityImpl();
 270             document.setId(id);
 271             document.setVersion(resourceVersion);
 272
 273             DocumentOperationResult result = documentStore.getDocument(index, document);
 274             String output = null;
 275             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
 276                 output = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getDocument());
 277             } else {
 278                 output = result.getError() != null
 279                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
 280                         : result.getFailureCause();
 281             }
 282             if (httpResponse != null) {
 283                 httpResponse.setHeader(RESPONSE_HEADER_RESOURCE_VERSION, result.getResultVersion());
 284             }
 285             ResponseEntity<String> response =
 286                     ResponseEntity.status(result.getResultCode()).contentType(MediaType.APPLICATION_JSON).body(output);
 287             logResult(request, HttpStatus.valueOf(response.getStatusCodeValue()));
 288
 289             // Clear the MDC context so that no other transaction inadvertently
 290             // uses our transaction id.
 291             ApiUtils.clearMdcContext();
 292
 293             return response;
 294         } catch (Exception e) {
 295             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 296         }
 297     }
 298
 299     public ResponseEntity<String> processSearchWithGet(String content, HttpServletRequest request, HttpHeaders headers,
 300             String index, String queryText, DocumentStoreInterface documentStore) {
 301
 302         // Initialize the MDC Context for logging purposes.
 303         ApiUtils.initMdcContext(request, headers);
 304
 305         try {
 306             ObjectMapper mapper = new ObjectMapper();
 307             mapper.setSerializationInclusion(Include.NON_EMPTY);
 308
 309             boolean isValid;
 310             try {
 311                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.GET,
 312                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
 313             } catch (Exception e) {
 314                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "processSearchWithGet", e.getMessage());
 315                 return handleError(request, content, HttpStatus.FORBIDDEN);
 316             }
 317
 318             if (!isValid) {
 319                 return handleError(request, content, HttpStatus.FORBIDDEN);
 320             }
 321
 322             SearchOperationResult result = documentStore.search(index, queryText);
 323             String output = null;
 324             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
 325                 output = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getSearchResult());
 326             } else {
 327                 output = result.getError() != null
 328                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
 329                         : result.getFailureCause();
 330             }
 331             ResponseEntity<String> response =
 332                     ResponseEntity.status(result.getResultCode()).contentType(MediaType.APPLICATION_JSON).body(output);
 333
 334             // Clear the MDC context so that no other transaction inadvertently
 335             // uses our transaction id.
 336             ApiUtils.clearMdcContext();
 337
 338             return response;
 339         } catch (Exception e) {
 340             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 341         }
 342     }
 343
 344     public ResponseEntity<String> queryWithGetWithPayload(String content, HttpServletRequest request,
 345             HttpHeaders headers, String index, DocumentStoreInterface documentStore) {
 346
 347         // Initialize the MDC Context for logging purposes.
 348         ApiUtils.initMdcContext(request, headers);
 349
 350         logger.info(SearchDbMsgs.PROCESS_PAYLOAD_QUERY, "GET",
 351                 (request != null) ? request.getRequestURL().toString() : "");
 352         if (logger.isDebugEnabled()) {
 353             logger.debug(MSG_REQUEST_BODY + content);
 354         }
 355         return processQuery(index, content, request, headers, documentStore);
 356     }
 357
 358     public ResponseEntity<String> processSearchWithPost(String content, HttpServletRequest request, HttpHeaders headers,
 359             String index, DocumentStoreInterface documentStore) {
 360
 361         // Initialize the MDC Context for logging purposes.
 362         ApiUtils.initMdcContext(request, headers);
 363
 364         logger.info(SearchDbMsgs.PROCESS_PAYLOAD_QUERY, "POST",
 365                 (request != null) ? request.getRequestURL().toString() : "");
 366         if (logger.isDebugEnabled()) {
 367             logger.debug(MSG_REQUEST_BODY + content);
 368         }
 369
 370         return processQuery(index, content, request, headers, documentStore);
 371     }
 372
 373
 374     public ResponseEntity<String> processSuggestQueryWithPost(String content, HttpServletRequest request,
 375             HttpHeaders headers, String index, DocumentStoreInterface documentStore) {
 376
 377         // Initialize the MDC Context for logging purposes.
 378         ApiUtils.initMdcContext(request, headers);
 379
 380         logger.info(SearchDbMsgs.PROCESS_PAYLOAD_QUERY, "POST",
 381                 (request != null) ? request.getRequestURL().toString() : "");
 382         if (logger.isDebugEnabled()) {
 383             logger.debug(MSG_REQUEST_BODY + content);
 384         }
 385
 386         return processSuggestQuery(index, content, request, headers, documentStore);
 387     }
 388
 389     /**
 390      * Common handler for query requests. This is called by both the GET with payload and POST with payload variants of
 391      * the query endpoint.
 392      *
 393      * @param index - The index to be queried against.
 394      * @param content - The payload containing the query structure.
 395      * @param request - The HTTP request.
 396      * @param headers - The HTTP headers.
 397      * @return - A standard HTTP response.
 398      */
 399     private ResponseEntity<String> processQuery(String index, String content, HttpServletRequest request,
 400             HttpHeaders headers, DocumentStoreInterface documentStore) {
 401
 402         try {
 403             ObjectMapper mapper = new ObjectMapper();
 404             mapper.setSerializationInclusion(Include.NON_EMPTY);
 405
 406             // Make sure that we were supplied a payload before proceeding.
 407             if (content == null) {
 408                 return handleError(request, content, HttpStatus.BAD_REQUEST);
 409             }
 410
 411             // Validate that the request has the appropriate authorization.
 412             boolean isValid;
 413             try {
 414                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.POST,
 415                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
 416
 417             } catch (Exception e) {
 418                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "processQuery", e.getMessage());
 419                 return handleError(request, content, HttpStatus.FORBIDDEN);
 420             }
 421
 422             if (!isValid) {
 423                 return handleError(request, content, HttpStatus.FORBIDDEN);
 424             }
 425
 426             SearchStatement searchStatement;
 427
 428             try {
 429                 // Marshall the supplied request payload into a search statement
 430                 // object.
 431                 searchStatement = mapper.readValue(content, SearchStatement.class);
 432
 433             } catch (Exception e) {
 434                 return handleError(request, e.getMessage(), HttpStatus.BAD_REQUEST);
 435             }
 436
 437             // Now, submit the search statement, translated into
 438             // ElasticSearch syntax, to the document store DAO.
 439             SearchOperationResult result = documentStore.searchWithPayload(index, searchStatement.toElasticSearch());
 440             String output = null;
 441             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
 442                 output = prepareOutput(mapper, result);
 443             } else {
 444                 output = result.getError() != null
 445                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
 446                         : result.getFailureCause();
 447             }
 448             ResponseEntity<String> response =
 449                     ResponseEntity.status(result.getResultCode()).contentType(MediaType.APPLICATION_JSON).body(output);
 450
 451             // Clear the MDC context so that no other transaction inadvertently
 452             // uses our transaction id.
 453             ApiUtils.clearMdcContext();
 454
 455             return response;
 456
 457         } catch (Exception e) {
 458             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 459         }
 460     }
 461
 462
 463     /**
 464      * Common handler for query requests. This is called by both the GET with payload and POST with payload variants of
 465      * the query endpoint.
 466      *
 467      * @param index - The index to be queried against.
 468      * @param content - The payload containing the query structure.
 469      * @param request - The HTTP request.
 470      * @param headers - The HTTP headers.
 471      * @return - A standard HTTP response.
 472      */
 473     private ResponseEntity<String> processSuggestQuery(String index, String content, HttpServletRequest request,
 474             HttpHeaders headers, DocumentStoreInterface documentStore) {
 475
 476         try {
 477             ObjectMapper mapper = new ObjectMapper();
 478             mapper.setSerializationInclusion(Include.NON_EMPTY);
 479
 480             // Make sure that we were supplied a payload before proceeding.
 481             if (content == null) {
 482                 return handleError(request, content, HttpStatus.BAD_REQUEST);
 483             }
 484
 485             // Validate that the request has the appropriate authorization.
 486             boolean isValid;
 487             try {
 488                 isValid = searchService.validateRequest(headers, request, ApiUtils.Action.POST,
 489                         ApiUtils.SEARCH_AUTH_POLICY_NAME);
 490
 491             } catch (Exception e) {
 492                 logger.info(SearchDbMsgs.EXCEPTION_DURING_METHOD_CALL, "processQuery", e.getMessage());
 493                 return handleError(request, content, HttpStatus.FORBIDDEN);
 494             }
 495
 496             if (!isValid) {
 497                 return handleError(request, content, HttpStatus.FORBIDDEN);
 498             }
 499
 500             SuggestionStatement suggestionStatement;
 501
 502             try {
 503                 // Marshall the supplied request payload into a search statement
 504                 // object.
 505                 suggestionStatement = mapper.readValue(content, SuggestionStatement.class);
 506
 507             } catch (Exception e) {
 508                 return handleError(request, e.getMessage(), HttpStatus.BAD_REQUEST);
 509             }
 510
 511             // Now, submit the search statement, translated into
 512             // ElasticSearch syntax, to the document store DAO.
 513             SearchOperationResult result =
 514                     documentStore.suggestionQueryWithPayload(index, suggestionStatement.toElasticSearch());
 515             String output = null;
 516             if (ApiUtils.isSuccessStatusCode(result.getResultCode())) {
 517                 output = prepareSuggestOutput(mapper, result);
 518             } else {
 519                 output = result.getError() != null
 520                         ? mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getError())
 521                         : result.getFailureCause();
 522             }
 523             ResponseEntity<String> response = ResponseEntity.status(result.getResultCode()).body(output);
 524
 525             // Clear the MDC context so that no other transaction inadvertently
 526             // uses our transaction id.
 527             ApiUtils.clearMdcContext();
 528
 529             return response;
 530
 531         } catch (Exception e) {
 532             return handleError(request, e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
 533         }
 534     }
 535
 536     /**
 537      * Checks the supplied HTTP headers to see if we should allow the underlying document store to implicitly create the
 538      * index referenced in a document PUT or POST if it does not already exist in the data store.
 539      *
 540      * @param headers - The HTTP headers to examine.
 541      *
 542      * @return - true if the headers indicate that missing indices should be implicitly created, false otherwise.
 543      */
 544     private boolean implicitlyCreateIndex(HttpHeaders headers) {
 545         String implicitIndexCreationHeader = headers.getFirst(REQUEST_HEADER_ALLOW_IMPLICIT_INDEX_CREATION);
 546         return implicitIndexCreationHeader != null && "true".equals(implicitIndexCreationHeader);
 547     }
 548
 549     private String prepareOutput(ObjectMapper mapper, SearchOperationResult result) throws JsonProcessingException {
 550         StringBuffer output = new StringBuffer();
 551         output.append("{\r\n\"searchResult\":");
 552         output.append(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getSearchResult()));
 553         AggregationResults aggs = result.getAggregationResult();
 554         if (aggs != null) {
 555             output.append(",\r\n\"aggregationResult\":");
 556             output.append(mapper.setSerializationInclusion(Include.NON_NULL).writerWithDefaultPrettyPrinter()
 557                     .writeValueAsString(aggs));
 558         }
 559         output.append("\r\n}");
 560         return output.toString();
 561     }
 562
 563     private String prepareSuggestOutput(ObjectMapper mapper, SearchOperationResult result)
 564             throws JsonProcessingException {
 565         StringBuffer output = new StringBuffer();
 566         output.append("{\r\n\"searchResult\":");
 567         output.append(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result.getSuggestResult()));
 568         AggregationResults aggs = result.getAggregationResult();
 569         if (aggs != null) {
 570             output.append(",\r\n\"aggregationResult\":");
 571             output.append(mapper.setSerializationInclusion(Include.NON_NULL).writerWithDefaultPrettyPrinter()
 572                     .writeValueAsString(aggs));
 573         }
 574         output.append("\r\n}");
 575         return output.toString();
 576     }
 577
 578     private ResponseEntity<String> handleError(HttpServletRequest request, String message, HttpStatus status) {
 579         logResult(request, status);
 580         return ResponseEntity.status(status).contentType(MediaType.APPLICATION_JSON).body(message);
 581     }
 582
 583     void logResult(HttpServletRequest request, HttpStatus status) {
 584
 585         logger.info(SearchDbMsgs.PROCESS_REST_REQUEST, (request != null) ? request.getMethod() : "",
 586                 (request != null) ? request.getRequestURL().toString() : "",
 587                 (request != null) ? request.getRemoteHost() : "", Integer.toString(status.value()));
 588
 589         auditLogger.info(SearchDbMsgs.PROCESS_REST_REQUEST,
 590                 new LogFields().setField(LogLine.DefinedFields.RESPONSE_CODE, status.value())
 591                         .setField(LogLine.DefinedFields.RESPONSE_DESCRIPTION, status.getReasonPhrase()),
 592                 (request != null) ? request.getMethod() : "",
 593                 (request != null) ? request.getRequestURL().toString() : "",
 594                 (request != null) ? request.getRemoteHost() : "", Integer.toString(status.value()));
 595
 596         // Clear the MDC context so that no other transaction inadvertently uses our transaction id.
 597         ApiUtils.clearMdcContext();
 598     }
 599 }