vid-app-common/src/main/webapp/app/vid/scripts/modals/new-change-management/new-change-management.controller.js

   1 (function () {
   2     'use strict';
   3
   4     appDS2.controller("newChangeManagementModalController", ["$uibModalInstance", "$uibModal",'$q', "AaiService", "changeManagementService", "Upload",
   5         "$log", "$scope", "_", "COMPONENT", "VIDCONFIGURATION", newChangeManagementModalController]);
   6
   7     function newChangeManagementModalController($uibModalInstance, $uibModal,$q, AaiService, changeManagementService, Upload, $log, $scope, _, COMPONENT, VIDCONFIGURATION) {
   8
   9         var vm = this;
  10         vm.hasScheduler = !!VIDCONFIGURATION.SCHEDULER_PORTAL_URL;
  11         vm.configUpdatePatternError = "Invalid file type. Please select a file with a CSV extension.";
  12         vm.configUpdateContentError = "Invalid file structure.";
  13         vm.controllers = VIDCONFIGURATION.SCALE_OUT_CONTROLLERS;
  14         vm.wizardStep = 1;
  15         vm.nextStep = function(){
  16             vm.wizardStep++;
  17             $(".modal-dialog").animate({"width":"1200px"},400,'linear');
  18         };
  19         vm.prevStep = function(){
  20             vm.wizardStep--;
  21             $(".modal-dialog").animate({"width":"600px"},400,'linear');
  22         };
  23
  24         vm.softwareVersionRegex = "[-a-zA-Z0-9\.]+";
  25
  26         var init = function () {
  27             vm.changeManagement = {};
  28
  29             loadServicesCatalog();
  30             registerVNFNamesWatcher();
  31             vm.loadSubscribers();
  32         };
  33
  34         var loadServicesCatalog = function () {
  35             changeManagementService.getAllSDCServices()
  36                 .then(function (response) {
  37                     vm.SDCServicesCatalog = response.data;
  38                 })
  39                 .catch(function (error) {
  40                     $log.error(error);
  41                 })
  42         };
  43
  44         var registerVNFNamesWatcher = function () {
  45             $scope.$watch('vm.changeManagement.vnfNames', function (newVal, oldVal) {
  46                 if (!oldVal || newVal && newVal.length > oldVal.length) { //JUST THE LAST ONE ADDED
  47                     var newVNFName = _.last(vm.changeManagement.vnfNames);
  48                     if (oldVal) {
  49                         vm.changeManagement.vnfNames = oldVal;
  50                         vm.changeManagement.vnfNames.push(newVNFName);
  51                     }
  52                     if (newVNFName && newVNFName["service-instance-node"]) {
  53                         var availableVersions = [];
  54                         var services = _.filter(vm.SDCServicesCatalog.services,
  55                             {"invariantUUID": newVNFName["service-instance-node"][0].properties["model-invariant-id"]});
  56
  57                         _.each(services, function (service) {
  58                             changeManagementService.getSDCService(service.uuid)
  59                                 .then(function (response) {
  60                                     _.each(response.data.vnfs, function (vnf) {
  61                                         if (newVNFName["invariant-id"] === vnf.invariantUuid) {
  62                                             availableVersions.push(extractVNFModel(vnf, response.data.service, newVNFName));
  63
  64                                             //for scale out screen
  65                                             if(service.uuid === newVNFName["service-instance-node"][0].properties["model-version-id"]) {
  66                                                 newVNFName.vfModules = vnf.vfModules;
  67                                                 newVNFName.category = response.data.service.category;
  68                                                 newVNFName.groupModules = _.groupBy(newVNFName.vfModules, "customizationUuid");
  69
  70                                                 //list vfmodules ids in AAI that belong to that vnf instance
  71                                                 var modulesAaiIds = _.filter(newVNFName.relatedTo, function(item){
  72                                                                         return item["node-type"] === "vf-module";
  73                                                                     }).map(function(item){
  74                                                                         return item.id;
  75                                                                     });
  76
  77                                                 _.forEach(newVNFName.vfModules, function (mdl, key) {
  78                                                     mdl.scale = false; //defaults to not scale unless user changes it
  79                                                     if(mdl.properties && mdl.properties.max_vf_module_instances) {
  80
  81                                                         //how many vf modules of the same customizationId belong to that vnf instance
  82                                                         mdl.currentCount = _.filter(vm.vfModules, function(item){
  83                                                             return modulesAaiIds.indexOf(item.id) > -1 && item.properties["model-customization-id"] === mdl.customizationUuid;
  84                                                         }).length;
  85
  86                                                         mdl.scalable = mdl.properties.max_vf_module_instances.value - mdl.currentCount > 0;
  87                                                     }else{
  88                                                         mdl.scalable = false;
  89                                                     }
  90                                                 });
  91                                             }
  92                                         }
  93                                     });
  94                                     var versions = _.uniqBy(availableVersions, 'modelInfo.modelVersion');
  95                                     newVNFName.availableVersions = _.sortBy(_.uniq(versions, response.data.service, true),"modelInfo.modelVersion");
  96                                 }).catch(function (error) {
  97                                 $log.error(error);
  98                             });
  99                         });
 100                     }
 101                 }
 102             }, true);
 103         };
 104
 105         var extractVNFModel = function (csarVNF, sdcService, selectionVNF) {
 106             var versionCsarData = {
 107                 vnfInstanceId: "",
 108                 vnfName: csarVNF.name,
 109                 modelInfo: {
 110                     modelType: "vnf",
 111                     modelInvariantId: csarVNF.invariantUuid,
 112                     modelVersionId: selectionVNF.modelVersionId,
 113                     modelName: csarVNF.name,
 114                     modelVersion: csarVNF.version,
 115                     modelCustomizationName: csarVNF.modelCustomizationName,
 116                     modelCustomizationId: csarVNF.customizationUuid
 117                 },
 118                 cloudConfiguration: {
 119                     lcpCloudRegionId: "mdt1",
 120                     tenantId: "88a6ca3ee0394ade9403f075db23167e"
 121                 },
 122                 requestInfo: {
 123                     source: "VID",
 124                     suppressRollback: false,
 125                     requestorId: "az2016"
 126                 },
 127                 relatedInstanceList: [
 128                     {
 129                         relatedInstance: {
 130                             instanceId: selectionVNF["service-instance-node"]["0"].properties['service-instance-id'],
 131                             modelInfo: {
 132                                 modelType: "service",
 133                                 modelInvariantId: selectionVNF["service-instance-node"]["0"].properties['model-invariant-id'],
 134                                 modelVersionId: selectionVNF.modelVersionId,
 135                                 modelName: sdcService.name,
 136                                 modelVersion: sdcService.version,
 137                                 modelCustomizationName: selectionVNF["service-instance-node"]["0"].properties['model-customization-name'], //TODO: Missing
 138                                 modelCustomizationId: selectionVNF["service-instance-node"]["0"].properties['model-customization-id']
 139                             }
 140                         }
 141                     }
 142                 ],
 143                 requestParameters: {
 144                     usePreload: true
 145                 }
 146             };
 147
 148             return versionCsarData;
 149         };
 150
 151         vm.close = function () {
 152             $uibModalInstance.close();
 153         };
 154
 155         vm.uploadConfigFile = function (file) {
 156             var defer = $q.defer();
 157             Upload.upload({
 158                 url: "change-management/uploadConfigUpdateFile",
 159                 file: file,
 160                 transformResponse: [function (data) {
 161                     return data;
 162                 }]
 163             })
 164             .then(function (configUpdateResponse) {
 165                 vm.changeManagement.configUpdateFile = configUpdateResponse && JSON.parse(configUpdateResponse.data).payload;
 166                 defer.resolve(true);
 167             })
 168             .catch(function (error) {
 169                 defer.resolve(false);
 170             });
 171             return defer.promise;
 172         };
 173
 174
 175                 /***converting objects to scheduler format (taken from IST) - was altered for Scale out support ***/
 176                 function extractChangeManagementCallbackDataStr(changeManagement) {
 177                         console.log(changeManagement);
 178                         var result = {};
 179                         result.requestType = changeManagement.workflow;
 180                         var workflowType = changeManagement.workflow;
 181                         result.requestDetails = [];
 182                         _.forEach(changeManagement.vnfNames, function (vnf) {
 183
 184                                 try{
 185                                 var requestInfoData ={};
 186                                 var requestParametersData ={};
 187                 var moduleToScale = _.find(vnf.vfModules, function(key, item){
 188                     return !item.scale;
 189                 });
 190                                 if (vnf.availableVersions && vnf.availableVersions.length!=0){
 191
 192                                         requestInfoData ={
 193                                                 source: vnf.availableVersions[0].requestInfo.source,
 194                                                 suppressRollback: vnf.availableVersions[0].requestInfo.suppressRollback,
 195                                                 requestorId: vnf.availableVersions[0].requestInfo.requestorId
 196                                         }
 197
 198                                         if(workflowType=='Update'){
 199                                                 requestParametersData = {
 200                                                         usePreload: vnf.availableVersions[0].requestParameters.usePreload
 201                                                 }
 202                                         }else if(workflowType=="Replace"){
 203                                                 requestParametersData = {
 204                                                         rebuildVolumeGroups: vnf.availableVersions[0].requestParameters.usePreload
 205                                                 }
 206                                         }else if(workflowType=="VNF In Place Software Update"){
 207                                                 var payloadObj = {
 208                                                         'existing_software_version':changeManagement.existingSoftwareVersion,
 209                                                         'new_software_version':changeManagement.newSoftwareVersion,
 210                                                         'operations_timeout':changeManagement.operationTimeout
 211                                                 };
 212                                                 requestParametersData = {
 213                             controllerType: changeManagement.controllerType,
 214                             payload: JSON.stringify(payloadObj)
 215                                                 }
 216                                         }else if(workflowType=="VNF Config Update"){
 217                                                 requestParametersData = {
 218                                                         payload: changeManagement.configUpdateFile
 219                                                 }
 220                     }else if(workflowType=="VNF Scale Out"){
 221                         if(!moduleToScale) return null;
 222
 223                         if(moduleToScale.userParams) {
 224                             requestParametersData = {
 225                                 controllerType: changeManagement.controllerType,
 226                                 userParams: moduleToScale.userParams
 227                                 //,usePreload: true
 228                             }
 229                         }else{
 230                             requestParametersData = {
 231                                 controllerType: changeManagement.controllerType,
 232                                 userParams: []
 233                                 //,usePreload: false
 234                             }
 235                         }
 236                     }
 237                                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: workflowType '+ workflowType);
 238                                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: requestParametersData '+ requestParametersData);
 239
 240                                 }else if(workflowType=="VNF In Place Software Update"){
 241                                         var payloadObj = {
 242                                                 'existing_software_version':changeManagement.existingSoftwareVersion,
 243                                                 'new_software_version':changeManagement.newSoftwareVersion,
 244                                                 'operations_timeout':changeManagement.operationTimeout
 245                                         };
 246                                         requestParametersData = {
 247                                                 payload: JSON.stringify(payloadObj)
 248                                         }
 249                                 }else if(workflowType=="VNF Config Update"){
 250                                         requestParametersData = {
 251                                                 payload: changeManagement.configUpdateFile
 252                                         }
 253                                 }
 254
 255
 256                                 var data;
 257                                 if(workflowType=="VNF Scale Out") {
 258                     data = {
 259                         modelInfo: {
 260                             modelType: 'vfModule',
 261                             modelInvariantId: moduleToScale.invariantUuid,
 262                             modelName: moduleToScale.modelCustomizationName,
 263                             modelVersion: moduleToScale.version,
 264                             modelVersionId: moduleToScale.uuid
 265                         },
 266                         cloudConfiguration: vnf.cloudConfiguration,
 267                         requestInfo: requestInfoData,
 268                         relatedInstanceList: [],
 269                         requestParameters:requestParametersData
 270                     };
 271                     requestInfoData.instanceName = vnf.name + "_" + (moduleToScale.currentCount + 1);
 272                 }else{
 273                     data = {
 274                         vnfName: vnf.name,
 275                         vnfInstanceId: vnf.id,
 276                         modelInfo: {
 277                             modelType: 'vnf',
 278                             modelInvariantId: vnf.properties['model-invariant-id'],
 279                             modelVersionId: vnf.modelVersionId,
 280                             modelName: vnf.properties['vnf-name'],
 281                             modelVersion: vnf.version,
 282                             modelCustomizationName: vnf.properties['model-customization-name'],
 283                             modelCustomizationId: vnf.properties['model-customization-id']
 284                         },
 285                         cloudConfiguration: vnf.cloudConfiguration,
 286                         requestInfo: requestInfoData,
 287                         relatedInstanceList: [],
 288                         requestParameters:requestParametersData
 289                     };
 290                 }
 291
 292                                 var serviceInstanceId = '';
 293                                 _.forEach(vnf['service-instance-node'], function (instanceNode) {
 294                                         if(instanceNode['node-type'] === 'service-instance'){
 295                                                 serviceInstanceId = instanceNode.properties['service-instance-id'];
 296                                         }
 297                                 });
 298
 299                                 if (vnf.availableVersions && vnf.availableVersions.length!=0){
 300                                         _.forEach(vnf.availableVersions[0].relatedInstanceList, function (related) {
 301                                                 var rel = related.relatedInstance;
 302                                                 var relatedInstance = {
 303                                                         instanceId: serviceInstanceId,
 304                                                         modelInfo: {
 305                                                                 modelType: rel.modelInfo.modelType,
 306                                                                 modelInvariantId: rel.modelInfo.modelInvariantId,
 307                                                                 modelVersionId: rel.modelInfo.modelVersionId,
 308                                                                 modelName: rel.modelInfo.modelName,
 309                                                                 modelVersion: rel.modelInfo.modelVersion,
 310                                                                 modelCustomizationName: rel.modelInfo.modelCustomizationName,
 311                                                                 modelCustomizationId: rel.modelInfo.modelCustomizationId
 312                                                         }
 313                                                 };
 314                                                 if (rel.vnfInstanceId)
 315                                                         relatedInstance.instanceId = rel.vnfInstanceId;
 316
 317                                                 data.relatedInstanceList.push({relatedInstance: relatedInstance});
 318                                         });
 319                     if(workflowType=="VNF Scale Out") {
 320                         //push vnf to related as well as the service instance
 321                         var relatedInstance = {
 322                             instanceId: vnf.id,
 323                             modelInfo: {
 324                                 modelCustomizationName: vnf.availableVersions[0].modelInfo.modelCustomizationName,
 325                                 modelInvariantId: vnf.availableVersions[0].modelInfo.modelInvariantId,
 326                                 modelName: vnf.availableVersions[0].modelInfo.modelName,
 327                                 modelType: vnf.availableVersions[0].modelInfo.modelType,
 328                                 modelVersion: vnf.availableVersions[0].modelInfo.modelVersion,
 329                                 modelVersionId: vnf.availableVersions[0].modelInfo.modelVersionId
 330                             }
 331                         };
 332                         data.relatedInstanceList.push({relatedInstance: relatedInstance});
 333                     }
 334                 }
 335                                 }catch(err){
 336                                         $log.error('SchedulerCtrl::extractChangeManagementCallbackDataStr error: ' + err);
 337                                 }
 338
 339                                 result.requestDetails.push(data);
 340                         });
 341                         return JSON.stringify(result);
 342                 }
 343
 344         vm.openModal = function () {
 345             if(vm.hasScheduler) { //scheduling supported
 346                                 $scope.widgetParameter = ""; // needed by the scheduler?
 347
 348                                 // properties needed by the scheduler so it knows whether to show
 349                                 // policy or sniro related features on the scheduler UI or not.
 350                                 vm.changeManagement.policyYN = "Y";
 351                                 vm.changeManagement.sniroYN = "Y";
 352
 353                                 var data = {
 354                                         widgetName: 'Portal-Common-Scheduler',
 355                                         widgetData: vm.changeManagement,
 356                                         widgetParameter: $scope.widgetParameter
 357                                 };
 358
 359                                 window.parent.postMessage(data, VIDCONFIGURATION.SCHEDULER_PORTAL_URL);
 360                         } else {
 361                                 //no scheduling support
 362                                 var dataToSo = extractChangeManagementCallbackDataStr(vm.changeManagement);
 363                 if(dataToSo) {
 364
 365                     if(vm.changeManagement.workflow==="VNF Scale Out") {
 366                         dataToSo = JSON.parse(dataToSo);
 367                         dataToSo = {requestDetails: dataToSo.requestDetails[0]};
 368                         changeManagementService.postChangeManagementScaleOutNow(dataToSo, vm.changeManagement.vnfNames[0]["service-instance-node"][0].properties["service-instance-id"], vm.changeManagement.vnfNames[0].id);
 369                     }else{
 370                         //TODO: foreach
 371                         var vnfName = vm.changeManagement.vnfNames[0].name;
 372                         changeManagementService.postChangeManagementNow(dataToSo, vnfName);
 373                     }
 374                 }
 375                         }
 376         };
 377
 378         vm.loadSubscribers = function () {
 379             vm.subscribers = [];
 380             AaiService.getSubscribers(function (response) {
 381                 vm.subscribers = response;
 382             });
 383         };
 384
 385         vm.loadServiceTypes = function () {
 386             vm.serviceTypes = [];
 387
 388             AaiService.getSubscriberServiceTypes(vm.changeManagement.subscriberId)
 389                 .then(function (response) {
 390                     vm.serviceTypes = response.data;
 391                 })
 392                 .catch(function (error) {
 393                     $log.error(error);
 394                 });
 395         };
 396
 397         vm.loadVNFTypes = function () {
 398             vm.vnfTypes = [];
 399             vm.vnfTypesTemp = [];
 400             vm.serviceInstances = [];
 401
 402             var instances = vm.changeManagement.serviceType["service-instances"]["service-instance"];
 403             // var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
 404
 405             vm.vnfs = [];
 406             vm.vfModules = [];
 407
 408             AaiService.getVnfsByCustomerIdAndServiceType(
 409                 vm.changeManagement.subscriberId,
 410                 vm.changeManagement.serviceType["service-type"]
 411             ).then(function (response) {
 412                     var vnfsData = response.data.results;
 413                     if (vnfsData) {
 414                         for (var i = 0; i < vnfsData.length; i++) {
 415                             if (vnfsData[i]) {
 416                                 const nodeType = vnfsData[i]['node-type'];
 417                                 if (nodeType === "generic-vnf") {
 418                                     if (_.find(vnfsData[i]['related-to'], function (node) {
 419                                             return node['node-type'] === 'vserver'
 420                                         }) !== undefined) {
 421                                         vm.vnfs.push(vnfsData[i]);
 422                                     }
 423                                 } else if (nodeType === "service-instance") {
 424                                     vm.serviceInstances.push(vnfsData[i]);
 425                                 } else if (nodeType === "vf-module") {
 426                                     vm.vfModules.push(vnfsData[i]);
 427                                 }
 428                             }
 429                         }
 430
 431                         vm.vnfs = _.flattenDeep(
 432                             _.remove(vm.vnfs, function (vnf) {
 433                                 var nfRole = vnf.properties['nf-role'];
 434                                 if (nfRole !== undefined) {
 435                                     return nfRole !== 'null' && nfRole !== '';
 436                                 }
 437                             })
 438                         );
 439
 440                         var filteredVnfs = _.uniqBy(vm.vnfs, function (vnf) {
 441                             return vnf.properties['nf-role'];
 442                         });
 443
 444                         _.forEach(filteredVnfs, function (vnf) {
 445                             vm.vnfTypes.push(vnf.properties['nf-role'])
 446                         });
 447                     }
 448                 }
 449             );
 450         };
 451
 452         var fromVNFVersions = [];
 453
 454         vm.loadVNFVersions = function () {
 455             fromVNFVersions = [];
 456             vm.serviceInstancesToGetVersions = [];
 457             var versions = [];
 458             _.forEach(vm.vnfs, function (vnf) {
 459                 if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']) {
 460
 461                     vm.serviceInstancesToGetVersions.push({
 462                         "model-invariant-id": vnf.properties["model-invariant-id"],
 463                         "model-version-id": vnf.properties["model-version-id"] }
 464                     );
 465
 466                     versions.push(vnf.properties["model-invariant-id"]);
 467                 }
 468             });
 469
 470             if (versions.length > 0) {
 471                 AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
 472                     if (response.data) {
 473
 474                         $log.debug("getVnfVersionsByInvariantId: response", response);
 475
 476                         fromVNFVersions = vm.serviceInstancesToGetVersions
 477                             .map(function (serviceInstanceToGetVersion) {
 478                                 const model = _.find(response.data.model, {'model-invariant-id': serviceInstanceToGetVersion['model-invariant-id']});
 479                                 $log.debug("getVnfVersionsByInvariantId: model for " + serviceInstanceToGetVersion['model-invariant-id'], model);
 480
 481                                 const modelVer = _.find(model["model-vers"]["model-ver"], {'model-version-id': serviceInstanceToGetVersion['model-version-id']});
 482                                 $log.debug("getVnfVersionsByInvariantId: modelVer for " + serviceInstanceToGetVersion['model-version-id'], modelVer);
 483
 484                                 var modelVersionId = serviceInstanceToGetVersion["model-version-id"];
 485                                 var modelVersion = modelVer["model-version"];
 486
 487                                 return {"key": modelVersionId, "value": modelVersion};
 488                             });
 489
 490                         vm.fromVNFVersions = _.uniqBy(fromVNFVersions, 'value');
 491                     }
 492                 })
 493             }
 494         };
 495
 496
 497         function getVnfs(modelInvariantId) {
 498             return new Promise(function (resolve, reject) {
 499                 AaiService.getVnfVersionsByInvariantId(modelInvariantId)
 500                     .then(function (response) {
 501                         if (response.data.httpCode !== null &&
 502                             response.data.httpCode === 200) {
 503                             var vnfsData = response.data.t.results;
 504                             for (var i = 0; i < vnfsData.length; i++) {
 505                                 if (vnfsData[i]) {
 506                                     if (vnfsData[i].nodeType === "generic-vnf") {
 507                                         resolve(vnfsData[i]);
 508                                     } else if (vnfsData[i].nodeType === "service-instance") {
 509                                         vm.serviceInstances.push(vnfsData[i]);
 510                                     }
 511                                 }
 512                             }
 513                             resolve(null);
 514                         }
 515                         resolve(null);
 516                     })
 517                     .catch(function (error) {
 518                         reject(error);
 519                     });
 520             });
 521         }
 522
 523         var getVersionNameForId = function(versionId) {
 524             var version = _.find(fromVNFVersions, {"key": versionId});
 525             return version.value;
 526         };
 527
 528         vm.loadVNFNames = function () {
 529             vm.vnfNames = [];
 530             const vnfs = vm.changeManagement.fromVNFVersion ? vm.vnfs : [];
 531             _.forEach(vnfs, function (vnf) {
 532
 533                 var selectedVersionNumber = getVersionNameForId(vm.changeManagement.fromVNFVersion);
 534
 535                 if (vnf.properties['nf-role'] === vm.changeManagement.vnfType &&
 536                     selectedVersionNumber === getVersionNameForId(vnf.properties["model-version-id"])) {
 537                     var vServer = {};
 538
 539                     _.forEach(vnf['related-to'], function (node) {
 540                         if (node['node-type'] === 'vserver') {
 541                             vServer = extractLcpRegionIdAndTenantId(node.url);
 542                         }
 543                     });
 544
 545                     var serviceInstancesIds =
 546                         _.filter(vnf['related-to'], {'node-type': 'service-instance'})
 547                             .map(function (serviceInstance) { return serviceInstance.id });
 548
 549                     var serviceInstances = _.filter(vm.serviceInstances, function(serviceInstance) {
 550                         return _.includes(serviceInstancesIds, serviceInstance.id);
 551                     });
 552
 553                     // logging only
 554                     if (serviceInstancesIds.length === 0) {
 555                         $log.error("loadVNFNames: no serviceInstancesIds for vnf", vnf);
 556                     } else {
 557                         $log.debug("loadVNFNames: serviceInstancesIds", serviceInstancesIds);
 558                         $log.debug("loadVNFNames: serviceInstances", serviceInstances);
 559                     }
 560
 561                     vm.vnfNames.push({
 562                         "id": vnf.properties["vnf-id"],
 563                         "name": vnf.properties["vnf-name"],
 564                         "invariant-id": vnf.properties["model-invariant-id"],
 565                         "service-instance-node": serviceInstances,
 566                         "modelVersionId": vnf.properties["model-version-id"],
 567                         "properties": vnf.properties,
 568                         'cloudConfiguration': vServer,
 569                         "relatedTo": vnf['related-to']
 570                     });
 571                 }
 572             });
 573         };
 574
 575         function extractLcpRegionIdAndTenantId(url) {
 576
 577             var cloudConfiguration = {
 578                 lcpCloudRegionId: '',
 579                 tenantId: ''
 580             };
 581
 582             /*
 583              e.g., in both URLs below -
 584                - lcpCloudRegionId == 'rdm5b'
 585                - tenantId == '0675e0709bd7444a9e13eba8b40edb3c'
 586
 587              "url": "https://aai-conexus-e2e.ecomp.cci.att.com:8443/aai/v10/cloud-infrastructure/cloud-regions/cloud-region/att-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 588              "url": "/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/att-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 589              */
 590
 591             var cloudRegionMatch = url.match(/\/cloud-regions\/cloud-region\/[^\/]+\/([^\/]+)/);
 592             var tenantMatch = url.match(/\/tenants\/tenant\/([^\/]+)/);
 593
 594             cloudConfiguration.lcpCloudRegionId = cloudRegionMatch[1];
 595             cloudConfiguration.tenantId = tenantMatch[1];
 596
 597             return cloudConfiguration;
 598         };
 599
 600         vm.loadWorkFlows = function () {
 601             changeManagementService.getWorkflows(vm.changeManagement.vnfNames)
 602                 .then(function(response) {
 603                     vm.workflows = response.data.workflows;
 604                 })
 605                 .catch(function(error) {
 606                     $log.error(error);
 607                 });
 608         };
 609
 610         //Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
 611         $scope.selectFileForVNFName = function (fileInput) {
 612             if (fileInput && fileInput.id) {
 613                 var vnfName = _.filter(vm.changeManagement.vnfNames, {"invariant-id": fileInput.id});
 614                 var file = fileInput.files[0];
 615                 var fileReader = new FileReader();
 616                 fileReader.onload = function (load) {
 617                     try {
 618                         var lines = load.target.result;
 619                         vnfName[0].selectedFile = JSON.parse(lines);
 620                     } catch (error) {
 621                         $log.error(error);
 622                     }
 623                 };
 624                 fileReader.readAsText(file);
 625             }
 626         };
 627
 628         vm.selectVersionForVNFName = function (vnfName) {
 629             console.log("Will add version for selected vnf name: " + vnfName.name);
 630         };
 631
 632         vm.isConfigUpdate = function () {
 633             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfConfigUpdate;
 634         }
 635
 636         vm.isScaleOut = function () {
 637             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfScaleOut;
 638         }
 639
 640         vm.shouldShowVnfInPlaceFields = function () {
 641             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfInPlace;
 642         };
 643
 644         vm.setPreload = function (fileEl) {
 645             var files = fileEl.files;
 646             var file = files[0];
 647             var reader = new FileReader();
 648
 649             reader.onloadend = function(evt) {
 650                 if (evt.target.readyState === FileReader.DONE) {
 651                     $scope.$apply(function () {
 652                         $scope.moduleArr[0].userParams = JSON.parse(evt.target.result);
 653                     });
 654                 }
 655             };
 656
 657             reader.readAsText(file);
 658         };
 659
 660         init();
 661     }
 662 })();