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

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