src/main/java/org/onap/nbi/apis/serviceorder/workflow/PostSoProcessor.java

   1 /**
   2  * Copyright (c) 2018 Orange
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   5  * in compliance with the License. You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software distributed under the License
  10  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  11  * or implied. See the License for the specific language governing permissions and limitations under
  12  * the License.
  13  */
  14
  15 package org.onap.nbi.apis.serviceorder.workflow;
  16
  17 import java.io.IOException;
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.Iterator;
  21 import java.util.List;
  22 import java.util.Map;
  23
  24 import org.onap.nbi.apis.servicecatalog.ServiceSpecificationService;
  25 import org.onap.nbi.apis.serviceorder.SoClient;
  26 import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic;
  27 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  28 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  29 import org.onap.nbi.apis.serviceorder.model.StateType;
  30 import org.onap.nbi.apis.serviceorder.model.ServiceStateType;
  31 import org.onap.nbi.apis.serviceorder.model.consumer.CloudConfiguration;
  32 import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse;
  33 import org.onap.nbi.apis.serviceorder.model.consumer.CreateMacroServiceInstanceResponse;
  34 import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
  35 import org.onap.nbi.apis.serviceorder.model.consumer.MSOE2EPayload;
  36 import org.onap.nbi.apis.serviceorder.model.consumer.MSOPayload;
  37 import org.onap.nbi.apis.serviceorder.model.consumer.ModelInfo;
  38 import org.onap.nbi.apis.serviceorder.model.consumer.OwningEntity;
  39 import org.onap.nbi.apis.serviceorder.model.consumer.ParametersModel;
  40 import org.onap.nbi.apis.serviceorder.model.consumer.Project;
  41 import org.onap.nbi.apis.serviceorder.model.consumer.RequestDetails;
  42 import org.onap.nbi.apis.serviceorder.model.consumer.RequestInfo;
  43 import org.onap.nbi.apis.serviceorder.model.consumer.RequestParameters;
  44 import org.onap.nbi.apis.serviceorder.model.consumer.ResourceModel;
  45 import org.onap.nbi.apis.serviceorder.model.consumer.ServiceModel;
  46 import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
  47 import org.onap.nbi.apis.serviceorder.model.consumer.UserParams;
  48 import org.onap.nbi.apis.serviceorder.model.consumer.VFModelInfo;
  49 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
  50 import org.onap.nbi.apis.serviceorder.service.ServiceOrderService;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53 import org.springframework.beans.factory.annotation.Autowired;
  54 import org.springframework.beans.factory.annotation.Value;
  55 import org.springframework.http.ResponseEntity;
  56 import org.springframework.stereotype.Service;
  57 import org.springframework.util.CollectionUtils;
  58 import com.fasterxml.jackson.databind.JsonNode;
  59 import com.fasterxml.jackson.databind.ObjectMapper;
  60 import com.fasterxml.jackson.databind.node.ArrayNode;
  61 import com.fasterxml.jackson.databind.node.ObjectNode;
  62
  63 @Service
  64 public class PostSoProcessor {
  65
  66     private static final Logger LOGGER = LoggerFactory.getLogger(PostSoProcessor.class);
  67
  68     @Value("${onap.lcpCloudRegionId}")
  69     private String lcpCloudRegionId;
  70
  71     @Value("${onap.tenantId}")
  72     private String tenantId;
  73
  74     @Value("${so.owning.entity.id}")
  75     private String soOwningEntityId;
  76
  77     @Value("${so.owning.entity.name}")
  78     private String soOwningEntityName;
  79
  80     @Value("${so.project.name}")
  81     private String soProjectName;
  82
  83     @Value("${onap.cloudOwner}")
  84     private String cloudOwner;
  85
  86     @Value("${onap.k8sCloudOwner}")
  87         private String k8sCloudOwner;
  88
  89         @Value("${onap.k8sCloudRegionId}")
  90         private String k8sCloudRegionId;
  91
  92         @Value("${k8s-rb-profile-name}")
  93         private String k8sRbProfileName;
  94
  95     @Autowired
  96     private ServiceOrderService serviceOrderService;
  97
  98     @Autowired
  99     private SoClient soClient;
 100
 101     @Autowired
 102     ServiceSpecificationService serviceSpecificationService;
 103
 104     public ResponseEntity<CreateServiceInstanceResponse> postServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
 105             ServiceOrderItem serviceOrderItem) {
 106         ResponseEntity<CreateServiceInstanceResponse> response = null;
 107         try {
 108             response = postSORequest(serviceOrderItem, serviceOrderInfo);
 109         } catch (NullPointerException e) {
 110             LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
 111             response = null;
 112         }
 113         return response;
 114     }
 115
 116     public ResponseEntity<CreateE2EServiceInstanceResponse> postE2EServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
 117             ServiceOrderItem serviceOrderItem, ServiceOrder serviceOrder) {
 118         ResponseEntity<CreateE2EServiceInstanceResponse> response;
 119         try {
 120             response = postE2ESORequest(serviceOrderItem, serviceOrderInfo, serviceOrder);
 121         } catch (NullPointerException e) {
 122             LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
 123             response = null;
 124         }
 125         return response;
 126     }
 127
 128     public ResponseEntity<CreateMacroServiceInstanceResponse> postMacroServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
 129             ServiceOrderItem serviceOrderItem) {
 130         ResponseEntity<CreateMacroServiceInstanceResponse> response = null;
 131         try {
 132             // For Macro Flow
 133             response = postSOMacroRequest(serviceOrderItem, serviceOrderInfo);
 134         } catch (NullPointerException e) {
 135             LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
 136             response = null;
 137         }
 138         return response;
 139     }
 140
 141     private ResponseEntity<CreateServiceInstanceResponse> postSORequest(ServiceOrderItem serviceOrderItem,
 142             ServiceOrderInfo serviceOrderInfo) {
 143         RequestDetails requestDetails = buildSoRequest(serviceOrderItem, serviceOrderInfo);
 144         MSOPayload msoPayload = new MSOPayload(requestDetails);
 145         ResponseEntity<CreateServiceInstanceResponse> response = null;
 146
 147         switch (serviceOrderItem.getAction()) {
 148             case ADD:
 149                 response = soClient.callCreateServiceInstance(msoPayload);
 150                 break;
 151             case DELETE:
 152                 response = soClient.callDeleteServiceInstance(msoPayload, serviceOrderItem.getService().getId());
 153                 break;
 154             case MODIFY:
 155                 if (StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE == serviceOrderItem.getState()) {
 156                     response = soClient.callCreateServiceInstance(msoPayload);
 157                 }
 158                 if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
 159                     response = soClient.callDeleteServiceInstance(msoPayload, serviceOrderItem.getService().getId());
 160                 }
 161                 break;
 162             default:
 163                 break;
 164         }
 165         return response;
 166     }
 167
 168     private ResponseEntity<CreateE2EServiceInstanceResponse> postE2ESORequest(ServiceOrderItem serviceOrderItem,
 169             ServiceOrderInfo serviceOrderInfo, ServiceOrder serviceOrder) {
 170         ServiceModel service = buildE2ESoRequest(serviceOrderItem,
 171                 serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
 172                 serviceOrderInfo.getSubscriberInfo(), serviceOrder);
 173         MSOE2EPayload msoE2EPayload = new MSOE2EPayload(service);
 174         ResponseEntity<CreateE2EServiceInstanceResponse> response = null;
 175         switch (serviceOrderItem.getAction()) {
 176             case ADD:
 177                 response = soClient.callE2ECreateServiceInstance(msoE2EPayload);
 178                 break;
 179             case DELETE:
 180                 response = soClient.callE2EDeleteServiceInstance(service.getGlobalSubscriberId(),
 181                         service.getServiceType(), serviceOrderItem.getService().getId());
 182                 break;
 183             case MODIFY:
 184             //EXT-API supports E2E service activation/deactivation with action=modify and seviceState=active/inactive
 185                 boolean isActivateReq = ServiceStateType.ACTIVE == serviceOrderItem.getService().getServiceState() ||
 186                                 ServiceStateType.INACTIVE == serviceOrderItem.getService().getServiceState();
 187
 188                 if (ServiceStateType.ACTIVE == serviceOrderItem.getService().getServiceState()) {
 189                         response = soClient.callServiceActivationE2EService(service.getGlobalSubscriberId(),
 190                             service.getServiceType(), serviceOrderItem.getService().getId(),"activate");
 191                 }
 192                 if (ServiceStateType.INACTIVE == serviceOrderItem.getService().getServiceState()) {
 193                         response = soClient.callServiceActivationE2EService(service.getGlobalSubscriberId(),
 194                             service.getServiceType(), serviceOrderItem.getService().getId(),"deactivate");
 195                 }
 196                 //Other E2E service modification follows Deletion followed by activation.
 197                 //For service modification, do not send serviceState=active/inactive
 198                 if (!isActivateReq && StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE == serviceOrderItem.getState()) {
 199                     response = soClient.callE2ECreateServiceInstance(msoE2EPayload);
 200                 }
 201                 if (!isActivateReq && StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
 202                     response = soClient.callE2EDeleteServiceInstance(service.getGlobalSubscriberId(),
 203                             service.getServiceType(), serviceOrderItem.getService().getId());
 204                 }
 205                 break;
 206             default:
 207                 break;
 208         }
 209         return response;
 210     }
 211
 212     private ResponseEntity<CreateMacroServiceInstanceResponse> postSOMacroRequest(ServiceOrderItem serviceOrderItem,
 213                             ServiceOrderInfo serviceOrderInfo) {
 214
 215       String serviceModuleName = (String) serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId())
 216             .getCatalogResponse().get("name");
 217
 218       RequestDetails requestDetails = buildSoMacroRequest(serviceOrderItem, serviceOrderInfo);
 219       MSOPayload msoMacroPayload = new MSOPayload(requestDetails);
 220       ResponseEntity<CreateMacroServiceInstanceResponse> response = null;
 221
 222       switch (serviceOrderItem.getAction()) {
 223         case ADD:
 224           response = soClient.callMacroCreateServiceInstance(msoMacroPayload);
 225           break;
 226         case DELETE:
 227           // response = soClient.callDeleteServiceInstance(msoPayload,
 228           // serviceOrderItem.getService().getId());
 229           break;
 230         case MODIFY:
 231           if (StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE == serviceOrderItem.getState()) {
 232             // response = soClient.callCreateServiceInstance(msoPayload);
 233           }
 234           if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
 235             // response = soClient.callDeleteServiceInstance(msoPayload,
 236             // serviceOrderItem.getService().getId());
 237           }
 238           break;
 239         default:
 240           break;
 241       }
 242       return response;
 243     }
 244
 245     /**
 246      * Build SO MACRO CREATE request from the ServiceOrder and catalog informations from SDC
 247      *
 248      * @param orderItem
 249      * @param serviceOrderInfo
 250      * @param subscriberInfo
 251      * @return
 252      */
 253     private RequestDetails buildSoMacroRequest(ServiceOrderItem orderItem, ServiceOrderInfo serviceOrderInfo) {
 254
 255         RequestDetails requestDetails = new RequestDetails();
 256                 Map<String, Object> sdcInfos = serviceOrderInfo.getServiceOrderItemInfos().get(orderItem.getId())
 257                                 .getCatalogResponse();
 258
 259                 String id = orderItem.getService().getServiceSpecification().getId();
 260                 Map responseChildRes = serviceSpecificationService.get(id);
 261                 ArrayList<Map<String, Object>> resourseSpecificationArray = (ArrayList<Map<String, Object>>) responseChildRes
 262                                 .get("resourceSpecification");
 263
 264                 Map<String, Object> resourseSpecificationMap = resourseSpecificationArray.get(0);
 265
 266                 Map instanceSpecification = (Map) resourseSpecificationMap.get("InstanceSpecification");
 267                 ArrayList<VFModelInfo> childResourceSpecification = (ArrayList<VFModelInfo>) resourseSpecificationMap
 268                                 .get("childResourceSpecification");
 269
 270                 List<Object> serviceObject = new ArrayList<>();
 271
 272                 ArrayList<Object> vnfInstanceParam = new ArrayList<>();
 273
 274                 //Differentiating vnf with cnf(Can be discussed and improved)
 275                 if (instanceSpecification.get("public_net_id") != null) {
 276                         vnfInstanceParam.add(instanceSpecification);
 277                 } else {
 278                         Map<String, Object> instanceParam = new HashMap<>();
 279                         instanceParam.put("k8s-rb-profile-name", k8sRbProfileName);
 280                         vnfInstanceParam.add(instanceParam);
 281                 }
 282
 283                 List resSpec = (ArrayList) sdcInfos.get("resourceSpecification");
 284                 Map resSpecMap = (Map) resSpec.get(0);
 285
 286                 Map<String, String> vnfInfoObject = new HashMap<>();
 287                 vnfInfoObject.put("modelName", (String) resSpecMap.get("name"));
 288                 vnfInfoObject.put("modelVersionId", (String) resSpecMap.get("id"));
 289                 vnfInfoObject.put("modelInvariantUuid", (String) resSpecMap.get("resourceInvariantUUID"));
 290                 vnfInfoObject.put("modelVersion", (String) resSpecMap.get("version"));
 291                 vnfInfoObject.put("modelCustomizationId", (String) resSpecMap.get("modelCustomizationId"));
 292                 vnfInfoObject.put("modelInstanceName", (String) resSpecMap.get("resourceInstanceName"));
 293
 294                 //initialization
 295                 CloudConfiguration cloudConfiguration = null;
 296
 297                 //Differentiating vnf with cnf(Can be discussed and improved)
 298                 if (instanceSpecification.get("public_net_id") != null) {
 299                         cloudConfiguration = new CloudConfiguration(lcpCloudRegionId, tenantId, cloudOwner);
 300                 } else {
 301                         cloudConfiguration = new CloudConfiguration(k8sCloudRegionId, tenantId, k8sCloudOwner);
 302                 }
 303
 304                 Map<String, String> platformName = new HashMap<>();
 305                 platformName.put("platformName", "test");
 306
 307                 Map<String, String> lob = new HashMap<>();
 308                 lob.put("lineOfBusinessName", "LOB-Demonstration");
 309
 310                 Map<String, Object> vnfModel = new HashMap<>();
 311                 vnfModel.put("modelInfo", vnfInfoObject);
 312                 vnfModel.put("cloudConfiguration", cloudConfiguration);
 313                 vnfModel.put("platform", platformName);
 314                 vnfModel.put("lineOfBusiness", lob);
 315                 vnfModel.put("productFamilyId", "a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb");
 316                 vnfModel.put("instanceName", (String) resSpecMap.get("resourceInstanceName"));
 317                 vnfModel.put("instanceParams", vnfInstanceParam);
 318
 319                 List<Object> vfModulesObjects = new ArrayList<>();
 320                 ArrayList<Map<String, Object>> vfInstanceParam = new ArrayList<>();
 321
 322                 //Differentiate CNF from VNF
 323                 if (instanceSpecification.get("public_net_id") != null) {
 324                         vfInstanceParam.add(instanceSpecification);
 325
 326                 } else {
 327                         Map<String, Object> instanceParam = new HashMap<>();
 328                         instanceParam.put("k8s-rb-profile-name", k8sRbProfileName);
 329                         vfInstanceParam.add(instanceParam);
 330                 }
 331
 332                 for (VFModelInfo crsObject : childResourceSpecification) {
 333                         Map<String, Object> vfModuleObject = new HashMap<>();
 334                         Map<String, String> vfModuleInfo = new HashMap<>();
 335
 336                         vfModuleInfo.put("modelName", crsObject.getModelName());
 337                         vfModuleInfo.put("modelVersionId", crsObject.getModelUuid());
 338                         vfModuleInfo.put("modelInvariantUuid", crsObject.getModelInvariantUuid());
 339                         vfModuleInfo.put("modelVersion", crsObject.getModelVersion());
 340                         vfModuleInfo.put("modelCustomizationId", crsObject.getModelCustomizationUuid());
 341                         vfModuleObject.put("modelInfo", vfModuleInfo);
 342                         vfModuleObject.put("instanceName", crsObject.getModelName());
 343                         vfModuleObject.put("instanceParams", vfInstanceParam);
 344
 345                         vfModulesObjects.add(vfModuleObject);
 346                 }
 347                 vnfModel.put("vfModules", vfModulesObjects);
 348
 349                 List<Object> vnfObjects = new ArrayList<>();
 350                 vnfObjects.add(vnfModel);
 351
 352                 Map<String, Object> vnfData = new HashMap<>();
 353                 vnfData.put("vnfs", vnfObjects);
 354
 355                 ModelInfo serviceModelInfo = new ModelInfo();
 356                 serviceModelInfo.setModelType("service");
 357                 serviceModelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
 358                 serviceModelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
 359                 serviceModelInfo.setModelName((String) sdcInfos.get("name"));
 360                 serviceModelInfo.setModelVersion((String) sdcInfos.get("version"));
 361
 362                 // Adding List of instanceParams for service
 363                 // We can add instanceParams Key Value in Map Object and add it to the List, for
 364                 // For now it is empty to comply with so request
 365
 366                 List<Map<String, String>> listOfServiceLevelInstanceParams = new ArrayList<>();
 367                 Map<String, String> serviceInstanceParams= new HashMap<>();
 368                 listOfServiceLevelInstanceParams.add(serviceInstanceParams);
 369
 370                 Map<String, Object> serviceData = new HashMap<>();
 371                 serviceData.put("instanceParams", listOfServiceLevelInstanceParams);
 372                 serviceData.put("instanceName", orderItem.getService().getName());
 373                 serviceData.put("resources", vnfData);
 374                 serviceData.put("modelInfo", serviceModelInfo);
 375
 376                 Map<String, String> homingObject = new HashMap<>();
 377                 homingObject.put("Homing_Solution", "none");
 378                 serviceObject.add(homingObject);
 379
 380                 Map<String, Object> serviceObject1 = new HashMap<>();
 381                 serviceObject1.put("service", serviceData);
 382                 serviceObject.add(serviceObject1);
 383                 requestDetails.setSubscriberInfo(serviceOrderInfo.getSubscriberInfo());
 384
 385                 ModelInfo modelInfo = new ModelInfo();
 386                 modelInfo.setModelType("service");
 387                 modelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
 388                 modelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
 389                 modelInfo.setModelName((String) sdcInfos.get("name"));
 390                 modelInfo.setModelVersion((String) sdcInfos.get("version"));
 391                 requestDetails.setModelInfo(modelInfo);
 392
 393                 RequestInfo requestInfo = new RequestInfo();
 394                 requestInfo.setInstanceName(orderItem.getService().getName());
 395                 requestInfo.setSource("VID");
 396                 requestInfo.setSuppressRollback(false);
 397                 requestInfo.setRequestorId("NBI");
 398                 requestInfo.setProductFamilyId("a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb");
 399                 requestDetails.setRequestInfo(requestInfo);
 400
 401                 // We are taking RequestParameters as map because it has UserParams which gives value as
 402                 // "name" : "service"
 403                 // "value" : "", which SO is not accepting
 404                 Map<String, Object> requestParameters = new HashMap<>();
 405
 406                 // Get value from serviceOrder request or generate one
 407                 String serviceTypeFromJson = orderItem.getService().getServicetype();
 408                 requestParameters.put("subscriptionServiceType",
 409                                 serviceTypeFromJson != null ? serviceTypeFromJson : (String) sdcInfos.get("name"));
 410                 requestParameters.put("userParams", serviceObject);
 411                 requestParameters.put("aLaCarte", false);
 412                 requestDetails.setRequestParameters(requestParameters);
 413                 requestDetails.setCloudConfiguration(cloudConfiguration);
 414
 415                 OwningEntity owningEntity = new OwningEntity();
 416                 owningEntity.setOwningEntityId(soOwningEntityId);
 417                 owningEntity.setOwningEntityName(soOwningEntityName);
 418                 requestDetails.setOwningEntity(owningEntity);
 419
 420                 Project project = new Project();
 421                 project.setProjectName(soProjectName);
 422
 423                 requestDetails.setProject(project);
 424         return requestDetails;
 425         }
 426
 427     /**
 428      * Build SO CREATE request from the ServiceOrder and catalog informations from SDC
 429      *
 430      * @param orderItem
 431      * @param serviceOrderInfo
 432      * @return
 433      */
 434     private RequestDetails buildSoRequest(ServiceOrderItem orderItem, ServiceOrderInfo serviceOrderInfo) {
 435         RequestDetails requestDetails = new RequestDetails();
 436
 437         requestDetails.setSubscriberInfo(serviceOrderInfo.getSubscriberInfo());
 438         Map<String, Object> sdcInfos =
 439                 serviceOrderInfo.getServiceOrderItemInfos().get(orderItem.getId()).getCatalogResponse();
 440         ModelInfo modelInfo = new ModelInfo();
 441         modelInfo.setModelType("service");
 442         modelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
 443         modelInfo.setModelNameVersionId(orderItem.getService().getServiceSpecification().getId());
 444         modelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
 445         modelInfo.setModelName((String) sdcInfos.get("name"));
 446         modelInfo.setModelVersion((String) sdcInfos.get("version"));
 447         requestDetails.setModelInfo(modelInfo);
 448
 449         RequestInfo requestInfo = new RequestInfo();
 450         requestInfo.setInstanceName(orderItem.getService().getName());
 451         requestInfo.setSource("VID");
 452         requestInfo.setSuppressRollback(false);
 453         requestInfo.setRequestorId("NBI");
 454         requestDetails.setRequestInfo(requestInfo);
 455
 456         RequestParameters requestParameters = new RequestParameters();
 457
 458         String serviceTypeFromJson = orderItem.getService().getServicetype();
 459         requestParameters.setSubscriptionServiceType(serviceTypeFromJson != null ? serviceTypeFromJson:(String) sdcInfos.get("name"));
 460         requestParameters.setUserParams(
 461                 retrieveUserParamsFromServiceCharacteristics(orderItem.getService().getServiceCharacteristic()));
 462         requestParameters.setaLaCarte(true);
 463         requestParameters.setTestApi("GR_API");
 464         requestDetails.setRequestParameters(requestParameters);
 465
 466         CloudConfiguration cloudConfiguration = new CloudConfiguration(lcpCloudRegionId, tenantId, cloudOwner);
 467         requestDetails.setCloudConfiguration(cloudConfiguration);
 468
 469         OwningEntity owningEntity = new OwningEntity();
 470         owningEntity.setOwningEntityId(serviceOrderInfo.getOwningEntityId());
 471         owningEntity.setOwningEntityName(soOwningEntityName);
 472         requestDetails.setOwningEntity(owningEntity);
 473
 474         Project project = new Project();
 475         project.setProjectName(soProjectName);
 476
 477         requestDetails.setProject(project);
 478
 479         return requestDetails;
 480     }
 481
 482     /**
 483      * Build E2E SO CREATE request from the ServiceOrder and catalog informations from SDC
 484      *
 485      * @param serviceOrderItem
 486      * @param serviceOrder
 487      * @param sdcInfos
 488      * @return
 489      */
 490     // ServiceOrderItem serviceOrderItem --> orderItem?
 491     private ServiceModel buildE2ESoRequest(ServiceOrderItem serviceOrderItem, Map<String, Object> sdcInfos,
 492             SubscriberInfo subscriberInfo, ServiceOrder serviceOrder) {
 493
 494         subscriberInfo.getGlobalSubscriberId();
 495         ServiceModel service = new ServiceModel();
 496         service.setName(serviceOrderItem.getService().getName());
 497         service.setDescription(serviceOrder.getDescription());
 498         service.setServiceUuid(serviceOrderItem.getService().getServiceSpecification().getId());
 499         service.setServiceInvariantUuid((String) sdcInfos.get("invariantUUID"));
 500         service.setGlobalSubscriberId(subscriberInfo.getGlobalSubscriberId());
 501         String serviceTypeFromJson = serviceOrderItem.getService().getServicetype();
 502         service.setServiceType(serviceTypeFromJson != null ? serviceTypeFromJson : (String) sdcInfos.get("name"));
 503         ParametersModel parameters = new ParametersModel();
 504         ArrayList<ResourceModel> resources = new ArrayList();
 505
 506         ArrayList<Object> resourceObjects = (ArrayList<Object>) sdcInfos.get("resourceSpecification");
 507
 508         for (int i = 0; i < resourceObjects.size(); i++) {
 509
 510             ResourceModel resourceModel = new ResourceModel((Map<String, Object>) resourceObjects.get(i));
 511             ParametersModel resourceParameters = new ParametersModel();
 512             resourceModel.setParameters(resourceParameters);
 513             resources.add(resourceModel);
 514
 515         }
 516         parameters.setResources(resources);
 517         List<UserParams> userParams =
 518                 retrieveUserParamsFromServiceCharacteristics(serviceOrderItem.getService().getServiceCharacteristic());
 519
 520         // If there are ServiceCharacteristics add them to requestInputs
 521         if (!userParams.isEmpty()) {
 522             Map<String, String> requestInputs = new HashMap<String, String>();
 523             for (int i = 0; i < userParams.size(); i++) {
 524                 requestInputs.put(userParams.get(i).getName(), (String) userParams.get(i).getValue());
 525             }
 526
 527             parameters.setRequestInputs(requestInputs);
 528         }
 529         service.setParameters(parameters);
 530
 531         return service;
 532     }
 533
 534     /**
 535      * Build a list of UserParams for the SO request by browsing a list of ServiceCharacteristics from
 536      * SDC
 537      */
 538     private List<UserParams> retrieveUserParamsFromServiceCharacteristics(List<ServiceCharacteristic> characteristics) {
 539         List<UserParams> userParams = new ArrayList<>();
 540         UserParams userParam;
 541
 542         if (!CollectionUtils.isEmpty(characteristics)) {
 543             for (ServiceCharacteristic characteristic : characteristics) {
 544                 // Check is the characteristic is of type object, if proceed as before to allow for
 545                 // backwards compatibility.
 546                 if (characteristic.getValueType() != null && !characteristic.getValueType().isEmpty()
 547                         && characteristic.getValueType().equals("object")) {
 548                     ObjectMapper mapper = new ObjectMapper();
 549                     JsonNode jsonNode = null;
 550                     try {
 551                         jsonNode = mapper.readTree(characteristic.getValue().getServiceCharacteristicValue());
 552                     } catch (IOException e) {
 553                         LOGGER.error("Failed to read object json {} , exception is ",
 554                                 characteristic.getValue().getServiceCharacteristicValue(), e.getMessage());
 555                     }
 556                     ObjectNode objectNode = (ObjectNode) jsonNode;
 557                     Iterator<Map.Entry<String, JsonNode>> iter = objectNode.fields();
 558                     while (iter.hasNext()) {
 559                         Map.Entry<String, JsonNode> entry = iter.next();
 560                         if (!entry.getValue().isArray()) {
 561                             userParam = new UserParams(entry.getKey(), entry.getValue().asText());
 562                         } else {
 563                             ArrayNode arrayNode = (ArrayNode) entry.getValue();
 564                             String arrayNodeValueString = arrayNode.toString();
 565                             userParam = new UserParams(entry.getKey(), arrayNodeValueString);
 566                         }
 567                         userParams.add(userParam);
 568                     }
 569                 }
 570                 // as UserParams for all other types, boolean, string, integer etc
 571                 else {
 572                     userParam = new UserParams(characteristic.getName(),
 573                             characteristic.getValue().getServiceCharacteristicValue());
 574                     userParams.add(userParam);
 575                 }
 576             }
 577         }
 578
 579         return userParams;
 580     }
 581
 582 }