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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright (C) 2017 Huawei Technologies Co., Ltd. All rights reserved.
   7  * ================================================================================
   8  * Modifications Copyright (c) 2019 Samsung
   9  * ================================================================================
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.so.apihandlerinfra;
  25
  26
  27 import com.fasterxml.jackson.annotation.JsonInclude.Include;
  28 import com.fasterxml.jackson.databind.ObjectMapper;
  29
  30 import org.apache.commons.lang.StringUtils;
  31 import org.apache.http.HttpResponse;
  32 import org.apache.http.HttpStatus;
  33 import org.camunda.bpm.engine.history.HistoricProcessInstance;
  34 import org.camunda.bpm.engine.impl.persistence.entity.HistoricProcessInstanceEntity;
  35 import org.onap.logging.ref.slf4j.ONAPLogConstants;
  36 import org.onap.so.apihandler.camundabeans.CamundaResponse;
  37 import org.onap.so.apihandler.common.CommonConstants;
  38 import org.onap.so.apihandler.common.ErrorNumbers;
  39 import org.onap.so.apihandler.common.RequestClient;
  40 import org.onap.so.apihandler.common.RequestClientFactory;
  41 import org.onap.so.apihandler.common.RequestClientParameter;
  42 import org.onap.so.apihandler.common.ResponseBuilder;
  43 import org.onap.so.apihandler.common.ResponseHandler;
  44 import org.onap.so.apihandlerinfra.exceptions.ApiException;
  45 import org.onap.so.apihandlerinfra.exceptions.BPMNFailureException;
  46 import org.onap.so.apihandlerinfra.exceptions.ClientConnectionException;
  47 import org.onap.so.apihandlerinfra.exceptions.ContactCamundaException;
  48 import org.onap.so.apihandlerinfra.exceptions.DuplicateRequestException;
  49 import org.onap.so.apihandlerinfra.exceptions.RequestDbFailureException;
  50 import org.onap.so.apihandlerinfra.exceptions.ValidateException;
  51 import org.onap.so.apihandlerinfra.logging.ErrorLoggerInfo;
  52 import org.onap.so.db.catalog.client.CatalogDbClient;
  53 import org.onap.so.db.request.beans.InfraActiveRequests;
  54 import org.onap.so.db.request.client.RequestsDbClient;
  55 import org.onap.so.exceptions.ValidationException;
  56 import org.onap.so.logger.ErrorCode;
  57 import org.onap.so.logger.LogConstants;
  58 import org.onap.so.logger.MessageEnum;
  59 import org.onap.so.serviceinstancebeans.ModelType;
  60 import org.onap.so.serviceinstancebeans.RelatedInstance;
  61 import org.onap.so.serviceinstancebeans.RelatedInstanceList;
  62 import org.onap.so.serviceinstancebeans.RequestParameters;
  63 import org.onap.so.serviceinstancebeans.ServiceInstancesRequest;
  64 import org.onap.so.serviceinstancebeans.ServiceInstancesResponse;
  65 import org.onap.so.utils.CryptoUtils;
  66 import org.onap.so.utils.UUIDChecker;
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69 import org.slf4j.MDC;
  70 import org.springframework.beans.factory.annotation.Autowired;
  71 import org.springframework.core.ParameterizedTypeReference;
  72 import org.springframework.core.env.Environment;
  73 import org.springframework.http.HttpEntity;
  74 import org.springframework.http.HttpHeaders;
  75 import org.springframework.http.HttpMethod;
  76 import org.springframework.http.ResponseEntity;
  77 import org.springframework.stereotype.Component;
  78 import org.springframework.web.client.HttpStatusCodeException;
  79 import org.springframework.web.client.RestTemplate;
  80
  81 import javax.ws.rs.container.ContainerRequestContext;
  82 import javax.ws.rs.core.MultivaluedMap;
  83 import javax.ws.rs.core.Response;
  84 import javax.xml.bind.DatatypeConverter;
  85
  86 import static org.onap.so.logger.HttpHeadersConstants.REQUESTOR_ID;
  87
  88 import java.io.IOException;
  89 import java.net.URL;
  90 import java.security.GeneralSecurityException;
  91 import java.sql.Timestamp;
  92 import java.util.ArrayList;
  93 import java.util.HashMap;
  94 import java.util.List;
  95 import java.util.Map;
  96 import java.util.Optional;
  97
  98 @Component
  99 public class RequestHandlerUtils {
 100
 101         private static Logger logger = LoggerFactory.getLogger(RequestHandlerUtils.class);
 102
 103         private static final String SAVE_TO_DB = "save instance to db";
 104
 105         @Autowired
 106         private Environment env;
 107
 108         @Autowired
 109         private RequestClientFactory reqClientFactory;
 110
 111         @Autowired
 112         private RequestsDbClient infraActiveRequestsClient;
 113
 114         @Autowired
 115         private ResponseBuilder builder;
 116
 117         @Autowired
 118         private MsoRequest msoRequest;
 119
 120         @Autowired
 121         private RestTemplate restTemplate;
 122
 123         @Autowired
 124         private CatalogDbClient catalogDbClient;
 125
 126         public Response postBPELRequest(InfraActiveRequests currentActiveReq, RequestClientParameter requestClientParameter, 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 = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, ErrorCode.AvailabilityError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 135             String url = requestClient != null ? requestClient.getUrl() : "";
 136             ClientConnectionException clientException = new ClientConnectionException.Builder(url, HttpStatus.SC_BAD_GATEWAY, ErrorNumbers.SVC_NO_SERVER_RESOURCES).cause(e).errorInfo(errorLoggerInfo).build();
 137             updateStatus(currentActiveReq, Status.FAILED, clientException.getMessage());
 138
 139             throw clientException;
 140                 }
 141
 142                 if (response == null) {
 143
 144             ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, ErrorCode.BusinessProcesssError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 145             ClientConnectionException clientException = new ClientConnectionException.Builder(requestClient.getUrl(), HttpStatus.SC_BAD_GATEWAY, ErrorNumbers.SVC_NO_SERVER_RESOURCES).errorInfo(errorLoggerInfo).build();
 146
 147             updateStatus(currentActiveReq, Status.FAILED, clientException.getMessage());
 148
 149             throw clientException;
 150                 }
 151
 152                 ResponseHandler respHandler = null;
 153         int bpelStatus = 500;
 154         try {
 155             respHandler = new ResponseHandler (response, requestClient.getType ());
 156             bpelStatus = respHandler.getStatus ();
 157         } catch (ApiException e) {
 158             logger.error("Exception occurred", e);
 159             ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 160             ValidateException validateException = new ValidateException.Builder("Exception caught mapping Camunda JSON response to object", HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_BAD_PARAMETER).cause(e)
 161                         .errorInfo(errorLoggerInfo).build();
 162             updateStatus(currentActiveReq, Status.FAILED, validateException.getMessage());
 163             throw validateException;
 164         }
 165
 166                 // BPEL accepted the request, the request is in progress
 167                 if (bpelStatus == HttpStatus.SC_ACCEPTED) {
 168                         ServiceInstancesResponse jsonResponse;
 169                         CamundaResponse camundaResp = respHandler.getResponse();
 170
 171                         if("Success".equalsIgnoreCase(camundaResp.getMessage())) {
 172                                 try {
 173                                         ObjectMapper mapper = new ObjectMapper();
 174                                         jsonResponse = mapper.readValue(camundaResp.getResponse(), ServiceInstancesResponse.class);
 175                                         jsonResponse.getRequestReferences().setRequestId(requestClientParameter.getRequestId());
 176                                         Optional<URL> selfLinkUrl = msoRequest.buildSelfLinkUrl(currentActiveReq.getRequestUrl(), requestClientParameter.getRequestId());
 177                                         if(selfLinkUrl.isPresent()){
 178                                                 jsonResponse.getRequestReferences().setRequestSelfLink(selfLinkUrl.get());
 179                                         } else {
 180                                             jsonResponse.getRequestReferences().setRequestSelfLink(null);
 181                                         }
 182                                 } catch (IOException e) {
 183                                         logger.error("Exception occurred", e);
 184                                         ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 185                                         ValidateException validateException = new ValidateException.Builder("Exception caught mapping Camunda JSON response to object", HttpStatus.SC_NOT_ACCEPTABLE, ErrorNumbers.SVC_BAD_PARAMETER).cause(e)
 186                                             .errorInfo(errorLoggerInfo).build();
 187                                         updateStatus(currentActiveReq, Status.FAILED, validateException.getMessage());
 188                                         throw validateException;
 189                                 }
 190                                 return builder.buildResponse(HttpStatus.SC_ACCEPTED, requestClientParameter.getRequestId(), jsonResponse, requestClientParameter.getApiVersion());
 191                         }
 192                 }
 193
 194                 List<String> variables = new ArrayList<>();
 195                 variables.add(bpelStatus + "");
 196                 String camundaJSONResponseBody = respHandler.getResponseBody ();
 197                 if (camundaJSONResponseBody != null && !camundaJSONResponseBody.isEmpty ()) {
 198
 199                     ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.BusinessProcesssError).errorSource(requestClient.getUrl()).build();
 200                     BPMNFailureException bpmnException = new BPMNFailureException.Builder(String.valueOf(bpelStatus) + camundaJSONResponseBody, bpelStatus, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR)
 201                             .errorInfo(errorLoggerInfo).build();
 202
 203                     updateStatus(currentActiveReq, Status.FAILED, bpmnException.getMessage());
 204
 205                     throw bpmnException;
 206                 } else {
 207
 208                     ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.BusinessProcesssError).errorSource(requestClient.getUrl()).build();
 209
 210
 211                     BPMNFailureException servException = new BPMNFailureException.Builder(String.valueOf(bpelStatus), bpelStatus, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR)
 212                             .errorInfo(errorLoggerInfo).build();
 213                     updateStatus(currentActiveReq, Status.FAILED, servException.getMessage());
 214
 215                     throw servException;
 216                 }
 217         }
 218
 219         public void updateStatus(InfraActiveRequests aq, Status status, String errorMessage) throws RequestDbFailureException{
 220                 if ((status == Status.FAILED) || (status == Status.COMPLETE)) {
 221                         aq.setStatusMessage (errorMessage);
 222                         aq.setProgress(new Long(100));
 223                         aq.setRequestStatus(status.toString());
 224                         Timestamp endTimeStamp = new Timestamp (System.currentTimeMillis());
 225                         aq.setEndTime (endTimeStamp);
 226                         try{
 227                                 infraActiveRequestsClient.save(aq);
 228                         }catch(Exception e){
 229                                 ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_DB_ACCESS_EXC, ErrorCode.DataError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 230                     throw new RequestDbFailureException.Builder(SAVE_TO_DB, e.toString(), HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 231                             .errorInfo(errorLoggerInfo).build();
 232                         }
 233                 }
 234         }
 235
 236         public String deriveRequestScope(Actions action, ServiceInstancesRequest sir, String requestUri) {
 237                 if(action == Action.inPlaceSoftwareUpdate || action == Action.applyUpdatedConfig){
 238                         return (ModelType.vnf.name());
 239                 }else if(action == Action.addMembers || action == Action.removeMembers){
 240                         return(ModelType.instanceGroup.toString());
 241                 }else{
 242                         String requestScope;
 243                         if(sir.getRequestDetails().getModelInfo().getModelType() == null){
 244                                 requestScope = requestScopeFromUri(requestUri);
 245                         }else{
 246                                 requestScope = sir.getRequestDetails().getModelInfo().getModelType().name();
 247                         }
 248                         return requestScope;
 249                 }
 250         }
 251
 252
 253         public void validateHeaders(ContainerRequestContext context) throws ValidationException{
 254                 MultivaluedMap<String, String> headers = context.getHeaders();
 255                 if(!headers.containsKey(ONAPLogConstants.Headers.REQUEST_ID)){
 256                          throw new ValidationException(ONAPLogConstants.Headers.REQUEST_ID + " header", true);
 257                 }
 258                 if(!headers.containsKey(ONAPLogConstants.Headers.PARTNER_NAME)){
 259                         throw new ValidationException(ONAPLogConstants.Headers.PARTNER_NAME + " header", true);
 260                 }
 261                 if(!headers.containsKey(REQUESTOR_ID)){
 262                         throw new ValidationException(REQUESTOR_ID + " header", true);
 263                 }
 264         }
 265
 266         public String getRequestUri(ContainerRequestContext context, String uriPrefix){
 267                 String requestUri = context.getUriInfo().getPath();
 268                 String httpUrl = MDC.get(LogConstants.URI_BASE).concat(requestUri);
 269                 MDC.put(LogConstants.HTTP_URL, httpUrl);
 270                 requestUri = requestUri.substring(requestUri.indexOf(uriPrefix) + uriPrefix.length());
 271                 return requestUri;
 272         }
 273
 274         public InfraActiveRequests duplicateCheck(Actions action, HashMap<String, String> instanceIdMap, long startTime,
 275             MsoRequest msoRequest, String instanceName, String requestScope, InfraActiveRequests currentActiveReq) throws ApiException {
 276                 InfraActiveRequests dup = null;
 277                 try {
 278                         if(!(instanceName==null && requestScope.equals("service") && (action == Action.createInstance || action == Action.activateInstance || action == Action.assignInstance))){
 279                                 dup = infraActiveRequestsClient.checkInstanceNameDuplicate (instanceIdMap, instanceName, requestScope);
 280                         }
 281                 } catch (Exception e) {
 282                         ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_DUPLICATE_CHECK_EXC, ErrorCode.DataError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 283                         RequestDbFailureException requestDbFailureException = new RequestDbFailureException.Builder("check for duplicate instance", e.toString(), HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 284                                         .errorInfo(errorLoggerInfo).build();
 285                         updateStatus(currentActiveReq, Status.FAILED, requestDbFailureException.getMessage());
 286                         throw requestDbFailureException;
 287                 }
 288                 return dup;
 289         }
 290
 291         public boolean camundaHistoryCheck(InfraActiveRequests duplicateRecord, InfraActiveRequests currentActiveReq) throws RequestDbFailureException, ContactCamundaException{
 292                 String requestId = duplicateRecord.getRequestId();
 293                 String path = env.getProperty("mso.camunda.rest.history.uri") + requestId;
 294                 String targetUrl = env.getProperty("mso.camundaURL") + path;
 295                 HttpHeaders headers = setCamundaHeaders(env.getRequiredProperty("mso.camundaAuth"), env.getRequiredProperty("mso.msoKey"));
 296                 HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 297                 ResponseEntity<List<HistoricProcessInstanceEntity>> response = null;
 298                 try{
 299                         response = restTemplate.exchange(targetUrl, HttpMethod.GET, requestEntity, new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>(){});
 300                 }catch(HttpStatusCodeException e){
 301                         ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_DUPLICATE_CHECK_EXC, ErrorCode.DataError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 302                         ContactCamundaException contactCamundaException= new ContactCamundaException.Builder(requestId, e.toString(), HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 303                                         .errorInfo(errorLoggerInfo).build();
 304                         updateStatus(currentActiveReq, Status.FAILED, contactCamundaException.getMessage());
 305                         throw contactCamundaException;
 306                 }
 307                 if(response.getBody().isEmpty()){
 308                         updateStatus(duplicateRecord, Status.COMPLETE, "Request Completed");
 309                 }
 310                 for(HistoricProcessInstance instance : response.getBody()){
 311                         if(instance.getState().equals("ACTIVE")){
 312                                 return true;
 313                         }else{
 314                                 updateStatus(duplicateRecord, Status.COMPLETE, "Request Completed");
 315                         }
 316                 }
 317                 return false;
 318         }
 319
 320         protected HttpHeaders setCamundaHeaders(String auth, String msoKey) {
 321                 HttpHeaders headers = new HttpHeaders();
 322                 List<org.springframework.http.MediaType> acceptableMediaTypes = new ArrayList<>();
 323                 acceptableMediaTypes.add(org.springframework.http.MediaType.APPLICATION_JSON);
 324                 headers.setAccept(acceptableMediaTypes);
 325                 try {
 326                         String userCredentials = CryptoUtils.decrypt(auth, msoKey);
 327                         if(userCredentials != null) {
 328                                 headers.add(HttpHeaders.AUTHORIZATION, "Basic " + DatatypeConverter.printBase64Binary(userCredentials.getBytes()));
 329                         }
 330                 } catch(GeneralSecurityException e) {
 331                         logger.error("Security exception", e);
 332                 }
 333                 return headers;
 334         }
 335
 336         public ServiceInstancesRequest convertJsonToServiceInstanceRequest(String requestJSON, Actions action, long startTime,
 337                                      ServiceInstancesRequest sir, MsoRequest msoRequest, String requestId, String requestUri) throws ApiException {
 338                 try{
 339                         ObjectMapper mapper = new ObjectMapper();
 340                         return mapper.readValue(requestJSON, ServiceInstancesRequest.class);
 341
 342                 } catch (IOException e) {
 343
 344                         ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, ErrorCode.SchemaError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 345
 346                         ValidateException validateException = new ValidateException.Builder("Error mapping request: " + e.getMessage(), HttpStatus.SC_BAD_REQUEST, ErrorNumbers.SVC_BAD_PARAMETER).cause(e)
 347                                         .errorInfo(errorLoggerInfo).build();
 348                         String requestScope = requestScopeFromUri(requestUri);
 349
 350                         msoRequest.createErrorRequestRecord(Status.FAILED, requestId, validateException.getMessage(), action, requestScope, requestJSON);
 351
 352                         throw validateException;
 353                 }
 354         }
 355
 356         public void parseRequest(ServiceInstancesRequest sir, HashMap<String, String> instanceIdMap, Actions action, String version,
 357                         String requestJSON, Boolean aLaCarte, String requestId, InfraActiveRequests currentActiveReq) throws ValidateException, RequestDbFailureException {
 358                 int reqVersion = Integer.parseInt(version.substring(1));
 359                 try {
 360                         msoRequest.parse(sir, instanceIdMap, action, version, requestJSON, reqVersion, aLaCarte);
 361                 } catch (Exception e) {
 362                         logger.error("failed to parse request", e);
 363                         ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, ErrorCode.SchemaError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 364                         ValidateException validateException = new ValidateException.Builder("Error parsing request: " + e.getMessage(), HttpStatus.SC_BAD_REQUEST, ErrorNumbers.SVC_BAD_PARAMETER).cause(e)
 365                                         .errorInfo(errorLoggerInfo).build();
 366
 367                         updateStatus(currentActiveReq, Status.FAILED, validateException.getMessage());
 368
 369                         throw validateException;
 370                 }
 371         }
 372
 373         public void buildErrorOnDuplicateRecord(InfraActiveRequests currentActiveReq, Actions action, HashMap<String, String> instanceIdMap, long startTime, MsoRequest msoRequest,
 374              String instanceName, String requestScope, InfraActiveRequests dup) throws ApiException {
 375
 376                 String instance = null;
 377                 if(instanceName != null){
 378                         instance = instanceName;
 379                 }else{
 380                         instance = instanceIdMap.get(requestScope + "InstanceId");
 381                 }
 382                 ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_DUPLICATE_FOUND, ErrorCode.SchemaError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 383
 384                 DuplicateRequestException dupException = new DuplicateRequestException.Builder(requestScope,instance,dup.getRequestStatus(),dup.getRequestId(), HttpStatus.SC_CONFLICT, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR)
 385                                 .errorInfo(errorLoggerInfo).build();
 386
 387                 updateStatus(currentActiveReq, Status.FAILED, dupException.getMessage());
 388
 389                 throw dupException;
 390         }
 391
 392          public String getRequestId(ContainerRequestContext requestContext) throws ValidateException {
 393             String requestId = null;
 394             if (requestContext.getProperty("requestId") != null) {
 395                 requestId = requestContext.getProperty("requestId").toString();
 396             }
 397             if (UUIDChecker.isValidUUID(requestId)) {
 398                 return requestId;
 399             } else {
 400                 ErrorLoggerInfo errorLoggerInfo = new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError).errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 401                         ValidateException validateException = new ValidateException.Builder("Request Id " + requestId + " is not a valid UUID", HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_BAD_PARAMETER)
 402                                    .errorInfo(errorLoggerInfo).build();
 403
 404                         throw validateException;
 405             }
 406          }
 407
 408          public void setInstanceId(InfraActiveRequests currentActiveReq, String requestScope, String instanceId, Map<String, String> instanceIdMap) {
 409                 if(StringUtils.isNotBlank(instanceId)) {
 410                         if(ModelType.service.name().equalsIgnoreCase(requestScope)) {
 411                                 currentActiveReq.setServiceInstanceId(instanceId);
 412                         } else if(ModelType.vnf.name().equalsIgnoreCase(requestScope)) {
 413                                 currentActiveReq.setVnfId(instanceId);
 414                         } else if(ModelType.vfModule.name().equalsIgnoreCase(requestScope)) {
 415                                 currentActiveReq.setVfModuleId(instanceId);
 416                         } else if(ModelType.volumeGroup.name().equalsIgnoreCase(requestScope)) {
 417                                 currentActiveReq.setVolumeGroupId(instanceId);
 418                         } else if(ModelType.network.name().equalsIgnoreCase(requestScope)) {
 419                                 currentActiveReq.setNetworkId(instanceId);
 420                         } else if(ModelType.configuration.name().equalsIgnoreCase(requestScope)) {
 421                                 currentActiveReq.setConfigurationId(instanceId);
 422                         }else if(ModelType.instanceGroup.toString().equalsIgnoreCase(requestScope)){
 423                                 currentActiveReq.setInstanceGroupId(instanceId);
 424                         }
 425                 } else if(instanceIdMap != null && !instanceIdMap.isEmpty()) {
 426                         if(instanceIdMap.get("serviceInstanceId") != null){
 427                                 currentActiveReq.setServiceInstanceId(instanceIdMap.get("serviceInstanceId"));
 428                 }
 429                 if(instanceIdMap.get("vnfInstanceId") != null){
 430                         currentActiveReq.setVnfId(instanceIdMap.get("vnfInstanceId"));
 431                 }
 432                 if(instanceIdMap.get("vfModuleInstanceId") != null){
 433                         currentActiveReq.setVfModuleId(instanceIdMap.get("vfModuleInstanceId"));
 434                 }
 435                 if(instanceIdMap.get("volumeGroupInstanceId") != null){
 436                         currentActiveReq.setVolumeGroupId(instanceIdMap.get("volumeGroupInstanceId"));
 437                 }
 438                 if(instanceIdMap.get("networkInstanceId") != null){
 439                         currentActiveReq.setNetworkId(instanceIdMap.get("networkInstanceId"));
 440                 }
 441                 if(instanceIdMap.get("configurationInstanceId") != null){
 442                         currentActiveReq.setConfigurationId(instanceIdMap.get("configurationInstanceId"));
 443                 }
 444                 if(instanceIdMap.get(CommonConstants.INSTANCE_GROUP_INSTANCE_ID) != null){
 445                         currentActiveReq.setInstanceGroupId(instanceIdMap.get(CommonConstants.INSTANCE_GROUP_INSTANCE_ID));
 446                 }
 447                 }
 448          }
 449
 450          public String mapJSONtoMSOStyle(String msoRawRequest, ServiceInstancesRequest serviceInstRequest, boolean isAlaCarte, Actions action) throws IOException {
 451             ObjectMapper mapper = new ObjectMapper();
 452             mapper.setSerializationInclusion(Include.NON_NULL);
 453             if(msoRawRequest != null){
 454                         ServiceInstancesRequest sir = mapper.readValue(msoRawRequest, ServiceInstancesRequest.class);
 455                         if(     serviceInstRequest != null &&
 456                                 serviceInstRequest.getRequestDetails() != null &&
 457                                 serviceInstRequest.getRequestDetails().getRequestParameters() != null) {
 458                                 if(     !isAlaCarte && Action.createInstance.equals(action)) {
 459                                         sir.getRequestDetails().setCloudConfiguration(serviceInstRequest.getRequestDetails().getCloudConfiguration());
 460                                         sir.getRequestDetails().getRequestParameters().setUserParams(serviceInstRequest.getRequestDetails().getRequestParameters().getUserParams());
 461                                 }
 462                                 sir.getRequestDetails().getRequestParameters().setUsePreload(serviceInstRequest.getRequestDetails().getRequestParameters().getUsePreload());
 463                         }
 464
 465                         logger.debug("Value as string: {}", mapper.writeValueAsString(sir));
 466                         return mapper.writeValueAsString(sir);
 467             }
 468             return null;
 469         }
 470
 471         public Optional<String> retrieveModelName(RequestParameters requestParams) {
 472                 String requestTestApi = null;
 473                 TestApi testApi = null;
 474
 475                 if (requestParams != null) {
 476                         requestTestApi = requestParams.getTestApi();
 477                 }
 478
 479                 if (requestTestApi == null) {
 480                         if(requestParams != null && requestParams.getALaCarte() != null && !requestParams.getALaCarte()) {
 481                         requestTestApi = env.getProperty(CommonConstants.MACRO_TEST_API);
 482                         } else {
 483                                 requestTestApi = env.getProperty(CommonConstants.ALACARTE_TEST_API);
 484                         }
 485                 }
 486
 487                 try {
 488                         testApi = TestApi.valueOf(requestTestApi);
 489                         return Optional.of(testApi.getModelName());
 490                 } catch (Exception e) {
 491                         logger.warn("Catching the exception on the valueOf enum call and continuing", e);
 492                         throw new IllegalArgumentException("Invalid TestApi is provided", e);
 493                 }
 494            }
 495
 496         public String getDefaultModel(ServiceInstancesRequest sir) {
 497                 String defaultModel = sir.getRequestDetails().getRequestInfo().getSource() + "_DEFAULT";
 498                 Optional<String> oModelName = retrieveModelName(sir.getRequestDetails().getRequestParameters());
 499                 if (oModelName.isPresent()) {
 500                         defaultModel = oModelName.get();
 501                 }
 502                 return defaultModel;
 503         }
 504
 505         public String getServiceType(String requestScope, ServiceInstancesRequest sir, Boolean aLaCarteFlag){
 506                 String serviceType = null;
 507                 if(requestScope.equalsIgnoreCase(ModelType.service.toString())){
 508                         String defaultServiceModelName = getDefaultModel(sir);
 509                         org.onap.so.db.catalog.beans.Service serviceRecord;
 510                         if(aLaCarteFlag){
 511                                  serviceRecord = catalogDbClient.getFirstByModelNameOrderByModelVersionDesc(defaultServiceModelName);
 512                                  if(serviceRecord != null){
 513                                          serviceType = serviceRecord.getServiceType();
 514                                  }
 515                         }else{
 516                                 serviceRecord = catalogDbClient.getServiceByID(sir.getRequestDetails().getModelInfo().getModelVersionId());
 517                                 if(serviceRecord != null){
 518                                          serviceType = serviceRecord.getServiceType();
 519                                  }else{
 520                                          serviceRecord = catalogDbClient.getFirstByModelNameOrderByModelVersionDesc(defaultServiceModelName);
 521                                          if(serviceRecord != null){
 522                                                  serviceType = serviceRecord.getServiceType();
 523                                          }
 524                                  }
 525                         }
 526                 }else{
 527                         serviceType = msoRequest.getServiceInstanceType(sir, requestScope);
 528                         }
 529                 return serviceType;
 530         }
 531
 532         protected String setServiceInstanceId(String requestScope, ServiceInstancesRequest sir){
 533                 if(sir.getServiceInstanceId () != null){
 534                         return sir.getServiceInstanceId ();
 535                 }else if(requestScope.equalsIgnoreCase(ModelType.instanceGroup.toString())){
 536                         RelatedInstanceList[] relatedInstances = sir.getRequestDetails().getRelatedInstanceList();
 537                         if(relatedInstances != null){
 538                                 for(RelatedInstanceList relatedInstanceList : relatedInstances){
 539                                         RelatedInstance relatedInstance = relatedInstanceList.getRelatedInstance();
 540                                         if(relatedInstance.getModelInfo().getModelType() == ModelType.service){
 541                                                 return relatedInstance.getInstanceId();
 542                                         }
 543                                 }
 544                         }
 545                 }
 546                 return null;
 547         }
 548
 549         private String requestScopeFromUri(String requestUri){
 550                 String requestScope;
 551                 if(requestUri.contains(ModelType.network.name())){
 552                         requestScope = ModelType.network.name();
 553                 }else if(requestUri.contains(ModelType.vfModule.name())){
 554                         requestScope = ModelType.vfModule.name();
 555                 }else if(requestUri.contains(ModelType.volumeGroup.name())){
 556                         requestScope = ModelType.volumeGroup.name();
 557                 }else if(requestUri.contains(ModelType.configuration.name())){
 558                         requestScope = ModelType.configuration.name();
 559                 }else if(requestUri.contains(ModelType.vnf.name())){
 560                         requestScope = ModelType.vnf.name();
 561                 }else{
 562                         requestScope = ModelType.service.name();
 563                 }
 564                 return requestScope;
 565         }
 566
 567 }