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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (c) 2022 Deutsche telekom
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.so.apihandlerinfra;
  22
  23
  24 import com.fasterxml.jackson.core.JsonProcessingException;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import io.swagger.v3.oas.annotations.OpenAPIDefinition;
  27 import io.swagger.v3.oas.annotations.Operation;
  28 import io.swagger.v3.oas.annotations.info.Info;
  29 import io.swagger.v3.oas.annotations.media.ArraySchema;
  30 import io.swagger.v3.oas.annotations.media.Content;
  31 import io.swagger.v3.oas.annotations.media.Schema;
  32 import io.swagger.v3.oas.annotations.responses.ApiResponse;
  33 import org.apache.http.HttpStatus;
  34 import org.onap.aai.domain.yang.Relationship;
  35 import org.onap.aai.domain.yang.RelationshipData;
  36 import org.onap.aai.domain.yang.ServiceInstance;
  37 import org.onap.aai.domain.yang.SliceProfile;
  38 import org.onap.aaiclient.client.aai.AAIRestClientImpl;
  39 import org.onap.logging.filter.base.ErrorCode;
  40 import org.onap.so.apihandler.camundabeans.CamundaResponse;
  41 import org.onap.so.apihandler.common.*;
  42 import org.onap.so.apihandlerinfra.exceptions.ApiException;
  43 import org.onap.so.apihandlerinfra.exceptions.BPMNFailureException;
  44 import org.onap.so.apihandlerinfra.exceptions.RequestDbFailureException;
  45 import org.onap.so.apihandlerinfra.exceptions.ValidateException;
  46 import org.onap.so.apihandlerinfra.logging.ErrorLoggerInfo;
  47 import org.onap.so.moi.*;
  48 import org.onap.so.constants.Status;
  49 import org.onap.so.db.catalog.beans.Service;
  50 import org.onap.so.db.catalog.beans.ServiceRecipe;
  51 import org.onap.so.db.catalog.client.CatalogDbClient;
  52 import org.onap.so.db.request.beans.InfraActiveRequests;
  53 import org.onap.so.db.request.client.RequestsDbClient;
  54 import org.onap.so.logger.LogConstants;
  55 import org.onap.so.logger.LoggingAnchor;
  56 import org.onap.so.logger.MessageEnum;
  57 import org.onap.so.rest.catalog.beans.Vnf;
  58 import org.onap.so.serviceinstancebeans.*;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61 import org.slf4j.MDC;
  62 import org.springframework.beans.factory.annotation.Autowired;
  63 import org.springframework.http.ResponseEntity;
  64 import org.springframework.stereotype.Component;
  65 import org.springframework.transaction.annotation.Transactional;
  66 import javax.ws.rs.*;
  67 import javax.ws.rs.container.ContainerRequestContext;
  68 import javax.ws.rs.core.Context;
  69 import javax.ws.rs.core.MediaType;
  70 import javax.ws.rs.core.Response;
  71 import java.sql.Timestamp;
  72 import java.util.*;
  73 import java.util.function.Function;
  74 import java.util.stream.Collectors;
  75
  76 @Component
  77 @Path("/onap/so/infra/moi/api/rest/")
  78 @OpenAPIDefinition(
  79         info = @Info(title = "/onap/so/infra/moi/api/rest/", description = "API Requests for 3gpp MO Instances"))
  80 public class ManagedObject3gppServiceInstances {
  81
  82     private static final Logger LOGGER = LoggerFactory.getLogger(ManagedObject3gppServiceInstances.class);
  83
  84     private static final String MSO_PROP_APIHANDLER_INFRA = "MSO_PROP_APIHANDLER_INFRA";
  85
  86     private static final String END_OF_THE_TRANSACTION = "End of the transaction, the final response is: ";
  87
  88     private static final String SAVE_TO_DB = "save instance to db";
  89
  90     private static final String URI_PREFIX = "/moi/api/rest/";
  91
  92     @Autowired
  93     private MsoRequest msoRequest;
  94
  95     @Autowired
  96     private CatalogDbClient catalogDbClient;
  97
  98     @Autowired
  99     private RequestsDbClient requestsDbClient;
 100
 101     @Autowired
 102     private RequestHandlerUtils requestHandlerUtils;
 103
 104     @Autowired
 105     private ResponseBuilder builder;
 106
 107     @Autowired
 108     private CamundaClient camundaClient;
 109
 110     @Autowired
 111     private ResponseHandler responseHandler;
 112
 113     private AAIRestClientImpl aaiRestClient = new AAIRestClientImpl();
 114
 115     /**
 116      * POST Requests for 3GPP MOI Service create nssi on a version provided
 117      *
 118      * @throws ApiException
 119      */
 120
 121     @PUT
 122     @Path("/{version:[vV][1]}/NetworkSliceSubnet/{id}")
 123     @Consumes(MediaType.APPLICATION_JSON)
 124     @Produces(MediaType.APPLICATION_JSON)
 125     @Operation(description = "Create a 3GPP MOI NSSI on a version provided", responses = @ApiResponse(
 126             content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))))
 127     public Response allocateNssi(MoiAllocateRequest request, @PathParam("version") String version,
 128             @PathParam("id") String id, @Context ContainerRequestContext requestContext) throws ApiException {
 129         String requestId = requestHandlerUtils.getRequestId(requestContext);
 130         HashMap<String, String> instanceIdMap = new HashMap<>();
 131         instanceIdMap.put("serviceInstanceId", id);
 132         return processAllocateRequest(request, Action.createRanSlice, version, requestId, instanceIdMap,
 133                 requestHandlerUtils.getRequestUri(requestContext, URI_PREFIX));
 134     }
 135
 136     @PATCH
 137     @Path("/{version:[vV][1]}/NetworkSliceSubnet/{id}")
 138     @Consumes(MediaType.APPLICATION_JSON)
 139     @Produces(MediaType.APPLICATION_JSON)
 140     @Operation(description = "Modify a 3GPP MOI NSSI on a version provided", responses = @ApiResponse(
 141             content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))))
 142     public Response modifyNssi(MoiAllocateRequest request, @PathParam("version") String version,
 143             @PathParam("id") String id, @Context ContainerRequestContext requestContext) throws ApiException {
 144         String requestId = requestHandlerUtils.getRequestId(requestContext);
 145         HashMap<String, String> instanceIdMap = new HashMap<>();
 146         instanceIdMap.put("serviceInstanceId", id);
 147         return processAllocateRequest(request, Action.modifyRanSlice, version, requestId, instanceIdMap,
 148                 requestHandlerUtils.getRequestUri(requestContext, URI_PREFIX));
 149     }
 150
 151     /**
 152      * DELETE Requests to delete 3GPP MOI Service instance on a version provided
 153      *
 154      * @throws ApiException
 155      */
 156     @DELETE
 157     @Path("/{version:[vV][1]}/NetworkSliceSubnet/{id}")
 158     @Consumes(MediaType.APPLICATION_JSON)
 159     @Produces(MediaType.APPLICATION_JSON)
 160     @Operation(description = "Delete a 3GPP MOI NSSI on a version provided", responses = @ApiResponse(
 161             content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))))
 162     public Response deleteNssi(MoiAllocateRequest request, @PathParam("version") String version,
 163             @PathParam("id") String id, @Context ContainerRequestContext requestContext) throws ApiException {
 164         String requestId = requestHandlerUtils.getRequestId(requestContext);
 165         HashMap<String, String> instanceIdMap = new HashMap<>();
 166         instanceIdMap.put("serviceInstanceId", id);
 167         return processAllocateRequest(request, Action.deleteRanSlice, version, requestId, instanceIdMap,
 168                 requestHandlerUtils.getRequestUri(requestContext, URI_PREFIX));
 169     }
 170
 171     /**
 172      * GET Requests for 3GPP MOI Service get nssi on a version provided
 173      *
 174      * @throws ApiException
 175      */
 176     @GET
 177     @Operation(description = "Find slice Profile for nssi id", responses = @ApiResponse(
 178             content = @Content(array = @ArraySchema(schema = @Schema(implementation = Vnf.class)))))
 179     @Path("/{version:[vV][1]}/NetworkSliceSubnet/{id}")
 180     @Produces({MediaType.APPLICATION_JSON})
 181     @Transactional(readOnly = true)
 182     public Response getMOIAttributes(@PathParam("version") String version, @PathParam("id") String id)
 183             throws ApiException {
 184         GETMoiResponse mOIResponse = new GETMoiResponse();
 185         String response = null;
 186
 187         Optional<ServiceInstance> serviceInstance = aaiRestClient.getServiceInstanceById(id, "5G", "5GCustomer");
 188         if (serviceInstance.isPresent()) {
 189             LOGGER.info("Id from request {}", id);
 190             ServiceInstance serviceInstanceObj = serviceInstance.get();
 191             mOIResponse.setId(serviceInstanceObj.getServiceInstanceId());
 192             mOIResponse.setAdministrativeState(serviceInstanceObj.getOperationalStatus());
 193             mOIResponse.setOperationalState(serviceInstanceObj.getOrchestrationStatus());
 194
 195
 196             Attributes attributes = new Attributes();
 197             List<org.onap.so.moi.SliceProfile> sliceProfileList = new ArrayList<org.onap.so.moi.SliceProfile>();
 198
 199             List<Relationship> listOfNssiRelationship = serviceInstanceObj.getRelationshipList().getRelationship();
 200
 201             List<Relationship> listOfNssiRelationshipAR = listOfNssiRelationship.stream()
 202                     .filter(relationship -> relationship.getRelatedTo().equalsIgnoreCase("allotted-resource"))
 203                     .collect(Collectors.toList());
 204
 205             for (Relationship relationship : listOfNssiRelationshipAR) {
 206                 org.onap.so.moi.SliceProfile sliceProfile = new org.onap.so.moi.SliceProfile();
 207                 for (RelationshipData relationshipData : relationship.getRelationshipData()) {
 208                     if (relationshipData.getRelationshipKey()
 209                             .equalsIgnoreCase("service-instance.service-instance-id")) {
 210                         String sliceProfileInstanceId = relationshipData.getRelationshipValue();
 211                         LOGGER.debug(">>> sliceProfileInstance: {}", sliceProfileInstanceId);
 212
 213                         Optional<ServiceInstance> sliceProfileServiceInstance = aaiRestClient
 214                                 .getServiceInstanceByIdWithDepth(sliceProfileInstanceId, "5G", "5GCustomer");
 215                         if (sliceProfileServiceInstance.isPresent()) {
 216                             ServiceInstance sliceProfileServiceInstanceObj = sliceProfileServiceInstance.get();
 217                             SliceProfile sliceProfile1 =
 218                                     sliceProfileServiceInstanceObj.getSliceProfiles().getSliceProfile().get(0);
 219                             try {
 220                                 sliceProfileList
 221                                         .add(AAISliceProfileToMOISlice(sliceProfile1, sliceProfileServiceInstanceObj));
 222                             } catch (Exception e) {
 223                                 LOGGER.info("Can not construct responce {}", e);
 224                             }
 225
 226                         }
 227
 228
 229                     }
 230                 }
 231
 232             }
 233
 234             attributes.setSliceProfileList(sliceProfileList);
 235             mOIResponse.setAttributes(attributes);
 236             ObjectMapper mapper = new ObjectMapper();
 237             try {
 238                 response = mapper.writeValueAsString(mOIResponse);
 239             } catch (Exception exception) {
 240                 LOGGER.error("Error while creating MOIResponse JSON" + exception.getMessage());
 241             }
 242
 243             return builder.buildResponse(HttpStatus.SC_OK, null, response, version);
 244
 245
 246         }
 247         return builder.buildResponse(HttpStatus.SC_NOT_FOUND, null, null, version);
 248     }
 249
 250     private org.onap.so.moi.SliceProfile AAISliceProfileToMOISlice(SliceProfile sliceProfile,
 251             ServiceInstance serviceInstance) {
 252         org.onap.so.moi.SliceProfile sliceProfileMoi = new org.onap.so.moi.SliceProfile();
 253
 254         sliceProfileMoi.setSliceProfileId(sliceProfile.getProfileId());
 255
 256         String serviceType = serviceInstance.getServiceType();
 257
 258         // rANSliceSubnetProfile
 259         RANSliceSubnetProfile ranSliceSubnetProfile = new RANSliceSubnetProfile();
 260         ranSliceSubnetProfile.setServiceType(serviceType);
 261         ranSliceSubnetProfile.setdLLatency(sliceProfile.getLatency());
 262         ranSliceSubnetProfile.setCoverageAreaTAList(Integer.valueOf(sliceProfile.getCoverageAreaTAList()));
 263         ranSliceSubnetProfile.setMaxNumberofUEs(sliceProfile.getMaxNumberOfUEs());
 264         ranSliceSubnetProfile.setResourceSharingLevel(sliceProfile.getResourceSharingLevel());
 265         ranSliceSubnetProfile.setAreaTrafficCapDL(sliceProfile.getAreaTrafficCapDL());
 266
 267         // plmnId
 268         String[] plmnIdData = serviceInstance.getServiceInstanceLocationId().split("-");
 269         PlmnId plmnId = new PlmnId();
 270         plmnId.setMcc(Integer.valueOf(plmnIdData[0]));
 271         plmnId.setMnc(Integer.valueOf(plmnIdData[1]));
 272
 273         // snssai
 274         String[] snssaiData = serviceInstance.getEnvironmentContext().split("-");
 275         Snssai snssai = new Snssai();
 276         snssai.setSst(snssaiData[0]);
 277         snssai.setSd(snssaiData[1]);
 278
 279         // Plmninfo
 280         PlmnInfo plmnInfo = new PlmnInfo();
 281         plmnInfo.setPlmnId(plmnId);
 282         plmnInfo.setSnssai(snssai);
 283
 284         List<PlmnInfo> plmnInfoList = new ArrayList<PlmnInfo>();
 285         plmnInfoList.add(plmnInfo);
 286
 287         sliceProfileMoi.setrANSliceSubnetProfile(ranSliceSubnetProfile);
 288         sliceProfileMoi.setPlmnInfoList(plmnInfoList);
 289
 290         return sliceProfileMoi;
 291
 292     }
 293
 294     /**
 295      * Process allocate service request and send request to corresponding workflow
 296      *
 297      * @param request
 298      * @param action
 299      * @param version
 300      * @return
 301      * @throws ApiException
 302      */
 303     private Response processAllocateRequest(MoiAllocateRequest request, Action action, String version, String requestId,
 304             HashMap<String, String> instanceIdMap, String requestUri) throws ApiException {
 305         String defaultServiceModelName = "UUI_DEFAULT";
 306         String requestScope = ModelType.service.name();
 307         String apiVersion = version.substring(1);
 308         String serviceRequestJson = toString.apply(request);
 309
 310         ServiceInstancesRequest sir = createServiceInstanceRequest(request, requestId);
 311         String requestDetails = null;
 312         try {
 313             requestDetails = new ObjectMapper().writeValueAsString(sir);
 314             LOGGER.debug(">>> sir: {}", sir);
 315         } catch (JsonProcessingException e) {
 316             e.printStackTrace();
 317         }
 318         if (serviceRequestJson != null) {
 319             InfraActiveRequests currentActiveReq = createRequestObject(request, action, requestId, Status.IN_PROGRESS,
 320                     requestScope, serviceRequestJson);
 321             // instanceName ???
 322             String instanceId = instanceIdMap.get("serviceInstanceId");
 323             String instanceName = sir.getRequestDetails().getRequestInfo().getInstanceName();
 324             requestHandlerUtils.checkForDuplicateRequests(action, instanceIdMap, requestScope, currentActiveReq,
 325                     instanceName);
 326
 327             requestHandlerUtils.setInstanceId(currentActiveReq, requestScope, instanceId, instanceIdMap);
 328             try {
 329                 requestsDbClient.save(currentActiveReq);
 330             } catch (Exception e) {
 331                 LOGGER.error("Exception occurred", e);
 332                 ErrorLoggerInfo errorLoggerInfo =
 333                         new ErrorLoggerInfo.Builder(MessageEnum.APIH_DB_ACCESS_EXC, ErrorCode.DataError)
 334                                 .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 335                 throw new RequestDbFailureException.Builder(SAVE_TO_DB, e.toString(),
 336                         HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).cause(e)
 337                                 .errorInfo(errorLoggerInfo).build();
 338             }
 339
 340             RecipeLookupResult recipeLookupResult;
 341             try {
 342                 recipeLookupResult = getServiceInstanceOrchestrationURI("123", action, defaultServiceModelName);
 343
 344                 LOGGER.debug("recipeLookupResult: {}", recipeLookupResult);
 345             } catch (Exception e) {
 346                 LOGGER.error(LoggingAnchor.FOUR, MessageEnum.APIH_DB_ACCESS_EXC.toString(), MSO_PROP_APIHANDLER_INFRA,
 347                         ErrorCode.AvailabilityError.getValue(), "Exception while communciate with Catalog DB", e);
 348                 Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 349                         MsoException.ServiceException, "No communication to catalog DB " + e.getMessage(),
 350                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null, version);
 351                 LOGGER.debug(END_OF_THE_TRANSACTION + response.getEntity());
 352                 return response;
 353             }
 354
 355             if (recipeLookupResult == null) {
 356                 LOGGER.error(LoggingAnchor.FOUR, MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND.toString(),
 357                         MSO_PROP_APIHANDLER_INFRA, ErrorCode.DataError.getValue(), "No recipe found in DB");
 358                 Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 359                         MsoException.ServiceException, "Recipe does not exist in catalog DB",
 360                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null, version);
 361                 LOGGER.debug(END_OF_THE_TRANSACTION + response.getEntity());
 362                 return response;
 363             }
 364
 365             String serviceInstanceType = sir.getRequestDetails().getRequestParameters().getSubscriptionServiceType();
 366             RequestClientParameter parameter;
 367             try {
 368                 parameter = new RequestClientParameter.Builder().setRequestId(requestId).setBaseVfModule(false)
 369                         .setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name())
 370                         .setServiceInstanceId(instanceId).setServiceType(serviceInstanceType)
 371                         .setRequestDetails(requestDetails).setApiVersion(version).setALaCarte(false)
 372                         .setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).setApiVersion(apiVersion)
 373                         .setRequestUri(requestUri).build();
 374             } catch (Exception e) {
 375                 LOGGER.error("Exception occurred", e);
 376                 ErrorLoggerInfo errorLoggerInfo =
 377                         new ErrorLoggerInfo.Builder(MessageEnum.APIH_BPEL_RESPONSE_ERROR, ErrorCode.SchemaError)
 378                                 .errorSource(Constants.MSO_PROP_APIHANDLER_INFRA).build();
 379                 throw new ValidateException.Builder("Unable to generate RequestClientParamter object" + e.getMessage(),
 380                         HttpStatus.SC_INTERNAL_SERVER_ERROR, ErrorNumbers.SVC_BAD_PARAMETER).errorInfo(errorLoggerInfo)
 381                                 .build();
 382             }
 383             return postBPELRequest(currentActiveReq, parameter, recipeLookupResult.getOrchestrationURI(), requestScope);
 384         } else {
 385             Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR,
 386                     MsoException.ServiceException, "JsonProcessingException occurred - serviceRequestJson is null",
 387                     ErrorNumbers.SVC_BAD_PARAMETER, null, version);
 388             return response;
 389         }
 390     }
 391
 392
 393     private ServiceInstancesRequest createServiceInstanceRequest(MoiAllocateRequest request, String id) {
 394
 395         RequestDetails requestDetails = new RequestDetails();
 396         RequestInfo requestInfo = new RequestInfo();
 397         requestInfo.setInstanceName("ran_nssi_" + id);
 398         requestInfo.setRequestorId("MO");
 399         requestInfo.setProductFamilyId("5G");
 400         requestInfo.setSource("MO");
 401
 402         requestDetails.setRequestInfo(requestInfo);
 403
 404         SubscriberInfo subscriberInfo = new SubscriberInfo();
 405         subscriberInfo.setGlobalSubscriberId("5GCustomer");
 406         requestDetails.setSubscriberInfo(subscriberInfo);
 407
 408         Project project = new Project();
 409         project.setProjectName("basicnw-project");
 410         requestDetails.setProject(project);
 411
 412         OwningEntity owningEntity = new OwningEntity();
 413         owningEntity.setOwningEntityId("67f2e84c-734d-4e90-a1e4-d2ffa2e75849");
 414         owningEntity.setOwningEntityName("OE-5GCustomer");
 415         requestDetails.setOwningEntity(owningEntity);
 416
 417         RequestParameters requestParameters = new RequestParameters();
 418         requestParameters.setaLaCarte(false);
 419         requestParameters.setSubscriptionServiceType("5G");
 420
 421         Map<String, Object> nssiUserParams = new HashMap<>();
 422         Attributes attributes = request.getAttributes();
 423         nssiUserParams.put("nssi", attributes);
 424
 425         Map<String, Object> homingSolution = new HashMap<>();
 426         homingSolution.put("Homing_Solution", "true");
 427
 428         List<Map<String, Object>> userParams = new ArrayList<>();
 429
 430         userParams.add(nssiUserParams);
 431         userParams.add(homingSolution);
 432
 433         requestParameters.setUserParams(userParams);
 434
 435         requestDetails.setRequestParameters(requestParameters);
 436
 437         ServiceInstancesRequest sir = new ServiceInstancesRequest();
 438         sir.setServiceInstanceId(id);
 439         sir.setRequestDetails(requestDetails);
 440
 441         return sir;
 442     }
 443
 444     public InfraActiveRequests createRequestObject(Object request, Action action, String requestId, Status status,
 445             String requestScope, String requestJson) {
 446         InfraActiveRequests aq = new InfraActiveRequests();
 447         try {
 448             String serviceInstanceName = null;
 449             String serviceInstanceId = null;
 450             if (action.name().equals("ranSlice")) {
 451                 serviceInstanceName = "ran_nssi_" + requestId;
 452                 aq.setServiceInstanceName(serviceInstanceName);
 453             } else if (action.name().equals("updateInstance")) {
 454                 LOGGER.debug(">>>>> updateInstance");
 455             }
 456
 457             aq.setRequestId(requestId);
 458             aq.setRequestAction(action.toString());
 459             aq.setRequestUrl(MDC.get(LogConstants.HTTP_URL));
 460             Timestamp startTimeStamp = new Timestamp(System.currentTimeMillis());
 461             aq.setStartTime(startTimeStamp);
 462             aq.setRequestScope(requestScope);
 463             aq.setRequestBody(requestJson);
 464             aq.setRequestStatus(status.toString());
 465             aq.setLastModifiedBy(Constants.MODIFIED_BY_APIHANDLER);
 466         } catch (Exception e) {
 467             LOGGER.error("Exception when creation record request", e);
 468
 469             if (!status.equals(Status.FAILED)) {
 470                 throw e;
 471             }
 472         }
 473         return aq;
 474     }
 475
 476     /**
 477      * Getting recipes from catalogDb
 478      *
 479      * @param serviceModelUUID the service model version uuid
 480      * @param action the action for the service
 481      * @param defaultServiceModelName default service name
 482      * @return the service recipe result
 483      */
 484     private RecipeLookupResult getServiceInstanceOrchestrationURI(String serviceModelUUID, Action action,
 485             String defaultServiceModelName) {
 486
 487         RecipeLookupResult recipeLookupResult = getServiceURI(serviceModelUUID, action, defaultServiceModelName);
 488
 489         if (recipeLookupResult != null) {
 490             LOGGER.debug("Orchestration URI is: " + recipeLookupResult.getOrchestrationURI() + ", recipe Timeout is: "
 491                     + Integer.toString(recipeLookupResult.getRecipeTimeout()));
 492         } else {
 493             LOGGER.debug("No matching recipe record found");
 494         }
 495         return recipeLookupResult;
 496     }
 497
 498     Function<Object, String> toString = serviceRequest -> {
 499         ObjectMapper mapper = new ObjectMapper();
 500         String requestAsString = null;
 501         try {
 502             requestAsString = mapper.writeValueAsString(serviceRequest);
 503         } catch (JsonProcessingException e) {
 504             LOGGER.debug("Exception while converting service request object to String {}", e);
 505         }
 506         return requestAsString;
 507     };
 508
 509     /**
 510      * Getting recipes from catalogDb If Service recipe is not set, use default recipe, if set , use special recipe.
 511      *
 512      * @param serviceModelUUID the service version uuid
 513      * @param action the action of the service.
 514      * @param defaultServiceModelName default service name
 515      * @return the service recipe result.
 516      */
 517     private RecipeLookupResult getServiceURI(String serviceModelUUID, Action action, String defaultServiceModelName) {
 518
 519         Service defaultServiceRecord =
 520                 catalogDbClient.getFirstByModelNameOrderByModelVersionDesc(defaultServiceModelName);
 521         // set recipe as default generic recipe
 522         ServiceRecipe recipe =
 523                 catalogDbClient.getFirstByServiceModelUUIDAndAction(defaultServiceRecord.getModelUUID(), action.name());
 524         // check the service special recipe
 525         if (null != serviceModelUUID && !serviceModelUUID.isEmpty()) {
 526             ServiceRecipe serviceSpecialRecipe =
 527                     catalogDbClient.getFirstByServiceModelUUIDAndAction(serviceModelUUID, action.name());
 528             if (null != serviceSpecialRecipe) {
 529                 // set service special recipe.
 530                 recipe = serviceSpecialRecipe;
 531             }
 532         }
 533
 534         if (recipe == null) {
 535             return null;
 536         }
 537         return new RecipeLookupResult(recipe.getOrchestrationUri(), recipe.getRecipeTimeout(), recipe.getParamXsd());
 538
 539     }
 540
 541     private Response postBPELRequest(InfraActiveRequests currentActiveReq, RequestClientParameter parameter,
 542             String orchestrationURI, String requestScope) throws ApiException {
 543         ResponseEntity<String> response =
 544                 requestHandlerUtils.postRequest(currentActiveReq, parameter, orchestrationURI);
 545         LOGGER.debug("BPEL response : " + response);
 546         int bpelStatus = responseHandler.setStatus(response.getStatusCodeValue());
 547         String jsonResponse;
 548         try {
 549             responseHandler.acceptedResponse(response);
 550             CamundaResponse camundaResponse = responseHandler.getCamundaResponse(response);
 551             String responseBody = camundaResponse.getResponse();
 552             if ("Success".equalsIgnoreCase(camundaResponse.getMessage())) {
 553                 jsonResponse = responseBody;
 554             } else {
 555                 BPMNFailureException bpmnException =
 556                         new BPMNFailureException.Builder(String.valueOf(bpelStatus) + responseBody, bpelStatus,
 557                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR).build();
 558                 requestHandlerUtils.updateStatus(currentActiveReq, Status.FAILED, bpmnException.getMessage());
 559                 throw bpmnException;
 560             }
 561         } catch (ApiException e) {
 562             requestHandlerUtils.updateStatus(currentActiveReq, Status.FAILED, e.getMessage());
 563             throw e;
 564         }
 565         return builder.buildResponse(HttpStatus.SC_ACCEPTED, parameter.getRequestId(), jsonResponse,
 566                 parameter.getApiVersion());
 567     }
 568 }