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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 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,
  33                 ComponentService, COMPONENT, FIELD, PARAMETER, UtilityService) {
  34
  35         var _this = this;
  36
  37         var getAsyncOperationList = function() {
  38                 switch (_this.componentId) {
  39                 case COMPONENT.SERVICE:
  40                         return [ getSubscribers ];
  41                 case COMPONENT.NETWORK:
  42                         return [];
  43                 case COMPONENT.VNF:
  44                         return [ getLcpCloudRegionTenantList ];
  45                 case COMPONENT.VF_MODULE:
  46                         return [ getLcpCloudRegionTenantList ];
  47                 case COMPONENT.VOLUME_GROUP:
  48                         return [ getLcpCloudRegionTenantList ];
  49                 }
  50         };
  51
  52         /*
  53          * "getSummaryList" and "getUserProvidedList" return parameters that should
  54          * be displayed in the summary and user provided sections, respectively. The
  55          * functions are expected to return lists that are in the format needed by
  56          * the parameter-block directive.
  57          */
  58
  59         var getSummaryList = function() {
  60
  61                 /*
  62                  * These placeholders should be removed and their usage in
  63                  * "getSummaryList" should be replaced by appropriate code as the
  64                  * requirements and interfaces firm up.
  65                  */
  66
  67                 var PLACEHOLDER_RESOURCE_DESCRIPTION = "Resource Description (PLACEHOLDER)";
  68                 var PLACEHOLDER_SERVICE_CATEGORY = "Service Category (PLACEHOLDER)";
  69                 var PLACEHOLDER_VF_MODULE_DESCRIPTION = "VF Module Description (PLACEHOLDER)";
  70                 var PLACEHOLDER_VF_MODULE_LABEL = "VF Module Label (PLACEHOLDER)";
  71                 var PLACEHOLDER_VF_MODULE_TYPE = "VF Module Type (PLACEHOLDER)";
  72
  73                 _this.parameterList = new Array();
  74
  75                 /*
  76                  * Common fields displayed at the top of all create instance screens.
  77                  */
  78                 addToList(FIELD.NAME.SERVICE_NAME, DataService.getServiceName());
  79
  80                 switch (_this.componentId) {
  81                 case COMPONENT.SERVICE:
  82                         addToList(FIELD.NAME.SERVICE_INVARIANT_UUID, DataService
  83                                         .getModelInfo(_this.componentId)["modelInvariantId"]);
  84                         addToList(FIELD.NAME.SERVICE_VERSION, DataService
  85                                         .getModelInfo(_this.componentId)["modelVersion"]);
  86                         addToList(FIELD.NAME.SERVICE_UUID, DataService
  87                                         .getModelInfo(_this.componentId)["modelNameVersionId"]);
  88                         addToList(FIELD.NAME.SERVICE_DESCRIPTION, DataService
  89                                         .getModelInfo(_this.componentId)["description"]);
  90                         addToList(FIELD.NAME.SERVICE_CATEGORY, DataService
  91                                         .getModelInfo(_this.componentId)["category"]);
  92                         break;
  93                 case COMPONENT.VF_MODULE:
  94                         addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
  95                                         .getSubscriberName());
  96                         addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
  97                                         .getServiceInstanceName());
  98                         addToList(FIELD.NAME.MODEL_NAME, DataService
  99                                         .getModelInfo(_this.componentId)["modelName"]);
 100                         addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 101                                         .getModelInfo(_this.componentId)["modelInvariantId"]);
 102                         addToList(FIELD.NAME.MODEL_VERSION, DataService
 103                                         .getModelInfo(_this.componentId)["modelVersion"]);
 104                         addToList(FIELD.NAME.MODEL_UUID, DataService
 105                                         .getModelInfo(_this.componentId)["modelNameVersionId"]);
 106                         break;
 107                 case COMPONENT.NETWORK:
 108                 case COMPONENT.VNF:
 109                 case COMPONENT.VOLUME_GROUP:
 110                         addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 111                                         .getSubscriberName());
 112                         addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
 113                                         .getServiceInstanceName());
 114                         addToList(FIELD.NAME.MODEL_NAME, DataService
 115                                         .getModelInfo(_this.componentId)["modelName"]);
 116                         addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 117                                         .getModelInfo(_this.componentId)["modelInvariantId"]);
 118                         addToList(FIELD.NAME.MODEL_VERSION, DataService
 119                                         .getModelInfo(_this.componentId)["modelVersion"]);
 120                         addToList(FIELD.NAME.MODEL_UUID, DataService
 121                                         .getModelInfo(_this.componentId)["modelNameVersionId"]);
 122                         break;
 123                 }
 124
 125                 return _this.parameterList;
 126         };
 127
 128         var getUserProvidedList = function() {
 129
 130                 var parameterList = [ FIELD.PARAMETER.INSTANCE_NAME ];
 131
 132                 switch (_this.componentId) {
 133                 case COMPONENT.SERVICE:
 134                         parameterList = parameterList.concat([ getSubscribersParameter(),
 135                                         FIELD.PARAMETER.SERVICE_TYPE_DISABLED ]);
 136                         break;
 137                 case COMPONENT.NETWORK:
 138                 case COMPONENT.VNF:
 139                         parameterList = parameterList.concat([ getServiceId(),
 140                                         getLcpRegion(), FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 141                                         FIELD.PARAMETER.TENANT_DISABLED ]);
 142                         break;
 143                 case COMPONENT.VF_MODULE:
 144                         parameterList = parameterList.concat([
 145                                 getLcpRegion(),
 146                                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 147                                         FIELD.PARAMETER.TENANT_DISABLED
 148                         ]);
 149
 150                         var availableVolumeGroupList = DataService.getAvailableVolumeGroupList();
 151
 152                         if (availableVolumeGroupList && availableVolumeGroupList.length > 0) {
 153                                 var availableVolumeGroupNames = ["None"];
 154
 155                                 for (var i = 0; i < availableVolumeGroupList.length; i++) {
 156                                         availableVolumeGroupNames.push(availableVolumeGroupList[i].instance.name);
 157                                 }
 158
 159                                 parameterList.push(addOptionList(
 160                                                 FIELD.PARAMETER.AVAILABLE_VOLUME_GROUP,
 161                                                 availableVolumeGroupNames));
 162                         }
 163                         break;
 164                 case COMPONENT.VOLUME_GROUP:
 165                         parameterList = parameterList.concat([ getLcpRegion(),
 166                                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 167                                         FIELD.PARAMETER.TENANT_DISABLED ]);
 168                 }
 169
 170                 parameterList.push(FIELD.PARAMETER.SUPPRESS_ROLLBACK);
 171
 172                 addArbitraryParameters(parameterList);
 173
 174                 return parameterList;
 175         };
 176
 177         var addArbitraryParameters = function(parameterList) {
 178                 var inputs = DataService.getModelInfo(_this.componentId).inputs;
 179                 if (inputs) {
 180                         for ( var key in inputs) {
 181                                 parameterList.push({
 182                                         id : key,
 183                                         /*
 184                                          * "name" is the display name. The simplest option is to just
 185                                          * display this value (e.g. "name: key"). An alternative used
 186                                          * here is to use "getFieldDisplayName" to display a more "user
 187                                          * friendly" value. See "componentService:getDisplayName" for
 188                                          * mapping details.
 189                                          */
 190                                         name : ComponentService.getFieldDisplayName(key),
 191                                         value : inputs[key]["default"],
 192                                         isRequired : true,
 193                                         /*
 194                                          * If the field needs to be considered required, the attribute
 195                                          * "isRequired: true" can be added here.
 196                                          */
 197                                         description : inputs[key]["description"]
 198                                 });
 199                         }
 200                 }
 201         };
 202
 203         var addToList = function(name, value) {
 204                 _this.parameterList.push({
 205                         name : name,
 206                         value : value
 207                 });
 208         };
 209
 210         /*
 211          * The "*Mso*" functions return URL and request details that can be passed
 212          * to the MSO controller. The request details defines the info passed as
 213          * part of the POST body.
 214          */
 215
 216         var getMsoUrl = function() {
 217                 switch (_this.componentId) {
 218                 case COMPONENT.NETWORK:
 219                         return "mso_create_nw_instance/"
 220                                         + DataService.getServiceInstanceId();
 221                 case COMPONENT.SERVICE:
 222                         return "mso_create_svc_instance";
 223                 case COMPONENT.VNF:
 224                         return "mso_create_vnf_instance/"
 225                                         + DataService.getServiceInstanceId();
 226                 case COMPONENT.VF_MODULE:
 227                         return "mso_create_vfmodule_instance/"
 228                                         + DataService.getServiceInstanceId() + "/vnfs/"
 229                                         + DataService.getVnfInstanceId();
 230                 case COMPONENT.VOLUME_GROUP:
 231                         return "mso_create_volumegroup_instance/"
 232                                         + DataService.getServiceInstanceId() + "/vnfs/"
 233                                         + DataService.getVnfInstanceId();
 234                 }
 235         };
 236
 237         var getMsoRequestDetails = function(parameterList) {
 238                 console.log("getMsoRequestDetails invoked");
 239                 var modelInfo = DataService.getModelInfo(_this.componentId);
 240                 var requestDetails = {
 241                         requestInfo : {
 242                                 instanceName : getValueFromList(FIELD.ID.INSTANCE_NAME,
 243                                                 parameterList),
 244                                 source : "VID",
 245                                 suppressRollback : getValueFromList(FIELD.ID.SUPPRESS_ROLLBACK,
 246                                                 parameterList),
 247                         },
 248                         modelInfo : {
 249                                 modelType : _this.componentId,
 250                                 modelInvariantId : modelInfo.modelInvariantId,
 251                                 modelNameVersionId : modelInfo.modelNameVersionId,
 252                                 modelName : modelInfo.modelName,
 253                                 modelVersion : modelInfo.modelVersion
 254                         },
 255                         requestParameters : {
 256                                 userParams : getArbitraryParameters(parameterList)
 257                         }
 258                 };
 259
 260                 switch (_this.componentId) {
 261                 case COMPONENT.SERVICE:
 262                         requestDetails.subscriberInfo = {
 263                                 globalSubscriberId : DataService.getGlobalCustomerId(),
 264                                 subscriberName : DataService.getSubscriberName()
 265                         };
 266                         requestDetails.requestParameters.subscriptionServiceType = getValueFromList(
 267                                         FIELD.ID.SERVICE_TYPE, parameterList);
 268                         break;
 269                 case COMPONENT.NETWORK:
 270                 case COMPONENT.VNF:
 271                         console.log("getMsoRequestDetails COMPONENT.VNF");
 272                         var lcpRegion = getValueFromList(FIELD.ID.LCP_REGION, parameterList);
 273                         if (lcpRegion === FIELD.KEY.LCP_REGION_TEXT) {
 274                                 lcpRegion = getValueFromList(FIELD.ID.LCP_REGION_TEXT,
 275                                                 parameterList);
 276                         }
 277                         requestDetails.cloudConfiguration = {
 278                                 lcpCloudRegionId : lcpRegion,
 279                                 tenantId : getValueFromList(FIELD.ID.TENANT, parameterList)
 280                         };
 281                         requestDetails.requestInfo.productFamilyId = getValueFromList(
 282                                         FIELD.ID.PRODUCT_FAMILY, parameterList);
 283                         // override model info for VNF since it needs the customization name
 284                         var vnfModelInfo = {
 285                                 modelType : _this.componentId,
 286                                 modelInvariantId : modelInfo.modelInvariantId,
 287                                 modelNameVersionId : modelInfo.modelNameVersionId,
 288                                 modelName : modelInfo.modelName,
 289                                 modelVersion : modelInfo.modelVersion,
 290                                 modelCustomizationName : modelInfo.modelCustomizationName
 291                         };
 292                         requestDetails.modelInfo = vnfModelInfo;
 293                         break;
 294                 case COMPONENT.VF_MODULE:
 295                                 var lcpRegion = getValueFromList(FIELD.ID.LCP_REGION, parameterList);
 296                                 if (lcpRegion === FIELD.KEY.LCP_REGION_TEXT) {
 297                                         lcpRegion = getValueFromList(FIELD.ID.LCP_REGION_TEXT,
 298                                                         parameterList);
 299                                 }
 300                                 requestDetails.cloudConfiguration = {
 301                                                 lcpCloudRegionId : lcpRegion,
 302                                                 tenantId : getValueFromList(FIELD.ID.TENANT, parameterList)
 303                                 };
 304                                 break;
 305                 case COMPONENT.VOLUME_GROUP:
 306                         var lcpRegion = getValueFromList(FIELD.ID.LCP_REGION, parameterList);
 307                         if (lcpRegion === FIELD.KEY.LCP_REGION_TEXT) {
 308                                 lcpRegion = getValueFromList(FIELD.ID.LCP_REGION_TEXT,
 309                                                 parameterList);
 310                         }
 311                         requestDetails.cloudConfiguration = {
 312                                         lcpCloudRegionId : lcpRegion,
 313                                         tenantId : getValueFromList(FIELD.ID.TENANT, parameterList)
 314                         };
 315
 316                         break;
 317                 }
 318
 319                 var relatedInstanceList = getRelatedInstanceList(parameterList);
 320
 321                 if (relatedInstanceList !== undefined) {
 322                         requestDetails.relatedInstanceList = relatedInstanceList;
 323                 }
 324
 325                 return requestDetails;
 326         };
 327
 328         var getRelatedInstanceList = function(parameterList) {
 329                 var relatedInstanceList = new Array();
 330                 switch (_this.componentId) {
 331                 case COMPONENT.SERVICE:
 332                         return undefined;
 333                 case COMPONENT.NETWORK:
 334                 case COMPONENT.VNF:
 335                         addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 336                                         DataService.getServiceInstanceId());
 337                         break;
 338                 case COMPONENT.VF_MODULE:
 339                         addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 340                                         DataService.getServiceInstanceId());
 341                         addRelatedInstance(relatedInstanceList, COMPONENT.VNF, DataService
 342                                         .getVnfInstanceId());
 343
 344                         var availableVolumeGroup = getValueFromList(
 345                                         FIELD.ID.AVAILABLE_VOLUME_GROUP, parameterList);
 346
 347                         if (UtilityService.hasContents(availableVolumeGroup) && availableVolumeGroup !== "None") {
 348                                 var availableVolumeGroups = DataService.getAvailableVolumeGroupList();
 349
 350                                 for (var i = 0; i < availableVolumeGroups.length; i++) {
 351                                         if (availableVolumeGroups[i].instance.name == availableVolumeGroup) {
 352                                                 DataService.setModelInfo(COMPONENT.VOLUME_GROUP, DataService.getModelInfo(COMPONENT.VF_MODULE));
 353                                                 DataService.setVolumeGroupInstanceId(availableVolumeGroups[i].instance.object["volume-group-id"]);
 354                                                 break;
 355                                         }
 356                                 }
 357
 358                                 addRelatedInstance(relatedInstanceList, COMPONENT.VOLUME_GROUP,
 359                                                 DataService.getVolumeGroupInstanceId());
 360                         }
 361                         break;
 362                 case COMPONENT.VOLUME_GROUP:
 363                         addRelatedInstance(relatedInstanceList, COMPONENT.SERVICE,
 364                                         DataService.getServiceInstanceId());
 365                         addRelatedInstance(relatedInstanceList, COMPONENT.VNF, DataService
 366                                         .getVnfInstanceId());
 367                         break;
 368                 }
 369
 370                 return relatedInstanceList;
 371         };
 372
 373         var addRelatedInstance = function(relatedInstanceList, componentId,
 374                         instanceId) {
 375                 var modelInfo = DataService.getModelInfo(componentId);
 376                 var relatedInstance;
 377                 if (modelInfo !== undefined) {
 378                         if (componentId === COMPONENT.VNF) {
 379                                 relatedInstance = {
 380                                         "instanceId" : instanceId,
 381                                         "modelInfo" : {
 382                                                 "modelType" : componentId,
 383                                                 "modelName" : modelInfo.modelName,
 384                                                 "modelInvariantId" : modelInfo.modelInvariantId,
 385                                                 "modelVersion" : modelInfo.modelVersion,
 386                                                 "modelNameVersionId" : modelInfo.modelNameVersionId,
 387                                                 "modelCustomizationName" : modelInfo.modelCustomizationName
 388                                         }
 389                                 };
 390                         } else {
 391                                 relatedInstance = {
 392                                         "instanceId" : instanceId,
 393                                         "modelInfo" : {
 394                                                 "modelType" : componentId,
 395                                                 "modelName" : modelInfo.modelName,
 396                                                 "modelInvariantId" : modelInfo.modelInvariantId,
 397                                                 "modelVersion" : modelInfo.modelVersion,
 398                                                 "modelNameVersionId" : modelInfo.modelNameVersionId
 399                                         }
 400                                 };
 401                         }
 402                         relatedInstanceList.push({
 403                                 relatedInstance : relatedInstance
 404                         });
 405                 }
 406         };
 407
 408         /*
 409          * var getArbitraryParameters = function(parameterList) { var
 410          * arbitraryParameters = new Object(); for (var i = 0; i <
 411          * parameterList.length; i++) { var parameter = parameterList[i]; switch
 412          * (parameter.id) { case FIELD.ID.INSTANCE_NAME: case
 413          * FIELD.ID.PRODUCT_FAMILY: case FIELD.ID.LCP_REGION: case
 414          * FIELD.ID.LCP_REGION_TEXT: case FIELD.ID.SERVICE_TYPE: case
 415          * FIELD.ID.TENANT: case FIELD.ID.SUPPRESS_ROLLBACK: break; default:
 416          * arbitraryParameters[parameter.id] = parameter.value; } } return
 417          * arbitraryParameters; }
 418          */
 419         var getArbitraryParameters = function(parameterList) {
 420                 var arbitraryParameters = new Object();
 421                 var arbitraryArray = new Array();
 422                 for (var i = 0; i < parameterList.length; i++) {
 423                         var parameter = parameterList[i];
 424                         switch (parameter.id) {
 425                         case FIELD.ID.AVAILABLE_VOLUME_GROUP:
 426                                 break;
 427                         case FIELD.ID.INSTANCE_NAME:
 428                                 break;
 429                         case FIELD.ID.PRODUCT_FAMILY:
 430                                 break;
 431                         case FIELD.ID.LCP_REGION:
 432                                 break;
 433                         case FIELD.ID.LCP_REGION_TEXT:
 434                                 break;
 435                         case FIELD.ID.SERVICE_TYPE:
 436                                 break;
 437                         case FIELD.ID.TENANT:
 438                                 break;
 439                         case FIELD.ID.SUPPRESS_ROLLBACK:
 440                                 break;
 441                         case FIELD.ID.SUBSCRIBER_NAME:
 442                                 break;
 443                         default:
 444                                 arbitraryParameters = {
 445                                         name : parameter.id,
 446                                         value : parameter.value
 447                                 }
 448                                 arbitraryArray.push(arbitraryParameters);
 449                         }
 450                 }
 451                 return (arbitraryArray);
 452         }
 453
 454         var getModel = function() {
 455                 AsdcService.getModel(DataService.getModelId(), function(response) {
 456                         DataService.setModelInfo(_this.componentId, {
 457                                 modelInvariantId : response.data.invariantUUID,
 458                                 modelNameVersionId : response.data.uuid,
 459                                 modelName : response.data.name,
 460                                 modelVersion : response.data.version,
 461                                 inputs : response.data.inputs
 462                         });
 463                         UtilityService.startNextAsyncOperation();
 464                 });
 465         };
 466
 467         var getSubscriptionServiceTypeList = function() {
 468                 AaiService.getSubscriptionServiceTypeList(DataService
 469                                 .getGlobalCustomerId(), function(response) {
 470                         DataService.setSubscriptionServiceTypeList(response);
 471                         UtilityService.startNextAsyncOperation();
 472                 });
 473         };
 474
 475         var getSubscribers = function() {
 476                 AaiService.getSubscribers(function(response) {
 477                         DataService.setSubscribers(response);
 478                         UtilityService.startNextAsyncOperation();
 479                 });
 480         };
 481
 482         var getLcpCloudRegionTenantList = function() {
 483                 AaiService.getLcpCloudRegionTenantList(DataService
 484                                 .getGlobalCustomerId(), DataService.getServiceType(), function(
 485                                 response) {
 486                         DataService.setCloudRegionTenantList(response);
 487                         UtilityService.startNextAsyncOperation();
 488                 });
 489         };
 490
 491         var internalGetParametersHandler = function() {
 492                 if (angular.isFunction(_this.getParametersHandler)) {
 493                         _this.getParametersHandler({
 494                                 summaryList : getSummaryList(),
 495                                 userProvidedList : getUserProvidedList()
 496                         });
 497                 }
 498         };
 499
 500         var getSubscribersParameter = function() {
 501                 var subscribers = DataService.getSubscribers();
 502                 var parameter = FIELD.PARAMETER.SUBSCRIBER_NAME;
 503                 parameter.optionList = [];
 504
 505                 for (var i = 0; i < subscribers.length; i++) {
 506                         parameter.optionList.push({
 507                                 id : subscribers[i]["global-customer-id"],
 508                                 name : subscribers[i]["subscriber-name"]
 509                         })
 510                 }
 511                 return parameter;
 512         };
 513
 514         var getServiceId = function() {
 515                 var serviceIdList = DataService.getServiceIdList();
 516                 var serviceTypeList = DataService.getSubscriptionServiceTypeList();
 517                 var parameter = FIELD.PARAMETER.PRODUCT_FAMILY;
 518                 parameter.optionList = new Array();
 519
 520                 if (serviceTypeList == null) {
 521                         getSubscriptionServiceTypeList();
 522                         serviceTypeList = DataService.getSubscriptionServiceTypeList();
 523                 }
 524                 var went = 0;
 525                 for (var i = 0; i < serviceIdList.length; i++) {
 526                         var go = 0;
 527                         var name = serviceIdList[i].id;
 528
 529                         if (serviceTypeList != null) {
 530                                 console.log("STL: " + serviceTypeList);
 531                                 for (var k = 0; k < serviceTypeList.length; k++) {
 532                                         if (angular.equals(name,serviceTypeList[k])) {
 533                                                 go = 1;
 534                                                 went = 1;
 535                                         }
 536                                 }
 537                         } else {
 538                                 go = 1;
 539                                 went = 1;
 540                         }
 541                         if (go == 1) {
 542                                 parameter.optionList.push({
 543                                         id : serviceIdList[i].id,
 544                                         name : serviceIdList[i].description
 545                                 });
 546                         }
 547                 }  // load them all, ours wasn't in the list
 548                 if (went == 0) {
 549                         for (var i = 0; i < serviceIdList.length; i++) {
 550                                         parameter.optionList.push({
 551                                                 id : serviceIdList[i].id,
 552                                                 name : serviceIdList[i].description
 553                                         });
 554                         }
 555                 }
 556                 return parameter;
 557         };
 558
 559         var getLcpRegion = function() {
 560                 var cloudRegionTenantList = DataService.getCloudRegionTenantList();
 561                 var parameter = FIELD.PARAMETER.LCP_REGION;
 562                 parameter.optionList = new Array();
 563                 for (var i = 0; i < cloudRegionTenantList.length; i++) {
 564                         for (var j = 0; j < parameter.optionList.length; j++) {
 565                                 if (parameter.optionList[j].id === cloudRegionTenantList[i].cloudRegionId) {
 566                                         break;
 567                                 }
 568                         }
 569                         if (j < parameter.optionList.length) {
 570                                 continue;
 571                         }
 572                         parameter.optionList.push({
 573                                 id : cloudRegionTenantList[i].cloudRegionId
 574                         });
 575                 }
 576                 return parameter;
 577         };
 578
 579         var getTenantList = function(cloudRegionId) {
 580                 var cloudRegionTenantList = DataService.getCloudRegionTenantList();
 581                 var parameter = FIELD.PARAMETER.TENANT_ENABLED;
 582                 parameter.optionList = new Array();
 583                 for (var i = 0; i < cloudRegionTenantList.length; i++) {
 584                         if (cloudRegionTenantList[i].cloudRegionId === cloudRegionId) {
 585                                 parameter.optionList.push({
 586                                         id : cloudRegionTenantList[i].tenantId,
 587                                         name : cloudRegionTenantList[i].tenantName
 588                                 });
 589                         }
 590                 }
 591                 return parameter;
 592
 593         };
 594
 595         var addOptionList = function(parameter, optionSimpleArray) {
 596                 var optionList = new Array();
 597                 if (!angular.isArray(optionSimpleArray)) {
 598                         return optionList;
 599                 }
 600                 for (var i = 0; i < optionSimpleArray.length; i++) {
 601                         optionList.push({
 602                                 name : optionSimpleArray[i]
 603                         });
 604                 }
 605                 parameter.optionList = optionList;
 606                 return parameter;
 607         };
 608
 609         var getValueFromList = function(id, parameterList) {
 610                 for (var i = 0; i < parameterList.length; i++) {
 611                         if (parameterList[i].id === id) {
 612                                 return parameterList[i].value;
 613                         }
 614                 }
 615         };
 616
 617         var updateUserParameterList = function(updatedId, parameterListControl) {
 618                 if (updatedId === FIELD.ID.LCP_REGION) {
 619                         var list = parameterListControl.getList(updatedId);
 620                         if (list[0].selectedIndex >= 0) {
 621                                 parameterListControl
 622                                                 .updateList([ getTenantList(list[0].value) ]);
 623                         } else {
 624                                 parameterListControl
 625                                                 .updateList([ FIELD.PARAMETER.TENANT_DISABLED ]);
 626                         }
 627                         if (list[0].value === FIELD.KEY.LCP_REGION_TEXT) {
 628                                 parameterListControl
 629                                                 .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_VISIBLE ]);
 630                         } else {
 631                                 parameterListControl
 632                                                 .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN ]);
 633                         }
 634                 } else if (updatedId === FIELD.ID.SUBSCRIBER_NAME) {
 635                         var list = parameterListControl.getList(updatedId);
 636                         if (list[0].selectedIndex >= 0) {
 637                                 DataService.setGlobalCustomerId(list[0].value);
 638
 639                                 AaiService.getSubscriptionServiceTypeList(DataService
 640                                                 .getGlobalCustomerId(), function(response) {
 641                                         DataService.setSubscriptionServiceTypeList(response);
 642                                         var serviceTypeParameters = FIELD.PARAMETER.SERVICE_TYPE;
 643                                         serviceTypeParameters.optionList = [];
 644
 645                                         for (var i = 0; i < response.length; i++) {
 646                                                 serviceTypeParameters.optionList.push({
 647                                                         "id" : response[i],
 648                                                         "name" : response[i]
 649                                                 });
 650                                         }
 651                                         parameterListControl.updateList([ serviceTypeParameters ]);
 652                                 });
 653
 654                         } else {
 655                                 parameterListControl
 656                                                 .updateList([ FIELD.PARAMETER.SERVICE_TYPE_DISABLED ]);
 657                         }
 658                 }
 659         };
 660
 661         return {
 662                 initializeComponent : function(componentId) {
 663                         _this.componentId = ComponentService.initialize(componentId);
 664                 },
 665                 setHttpErrorHandler : function(httpErrorHandler) {
 666                         _this.httpErrorHandler = httpErrorHandler;
 667                 },
 668                 getComponentDisplayName : ComponentService.getComponentDisplayName,
 669                 getParameters : function(getParametersHandler) {
 670                         _this.getParametersHandler = getParametersHandler;
 671                         UtilityService.setHttpErrorHandler(_this.httpErrorHandler);
 672                         UtilityService.startAsyncOperations(getAsyncOperationList(),
 673                                         internalGetParametersHandler);
 674                 },
 675                 updateUserParameterList : updateUserParameterList,
 676                 getMsoRequestDetails : getMsoRequestDetails,
 677                 getMsoUrl : getMsoUrl
 678         }
 679 }
 680
 681 app.factory("CreationService", [ "$log", "AaiService", "AsdcService",
 682                 "DataService", "ComponentService", "COMPONENT", "FIELD", "PARAMETER",
 683                 "UtilityService", CreationService ]);