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