gerrit.onap Code Review - so.git/blob

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