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

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