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