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