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