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