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
 718                 requestDetails.requestInfo.productFamilyId = getValueFromList(
 719                     FIELD.ID.PRODUCT_FAMILY, parameterList);
 720
 721                 var lineOfBusiness = getValueFromList(FIELD.ID.LINE_OF_BUSINESS, parameterList);
 722
 723                 if(lineOfBusiness) {
 724                     requestDetails.lineOfBusiness = {
 725                         lineOfBusinessName: lineOfBusiness
 726                     };
 727                 }
 728
 729                 requestDetails.platform = {
 730                     platformName: getValueFromList(FIELD.ID.PLATFORM, parameterList)
 731                 };
 732
 733                 break;
 734             case COMPONENT.NETWORK:
 735                 requestDetails.requestInfo.productFamilyId = getValueFromList(
 736                     FIELD.ID.PRODUCT_FAMILY, parameterList);
 737                 var lineOfBusiness = getValueFromList(FIELD.ID.LINE_OF_BUSINESS, parameterList);
 738
 739                 if(lineOfBusiness) {
 740                     var lineOfBusinessNamesString = _.map(lineOfBusiness, "name").join(", ");
 741
 742                     requestDetails.lineOfBusiness = {
 743                         lineOfBusinessName: lineOfBusinessNamesString
 744                     };
 745                 }
 746
 747                 var platform = getValueFromList(FIELD.ID.PLATFORM, parameterList);
 748                 if(platform !== null && platform !== ""){
 749                 requestDetails.platform = {
 750                         platformName: platform
 751                 };
 752                 }
 753
 754
 755
 756                 break;
 757             case COMPONENT.VF_MODULE:
 758                 requestDetails.requestParameters.usePreload = getValueFromList(
 759                     FIELD.ID.SDN_C_PRELOAD, parameterList);
 760                 if(_this.componentId == COMPONENT.VF_MODULE &&(requestDetails.requestParameters.usePreload== null || requestDetails.requestParameters.usePreload === '')){
 761                     requestDetails.requestParameters.usePreload = false;
 762                 }
 763                 break;
 764             case COMPONENT.VOLUME_GROUP:
 765                 break;
 766         }
 767
 768         var relatedInstanceList = getRelatedInstanceList(parameterList);
 769
 770         if (relatedInstanceList !== undefined) {
 771             requestDetails.relatedInstanceList = relatedInstanceList;
 772         }
 773
 774         return requestDetails;
 775     };
 776
 777     var buildCloudConfiguration = function (parameterList) {
 778
 779         var lcpRegionOptionId = getValueFromList(FIELD.ID.LCP_REGION, parameterList);
 780         var cloudOwnerAndLcpCloudRegion = DataService.getCloudOwnerAndLcpCloudRegionFromOptionId(lcpRegionOptionId);
 781         var cloudOwner = cloudOwnerAndLcpCloudRegion.cloudOwner;
 782         var lcpRegion = cloudOwnerAndLcpCloudRegion.cloudRegionId === FIELD.KEY.LCP_REGION_TEXT ?
 783             getValueFromList(FIELD.ID.LCP_REGION_TEXT,parameterList) :
 784             cloudOwnerAndLcpCloudRegion.cloudRegionId;
 785
 786         return {
 787             lcpCloudRegionId: lcpRegion,
 788             cloudOwner: featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) ? cloudOwner : undefined,
 789             tenantId: getValueFromList(FIELD.ID.TENANT, parameterList)
 790         };
 791     };
 792
 793
 794     var getRelatedInstanceList = function(parameterList) {
 795         var relatedInstanceList = new Array();
 796         switch (_this.componentId) {
 797             case COMPONENT.SERVICE:
 798                 return undefined;
 799             case COMPONENT.NETWORK:
 800             case COMPONENT.VNF:
 801                 addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 802                     DataService.getServiceInstanceId());
 803                 break;
 804             case COMPONENT.VF_MODULE:
 805                 addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 806                     DataService.getServiceInstanceId());
 807                 addRelatedInstance(relatedInstanceList, COMPONENT.VNF, DataService
 808                     .getVnfInstanceId());
 809
 810                 var availableVolumeGroup = getValueFromList(
 811                     FIELD.ID.AVAILABLE_VOLUME_GROUP, parameterList);
 812
 813                 if (UtilityService.hasContents(availableVolumeGroup) && availableVolumeGroup !== "None") {
 814                     var availableVolumeGroups = DataService.getAvailableVolumeGroupList();
 815
 816                     for (var i = 0; i < availableVolumeGroups.length; i++) {
 817                         if (availableVolumeGroups[i].instance.name == availableVolumeGroup) {
 818                             DataService.setModelInfo(COMPONENT.VOLUME_GROUP, DataService.getModelInfo(COMPONENT.VF_MODULE));
 819                             DataService.setVolumeGroupInstanceId(availableVolumeGroups[i].instance.object["volume-group-id"]);
 820                             break;
 821                         }
 822                     }
 823
 824                     addRelatedInstance(relatedInstanceList, COMPONENT.VOLUME_GROUP,
 825                         DataService.getVolumeGroupInstanceId());
 826                 }
 827                 break;
 828             case COMPONENT.VOLUME_GROUP:
 829                 addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 830                     DataService.getServiceInstanceId());
 831                 addRelatedInstance(relatedInstanceList, COMPONENT.VNF, DataService
 832                     .getVnfInstanceId());
 833                 break;
 834         }
 835
 836         return relatedInstanceList;
 837     };
 838
 839     var addRelatedInstance = function(relatedInstanceList, componentId,
 840                                       instanceId) {
 841         var modelInfo = DataService.getModelInfo(componentId);
 842         var relatedInstance;
 843         if (modelInfo !== undefined) {
 844             if (componentId === COMPONENT.SERVICE) {
 845                 relatedInstance = {
 846                     "instanceId" : instanceId,
 847                     "modelInfo" : {
 848                         "modelType" : componentId,
 849                         "modelName" : modelInfo.modelName,
 850                         "modelInvariantId" : modelInfo.modelInvariantId,
 851                         "modelVersion" : modelInfo.modelVersion,
 852                         "modelVersionId" : modelInfo.modelNameVersionId,
 853
 854                     }
 855                 };
 856             }
 857             else {
 858                 relatedInstance = {
 859                     "instanceId" : instanceId,
 860                     "modelInfo" : {
 861                         "modelType" : componentId,
 862                         "modelName" : modelInfo.modelName,
 863                         "modelInvariantId" : modelInfo.modelInvariantId,
 864                         "modelVersion" : modelInfo.modelVersion,
 865                         "modelVersionId" : modelInfo.modelNameVersionId,
 866                         "modelCustomizationId": modelInfo.customizationUuid,
 867                         "modelCustomizationName": modelInfo.modelCustomizationName
 868                     }
 869                 };
 870             }
 871             relatedInstanceList.push({
 872                 relatedInstance : relatedInstance
 873             });
 874         }
 875     };
 876
 877     /*
 878      * var getArbitraryParameters = function(parameterList) { var
 879      * arbitraryParameters = new Object(); for (var i = 0; i <
 880      * parameterList.length; i++) { var parameter = parameterList[i]; switch
 881      * (parameter.id) { case FIELD.ID.INSTANCE_NAME: case
 882      * FIELD.ID.PRODUCT_FAMILY: case FIELD.ID.LCP_REGION: case
 883      * FIELD.ID.LCP_REGION_TEXT: case FIELD.ID.SERVICE_TYPE: case
 884      * FIELD.ID.TENANT: case FIELD.ID.SUPPRESS_ROLLBACK: break; default:
 885      * arbitraryParameters[parameter.id] = parameter.value; } } return
 886      * arbitraryParameters; }
 887      */
 888     var getArbitraryParameters = function(parameterList) {
 889         var arbitraryParameters = new Object();
 890         var arbitraryArray = new Array();
 891         for (var i = 0; i < parameterList.length; i++) {
 892             var parameter = parameterList[i];
 893             switch (parameter.id) {
 894                 case FIELD.ID.AVAILABLE_VOLUME_GROUP:
 895                 case FIELD.ID.INSTANCE_NAME:
 896                 case FIELD.ID.PRODUCT_FAMILY:
 897                 case FIELD.ID.LCP_REGION:
 898                 case FIELD.ID.LCP_REGION_TEXT:
 899                 case FIELD.ID.SERVICE_TYPE:
 900                 case FIELD.ID.TENANT:
 901                 case FIELD.ID.SUPPRESS_ROLLBACK:
 902                 case FIELD.ID.SUBSCRIBER_NAME:
 903                 case FIELD.ID.SDN_C_PRELOAD:
 904                 case FIELD.ID.UPLOAD_SUPPLEMENTORY_DATA_FILE:
 905                 case FIELD.ID.OWNING_ENTITY:
 906                 case FIELD.ID.PLATFORM:
 907                 case FIELD.ID.LINE_OF_BUSINESS:
 908                 case FIELD.ID.PROJECT:
 909                     break;
 910                 case FIELD.ID.SUPPLEMENTORY_DATA_FILE:
 911                     arbitraryParameters =  FIELD.PARAMETER.SUPPLEMENTORY_DATA_FILE['value'];
 912                     arbitraryArray=arbitraryParameters;
 913                     FIELD.PARAMETER.SUPPLEMENTORY_DATA_FILE['value']=[];
 914                     break;
 915
 916                 default:
 917                     if (parameter.value != '') {
 918                         arbitraryParameters = {
 919                             name: parameter.id,
 920                             value: parameter.value
 921                         };
 922                         arbitraryArray.push(arbitraryParameters);
 923                     }
 924             }
 925         }
 926         return (arbitraryArray);
 927     };
 928
 929     var getModel = function() {
 930         AsdcService.getModel(DataService.getModelId(), function(response) {
 931             DataService.setModelInfo(_this.componentId, {
 932                 modelInvariantId : response.data.invariantUUID,
 933                 modelNameVersionId : response.data.uuid,
 934                 modelName : response.data.name,
 935                 modelVersion : response.data.version,
 936                 inputs : response.data.inputs
 937             });
 938             UtilityService.startNextAsyncOperation();
 939         });
 940     };
 941
 942     var getSubscriptionServiceTypeList = function() {
 943         AaiService.getSubscriptionServiceTypeList(DataService
 944             .getGlobalCustomerId(), function(response) {
 945             DataService.setSubscriptionServiceTypeList(response);
 946             UtilityService.startNextAsyncOperation();
 947         });
 948     };
 949
 950     var getLoggedInUserID = function() {
 951         AaiService.getLoggedInUserID(function(response) {
 952             DataService.setLoggedInUserId(response.data);
 953             UtilityService.startNextAsyncOperation();
 954         });
 955     };
 956
 957     var getSubscribers = function() {
 958         AaiService.getSubscribers(function(response) {
 959             DataService.setSubscribers(response);
 960             UtilityService.startNextAsyncOperation();
 961         });
 962     };
 963     var getServices = function() {
 964         AaiService.getServices(function(response) {
 965             var serviceIdList = [];
 966             angular.forEach(response.data, function(value, key) {
 967                 angular.forEach(value, function(subVal, key) {
 968                     var newVal = {
 969                         "id" : subVal[FIELD.ID.SERVICE_ID],
 970                         "description" : subVal[FIELD.ID.SERVICE_DESCRIPTION],
 971                         "isPermitted" : subVal[FIELD.ID.IS_PERMITTED],
 972                     };
 973                     serviceIdList.push(newVal);
 974                     DataService.setServiceIdList(serviceIdList);
 975                 });
 976             });
 977
 978             UtilityService.startNextAsyncOperation();
 979         });
 980     };
 981     var getAicZones = function() {
 982         AaiService.getAicZones(function(response) {
 983             var serviceIdList = [];
 984             angular.forEach(response.data, function(value, key) {
 985                 angular.forEach(value, function(subVal, key) {
 986                     var newVal = {
 987                         "id" : subVal[FIELD.ID.ZONE_ID],
 988                         "name" : subVal[FIELD.ID.ZONE_NAME],
 989                     };
 990                     serviceIdList.push(newVal);
 991                     DataService.setAicZones(serviceIdList);
 992                 });
 993             });
 994
 995             UtilityService.startNextAsyncOperation();
 996         });
 997     };
 998
 999     var getOwningEntityProperties = function() {
1000         OwningEntityService.getOwningEntityProperties(function(owningEntityProperties) {
1001             DataService.setOwningEntityProperties(owningEntityProperties);
1002             UtilityService.startNextAsyncOperation();
1003         });
1004
1005     };
1006
1007     var getLcpCloudRegionTenantList = function() {
1008         AaiService.getLcpCloudRegionTenantList(DataService
1009             .getGlobalCustomerId(), DataService.getServiceType(), function(
1010             response) {
1011             DataService.setCloudRegionTenantList(response);
1012             UtilityService.startNextAsyncOperation();
1013         });
1014     };
1015
1016     var internalGetParametersHandler = function() {
1017         if (angular.isFunction(_this.getParametersHandler)) {
1018             _this.getParametersHandler({
1019                 summaryList : getSummaryList(),
1020                 userProvidedList : getUserProvidedList()
1021             });
1022         }
1023     };
1024
1025     var getSubscribersParameter = function() {
1026         var subscribers = DataService.getSubscribers();
1027         var parameter = FIELD.PARAMETER.SUBSCRIBER_NAME;
1028         if ( UtilityService.hasContents(subscribers)) {
1029             parameter.optionList = [];
1030
1031             for (var i = 0; i < subscribers.length; i++) {
1032                 parameter.optionList.push({
1033                     id : subscribers[i][FIELD.ID.GLOBAL_CUSTOMER_ID],
1034                     name : subscribers[i][FIELD.ID.SUBNAME],
1035                     isPermitted : subscribers[i][FIELD.ID.IS_PERMITTED]
1036                 })
1037             }
1038         }
1039         return parameter;
1040     };
1041
1042     var getServiceId = function() {
1043         var serviceIdList = DataService.getServiceIdList();
1044         //var serviceTypeList = DataService.getSubscriptionServiceTypeList();
1045         var parameter = FIELD.PARAMETER.PRODUCT_FAMILY;
1046         parameter.optionList = new Array();
1047         if ( UtilityService.hasContents(serviceIdList) ) {
1048             // load them all
1049             for (var i = 0; i < serviceIdList.length; i++) {
1050                 parameter.optionList.push({
1051                     id : serviceIdList[i].id,
1052                     name : serviceIdList[i].description,
1053                     isPermitted : serviceIdList[i].isPermitted
1054                 });
1055             }
1056         }
1057
1058         return parameter;
1059     };
1060
1061     var getAicZonesParameter = function() {
1062         var aicList = DataService.getAicZones();
1063         var parameter = FIELD.PARAMETER.AIC_ZONES;
1064         parameter.optionList = new Array();
1065         if ( UtilityService.hasContents(aicList) ) {
1066             // load them all
1067             for (var i = 0; i < aicList.length; i++) {
1068                 parameter.optionList.push({
1069                     id : aicList[i].id,
1070                     name : aicList[i].name,
1071                     isPermitted : true
1072
1073                 });
1074             }
1075         }
1076
1077         return parameter;
1078     };
1079
1080     var getProjectParameter = function() {
1081         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.PROJECT);
1082     };
1083
1084     var getOwningEntityParameter = function() {
1085         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.OWNING_ENTITY);
1086     };
1087
1088     var getLineOfBusinessParameter = function() {
1089         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.LINE_OF_BUSINESS);
1090     };
1091
1092     var getPlatformParameter = function() {
1093         return getOwningEntityParameterWithOptions(FIELD.PARAMETER.PLATFORM);
1094     };
1095
1096     var getOwningEntityNameById = function (id) {
1097         var properties = DataService.getOwningEntityProperties();
1098         var parameter = _.find(properties[FIELD.ID.OWNING_ENTITY], {"id": id});
1099         return parameter && parameter.name;
1100     };
1101
1102     var getOwningEntityParameterWithOptions = function(parameter) {
1103         var properties = DataService.getOwningEntityProperties();
1104         if (properties && properties[parameter.id]) {
1105             parameter.optionList = _.map(properties[parameter.id], function(parameter) {
1106                 return {
1107                     "id" : parameter.id,
1108                     "name" : parameter.name,
1109                     "isPermitted": true
1110                 };
1111             });
1112         }
1113
1114         return parameter;
1115     };
1116
1117     var getLcpRegionParameter = function() {
1118         var cloudRegionTenantList = DataService.getCloudRegionTenantList();
1119         console.log ( "cloudRegionTenantList=");
1120         console.log ( JSON.stringify (cloudRegionTenantList, null, 4 ));
1121
1122         var parameter = FIELD.PARAMETER.LCP_REGION;
1123         if ( UtilityService.hasContents (cloudRegionTenantList) ) {
1124             parameter.optionList = new Array();
1125             for (var i = 0; i < cloudRegionTenantList.length; i++) {
1126                 for (var j = 0; j < parameter.optionList.length; j++) {
1127                     if (parameter.optionList[j].id === cloudRegionTenantList[i].cloudRegionOptionId) {
1128                         parameter.optionList[j].isPermitted =
1129                             parameter.optionList[j].isPermitted || cloudRegionTenantList[i].isPermitted;
1130                         break;
1131                     }
1132                 }
1133                 if (j < parameter.optionList.length) {
1134                     continue;
1135                 }
1136
1137                 var optionName = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) && cloudRegionTenantList[i].cloudOwner ?
1138                     cloudRegionTenantList[i].cloudRegionId + " (" + AaiService.removeVendorFromCloudOwner(cloudRegionTenantList[i].cloudOwner).toUpperCase() + ")" :
1139                     cloudRegionTenantList[i].cloudRegionId;
1140
1141                 parameter.optionList.push({
1142                     id : cloudRegionTenantList[i].cloudRegionOptionId,
1143                     name: optionName,
1144                     isPermitted : cloudRegionTenantList[i].isPermitted
1145                 });
1146             }
1147         }
1148         return parameter;
1149     };
1150
1151     var getTenantList = function(cloudRegionOptionId) {
1152         var cloudRegionTenantList = DataService.getCloudRegionTenantList();
1153         var parameter = "";
1154         if ( UtilityService.hasContents (cloudRegionTenantList) ) {
1155             parameter = FIELD.PARAMETER.TENANT_ENABLED;
1156             parameter.optionList = new Array();
1157             for (var i = 0; i < cloudRegionTenantList.length; i++) {
1158                 if (cloudRegionTenantList[i].cloudRegionOptionId === cloudRegionOptionId) {
1159                     parameter.optionList.push({
1160                         id : cloudRegionTenantList[i].tenantId,
1161                         name : cloudRegionTenantList[i].tenantName,
1162                         isPermitted : cloudRegionTenantList[i].isPermitted
1163
1164                     });
1165                 }
1166             }
1167         }
1168         return parameter;
1169
1170     };
1171
1172     var addOptionList = function(parameter, optionSimpleArray) {
1173         var optionList = new Array();
1174         if (!angular.isArray(optionSimpleArray)) {
1175             return optionList;
1176         }
1177         for (var i = 0; i < optionSimpleArray.length; i++) {
1178             optionList.push({
1179                 name : optionSimpleArray[i],
1180                 isPermitted :true,
1181             });
1182         }
1183         parameter.optionList = optionList;
1184         return parameter;
1185     };
1186
1187     var getValueFromList = function(id, parameterList) {
1188         for (var i = 0; i < parameterList.length; i++) {
1189             if (parameterList[i].id === id) {
1190                 return parameterList[i].value;
1191             }
1192         }
1193         return null;
1194     };
1195     var updateUserParameterList = function(updatedId, parameterListControl) {
1196         console.log ("updateUserParameterList() updatedId=" + updatedId);
1197         if (updatedId === FIELD.ID.PRODUCT_FAMILY && DataService.getHideServiceFields()) {
1198             var cloudRegionTenantList = new Array();
1199             AaiService.getLcpCloudRegionTenantList(DataService.getGlobalCustomerId(), DataService.getServiceType(), function(cloudRegionTenantList) {
1200                 DataService.setCloudRegionTenantList(cloudRegionTenantList);
1201                 parameterListControl.updateList([ getLcpRegionParameter() ]);
1202             });
1203         }else if (updatedId === FIELD.ID.SDN_C_PRELOAD) {
1204             var list = parameterListControl.getList(updatedId);
1205             if($('input[parameter-id="'+updatedId+'"]').is(':checked')){
1206                 FIELD.PARAMETER.SDN_C_PRELOAD_CHECKED.value=true;
1207                 parameterListControl
1208                     .updateList([ FIELD.PARAMETER.SDN_C_PRELOAD_CHECKED ]);
1209             }else{
1210                 parameterListControl
1211                     .updateList([ FIELD.PARAMETER.SDN_C_PRELOAD_UNCHECKED ]);
1212             }
1213         }else if (updatedId === FIELD.ID.UPLOAD_SUPPLEMENTORY_DATA_FILE) {
1214             if($('input[parameter-id="'+updatedId+'"]').is(':checked')){
1215                 $('input[parameter-id="'+FIELD.ID.SUPPLEMENTORY_DATA_FILE+'"]').closest('tr').show();
1216                 FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_CHECKED.value=true;
1217                 parameterListControl
1218                     .updateList([ FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_CHECKED ]);
1219             }else{
1220                 $('input[parameter-id="'+FIELD.ID.SUPPLEMENTORY_DATA_FILE+'"]').closest('tr').hide();
1221                 FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_CHECKED.value=false;
1222                 parameterListControl
1223                     .updateList([ FIELD.PARAMETER.UPLOAD_SUPPLEMENTORY_DATA_FILE_UNCHECKED ]);
1224             }
1225         } else if (updatedId === FIELD.ID.SUPPLEMENTORY_DATA_FILE) {
1226             var filePath =  $('input[parameter-id="'+updatedId+'"]').val();
1227             var arr =filePath.split('.');
1228             var fileExt  = arr[arr.length-1];
1229             if(fileExt!='' && fileExt.toLowerCase()!='json'){
1230                 $('input[parameter-id="'+updatedId+'"]').val('');
1231                 alert("Invalid file format. Please select *.json format file.");
1232                 return false;
1233             }
1234         } else  if (updatedId === FIELD.ID.LCP_REGION) {
1235             var list = parameterListControl.getList(updatedId);
1236             if (list[0].selectedIndex >= 0) {
1237                 parameterListControl
1238                     .updateList([ getTenantList(list[0].value) ]);
1239             } else {
1240                 parameterListControl
1241                     .updateList([ FIELD.PARAMETER.TENANT_DISABLED ]);
1242             }
1243
1244             var cloudOwnerAndLcpCloudRegion = DataService.getCloudOwnerAndLcpCloudRegionFromOptionId(list[0].value);
1245             if (cloudOwnerAndLcpCloudRegion.cloudRegionId === FIELD.KEY.LCP_REGION_TEXT) {
1246                 parameterListControl
1247                     .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_VISIBLE ]);
1248             } else {
1249                 parameterListControl
1250                     .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN ]);
1251             }
1252         } else if (updatedId === FIELD.ID.SUBSCRIBER_NAME) {
1253             var list = parameterListControl.getList(updatedId);
1254             if (list[0].selectedIndex >= 0) {
1255                 DataService.setGlobalCustomerId(list[0].value);
1256
1257                 AaiService.getSubscriptionServiceTypeList(DataService
1258                     .getGlobalCustomerId(), function(response) {
1259                     DataService.setSubscriptionServiceTypeList(response);
1260                     var serviceTypeParameters = FIELD.PARAMETER.SERVICE_TYPE;
1261                     serviceTypeParameters.optionList = [];
1262
1263                     for (var i = 0; i < response.length; i++) {
1264                         serviceTypeParameters.optionList.push({
1265                             "id" : response[i].name,
1266                             "name" : response[i].name,
1267                             "isPermitted" :response[i].isPermitted
1268
1269                         });
1270                     }
1271                     console.log ( "updateUserParameterList: service type parameters " );
1272                     console.log ( JSON.stringify (serviceTypeParameters, null, 4));
1273                     parameterListControl.updateList([ serviceTypeParameters ]);
1274                 });
1275
1276             }
1277         } else if ( updatedId === FIELD.ID.SERVICE_TYPE ) {
1278             var list = parameterListControl.getList(updatedId);
1279             if (list[0].selectedIndex >= 0) {
1280
1281                 DataService.setServiceType(list[0].value);
1282                 var cloudRegionTenantList = new Array();
1283                 AaiService.getLcpCloudRegionTenantList(DataService.getGlobalCustomerId(), DataService.getServiceType(), function(cloudRegionTenantList) {
1284                     DataService.setCloudRegionTenantList(cloudRegionTenantList);
1285                     parameterListControl.updateList([ getLcpRegionParameter() ]);
1286                 });
1287             } else {
1288                 parameterListControl
1289                     .updateList([ FIELD.PARAMETER.SERVICE_TYPE_DISABLED ]);
1290             }
1291         }
1292
1293     };
1294
1295     return {
1296         initializeComponent : function(componentId) {
1297             _this.componentId = ComponentService.initialize(componentId);
1298         },
1299         setHttpErrorHandler : function(httpErrorHandler) {
1300             _this.httpErrorHandler = httpErrorHandler;
1301         },
1302         getComponentDisplayName : ComponentService.getComponentDisplayName,
1303         getParameters : function(getParametersHandler) {
1304             _this.getParametersHandler = getParametersHandler;
1305             UtilityService.setHttpErrorHandler(_this.httpErrorHandler);
1306             UtilityService.startAsyncOperations(getAsyncOperationList(),
1307                 internalGetParametersHandler);
1308         },
1309         updateUserParameterList : updateUserParameterList,
1310         getMsoRequestDetails : getMsoRequestDetails,
1311         getMsoUrl : getMsoUrl,
1312         setInventoryInfo: setInventoryInfo
1313     };
1314 };
1315
1316 appDS2.factory("CreationService", [ "$log", "AaiService", "AsdcService",
1317     "DataService","VIDCONFIGURATION", "ComponentService", "COMPONENT", "FIELD", "PARAMETER",
1318     "UtilityService", "OwningEntityService","featureFlags", CreationService ]);