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