vid-app-common/src/main/webapp/app/vid/scripts/services/creationService.js

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   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 "use strict";
  22
  23 /*
  24  * "CreationService" isolates the "component-specific" logic required by the
  25  * "CreationDialog" controller.
  26  *
  27  * "Components" are defined as the 5 element types managed by the dialogs: A)
  28  * Service B) VNF C) VF Module D) Volume Group and E) Network.
  29  *
  30  */
  31
  32 var CreationService = function($log, AaiService, AsdcService, DataService,VIDCONFIGURATION,
  33                                ComponentService, COMPONENT, FIELD, PARAMETER, UtilityService, OwningEntityService,featureFlags) {
  34
  35     var _this = this;
  36     var getAsyncOperationList = function() {
  37         if (DataService.getLoggedInUserId() == null) {
  38             getLoggedInUserID();
  39         } else {
  40             UtilityService.startNextAsyncOperation();
  41         }
  42         switch (_this.componentId) {
  43             case COMPONENT.SERVICE:
  44                 return [ getSubscribers, getServices, getAicZones, getOwningEntityProperties ];
  45             case COMPONENT.NETWORK:
  46                 return [ getLcpCloudRegionTenantList, getOwningEntityProperties ];
  47             case COMPONENT.VNF:
  48                 return [ getLcpCloudRegionTenantList, getOwningEntityProperties ];
  49             case COMPONENT.VF_MODULE:
  50                 return [ getLcpCloudRegionTenantList ];
  51             case COMPONENT.VOLUME_GROUP:
  52                 return [ getLcpCloudRegionTenantList ];
  53         }
  54     };
  55
  56     /*
  57      * "getSummaryList" and "getUserProvidedList" return parameters that should
  58      * be displayed in the summary and user provided sections, respectively. The
  59      * functions are expected to return lists that are in the format needed by
  60      * the parameter-block directive.
  61      */
  62
  63     var getSummaryList = function() {
  64
  65         /*
  66          * These placeholders should be removed and their usage in
  67          * "getSummaryList" should be replaced by appropriate code as the
  68          * requirements and interfaces firm up.
  69          */
  70
  71         var PLACEHOLDER_RESOURCE_DESCRIPTION = "Resource Description (PLACEHOLDER)";
  72         var PLACEHOLDER_SERVICE_CATEGORY = "Service Category (PLACEHOLDER)";
  73         var PLACEHOLDER_VF_MODULE_DESCRIPTION = "VF Module Description (PLACEHOLDER)";
  74         var PLACEHOLDER_VF_MODULE_LABEL = "VF Module Label (PLACEHOLDER)";
  75         var PLACEHOLDER_VF_MODULE_TYPE = "VF Module Type (PLACEHOLDER)";
  76
  77         _this.parameterList = new Array();
  78
  79         /*
  80          * Common fields displayed at the top of all create instance screens.
  81          */
  82         if(DataService.getModelInfo(_this.componentId)["serviceTypeName"]==null
  83             || DataService.getModelInfo(_this.componentId)["serviceTypeName"]==undefined
  84             || DataService.getModelInfo(_this.componentId)["serviceTypeName"]==''){
  85             addToList(FIELD.NAME.SERVICE_NAME, DataService.getServiceName());
  86         }
  87
  88         switch (_this.componentId) {
  89             case COMPONENT.SERVICE:
  90                 if ( !DataService.getALaCarte() ) {
  91                     // for macro instantiation need to add the resource names under the node template list
  92                     // this field is called modelCustomizationName in the asdc client code
  93                     var p;
  94                     var rlist = DataService.getResources();
  95                     var res;
  96                     if ( rlist != null ) {
  97                         for (var i = 0; i < rlist.length; i++) {
  98                             res = rlist[i];
  99
 100                             p = FIELD.NAME.RESOURCE_NAME.concat(" " + (i+1));
 101                             addToList(p, res.name );
 102                             p = FIELD.NAME.RESOURCE_DESCRIPTION.concat(" " + (i+1));
 103                             addToList(p, res.description );
 104                         }
 105                     }
 106                 }
 107                 if(DataService.getModelInfo(_this.componentId)["createSubscriberName"]!=null && DataService.getModelInfo(_this.componentId)["createSubscriberName"]!=''){
 108                     addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 109                         .getModelInfo(_this.componentId)["createSubscriberName"]);
 110                 }
 111                 if(DataService.getModelInfo(_this.componentId)["serviceTypeName"]!=null && DataService.getModelInfo(_this.componentId)["serviceTypeName"]!=''){
 112                     addToList(FIELD.NAME.SERVICE_TYPE, DataService
 113                         .getModelInfo(_this.componentId)["serviceTypeName"]);
 114                     addToList(FIELD.NAME.SERVICE_NAME, DataService.getServiceName());
 115                 }
 116                 addToList(FIELD.NAME.SERVICE_INVARIANT_UUID, DataService
 117                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 118                 addToList(FIELD.NAME.SERVICE_VERSION, DataService
 119                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 120                 addToList(FIELD.NAME.SERVICE_UUID, DataService
 121                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 122                 addToList(FIELD.NAME.SERVICE_DESCRIPTION, DataService
 123                     .getModelInfo(_this.componentId)[FIELD.ID.DESCRIPTION]);
 124                 addToList(FIELD.NAME.SERVICE_CATEGORY, DataService
 125                     .getModelInfo(_this.componentId)[FIELD.ID.CATEGORY]);
 126                 if (DataService.getModelInfo(_this.componentId)[FIELD.ID.SERVICE_TYPE] != "null") {
 127                     addToList(FIELD.NAME.SERVICE_TYPE, DataService
 128                         .getModelInfo(_this.componentId)[FIELD.ID.SERVICE_TYPE]);
 129                     addToList(FIELD.NAME.SERVICE_ROLE, DataService
 130                         .getModelInfo(_this.componentId)[FIELD.ID.SERVICE_ROLE]);
 131                 }
 132
 133                 break;
 134             case COMPONENT.VF_MODULE:
 135                 addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 136                     .getSubscriberName());
 137                 addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
 138                     .getServiceInstanceName());
 139                 addToList(FIELD.NAME.MODEL_NAME, DataService
 140                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME]);
 141                 addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 142                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 143                 addToList(FIELD.NAME.MODEL_VERSION, DataService
 144                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 145                 addToList(FIELD.NAME.MODEL_UUID, DataService
 146                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 147                 addToList(FIELD.NAME.MODEL_CUSTOMIZATION_UUID, DataService
 148                     .getModelInfo(_this.componentId)[FIELD.ID.CUSTOMIZATION_UUID]);
 149                 break;
 150             case COMPONENT.VNF:
 151                 addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 152                     .getSubscriberName());
 153                 addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
 154                     .getServiceInstanceName());
 155                 addToList(FIELD.NAME.MODEL_NAME, DataService
 156                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME]);
 157                 addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 158                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 159                 addToList(FIELD.NAME.MODEL_VERSION, DataService
 160                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 161                 addToList(FIELD.NAME.MODEL_UUID, DataService
 162                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 163                 addToList(FIELD.NAME.MODEL_CUSTOMIZATION_UUID, DataService
 164                     .getModelInfo(_this.componentId)[FIELD.ID.CUSTOMIZATION_UUID]);
 165                 addToList(FIELD.NAME.MODEL_CUSTOMIZATION_NAME, DataService
 166                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_CUSTOMIZATION_NAME]);
 167                 addToList(FIELD.NAME.MODEL_VNF_TYPE, DataService
 168                     .getModelInfo(_this.componentId)[COMPONENT.VNF_TYPE]);
 169                 addToList(FIELD.NAME.MODEL_VNF_ROLE, DataService
 170                     .getModelInfo(_this.componentId)[COMPONENT.VNF_ROLE]);
 171                 addToList(FIELD.NAME.MODEL_VNF_FUNCTION, DataService
 172                     .getModelInfo(_this.componentId)[COMPONENT.VNF_FUNCTION]);
 173                 addToList(FIELD.NAME.MODEL_VNF_CODE, DataService
 174                     .getModelInfo(_this.componentId)[COMPONENT.VNF_CODE]);
 175                 break;
 176             case COMPONENT.NETWORK:
 177             case COMPONENT.VOLUME_GROUP:
 178                 addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 179                     .getSubscriberName());
 180                 addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
 181                     .getServiceInstanceName());
 182                 addToList(FIELD.NAME.MODEL_NAME, DataService
 183                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME]);
 184                 addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 185                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 186                 addToList(FIELD.NAME.MODEL_VERSION, DataService
 187                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 188                 addToList(FIELD.NAME.MODEL_UUID, DataService
 189                     .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 190                 addToList(FIELD.NAME.MODEL_CUSTOMIZATION_UUID, DataService
 191                     .getModelInfo(_this.componentId)[FIELD.ID.CUSTOMIZATION_UUID]);
 192                 break;
 193         }
 194
 195         return _this.parameterList;
 196     };
 197
 198     var getUserProvidedList = function() {
 199         var parameterList = [];
 200         var isUserProvidedNaming = false;
 201         if ( ((DataService.getModelInfo(_this.componentId).serviceEcompNaming != null)
 202             && (DataService.getModelInfo(_this.componentId).serviceEcompNaming === "false")) || DataService.getE2EService() ) {
 203             isUserProvidedNaming = true;
 204         }
 205
 206         var isInTop = DataService.getHideServiceFields() || false;
 207         if (_this.componentId === COMPONENT.SERVICE) {
 208             if ( DataService.getALaCarte() ) {
 209                 parameterList = [ FIELD.PARAMETER.INSTANCE_NAME ];
 210                 if(!isInTop){
 211                     parameterList = parameterList.concat([ getSubscribersParameter(),
 212                         FIELD.PARAMETER.SERVICE_TYPE_DISABLED ]);
 213                 }
 214             }
 215             else {
 216                 // macro
 217
 218                 if(!isInTop){
 219                     if (isUserProvidedNaming) {
 220                         parameterList = [ FIELD.PARAMETER.INSTANCE_NAME ];
 221
 222                     }
 223                     parameterList = parameterList.concat([ getSubscribersParameter() ]);
 224                     parameterList = parameterList.concat([ getServiceId(),
 225                         FIELD.PARAMETER.SERVICE_TYPE,
 226                         FIELD.PARAMETER.LCP_REGION,
 227                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 228                         FIELD.PARAMETER.TENANT_DISABLED
 229                     ]);
 230                     if(!DataService.getE2EService()) {
 231                         parameterList = parameterList.concat([getAicZonesParameter()]);
 232                     }
 233
 234                 }else{
 235                     parameterList = parameterList.concat([ getServiceId(),
 236                         FIELD.PARAMETER.LCP_REGION,
 237                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 238                         FIELD.PARAMETER.TENANT_DISABLED ]);
 239                 }
 240             }
 241
 242             if(!DataService.getE2EService()) {
 243                 parameterList = parameterList.concat([getProjectParameter()]);
 244                 parameterList = parameterList.concat([getOwningEntityParameter()]);
 245             }
 246
 247             //if service model has a pnf, add a PNF ID parameter
 248             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_PNP_INSTANTIATION) && DataService.getPnf()) {
 249                 parameterList = parameterList.concat([ FIELD.PARAMETER.PNF_ID ]);
 250             }
 251         }
 252         else {
 253             parameterList = [ FIELD.PARAMETER.INSTANCE_NAME ];
 254             switch (_this.componentId) {
 255                 case COMPONENT.NETWORK:
 256                 case COMPONENT.VNF:
 257                     parameterList = parameterList.concat([ getServiceId(),
 258                         getLcpRegionParameter(), FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 259                         FIELD.PARAMETER.TENANT_DISABLED ]);
 260                     parameterList = parameterList.concat([ getLineOfBusinessParameter() ]);
 261
 262
 263                     if(_this.componentId === COMPONENT.VNF){
 264                         parameterList[parameterList.length -1].isRequired = true;
 265                     }
 266
 267                     parameterList = parameterList.concat([ getPlatformParameter() ]);
 268
 269                     if(_this.componentId === COMPONENT.NETWORK){
 270                         parameterList[parameterList.length -1].isRequired = false;
 271                     }
 272
 273                     break;
 274                 case COMPONENT.VF_MODULE:
 275                     parameterList = parameterList.concat([
 276                         getLcpRegionParameter(),
 277                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 278                         FIELD.PARAMETER.TENANT_DISABLED
 279                     ]);
 280
 281                     var availableVolumeGroupList = DataService.getAvailableVolumeGroupList();
 282
 283                     if (availableVolumeGroupList && availableVolumeGroupList.length > 0) {
 284                         var availableVolumeGroupNames = [FIELD.STATUS.NONE];
 285
 286                         for (var i = 0; i < availableVolumeGroupList.length; i++) {
 287                             availableVolumeGroupNames.push(availableVolumeGroupList[i].instance.name);
 288                         }
 289
 290                         parameterList.push(addOptionList(
 291                             FIELD.PARAMETER.AVAILABLE_VOLUME_GROUP,
 292                             availableVolumeGroupNames));
 293                     }
 294                     break;
 295                 case COMPONENT.VOLUME_GROUP:
 296                     parameterList = parameterList.concat([ getLcpRegionParameter(),
 297                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 298                         FIELD.PARAMETER.TENANT_DISABLED ]);
 299             }
 300         }
 301         parameterList.push(FIELD.PARAMETER.SUPPRESS_ROLLBACK);
 302         if(_this.componentId === COMPONENT.VF_MODULE ){
 303             parameterList.push({name: FIELD.NAME.SDN_C_PRELOAD,
 304                     id: FIELD.ID.SDN_C_PRELOAD,
 305                     type: "checkbox",
 306                     isEnabled: true,
 307                     isRequired: false,
 308                     hideFieldAndLabel: true
 309                 }
 310             );
 311             parameterList.push({name: FIELD.NAME.UPLOAD_SUPPLEMENTORY_DATA_FILE,
 312                     id: FIELD.ID.UPLOAD_SUPPLEMENTORY_DATA_FILE,
 313                     type: "checkbox",
 314                     isEnabled: true,
 315                     isRequired: false,
 316                     value:false
 317                 }
 318             );
 319
 320             parameterList.push({name: FIELD.NAME.SUPPLEMENTORY_DATA_FILE,
 321                     id: FIELD.ID.SUPPLEMENTORY_DATA_FILE,
 322                     type: "file",
 323                     isRequired: false,
 324                     isVisiblity: false
 325                 }
 326             );
 327         }
 328
 329         if( VIDCONFIGURATION.UPLOAD_SUPPLEMENTARY_STATUS_CHECK_ENABLED  && _this.componentId === COMPONENT.VOLUME_GROUP){
 330             parameterList.push({name: FIELD.NAME.UPLOAD_SUPPLEMENTORY_DATA_FILE,
 331                     id: FIELD.ID.UPLOAD_SUPPLEMENTORY_DATA_FILE,
 332                     type: "checkbox",
 333                     isEnabled: true,
 334                     isRequired: false
 335                 }
 336             );
 337
 338             parameterList.push({name: FIELD.NAME.SUPPLEMENTORY_DATA_FILE,
 339                     id: FIELD.ID.SUPPLEMENTORY_DATA_FILE,
 340                     type: "file",
 341                     isRequired: false,
 342                     isVisiblity: false
 343                 }
 344             );
 345         }
 346
 347         addArbitraryParameters(parameterList);
 348
 349         return parameterList;
 350     };
 351
 352     var addArbitraryParameters = function(parameterList) {
 353         if ( DataService.getModelInfo(_this.componentId).displayInputs != null ) {
 354             var inputs = DataService.getModelInfo(_this.componentId).displayInputs;
 355             for ( var key in inputs) {
 356                 var parameter = {
 357                     id : key,
 358                     type : PARAMETER.STRING,
 359                     name : ComponentService.getFieldDisplayName(key),
 360                     value : inputs[key][PARAMETER.DEFAULT],
 361                     isRequired : inputs[key][PARAMETER.REQUIRED],
 362                     description : inputs[key][PARAMETER.DESCRIPTION]
 363                 };
 364                 if ( DataService.getALaCarte() ) {
 365                     parameter.name = ComponentService.getFieldDisplayName(inputs[key][PARAMETER.DISPLAY_NAME]);
 366                 }
 367                 switch (inputs[key][PARAMETER.TYPE]) {
 368                     case PARAMETER.INTEGER:
 369                         parameter.type = PARAMETER.NUMBER;
 370                         break;
 371                     case PARAMETER.BOOLEAN:
 372                         parameter.type = PARAMETER.BOOLEAN;
 373                         break;
 374                     case PARAMETER.RANGE:
 375                         break;
 376                     case PARAMETER.LIST:
 377                         parameter.type = PARAMETER.LIST;
 378                         break;
 379                     case PARAMETER.MAP:
 380                         parameter.type = PARAMETER.MAP;
 381                         break;
 382                 }
 383
 384                 if ( UtilityService.hasContents(inputs[key][PARAMETER.CONSTRAINTS])
 385                     && ( inputs[key][PARAMETER.CONSTRAINTS].length > 0 ) ) {
 386                     var constraintsArray = inputs[key][PARAMETER.CONSTRAINTS];
 387                     //console.log ("Calling addConstraintParameters for input name=" + key);
 388                     addConstraintParameters (parameterList, constraintsArray, key, inputs, parameter);
 389                 }
 390                 else {
 391
 392                     parameterList.push(parameter);
 393                 }
 394             }
 395             DataService.setArbitraryParameters (parameterList);
 396         }
 397     };
 398
 399         var addConstraintParameters = function(parameterList, constraintsArray, key, inputs, parameter) {
 400                 // If there are constraints and the operator is "valid_values",
 401                 // use a select parameter type.
 402                 var i = constraintsArray.length;
 403                 var parameterPushed = false;
 404                 if ( i > 0 ) {
 405                         while ( (i--) && (!parameterPushed) ) {
 406                                 var keys = Object.keys(constraintsArray[i]);
 407                                 //var keys_len = keys.length;
 408                                 for ( var operator in keys ) {
 409                                         //console.log ("keys[operator]=" + keys[operator]);
 410                                         switch (keys[operator]) {
 411                                         case PARAMETER.VALID_VALUES:
 412                                                 var j = constraintsArray[i][PARAMETER.VALID_VALUES].length;
 413                                                 if ( j > 0 ) {
 414                                                         var oList = [];
 415                                                         var option;
 416                                                         while (j--) {
 417                                                                 option = {
 418                                                                                 name: constraintsArray[i][PARAMETER.VALID_VALUES][j],
 419                                                                                 isDefault: false
 420                                                                 };
 421                                                                 if ( ( UtilityService.hasContents (inputs[key][PARAMETER.DEFAULT]) )
 422                                                                                 && (inputs[key][PARAMETER.DEFAULT] === constraintsArray[i][PARAMETER.VALID_VALUES][j] ) ) {
 423                                                                         option = {
 424                                                                                         name: constraintsArray[i][PARAMETER.VALID_VALUES][j],
 425                                                                                         isDefault: true
 426                                                                         }
 427                                                                 }
 428                                                                 oList.push(option);
 429                                                         }
 430                                                         parameter.type = PARAMETER.SELECT;
 431                                                         parameter.optionList = oList;
 432                                                         parameterList.push(parameter);
 433                                                         parameterPushed = true;
 434                                                         //console.log ("pushed param for valid values");
 435                                                 }
 436                                         break;
 437
 438                                         case PARAMETER.EQUAL:
 439                                                 if ( constraintsArray[i][PARAMETER.EQUAL] != null ) {
 440                                                         //override parameter type
 441                                                         parameter.type = PARAMETER.STRING;
 442                                                         parameter.isReadOnly = true;
 443                                                         parameter.value = constraintsArray[i][PARAMETER.EQUAL];
 444                                                         parameterList.push(parameter);
 445                                                         parameterPushed = true;
 446                                                         //console.log ("pushed param for equal");
 447                                                 }
 448                                         break;
 449
 450                                         case PARAMETER.LENGTH:
 451                                                 if ( constraintsArray[i][PARAMETER.LENGTH] != null ) {
 452                                                         parameter.minLength = constraintsArray[i][PARAMETER.LENGTH];
 453                                                         parameter.maxLength = constraintsArray[i][PARAMETER.LENGTH];
 454                                                         parameterList.push(parameter);
 455                                                         parameterPushed = true;
 456                                                         //console.log ("pushed param for length: ");
 457                                                         //console.log (JSON.stringify (parameter, null, 4));
 458                                                 }
 459                                         break;
 460                                         case PARAMETER.MAX_LENGTH:
 461                                                 if ( constraintsArray[i][PARAMETER.MAX_LENGTH] != null ) {
 462                                                         parameter.maxLength = constraintsArray[i][PARAMETER.MAX_LENGTH];
 463                                                         parameterList.push(parameter);
 464                                                         parameterPushed = true;
 465                                                         //console.log ("pushed param for max length: ");
 466                                                         //console.log (JSON.stringify (parameter, null, 4));
 467                                                 }
 468                                         break;
 469                                         case PARAMETER.MIN_LENGTH:
 470                                                 if ( constraintsArray[i][PARAMETER.MIN_LENGTH] != null ) {
 471                                                         parameter.minLength = constraintsArray[i][PARAMETER.MIN_LENGTH];
 472                                                         parameterList.push(parameter);
 473                                                         parameterPushed = true;
 474                                                         //console.log ("pushed param for min length: ");
 475                                                         //console.log (JSON.stringify (parameter, null, 4));
 476                                                 }
 477                                         break;
 478                                         case PARAMETER.IN_RANGE:
 479                                                 if ( constraintsArray[i][PARAMETER.IN_RANGE] != null ) {
 480                                                         if (constraintsArray[i][PARAMETER.IN_RANGE].length > 1 ) {
 481                                                                 parameter.min = constraintsArray[i][PARAMETER.IN_RANGE][0];
 482                                                                 parameter.max = constraintsArray[i][PARAMETER.IN_RANGE][1];
 483                                                                 parameter.type = PARAMETER.NUMBER;
 484                                                                 parameter.value = inputs[key][PARAMETER.DEFAULT];
 485                                                                 parameterList.push(parameter);
 486                                                                 parameterPushed = true;
 487                                                                 //console.log ("pushed param for in_range");
 488                                                         }
 489                                                 }
 490                                         break;
 491                                         case PARAMETER.GREATER_THAN:
 492                                                 if ( constraintsArray[i][PARAMETER.GREATER_THAN] != null ) {
 493                                                                 parameter.type = PARAMETER.NUMBER;
 494                                                                 parameter.min = constraintsArray[i][PARAMETER.GREATER_THAN];
 495                                                                 parameter.value = inputs[key][PARAMETER.DEFAULT];
 496                                                                 parameterList.push(parameter);
 497                                                                 parameterPushed = true;
 498                                                                 //console.log ("pushed param for greater_than");
 499
 500                                                 }
 501                                         break;
 502                                         }//switch
 503                                 }//for
 504
 505                         }//while
 506                 }//if
 507         };
 508         var addToList = function(name, value) {
 509                 _this.parameterList.push({
 510                         name : name,
 511                         value : value
 512                 });
 513         };
 514         var setInventoryInfo = function(){
 515         var inventoryItem = DataService.getInventoryItem();
 516         var inventoryInfo = ComponentService.getInventoryInfo(
 517             _this.componentId, inventoryItem);
 518         };
 519
 520     /*
 521      * The "*Mso*" functions return URL and request details that can be passed
 522      * to the MSO controller. The request details defines the info passed as
 523      * part of the POST body.
 524      */
 525
 526     var getMsoUrl = function() {
 527         switch (_this.componentId) {
 528             case COMPONENT.NETWORK:
 529                 return "mso_create_nw_instance/"
 530                     + DataService.getServiceInstanceId();
 531             case COMPONENT.SERVICE:
 532                 if(DataService.getE2EService() === true)
 533                     return "mso_create_e2e_svc_instance";
 534                 else
 535                     return "mso_create_svc_instance";
 536             case COMPONENT.VNF:
 537                 return "mso_create_vnf_instance/"
 538                     + DataService.getServiceInstanceId();
 539             case COMPONENT.VF_MODULE:
 540                 return "mso_create_vfmodule_instance/"
 541                     + DataService.getServiceInstanceId() + "/vnfs/"
 542                     + DataService.getVnfInstanceId();
 543             case COMPONENT.VOLUME_GROUP:
 544                 return "mso_create_volumegroup_instance/"
 545                     + DataService.getServiceInstanceId() + "/vnfs/"
 546                     + DataService.getVnfInstanceId();
 547         }
 548     };
 549
 550     var getMsoE2ERequest = function(parameterList) {
 551         var modelInfo = DataService.getModelInfo(_this.componentId);
 552
 553         //region id
 554         let cloudConfiguration = buildCloudConfiguration(parameterList);
 555         var lcpRegion = cloudConfiguration.lcpCloudRegionId;
 556         var cloudOwner = cloudConfiguration.cloudOwner;
 557
 558         var params = [];
 559         var displayInputs = modelInfo.displayInputs;
 560         var groupBy = _.groupBy(displayInputs, "templateUUID");
 561
 562         _.forEach(groupBy, function(nodeTemplateInputs, nodeTemplateUUID) {
 563             var reqParas = {};
 564             var vfLocations = [];
 565
 566             nodeTemplateInputs.forEach(function(parameter){
 567                 if(parameter.type === 'vf_location') {
 568                     var loc = {
 569                         vnfProfileId: parameter.displayName,
 570                         locationConstraints : {
 571                             vimId: cloudOwner + '_' + lcpRegion
 572                         }
 573                     };
 574                     vfLocations.push(loc);
 575                 } else if(parameter.type === 'sdn_controller') {
 576                     if(parameter.value === undefined || parameter.value === null) {
 577                         reqParas[parameter.name] = '';
 578                     } else {
 579                         reqParas[parameter.name] = parameter.value.value;
 580                     }
 581                 } else {
 582                     var name;
 583                     _.forEach(displayInputs, function(item, key){
 584                         if(item === parameter) {
 585                             name = key;
 586                         }
 587                     });
 588                     var value = _.find(parameterList, function(item){
 589                         return item.id === name;
 590                     }).value;
 591                     reqParas[parameter.displayName] = value;
 592                 }
 593             });
 594
 595             params.push({
 596                 resourceName: nodeTemplateInputs[0].templateName,
 597                 resourceInvariantUuid: nodeTemplateInputs[0].templateInvariantUUID,
 598                 resourceUuid: nodeTemplateInputs[0].templateUUID,
 599                 resourceCustomizationUuid: nodeTemplateInputs[0].templateCustomizationUUID,
 600                 parameters: {
 601                     locationConstraints: vfLocations,
 602                     //TODO resources: [],
 603                     requestInputs: reqParas
 604                 }
 605             });
 606         });
 607
 608         var requestBody = {
 609             service: {
 610                 name: getValueFromList(FIELD.ID.INSTANCE_NAME, parameterList),
 611                 description: modelInfo["description"],
 612                 serviceInvariantUuid: modelInfo["modelInvariantId"],
 613                 serviceUuid: modelInfo["modelNameVersionId"],
 614                 globalSubscriberId: DataService.getGlobalCustomerId(),
 615                 serviceType: getValueFromList(FIELD.ID.SERVICE_TYPE, parameterList) || modelInfo["serviceTypeName"],
 616                 parameters: {
 617                     locationConstraints: [],
 618                     resources: params,
 619                     requestInputs: {} //TODO
 620                 }
 621             }
 622         };
 623
 624         return requestBody;
 625     };
 626
 627     var getMsoRequestDetails = function(parameterList) {
 628         console.log("getMsoRequestDetails invoked, parameterList="); console.log(JSON.stringify(parameterList,null,4));
 629
 630         //VoLTE logic goes here
 631         if(DataService.getE2EService() === true) {
 632             return getMsoE2ERequest(parameterList);
 633         }
 634
 635         var modelInfo = DataService.getModelInfo(_this.componentId);
 636         var requestorloggedInId = DataService.getLoggedInUserId();
 637         var owningEntityId = getValueFromList(FIELD.ID.OWNING_ENTITY, parameterList);
 638         if (requestorloggedInId ==  null)
 639             requestorloggedInId = "";
 640         var isSupRollback = false;
 641         if (getValueFromList(FIELD.ID.SUPPRESS_ROLLBACK,parameterList) === "true") {
 642             isSupRollback = true;
 643         }
 644         var requestDetails = {
 645             requestInfo : {
 646                 instanceName : getValueFromList(FIELD.ID.INSTANCE_NAME,
 647                     parameterList) || DataService.getVfModuleInstanceName(),
 648                 source : FIELD.ID.VID,
 649                 suppressRollback : isSupRollback,
 650                 requestorId: requestorloggedInId
 651             },
 652             modelInfo : {
 653                 modelType : _this.componentId,
 654                 modelInvariantId : modelInfo.modelInvariantId,
 655                 modelVersionId : modelInfo.modelNameVersionId,
 656                 modelName : modelInfo.modelName,
 657                 modelVersion : modelInfo.modelVersion,
 658                 modelCustomizationId: modelInfo.customizationUuid,
 659                 modelCustomizationName : modelInfo.modelCustomizationName
 660             },
 661             requestParameters : {
 662                 userParams : getArbitraryParameters(parameterList)
 663             }
 664         };
 665         if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_ADD_MSO_TESTAPI_FIELD)) {
 666             if ((_this.componentId != COMPONENT.SERVICE) || ( DataService.getALaCarte() )) {
 667                 requestDetails.requestParameters.testApi = DataService.getMsoRequestParametersTestApi();
 668             }
 669         }
 670         if ( (_this.componentId != COMPONENT.SERVICE) || ( !DataService.getALaCarte() ) ) {
 671             // include cloud region for everything but service create alacarte
 672             requestDetails.cloudConfiguration = buildCloudConfiguration(parameterList);
 673         }
 674         switch (_this.componentId) {
 675
 676             case COMPONENT.SERVICE:
 677                 requestDetails.subscriberInfo = {
 678                     globalSubscriberId : DataService.getGlobalCustomerId(),
 679                     subscriberName : DataService.getSubscriberName()
 680                 };
 681                 var isInTop = DataService.getHideServiceFields() || false;
 682                 if(isInTop){
 683                     requestDetails.requestParameters.subscriptionServiceType = DataService.getModelInfo(_this.componentId)["serviceTypeName"];
 684                 }else{
 685                     requestDetails.requestParameters.subscriptionServiceType = getValueFromList(
 686                         FIELD.ID.SERVICE_TYPE, parameterList);
 687                 }
 688                 requestDetails.requestParameters.aLaCarte = DataService.getALaCarte();
 689                 if ( !DataService.getALaCarte() ) {
 690                     requestDetails.requestInfo.productFamilyId = getValueFromList(
 691                         FIELD.ID.PRODUCT_FAMILY, parameterList);
 692                 }
 693                 var svcModelInfo = {
 694                     modelType : _this.componentId,
 695                     modelInvariantId : modelInfo.modelInvariantId,
 696                     modelVersionId : modelInfo.modelNameVersionId,
 697                     modelName : modelInfo.modelName,
 698                     modelVersion : modelInfo.modelVersion
 699                 };
 700                 requestDetails.modelInfo = svcModelInfo;
 701
 702                 var selectedProject = getValueFromList(FIELD.ID.PROJECT, parameterList);
 703
 704                 if (selectedProject) {
 705                     requestDetails.project = {
 706                         projectName: getValueFromList(FIELD.ID.PROJECT, parameterList)
 707                     };
 708                 }
 709
 710                 requestDetails.owningEntity = {
 711                     owningEntityId: owningEntityId,
 712                     owningEntityName: getOwningEntityNameById(owningEntityId)
 713                 };
 714
 715                 break;
 716             case COMPONENT.VNF:
 717             case COMPONENT.NETWORK:
 718                 requestDetails.requestInfo.productFamilyId = getValueFromList(
 719                     FIELD.ID.PRODUCT_FAMILY, parameterList);
 720                 var lineOfBusiness = getValueFromList(FIELD.ID.LINE_OF_BUSINESS, parameterList);
 721                 if(lineOfBusiness) {
 722                     requestDetails.lineOfBusiness = {
 723                         lineOfBusinessName: lineOfBusiness
 724                     };
 725                 }
 726
 727                 var platform = getValueFromList(FIELD.ID.PLATFORM, parameterList);
 728                 if (platform !== null && platform !== "") {
 729                   requestDetails.platform = {
 730                     platformName: platform
 731                   };
 732                 }
 733
 734                 break;
 735             case COMPONENT.VF_MODULE:
 736                 requestDetails.requestParameters.usePreload = getValueFromList(
 737                     FIELD.ID.SDN_C_PRELOAD, parameterList);
 738                 if(_this.componentId == COMPONENT.VF_MODULE &&(requestDetails.requestParameters.usePreload== null || requestDetails.requestParameters.usePreload === '')){
 739                     requestDetails.requestParameters.usePreload = false;
 740                 }
 741                 break;
 742             case COMPONENT.VOLUME_GROUP:
 743                 break;
 744         }
 745
 746         var relatedInstanceList = getRelatedInstanceList(parameterList);
 747
 748         if (relatedInstanceList !== undefined) {
 749             requestDetails.relatedInstanceList = relatedInstanceList;
 750         }
 751
 752         return requestDetails;
 753     };
 754
 755     var buildCloudConfiguration = function (parameterList) {
 756
 757         var lcpRegionOptionId = getValueFromList(FIELD.ID.LCP_REGION, parameterList);
 758         var cloudOwnerAndLcpCloudRegion = DataService.getCloudOwnerAndLcpCloudRegionFromOptionId(lcpRegionOptionId);
 759         var cloudOwner = cloudOwnerAndLcpCloudRegion.cloudOwner;
 760         var lcpRegion = cloudOwnerAndLcpCloudRegion.cloudRegionId === FIELD.KEY.LCP_REGION_TEXT ?
 761             getValueFromList(FIELD.ID.LCP_REGION_TEXT,parameterList) :
 762             cloudOwnerAndLcpCloudRegion.cloudRegionId;
 763
 764         return {
 765             lcpCloudRegionId: lcpRegion,
 766             cloudOwner: featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) ? cloudOwner : undefined,
 767             tenantId: getValueFromList(FIELD.ID.TENANT, parameterList)
 768         };
 769     };
 770
 771
 772     var getRelatedInstanceList = function(parameterList) {
 773         var relatedInstanceList = new Array();
 774         switch (_this.componentId) {
 775             case COMPONENT.SERVICE:
 776                 return undefined;
 777             case COMPONENT.NETWORK:
 778             case COMPONENT.VNF:
 779                 addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 780                     DataService.getServiceInstanceId());
 781                 break;
 782             case COMPONENT.VF_MODULE:
 783                 addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 784                     DataService.getServiceInstanceId());
 785                 addRelatedInstance(relatedInstanceList, COMPONENT.VNF, DataService
 786                     .getVnfInstanceId());
 787
 788                 var availableVolumeGroup = getValueFromList(
 789                     FIELD.ID.AVAILABLE_VOLUME_GROUP, parameterList);
 790
 791                 if (UtilityService.hasContents(availableVolumeGroup) && availableVolumeGroup !== "None") {
 792                     var availableVolumeGroups = DataService.getAvailableVolumeGroupList();
 793
 794                     for (var i = 0; i < availableVolumeGroups.length; i++) {
 795                         if (availableVolumeGroups[i].instance.name == availableVolumeGroup) {
 796                             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, DataService.getModelInfo(COMPONENT.VF_MODULE));
 797                             DataService.setVolumeGroupInstanceId(availableVolumeGroups[i].instance.object["volume-group-id"]);
 798                             break;
 799                         }
 800                     }
 801
 802                     addRelatedInstance(relatedInstanceList, COMPONENT.VOLUME_GROUP,
 803                         DataService.getVolumeGroupInstanceId());
 804                 }
 805                 break;
 806             case COMPONENT.VOLUME_GROUP:
 807                 addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 808                     DataService.getServiceInstanceId());
 809                 addRelatedInstance(relatedInstanceList, COMPONENT.VNF, DataService
 810                     .getVnfInstanceId());
 811                 break;
 812         }
 813
 814         return relatedInstanceList;
 815     };
 816
 817     var addRelatedInstance = function(relatedInstanceList, componentId,
 818                                       instanceId) {
 819         var modelInfo = DataService.getModelInfo(componentId);
 820         var relatedInstance;
 821         if (modelInfo !== undefined) {
 822             if (componentId === COMPONENT.SERVICE) {
 823                 relatedInstance = {
 824                     "instanceId" : instanceId,
 825                     "modelInfo" : {
 826                         "modelType" : componentId,
 827                         "modelName" : modelInfo.modelName,
 828                         "modelInvariantId" : modelInfo.modelInvariantId,
 829                         "modelVersion" : modelInfo.modelVersion,
 830                         "modelVersionId" : modelInfo.modelNameVersionId,
 831
 832                     }
 833                 };
 834             }
 835             else {
 836                 relatedInstance = {
 837                     "instanceId" : instanceId,
 838                     "modelInfo" : {
 839                         "modelType" : componentId,
 840                         "modelName" : modelInfo.modelName,
 841                         "modelInvariantId" : modelInfo.modelInvariantId,
 842                         "modelVersion" : modelInfo.modelVersion,
 843                         "modelVersionId" : modelInfo.modelNameVersionId,
 844                         "modelCustomizationId": modelInfo.customizationUuid,
 845                         "modelCustomizationName": modelInfo.modelCustomizationName
 846                     }
 847                 };
 848             }
 849             relatedInstanceList.push({
 850                 relatedInstance : relatedInstance
 851             });
 852         }
 853     };
 854
 855     /*
 856      * var getArbitraryParameters = function(parameterList) { var
 857      * arbitraryParameters = new Object(); for (var i = 0; i <
 858      * parameterList.length; i++) { var parameter = parameterList[i]; switch
 859      * (parameter.id) { case FIELD.ID.INSTANCE_NAME: case
 860      * FIELD.ID.PRODUCT_FAMILY: case FIELD.ID.LCP_REGION: case
 861      * FIELD.ID.LCP_REGION_TEXT: case FIELD.ID.SERVICE_TYPE: case
 862      * FIELD.ID.TENANT: case FIELD.ID.SUPPRESS_ROLLBACK: break; default:
 863      * arbitraryParameters[parameter.id] = parameter.value; } } return
 864      * arbitraryParameters; }
 865      */
 866     var getArbitraryParameters = function(parameterList) {
 867         var arbitraryParameters = new Object();
 868         var arbitraryArray = new Array();
 869         for (var i = 0; i < parameterList.length; i++) {
 870             var parameter = parameterList[i];
 871             switch (parameter.id) {
 872                 case FIELD.ID.AVAILABLE_VOLUME_GROUP:
 873                 case FIELD.ID.INSTANCE_NAME:
 874                 case FIELD.ID.PRODUCT_FAMILY:
 875                 case FIELD.ID.LCP_REGION:
 876                 case FIELD.ID.LCP_REGION_TEXT:
 877                 case FIELD.ID.SERVICE_TYPE:
 878                 case FIELD.ID.TENANT:
 879                 case FIELD.ID.SUPPRESS_ROLLBACK:
 880                 case FIELD.ID.SUBSCRIBER_NAME:
 881                 case FIELD.ID.SDN_C_PRELOAD:
 882                 case FIELD.ID.UPLOAD_SUPPLEMENTORY_DATA_FILE:
 883                 case FIELD.ID.OWNING_ENTITY:
 884                 case FIELD.ID.PLATFORM:
 885                 case FIELD.ID.LINE_OF_BUSINESS:
 886                 case FIELD.ID.PROJECT:
 887                     break;
 888                 case FIELD.ID.SUPPLEMENTORY_DATA_FILE:
 889                     arbitraryParameters =  FIELD.PARAMETER.SUPPLEMENTORY_DATA_FILE['value'];
 890                     arbitraryArray=arbitraryParameters;
 891                     FIELD.PARAMETER.SUPPLEMENTORY_DATA_FILE['value']=[];
 892                     break;
 893
 894                 default:
 895                     if (parameter.value != '') {
 896                         arbitraryParameters = {
 897                             name: parameter.id,
 898                             value: parameter.value
 899                         };
 900                         arbitraryArray.push(arbitraryParameters);
 901                     }
 902             }
 903         }
 904         return (arbitraryArray);
 905     };
 906
 907     var getModel = function() {
 908         AsdcService.getModel(DataService.getModelId(), function(response) {
 909             DataService.setModelInfo(_this.componentId, {
 910                 modelInvariantId : response.data.invariantUUID,
 911                 modelNameVersionId : response.data.uuid,
 912                 modelName : response.data.name,
 913                 modelVersion : response.data.version,
 914                 inputs : response.data.inputs
 915             });
 916             UtilityService.startNextAsyncOperation();
 917         });
 918     };
 919
 920     var getSubscriptionServiceTypeList = function() {
 921         AaiService.getSubscriptionServiceTypeList(DataService
 922             .getGlobalCustomerId(), function(response) {
 923             DataService.setSubscriptionServiceTypeList(response);
 924             UtilityService.startNextAsyncOperation();
 925         });
 926     };
 927
 928     var getLoggedInUserID = function() {
 929         AaiService.getLoggedInUserID(function(response) {
 930             DataService.setLoggedInUserId(response.data);
 931             UtilityService.startNextAsyncOperation();
 932         });
 933     };
 934
 935     var getSubscribers = function() {
 936         AaiService.getSubscribers(function(response) {
 937             DataService.setSubscribers(response);
 938             UtilityService.startNextAsyncOperation();
 939         });
 940     };
 941     var getServices = function() {
 942         AaiService.getServices(function(response) {
 943             var serviceIdList = [];
 944             angular.forEach(response.data, function(value, key) {
 945                 angular.forEach(value, function(subVal, key) {
 946                     var newVal = {
 947                         "id" : subVal[FIELD.ID.SERVICE_ID],
 948                         "description" : subVal[FIELD.ID.SERVICE_DESCRIPTION],
 949                         "isPermitted" : subVal[FIELD.ID.IS_PERMITTED],
 950                     };
 951                     serviceIdList.push(newVal);
 952                     DataService.setServiceIdList(serviceIdList);
 953                 });
 954             });
 955
 956             UtilityService.startNextAsyncOperation();
 957         });
 958     };
 959     var getAicZones = function() {
 960         AaiService.getAicZones(function(response) {
 961             var serviceIdList = [];
 962             angular.forEach(response.data, function(value, key) {
 963                 angular.forEach(value, function(subVal, key) {
 964                     var newVal = {
 965                         "id" : subVal[FIELD.ID.ZONE_ID],
 966                         "name" : subVal[FIELD.ID.ZONE_NAME],
 967                     };
 968                     serviceIdList.push(newVal);
 969                     DataService.setAicZones(serviceIdList);
 970                 });
 971             });
 972
 973             UtilityService.startNextAsyncOperation();
 974         });
 975     };
 976
 977     var getOwningEntityProperties = function() {
 978         OwningEntityService.getOwningEntityProperties(function(owningEntityProperties) {
 979             DataService.setOwningEntityProperties(owningEntityProperties);
 980             UtilityService.startNextAsyncOperation();
 981         });
 982
 983     };
 984
 985     var getLcpCloudRegionTenantList = function() {
 986         AaiService.getLcpCloudRegionTenantList(DataService
 987             .getGlobalCustomerId(), DataService.getServiceType(), function(
 988             response) {
 989             DataService.setCloudRegionTenantList(response);
 990             UtilityService.startNextAsyncOperation();
 991         });
 992     };
 993
 994     var internalGetParametersHandler = function() {
 995         if (angular.isFunction(_this.getParametersHandler)) {
 996             _this.getParametersHandler({
 997                 summaryList : getSummaryList(),
 998                 userProvidedList : getUserProvidedList()
 999             });
1000         }
1001     };
1002
1003     var getSubscribersParameter = function() {
1004         var subscribers = DataService.getSubscribers();
1005         var parameter = FIELD.PARAMETER.SUBSCRIBER_NAME;
1006         if ( UtilityService.hasContents(subscribers)) {
1007             parameter.optionList = [];
1008
1009             for (var i = 0; i < subscribers.length; i++) {
1010                 parameter.optionList.push({
1011                     id : subscribers[i][FIELD.ID.GLOBAL_CUSTOMER_ID],
1012                     name : subscribers[i][FIELD.ID.SUBNAME],
1013                     isPermitted : subscribers[i][FIELD.ID.IS_PERMITTED]
1014                 })
1015             }
1016         }
1017         return parameter;
1018     };
1019
1020     var getServiceId = function() {
1021         var serviceIdList = DataService.getServiceIdList();
1022         //var serviceTypeList = DataService.getSubscriptionServiceTypeList();
1023         var parameter = FIELD.PARAMETER.PRODUCT_FAMILY;
1024         parameter.optionList = new Array();
1025         if ( UtilityService.hasContents(serviceIdList) ) {
1026             // load them all
1027             for (var i = 0; i < serviceIdList.length; i++) {
1028                 parameter.optionList.push({
1029                     id : serviceIdList[i].id,
1030                     name : serviceIdList[i].description,
1031                     isPermitted : serviceIdList[i].isPermitted
1032                 });
1033             }
1034         }
1035
1036         return parameter;
1037     };
1038
1039     var getAicZonesParameter = function() {
1040         var aicList = DataService.getAicZones();
1041         var parameter = FIELD.PARAMETER.AIC_ZONES;
1042         parameter.optionList = new Array();
1043         if ( UtilityService.hasContents(aicList) ) {
1044             // load them all
1045             for (var i = 0; i < aicList.length; i++) {
1046                 parameter.optionList.push({
1047                     id : aicList[i].id,
1048                     name : aicList[i].name,
1049                     isPermitted : true
1050
1051                 });
1052             }
1053         }
1054
1055         return parameter;
1056     };
1057
1058     var getProjectParameter = function() {
1059         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.PROJECT);
1060     };
1061
1062     var getOwningEntityParameter = function() {
1063         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.OWNING_ENTITY);
1064     };
1065
1066     var getLineOfBusinessParameter = function() {
1067         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.LINE_OF_BUSINESS);
1068     };
1069
1070     var getPlatformParameter = function() {
1071         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.PLATFORM);
1072     };
1073
1074     var getOwningEntityNameById = function (id) {
1075         var properties = DataService.getOwningEntityProperties();
1076         var parameter = _.find(properties[FIELD.ID.OWNING_ENTITY], {"id": id});
1077         return parameter && parameter.name;
1078     };
1079
1080     var getOwningEntityParameterWithOptions = function(parameter) {
1081         var properties = DataService.getOwningEntityProperties();
1082         if (properties && properties[parameter.id]) {
1083             parameter.optionList = _.map(properties[parameter.id], function(parameter) {
1084                 return {
1085                     "id" : parameter.id,
1086                     "name" : parameter.name,
1087                     "isPermitted": true
1088                 };
1089             });
1090         }
1091
1092         return parameter;
1093     };
1094
1095     var getLcpRegionParameter = function() {
1096         var cloudRegionTenantList = DataService.getCloudRegionTenantList();
1097         console.log ( "cloudRegionTenantList=");
1098         console.log ( JSON.stringify (cloudRegionTenantList, null, 4 ));
1099
1100         var parameter = FIELD.PARAMETER.LCP_REGION;
1101         if ( UtilityService.hasContents (cloudRegionTenantList) ) {
1102             parameter.optionList = new Array();
1103             for (var i = 0; i < cloudRegionTenantList.length; i++) {
1104                 for (var j = 0; j < parameter.optionList.length; j++) {
1105                     if (parameter.optionList[j].id === cloudRegionTenantList[i].cloudRegionOptionId) {
1106                         parameter.optionList[j].isPermitted =
1107                             parameter.optionList[j].isPermitted || cloudRegionTenantList[i].isPermitted;
1108                         break;
1109                     }
1110                 }
1111                 if (j < parameter.optionList.length) {
1112                     continue;
1113                 }
1114
1115                 var optionName = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) && cloudRegionTenantList[i].cloudOwner ?
1116                     cloudRegionTenantList[i].cloudRegionId + " (" + AaiService.removeVendorFromCloudOwner(cloudRegionTenantList[i].cloudOwner).toUpperCase() + ")" :
1117                     cloudRegionTenantList[i].cloudRegionId;
1118
1119                 parameter.optionList.push({
1120                     id : cloudRegionTenantList[i].cloudRegionOptionId,
1121                     name: optionName,
1122                     isPermitted : cloudRegionTenantList[i].isPermitted
1123                 });
1124             }
1125         }
1126         return parameter;
1127     };
1128
1129     var getTenantList = function(cloudRegionOptionId) {
1130         var cloudRegionTenantList = DataService.getCloudRegionTenantList();
1131         var parameter = "";
1132         if ( UtilityService.hasContents (cloudRegionTenantList) ) {
1133             parameter = FIELD.PARAMETER.TENANT_ENABLED;
1134             parameter.optionList = new Array();
1135             for (var i = 0; i < cloudRegionTenantList.length; i++) {
1136                 if (cloudRegionTenantList[i].cloudRegionOptionId === cloudRegionOptionId) {
1137                     parameter.optionList.push({
1138                         id : cloudRegionTenantList[i].tenantId,
1139                         name : cloudRegionTenantList[i].tenantName,
1140                         isPermitted : cloudRegionTenantList[i].isPermitted
1141
1142                     });
1143                 }
1144             }
1145         }
1146         return parameter;
1147
1148     };
1149
1150     var addOptionList = function(parameter, optionSimpleArray) {
1151         var optionList = new Array();
1152         if (!angular.isArray(optionSimpleArray)) {
1153             return optionList;
1154         }
1155         for (var i = 0; i < optionSimpleArray.length; i++) {
1156             optionList.push({
1157                 name : optionSimpleArray[i],
1158                 isPermitted :true,
1159             });
1160         }
1161         parameter.optionList = optionList;
1162         return parameter;
1163     };
1164
1165     var getValueFromList = function(id, parameterList) {
1166         for (var i = 0; i < parameterList.length; i++) {
1167             if (parameterList[i].id === id) {
1168                 return parameterList[i].value;
1169             }
1170         }
1171         return null;
1172     };
1173     var updateUserParameterList = function(updatedId, parameterListControl) {
1174         console.log ("updateUserParameterList() updatedId=" + updatedId);
1175         if (updatedId === FIELD.ID.PRODUCT_FAMILY && DataService.getHideServiceFields()) {
1176             var cloudRegionTenantList = new Array();
1177             AaiService.getLcpCloudRegionTenantList(DataService.getGlobalCustomerId(), DataService.getServiceType(), function(cloudRegionTenantList) {
1178                 DataService.setCloudRegionTenantList(cloudRegionTenantList);
1179                 parameterListControl.updateList([ getLcpRegionParameter() ]);
1180             });
1181         }else if (updatedId === FIELD.ID.SDN_C_PRELOAD) {
1182             var list = parameterListControl.getList(updatedId);
1183             if($('input[parameter-id="'+updatedId+'"]').is(':checked')){
1184                 FIELD.PARAMETER.SDN_C_PRELOAD_CHECKED.value=true;
1185                 parameterListControl
1186                     .updateList([ FIELD.PARAMETER.SDN_C_PRELOAD_CHECKED ]);
1187             }else{
1188                 parameterListControl
1189                     .updateList([ FIELD.PARAMETER.SDN_C_PRELOAD_UNCHECKED ]);
1190             }
1191         }else if (updatedId === FIELD.ID.UPLOAD_SUPPLEMENTORY_DATA_FILE) {
1192             if($('input[parameter-id="'+updatedId+'"]').is(':checked')){
1193                 $('input[parameter-id="'+FIELD.ID.SUPPLEMENTORY_DATA_FILE+'"]').closest('tr').show();
1194                 FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_CHECKED.value=true;
1195                 parameterListControl
1196                     .updateList([ FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_CHECKED ]);
1197             }else{
1198                 $('input[parameter-id="'+FIELD.ID.SUPPLEMENTORY_DATA_FILE+'"]').closest('tr').hide();
1199                 FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_CHECKED.value=false;
1200                 parameterListControl
1201                     .updateList([ FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_UNCHECKED ]);
1202             }
1203         } else if (updatedId === FIELD.ID.SUPPLEMENTORY_DATA_FILE) {
1204             var filePath =  $('input[parameter-id="'+updatedId+'"]').val();
1205             var arr =filePath.split('.');
1206             var fileExt  = arr[arr.length-1];
1207             if(fileExt!='' && fileExt.toLowerCase()!='json'){
1208                 $('input[parameter-id="'+updatedId+'"]').val('');
1209                 alert("Invalid file format. Please select *.json format file.");
1210                 return false;
1211             }
1212         } else  if (updatedId === FIELD.ID.LCP_REGION) {
1213             var list = parameterListControl.getList(updatedId);
1214             if (list[0].selectedIndex >= 0) {
1215                 parameterListControl
1216                     .updateList([ getTenantList(list[0].value) ]);
1217             } else {
1218                 parameterListControl
1219                     .updateList([ FIELD.PARAMETER.TENANT_DISABLED ]);
1220             }
1221
1222             var cloudOwnerAndLcpCloudRegion = DataService.getCloudOwnerAndLcpCloudRegionFromOptionId(list[0].value);
1223             if (cloudOwnerAndLcpCloudRegion.cloudRegionId === FIELD.KEY.LCP_REGION_TEXT) {
1224                 parameterListControl
1225                     .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_VISIBLE ]);
1226             } else {
1227                 parameterListControl
1228                     .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN ]);
1229             }
1230         } else if (updatedId === FIELD.ID.SUBSCRIBER_NAME) {
1231             var list = parameterListControl.getList(updatedId);
1232             if (list[0].selectedIndex >= 0) {
1233                 DataService.setGlobalCustomerId(list[0].value);
1234
1235                 AaiService.getSubscriptionServiceTypeList(DataService
1236                     .getGlobalCustomerId(), function(response) {
1237                     DataService.setSubscriptionServiceTypeList(response);
1238                     var serviceTypeParameters = FIELD.PARAMETER.SERVICE_TYPE;
1239                     serviceTypeParameters.optionList = [];
1240
1241                     for (var i = 0; i < response.length; i++) {
1242                         serviceTypeParameters.optionList.push({
1243                             "id" : response[i].name,
1244                             "name" : response[i].name,
1245                             "isPermitted" :response[i].isPermitted
1246
1247                         });
1248                     }
1249                     console.log ( "updateUserParameterList: service type parameters " );
1250                     console.log ( JSON.stringify (serviceTypeParameters, null, 4));
1251                     parameterListControl.updateList([ serviceTypeParameters ]);
1252                 });
1253
1254             }
1255         } else if ( updatedId === FIELD.ID.SERVICE_TYPE ) {
1256             var list = parameterListControl.getList(updatedId);
1257             if (list[0].selectedIndex >= 0) {
1258
1259                 DataService.setServiceType(list[0].value);
1260                 var cloudRegionTenantList = new Array();
1261                 AaiService.getLcpCloudRegionTenantList(DataService.getGlobalCustomerId(), DataService.getServiceType(), function(cloudRegionTenantList) {
1262                     DataService.setCloudRegionTenantList(cloudRegionTenantList);
1263                     parameterListControl.updateList([ getLcpRegionParameter() ]);
1264                 });
1265             } else {
1266                 parameterListControl
1267                     .updateList([ FIELD.PARAMETER.SERVICE_TYPE_DISABLED ]);
1268             }
1269         }
1270
1271     };
1272
1273     return {
1274         initializeComponent : function(componentId) {
1275             _this.componentId = ComponentService.initialize(componentId);
1276         },
1277         setHttpErrorHandler : function(httpErrorHandler) {
1278             _this.httpErrorHandler = httpErrorHandler;
1279         },
1280         getComponentDisplayName : ComponentService.getComponentDisplayName,
1281         getParameters : function(getParametersHandler) {
1282             _this.getParametersHandler = getParametersHandler;
1283             UtilityService.setHttpErrorHandler(_this.httpErrorHandler);
1284             UtilityService.startAsyncOperations(getAsyncOperationList(),
1285                 internalGetParametersHandler);
1286         },
1287         updateUserParameterList : updateUserParameterList,
1288         getMsoRequestDetails : getMsoRequestDetails,
1289         getMsoUrl : getMsoUrl,
1290         setInventoryInfo: setInventoryInfo
1291     };
1292 };
1293
1294 appDS2.factory("CreationService", [ "$log", "AaiService", "AsdcService",
1295     "DataService","VIDCONFIGURATION", "ComponentService", "COMPONENT", "FIELD", "PARAMETER",
1296     "UtilityService", "OwningEntityService","featureFlags", CreationService ]);