mso-api-handlers/mso-api-handler-infra/src/main/java/org/onap/so/apihandlerinfra/RequestHandlerUtils.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright (C) 2017 Huawei Technologies Co., Ltd. All rights reserved.
   7  * ================================================================================
   8  * Modifications Copyright (c) 2019 Samsung
   9  * ================================================================================
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.so.apihandlerinfra;
  25
  26
  27 import static org.onap.so.logger.HttpHeadersConstants.REQUESTOR_ID;
  28 import java.io.IOException;
  29 import java.net.URL;
  30 import java.sql.Timestamp;
  31 import java.util.ArrayList;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Optional;
  36 import javax.ws.rs.container.ContainerRequestContext;
  37 import javax.ws.rs.core.MultivaluedMap;
  38 import javax.ws.rs.core.Response;
  39 import org.apache.commons.lang.StringUtils;
  40 import org.apache.http.HttpResponse;
  41 import org.apache.http.HttpStatus;
  42 import org.camunda.bpm.engine.history.HistoricProcessInstance;
  43 import org.camunda.bpm.engine.impl.persistence.entity.HistoricProcessInstanceEntity;
  44 import org.onap.logging.ref.slf4j.ONAPLogConstants;
  45 import org.onap.so.apihandler.camundabeans.CamundaResponse;
  46 import org.onap.so.apihandler.common.CommonConstants;
  47 import org.onap.so.apihandler.common.ErrorNumbers;
  48 import org.onap.so.apihandler.common.RequestClient;
  49 import org.onap.so.apihandler.common.RequestClientFactory;
  50 import org.onap.so.apihandler.common.RequestClientParameter;
  51 import org.onap.so.apihandler.common.ResponseBuilder;
  52 import org.onap.so.apihandler.common.ResponseHandler;
  53 import org.onap.so.apihandlerinfra.exceptions.ApiException;
  54 import org.onap.so.apihandlerinfra.exceptions.BPMNFailureException;
  55 import org.onap.so.apihandlerinfra.exceptions.ClientConnectionException;
  56 import org.onap.so.apihandlerinfra.exceptions.ContactCamundaException;
  57 import org.onap.so.apihandlerinfra.exceptions.DuplicateRequestException;
  58 import org.onap.so.apihandlerinfra.exceptions.RequestDbFailureException;
  59 import org.onap.so.apihandlerinfra.exceptions.ValidateException;
  60 import org.onap.so.apihandlerinfra.exceptions.VfModuleNotFoundException;
  61 import org.onap.so.apihandlerinfra.infra.rest.handler.AbstractRestHandler;
  62 import org.onap.so.apihandlerinfra.logging.ErrorLoggerInfo;
  63 import org.onap.so.constants.Status;
  64 import org.onap.so.db.catalog.beans.VfModule;
  65 import org.onap.so.db.catalog.client.CatalogDbClient;
  66 import org.onap.so.db.request.beans.InfraActiveRequests;
  67 import org.onap.so.db.request.client.RequestsDbClient;
  68 import org.onap.so.exceptions.ValidationException;
  69 import org.onap.so.logger.ErrorCode;
  70 import org.onap.so.logger.LogConstants;
  71 import org.onap.so.logger.MessageEnum;
  72 import org.onap.so.serviceinstancebeans.ModelInfo;
  73 import org.onap.so.serviceinstancebeans.ModelType;
  74 import org.onap.so.serviceinstancebeans.RelatedInstance;
  75 import org.onap.so.serviceinstancebeans.RelatedInstanceList;
  76 import org.onap.so.serviceinstancebeans.RequestParameters;
  77 import org.onap.so.serviceinstancebeans.ServiceInstancesRequest;
  78 import org.onap.so.serviceinstancebeans.ServiceInstancesResponse;
  79 import org.onap.so.utils.UUIDChecker;
  80 import org.slf4j.Logger;
  81 import org.slf4j.LoggerFactory;
  82 import org.slf4j.MDC;
  83 import org.springframework.beans.factory.annotation.Autowired;
  84 import org.springframework.core.env.Environment;
  85 import org.springframework.http.ResponseEntity;
  86 import org.springframework.stereotype.Component;
  87 import org.springframework.web.client.HttpStatusCodeException;
  88 import org.springframework.web.client.RestClientException;
  89 import com.fasterxml.jackson.annotation.JsonInclude.Include;
  90 import com.fasterxml.jackson.databind.ObjectMapper;
  91
  92 @Component
  93 public class RequestHandlerUtils extends AbstractRestHandler {
  94
  95     private static Logger logger = LoggerFactory.getLogger(RequestHandlerUtils.class);
  96
  97     private static final String SAVE_TO_DB = "save instance to db";
  98
  99     @Autowired
 100     private Environment env;
 101
 102     @Autowired
 103     private RequestClientFactory reqClientFactory;
 104
 105     @Autowired
 106     private RequestsDbClient infraActiveRequestsClient;
 107
 108     @Autowired
 109     private ResponseBuilder builder;
 110
 111     @Autowired
 112     private MsoRequest msoRequest;
 113
 114     @Autowired
 115     private CamundaRequestHandler camundaRequestHandler;
 116
 117     @Autowired
 118     private CatalogDbClient catalogDbClient;
 119
 120     public Response postBPELRequest(InfraActiveRequests currentActiveReq, RequestClientParameter requestClientParameter,
 121             String orchestrationUri, String requestScope) throws ApiException {
 122         RequestClient requestClient = null;
 123         HttpResponse response = null;
 124         try {
 125             requestClient = reqClientFactory.getRequestClient(orchestrationUri);
 126             response = requestClient.post(requestClientParameter);
 127         } catch (Exception e) {
 128
 129             ErrorLoggerInfo errorLoggerInfo =
 130                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, ErrorCode.AvailabilityError)
 131                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 132             String url = requestClient != null ? requestClient.getUrl() : "";
 133             ClientConnectionException clientException =
 134                     new ClientConnectionException.Builder(url, HttpStatus.SC_BAD_GATEWAY,
 135                             ErrorNumbers.SVC_NO_SERVER_RESOURCES).cause(e).errorInfo(errorLoggerInfo).build();
 136             updateStatus(currentActiveReq, Status.FAILED, clientException.getMessage());
 137
 138             throw clientException;
 139         }
 140
 141         if (response == null) {
 142
 143             ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 144                     ErrorCode.BusinessProcesssError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 145             ClientConnectionException clientException = new ClientConnectionException.Builder(requestClient.getUrl(),
 146                     HttpStatus.SC_BAD_GATEWAY, ErrorNumbers.SVC_NO_SERVER_RESOURCES).errorInfo(errorLoggerInfo).build();
 147
 148             updateStatus(currentActiveReq, Status.FAILED, clientException.getMessage());
 149
 150             throw clientException;
 151         }
 152
 153         ResponseHandler respHandler = null;
 154         int bpelStatus = 500;
 155         try {
 156             respHandler = new ResponseHandler(response, requestClient.getType());
 157             bpelStatus = respHandler.getStatus();
 158         } catch (ApiException e) {
 159             logger.error("Exception occurred", e);
 160             ErrorLoggerInfo errorLoggerInfo =
 161                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError)
 162                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 163             ValidateException validateException =
 164                     new ValidateException.Builder("Exception caught mapping Camunda JSON response to object",
 165                             HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_BAD_PARAMETER).cause(e)
 166                                     .errorInfo(errorLoggerInfo).build();
 167             updateStatus(currentActiveReq, Status.FAILED, validateException.getMessage());
 168             throw validateException;
 169         }
 170
 171         // BPEL accepted the request, the request is in progress
 172         if (bpelStatus == HttpStatus.SC_ACCEPTED) {
 173             ServiceInstancesResponse jsonResponse;
 174             CamundaResponse camundaResp = respHandler.getResponse();
 175
 176             if ("Success".equalsIgnoreCase(camundaResp.getMessage())) {
 177                 try {
 178                     ObjectMapper mapper = new ObjectMapper();
 179                     jsonResponse = mapper.readValue(camundaResp.getResponse(), ServiceInstancesResponse.class);
 180                     jsonResponse.getRequestReferences().setRequestId(requestClientParameter.getRequestId());
 181                     Optional<URL> selfLinkUrl =
 182                             buildSelfLinkUrl(currentActiveReq.getRequestUrl(), requestClientParameter.getRequestId());
 183                     if (selfLinkUrl.isPresent()) {
 184                         jsonResponse.getRequestReferences().setRequestSelfLink(selfLinkUrl.get());
 185                     } else {
 186                         jsonResponse.getRequestReferences().setRequestSelfLink(null);
 187                     }
 188                 } catch (IOException e) {
 189                     logger.error("Exception occurred", e);
 190                     ErrorLoggerInfo errorLoggerInfo =
 191                             new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError)
 192                                     .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 193                     ValidateException validateException =
 194                             new ValidateException.Builder("Exception caught mapping Camunda JSON response to object",
 195                                     HttpStatus.SC_NOT_ACCEPTABLE, ErrorNumbers.SVC_BAD_PARAMETER).cause(e)
 196                                             .errorInfo(errorLoggerInfo).build();
 197                     updateStatus(currentActiveReq, Status.FAILED, validateException.getMessage());
 198                     throw validateException;
 199                 }
 200                 return builder.buildResponse(HttpStatus.SC_ACCEPTED, requestClientParameter.getRequestId(),
 201                         jsonResponse, requestClientParameter.getApiVersion());
 202             }
 203         }
 204
 205         List<String> variables = new ArrayList<>();
 206         variables.add(bpelStatus + "");
 207         String camundaJSONResponseBody = respHandler.getResponseBody();
 208         if (camundaJSONResponseBody != null && !camundaJSONResponseBody.isEmpty()) {
 209
 210             ErrorLoggerInfo errorLoggerInfo =
 211                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.BusinessProcesssError)
 212                             .errorSource(requestClient.getUrl()).build();
 213             BPMNFailureException bpmnException =
 214                     new BPMNFailureException.Builder(String.valueOf(bpelStatus) + camundaJSONResponseBody, bpelStatus,
 215                             ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).errorInfo(errorLoggerInfo).build();
 216
 217             updateStatus(currentActiveReq, Status.FAILED, bpmnException.getMessage());
 218
 219             throw bpmnException;
 220         } else {
 221
 222             ErrorLoggerInfo errorLoggerInfo =
 223                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.BusinessProcesssError)
 224                             .errorSource(requestClient.getUrl()).build();
 225
 226
 227             BPMNFailureException servException = new BPMNFailureException.Builder(String.valueOf(bpelStatus),
 228                     bpelStatus, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).errorInfo(errorLoggerInfo).build();
 229             updateStatus(currentActiveReq, Status.FAILED, servException.getMessage());
 230
 231             throw servException;
 232         }
 233     }
 234
 235     public void updateStatus(InfraActiveRequests aq, Status status, String errorMessage)
 236             throws RequestDbFailureException {
 237         if ((status == Status.FAILED) || (status == Status.COMPLETE)) {
 238             aq.setStatusMessage(errorMessage);
 239             aq.setProgress(new Long(100));
 240             aq.setRequestStatus(status.toString());
 241             Timestamp endTimeStamp = new Timestamp(System.currentTimeMillis());
 242             aq.setEndTime(endTimeStamp);
 243             try {
 244                 infraActiveRequestsClient.save(aq);
 245             } catch (Exception e) {
 246                 ErrorLoggerInfo errorLoggerInfo =
 247                         new ErrorLoggerInfo.Builder(MessageEnum.APIH_DB_ACCESS_EXC, ErrorCode.DataError)
 248                                 .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 249                 throw new RequestDbFailureException.Builder(SAVE_TO_DB, e.toString(),
 250                         HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 251                                 .errorInfo(errorLoggerInfo).build();
 252             }
 253         }
 254     }
 255
 256     public String deriveRequestScope(Actions action, ServiceInstancesRequest sir, String requestUri) {
 257         if (action == Action.inPlaceSoftwareUpdate || action == Action.applyUpdatedConfig) {
 258             return (ModelType.vnf.name());
 259         } else if (action == Action.addMembers || action == Action.removeMembers) {
 260             return (ModelType.instanceGroup.toString());
 261         } else {
 262             String requestScope;
 263             if (sir.getRequestDetails().getModelInfo().getModelType() == null) {
 264                 requestScope = requestScopeFromUri(requestUri);
 265             } else {
 266                 requestScope = sir.getRequestDetails().getModelInfo().getModelType().name();
 267             }
 268             return requestScope;
 269         }
 270     }
 271
 272
 273     public void validateHeaders(ContainerRequestContext context) throws ValidationException {
 274         MultivaluedMap<String, String> headers = context.getHeaders();
 275         if (!headers.containsKey(ONAPLogConstants.Headers.REQUEST_ID)) {
 276             throw new ValidationException(ONAPLogConstants.Headers.REQUEST_ID + " header", true);
 277         }
 278         if (!headers.containsKey(ONAPLogConstants.Headers.PARTNER_NAME)) {
 279             throw new ValidationException(ONAPLogConstants.Headers.PARTNER_NAME + " header", true);
 280         }
 281         if (!headers.containsKey(REQUESTOR_ID)) {
 282             throw new ValidationException(REQUESTOR_ID + " header", true);
 283         }
 284     }
 285
 286     public String getRequestUri(ContainerRequestContext context, String uriPrefix) {
 287         String requestUri = context.getUriInfo().getPath();
 288         String httpUrl = MDC.get(LogConstants.URI_BASE).concat(requestUri);
 289         MDC.put(LogConstants.HTTP_URL, httpUrl);
 290         requestUri = requestUri.substring(requestUri.indexOf(uriPrefix) + uriPrefix.length());
 291         return requestUri;
 292     }
 293
 294     public InfraActiveRequests duplicateCheck(Actions action, HashMap<String, String> instanceIdMap,
 295             String instanceName, String requestScope, InfraActiveRequests currentActiveReq) throws ApiException {
 296         InfraActiveRequests dup = null;
 297         try {
 298             if (!(instanceName == null && "service".equals(requestScope) && (action == Action.createInstance
 299                     || action == Action.activateInstance || action == Action.assignInstance))) {
 300                 dup = infraActiveRequestsClient.checkInstanceNameDuplicate(instanceIdMap, instanceName, requestScope);
 301             }
 302         } catch (Exception e) {
 303             ErrorLoggerInfo errorLoggerInfo =
 304                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_DUPLICATE_CHECK_EXC, ErrorCode.DataError)
 305                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 306             RequestDbFailureException requestDbFailureException =
 307                     new RequestDbFailureException.Builder("check for duplicate instance", e.toString(),
 308                             HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 309                                     .errorInfo(errorLoggerInfo).build();
 310             updateStatus(currentActiveReq, Status.FAILED, requestDbFailureException.getMessage());
 311             throw requestDbFailureException;
 312         }
 313         return dup;
 314     }
 315
 316     public boolean camundaHistoryCheck(InfraActiveRequests duplicateRecord, InfraActiveRequests currentActiveReq)
 317             throws RequestDbFailureException, ContactCamundaException {
 318         String requestId = duplicateRecord.getRequestId();
 319         ResponseEntity<List<HistoricProcessInstanceEntity>> response = null;
 320         try {
 321             response = camundaRequestHandler.getCamundaProcessInstanceHistory(requestId);
 322         } catch (RestClientException e) {
 323             logger.error("Error querying Camunda for process-instance history for requestId: {}, exception: {}",
 324                     requestId, e.getMessage());
 325             ContactCamundaException contactCamundaException =
 326                     new ContactCamundaException.Builder("process-instance", requestId, e.toString(),
 327                             HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 328                                     .build();
 329             updateStatus(currentActiveReq, Status.FAILED, contactCamundaException.getMessage());
 330             throw contactCamundaException;
 331         }
 332
 333         if (response.getBody().isEmpty()) {
 334             updateStatus(duplicateRecord, Status.COMPLETE, "Request Completed");
 335         }
 336         for (HistoricProcessInstance instance : response.getBody()) {
 337             if (("ACTIVE").equals(instance.getState())) {
 338                 return true;
 339             } else {
 340                 updateStatus(duplicateRecord, Status.COMPLETE, "Request Completed");
 341             }
 342         }
 343         return false;
 344     }
 345
 346     public ServiceInstancesRequest convertJsonToServiceInstanceRequest(String requestJSON, Actions action,
 347             String requestId, String requestUri) throws ApiException {
 348         try {
 349             ObjectMapper mapper = new ObjectMapper();
 350             return mapper.readValue(requestJSON, ServiceInstancesRequest.class);
 351
 352         } catch (IOException e) {
 353
 354             ErrorLoggerInfo errorLoggerInfo =
 355                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, ErrorCode.SchemaError)
 356                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 357
 358             ValidateException validateException =
 359                     new ValidateException.Builder("Error mapping request: " + e.getMessage(), HttpStatus.SC_BAD_REQUEST,
 360                             ErrorNumbers.SVC_BAD_PARAMETER).cause(e).errorInfo(errorLoggerInfo).build();
 361             String requestScope = requestScopeFromUri(requestUri);
 362
 363             msoRequest.createErrorRequestRecord(Status.FAILED, requestId, validateException.getMessage(), action,
 364                     requestScope, requestJSON);
 365
 366             throw validateException;
 367         }
 368     }
 369
 370     public void parseRequest(ServiceInstancesRequest sir, HashMap<String, String> instanceIdMap, Actions action,
 371             String version, String requestJSON, Boolean aLaCarte, String requestId,
 372             InfraActiveRequests currentActiveReq) throws ValidateException, RequestDbFailureException {
 373         int reqVersion = Integer.parseInt(version.substring(1));
 374         try {
 375             msoRequest.parse(sir, instanceIdMap, action, version, requestJSON, reqVersion, aLaCarte);
 376         } catch (Exception e) {
 377             logger.error("failed to parse request", e);
 378             ErrorLoggerInfo errorLoggerInfo =
 379                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, ErrorCode.SchemaError)
 380                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 381             ValidateException validateException =
 382                     new ValidateException.Builder("Error parsing request: " + e.getMessage(), HttpStatus.SC_BAD_REQUEST,
 383                             ErrorNumbers.SVC_BAD_PARAMETER).cause(e).errorInfo(errorLoggerInfo).build();
 384
 385             updateStatus(currentActiveReq, Status.FAILED, validateException.getMessage());
 386
 387             throw validateException;
 388         }
 389     }
 390
 391     public void buildErrorOnDuplicateRecord(InfraActiveRequests currentActiveReq, Actions action,
 392             HashMap<String, String> instanceIdMap, String instanceName, String requestScope, InfraActiveRequests dup)
 393             throws ApiException {
 394
 395         String instance = null;
 396         if (instanceName != null) {
 397             instance = instanceName;
 398         } else {
 399             instance = instanceIdMap.get(requestScope + "InstanceId");
 400         }
 401         ErrorLoggerInfo errorLoggerInfo =
 402                 new ErrorLoggerInfo.Builder(MessageEnum.APIH_DUPLICATE_FOUND, ErrorCode.SchemaError)
 403                         .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 404
 405         DuplicateRequestException dupException =
 406                 new DuplicateRequestException.Builder(requestScope, instance, dup.getRequestStatus(),
 407                         dup.getRequestId(), HttpStatus.SC_CONFLICT, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR)
 408                                 .errorInfo(errorLoggerInfo).build();
 409
 410         updateStatus(currentActiveReq, Status.FAILED, dupException.getMessage());
 411
 412         throw dupException;
 413     }
 414
 415     public String getRequestId(ContainerRequestContext requestContext) throws ValidateException {
 416         String requestId = null;
 417         if (requestContext.getProperty("requestId") != null) {
 418             requestId = requestContext.getProperty("requestId").toString();
 419         }
 420         if (UUIDChecker.isValidUUID(requestId)) {
 421             return requestId;
 422         } else {
 423             ErrorLoggerInfo errorLoggerInfo =
 424                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError)
 425                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 426             ValidateException validateException =
 427                     new ValidateException.Builder("Request Id " + requestId + " is not a valid UUID",
 428                             HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_BAD_PARAMETER)
 429                                     .errorInfo(errorLoggerInfo).build();
 430
 431             throw validateException;
 432         }
 433     }
 434
 435     public void setInstanceId(InfraActiveRequests currentActiveReq, String requestScope, String instanceId,
 436             Map<String, String> instanceIdMap) {
 437         if (StringUtils.isNotBlank(instanceId)) {
 438             if (ModelType.service.name().equalsIgnoreCase(requestScope)) {
 439                 currentActiveReq.setServiceInstanceId(instanceId);
 440             } else if (ModelType.vnf.name().equalsIgnoreCase(requestScope)) {
 441                 currentActiveReq.setVnfId(instanceId);
 442             } else if (ModelType.vfModule.name().equalsIgnoreCase(requestScope)) {
 443                 currentActiveReq.setVfModuleId(instanceId);
 444             } else if (ModelType.volumeGroup.name().equalsIgnoreCase(requestScope)) {
 445                 currentActiveReq.setVolumeGroupId(instanceId);
 446             } else if (ModelType.network.name().equalsIgnoreCase(requestScope)) {
 447                 currentActiveReq.setNetworkId(instanceId);
 448             } else if (ModelType.configuration.name().equalsIgnoreCase(requestScope)) {
 449                 currentActiveReq.setConfigurationId(instanceId);
 450             } else if (ModelType.instanceGroup.toString().equalsIgnoreCase(requestScope)) {
 451                 currentActiveReq.setInstanceGroupId(instanceId);
 452             }
 453         } else if (instanceIdMap != null && !instanceIdMap.isEmpty()) {
 454             if (instanceIdMap.get("serviceInstanceId") != null) {
 455                 currentActiveReq.setServiceInstanceId(instanceIdMap.get("serviceInstanceId"));
 456             }
 457             if (instanceIdMap.get("vnfInstanceId") != null) {
 458                 currentActiveReq.setVnfId(instanceIdMap.get("vnfInstanceId"));
 459             }
 460             if (instanceIdMap.get("vfModuleInstanceId") != null) {
 461                 currentActiveReq.setVfModuleId(instanceIdMap.get("vfModuleInstanceId"));
 462             }
 463             if (instanceIdMap.get("volumeGroupInstanceId") != null) {
 464                 currentActiveReq.setVolumeGroupId(instanceIdMap.get("volumeGroupInstanceId"));
 465             }
 466             if (instanceIdMap.get("networkInstanceId") != null) {
 467                 currentActiveReq.setNetworkId(instanceIdMap.get("networkInstanceId"));
 468             }
 469             if (instanceIdMap.get("configurationInstanceId") != null) {
 470                 currentActiveReq.setConfigurationId(instanceIdMap.get("configurationInstanceId"));
 471             }
 472             if (instanceIdMap.get(CommonConstants.INSTANCE_GROUP_INSTANCE_ID) != null) {
 473                 currentActiveReq.setInstanceGroupId(instanceIdMap.get(CommonConstants.INSTANCE_GROUP_INSTANCE_ID));
 474             }
 475         }
 476     }
 477
 478     public String mapJSONtoMSOStyle(String msoRawRequest, ServiceInstancesRequest serviceInstRequest,
 479             boolean isAlaCarte, Actions action) throws IOException {
 480         ObjectMapper mapper = new ObjectMapper();
 481         mapper.setSerializationInclusion(Include.NON_NULL);
 482         if (serviceInstRequest != null) {
 483             return mapper.writeValueAsString(serviceInstRequest);
 484         } else {
 485             return msoRawRequest;
 486         }
 487     }
 488
 489     public Optional<String> retrieveModelName(RequestParameters requestParams) {
 490         String requestTestApi = null;
 491         TestApi testApi = null;
 492
 493         if (requestParams != null) {
 494             requestTestApi = requestParams.getTestApi();
 495         }
 496
 497         if (requestTestApi == null) {
 498             if (requestParams != null && requestParams.getALaCarte() != null && !requestParams.getALaCarte()) {
 499                 requestTestApi = env.getProperty(CommonConstants.MACRO_TEST_API);
 500             } else {
 501                 requestTestApi = env.getProperty(CommonConstants.ALACARTE_TEST_API);
 502             }
 503         }
 504
 505         try {
 506             testApi = TestApi.valueOf(requestTestApi);
 507             return Optional.of(testApi.getModelName());
 508         } catch (Exception e) {
 509             logger.warn("Catching the exception on the valueOf enum call and continuing", e);
 510             throw new IllegalArgumentException("Invalid TestApi is provided", e);
 511         }
 512     }
 513
 514     public String getDefaultModel(ServiceInstancesRequest sir) {
 515         String defaultModel = sir.getRequestDetails().getRequestInfo().getSource() + "_DEFAULT";
 516         Optional<String> oModelName = retrieveModelName(sir.getRequestDetails().getRequestParameters());
 517         if (oModelName.isPresent()) {
 518             defaultModel = oModelName.get();
 519         }
 520         return defaultModel;
 521     }
 522
 523     public String getServiceType(String requestScope, ServiceInstancesRequest sir, Boolean aLaCarteFlag) {
 524         String serviceType = null;
 525         if (requestScope.equalsIgnoreCase(ModelType.service.toString())) {
 526             String defaultServiceModelName = getDefaultModel(sir);
 527             org.onap.so.db.catalog.beans.Service serviceRecord;
 528             if (aLaCarteFlag) {
 529                 serviceRecord = catalogDbClient.getFirstByModelNameOrderByModelVersionDesc(defaultServiceModelName);
 530                 if (serviceRecord != null) {
 531                     serviceType = serviceRecord.getServiceType();
 532                 }
 533             } else {
 534                 serviceRecord =
 535                         catalogDbClient.getServiceByID(sir.getRequestDetails().getModelInfo().getModelVersionId());
 536                 if (serviceRecord != null) {
 537                     serviceType = serviceRecord.getServiceType();
 538                 } else {
 539                     serviceRecord = catalogDbClient.getFirstByModelNameOrderByModelVersionDesc(defaultServiceModelName);
 540                     if (serviceRecord != null) {
 541                         serviceType = serviceRecord.getServiceType();
 542                     }
 543                 }
 544             }
 545         } else {
 546             serviceType = msoRequest.getServiceInstanceType(sir, requestScope);
 547         }
 548         return serviceType;
 549     }
 550
 551     protected String setServiceInstanceId(String requestScope, ServiceInstancesRequest sir) {
 552         if (sir.getServiceInstanceId() != null) {
 553             return sir.getServiceInstanceId();
 554         } else if (requestScope.equalsIgnoreCase(ModelType.instanceGroup.toString())) {
 555             RelatedInstanceList[] relatedInstances = sir.getRequestDetails().getRelatedInstanceList();
 556             if (relatedInstances != null) {
 557                 for (RelatedInstanceList relatedInstanceList : relatedInstances) {
 558                     RelatedInstance relatedInstance = relatedInstanceList.getRelatedInstance();
 559                     if (relatedInstance.getModelInfo().getModelType() == ModelType.service) {
 560                         return relatedInstance.getInstanceId();
 561                     }
 562                 }
 563             }
 564         }
 565         return null;
 566     }
 567
 568     private String requestScopeFromUri(String requestUri) {
 569         String requestScope;
 570         if (requestUri.contains(ModelType.network.name())) {
 571             requestScope = ModelType.network.name();
 572         } else if (requestUri.contains(ModelType.vfModule.name())) {
 573             requestScope = ModelType.vfModule.name();
 574         } else if (requestUri.contains(ModelType.volumeGroup.name())) {
 575             requestScope = ModelType.volumeGroup.name();
 576         } else if (requestUri.contains(ModelType.configuration.name())) {
 577             requestScope = ModelType.configuration.name();
 578         } else if (requestUri.contains(ModelType.vnf.name())) {
 579             requestScope = ModelType.vnf.name();
 580         } else {
 581             requestScope = ModelType.service.name();
 582         }
 583         return requestScope;
 584     }
 585
 586     protected InfraActiveRequests createNewRecordCopyFromInfraActiveRequest(InfraActiveRequests infraActiveRequest,
 587             String requestId, Timestamp startTimeStamp, String source, String requestUri, String requestorId,
 588             String originalRequestId) throws ApiException {
 589         InfraActiveRequests request = new InfraActiveRequests();
 590         request.setRequestId(requestId);
 591         request.setStartTime(startTimeStamp);
 592         request.setSource(source);
 593         request.setRequestUrl(requestUri);
 594         request.setProgress(new Long(5));
 595         request.setRequestorId(requestorId);
 596         request.setRequestStatus(Status.IN_PROGRESS.toString());
 597         request.setOriginalRequestId(originalRequestId);
 598         request.setLastModifiedBy(Constants.MODIFIED_BY_APIHANDLER);
 599         if (infraActiveRequest != null) {
 600             request.setTenantId(infraActiveRequest.getTenantId());
 601             request.setRequestBody(updateRequestorIdInRequestBody(infraActiveRequest, requestorId));
 602             request.setAicCloudRegion(infraActiveRequest.getAicCloudRegion());
 603             request.setRequestScope(infraActiveRequest.getRequestScope());
 604             request.setRequestAction(infraActiveRequest.getRequestAction());
 605             setInstanceIdAndName(infraActiveRequest, request);
 606         }
 607         return request;
 608     }
 609
 610     protected void setInstanceIdAndName(InfraActiveRequests infraActiveRequest,
 611             InfraActiveRequests currentActiveRequest) throws ApiException {
 612         String requestScope = infraActiveRequest.getRequestScope();
 613         try {
 614             ModelType type = ModelType.valueOf(requestScope);
 615             String instanceName = type.getName(infraActiveRequest);
 616             if (instanceName == null && type.equals(ModelType.vfModule)) {
 617                 logger.error("vfModule for requestId: {} being resumed does not have an instanceName.",
 618                         infraActiveRequest.getRequestId());
 619                 ValidateException validateException = new ValidateException.Builder(
 620                         "vfModule for requestId: " + infraActiveRequest.getRequestId()
 621                                 + " being resumed does not have an instanceName.",
 622                         HttpStatus.SC_BAD_REQUEST, ErrorNumbers.SVC_BAD_PARAMETER).build();
 623                 updateStatus(currentActiveRequest, Status.FAILED, validateException.getMessage());
 624                 throw validateException;
 625             }
 626             if (instanceName != null) {
 627                 type.setName(currentActiveRequest, instanceName);
 628             }
 629             type.setId(currentActiveRequest, type.getId(infraActiveRequest));
 630         } catch (IllegalArgumentException e) {
 631             logger.error(
 632                     "requestScope \"{}\" does not match a ModelType enum. Unable to set instanceId and instanceName from the original request.",
 633                     requestScope);
 634         }
 635     }
 636
 637     protected Boolean getIsBaseVfModule(ModelInfo modelInfo, Actions action, String vnfType,
 638             String sdcServiceModelVersion, InfraActiveRequests currentActiveReq) throws ApiException {
 639         // Get VF Module-specific base module indicator
 640         VfModule vfm = null;
 641         String modelVersionId = modelInfo.getModelVersionId();
 642         Boolean isBaseVfModule = false;
 643
 644         if (modelVersionId != null) {
 645             vfm = catalogDbClient.getVfModuleByModelUUID(modelVersionId);
 646         } else if (modelInfo.getModelInvariantId() != null && modelInfo.getModelVersion() != null) {
 647             vfm = catalogDbClient.getVfModuleByModelInvariantUUIDAndModelVersion(modelInfo.getModelInvariantId(),
 648                     modelInfo.getModelVersion());
 649         }
 650
 651         if (vfm != null) {
 652             if (vfm.getIsBase()) {
 653                 isBaseVfModule = true;
 654             }
 655         } else if (action == Action.createInstance || action == Action.updateInstance) {
 656             String serviceVersionText = "";
 657             if (sdcServiceModelVersion != null && !sdcServiceModelVersion.isEmpty()) {
 658                 serviceVersionText = " with version " + sdcServiceModelVersion;
 659             }
 660             String errorMessage = "VnfType " + vnfType + " and VF Module Model Name " + modelInfo.getModelName()
 661                     + serviceVersionText + " not found in MSO Catalog DB";
 662             ErrorLoggerInfo errorLoggerInfo =
 663                     new ErrorLoggerInfo.Builder(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND, ErrorCode.DataError)
 664                             .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 665             VfModuleNotFoundException vfModuleException = new VfModuleNotFoundException.Builder(errorMessage,
 666                     HttpStatus.SC_NOT_FOUND, ErrorNumbers.SVC_BAD_PARAMETER).errorInfo(errorLoggerInfo).build();
 667             updateStatus(currentActiveReq, Status.FAILED, vfModuleException.getMessage());
 668             throw vfModuleException;
 669         }
 670         return isBaseVfModule;
 671     }
 672
 673     protected ModelType getModelType(Actions action, ModelInfo modelInfo) {
 674         if (action == Action.applyUpdatedConfig || action == Action.inPlaceSoftwareUpdate) {
 675             return ModelType.vnf;
 676         } else if (action == Action.addMembers || action == Action.removeMembers) {
 677             return ModelType.instanceGroup;
 678         } else {
 679             return modelInfo.getModelType();
 680         }
 681     }
 682
 683     protected String updateRequestorIdInRequestBody(InfraActiveRequests infraActiveRequest, String newRequestorId) {
 684         String requestBody = infraActiveRequest.getRequestBody();
 685         return requestBody.replaceAll(
 686                 "(?s)(\"requestInfo\"\\s*?:\\s*?\\{.*?\"requestorId\"\\s*?:\\s*?\")(.*?)(\"[ ]*(?:,|\\R|\\}))",
 687                 "$1" + newRequestorId + "$3");
 688     }
 689 }