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
  30         var vm = this;
  31         vm.hasScheduler = !!VIDCONFIGURATION.SCHEDULER_PORTAL_URL;
  32         vm.errorMsg='';
  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         $scope.showReportWindow = function() {
  49             const modalWindow = $uibModal.open({
  50                 templateUrl: 'app/vid/scripts/modals/report-modal/report-modal.html',
  51                 controller: 'reportModalController',
  52                 controllerAs: 'vm',
  53                 resolve: {
  54                     errorMsg: function () {
  55                         return vm.errorMsg.message;
  56                     }
  57                 }
  58             });
  59
  60         };
  61
  62         $scope.isShowErrorReport = function() {
  63             return featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_CREATE_ERROR_REPORTS);
  64         };
  65
  66         function fetchAttUid() {
  67             var defer = $q.defer();
  68             if (attuid) {
  69                 defer.resolve(attuid);
  70             } else {
  71                 AaiService.getLoggedInUserID(function (response) {
  72                         attuid = response.data;
  73                         defer.resolve(attuid);
  74                     },
  75                     function (err) {
  76                         defer.reject(err);
  77                         vm.errorMsg = err;
  78                     });
  79             }
  80             return defer.promise;
  81         }
  82
  83         var init = function () {
  84             vm.changeManagement = {};
  85             vm.changeManagement.workflowParameters = new Map();
  86
  87             loadServicesCatalog();
  88             fetchAttUid().then(registerVNFNamesWatcher);
  89             vm.loadSubscribers();
  90         };
  91
  92         var loadServicesCatalog = function () {
  93             changeManagementService.getAllSDCServices()
  94                 .then(function (response) {
  95                     vm.SDCServicesCatalog = response.data;
  96                 })
  97                 .catch(function (error) {
  98                     $log.error(error);
  99                     vm.errorMsg = err;
 100                 })
 101         };
 102
 103         var registerVNFNamesWatcher = function () {
 104             $scope.$watch('vm.changeManagement.vnfNames', function (newVal, oldVal) {
 105                 if (!oldVal || newVal && newVal.length > oldVal.length) { //JUST THE LAST ONE ADDED
 106                     var newVNFName = _.last(vm.changeManagement.vnfNames);
 107                     if (oldVal) {
 108                         vm.changeManagement.vnfNames = oldVal;
 109                         vm.changeManagement.vnfNames.push(newVNFName);
 110                     }
 111                     if (newVNFName && newVNFName["service-instance-node"]) {
 112                         var availableVersions = [];
 113                         var services = _.filter(vm.SDCServicesCatalog.services,
 114                             {"invariantUUID": newVNFName["service-instance-node"][0].properties["model-invariant-id"]});
 115
 116                         _.each(services, function (service) {
 117                             changeManagementService.getSDCService(service.uuid)
 118                                 .then(function (response) {
 119                                     _.each(response.data.vnfs, function (vnf) {
 120                                         if (newVNFName["invariant-id"] === vnf.invariantUuid) {
 121                                             availableVersions.push(extractVNFModel(vnf, response.data.service, newVNFName));
 122
 123                                             //for scale out screen
 124                                             if(service.uuid === newVNFName["service-instance-node"][0].properties["model-version-id"]) {
 125                                                 newVNFName.vfModules = vnf.vfModules;
 126                                                 newVNFName.category = response.data.service.category;
 127                                                 newVNFName.groupModules = _.groupBy(newVNFName.vfModules, "customizationUuid");
 128
 129                                                 //list vfmodules ids in AAI that belong to that vnf instance
 130                                                 var modulesAaiIds = _.filter(newVNFName.relatedTo, function(item){
 131                                                     return item["node-type"] === "vf-module";
 132                                                 }).map(function(item){
 133                                                     return item.id;
 134                                                 });
 135
 136                                                 _.forEach(newVNFName.vfModules, function (mdl, key) {
 137                                                     mdl.scale = false; //defaults to not scale unless user changes it
 138                                                     if(mdl.properties && mdl.properties.maxCountInstances) {
 139
 140                                                         //how many vf modules of the same customizationId belong to that vnf instance
 141                                                         mdl.currentCount = _.filter(vm.vfModules, function(item){
 142                                                             return modulesAaiIds.indexOf(item.id) > -1 && item.properties["model-customization-id"] === mdl.customizationUuid;
 143                                                         }).length;
 144
 145                                                         mdl.scalable = mdl.properties.maxCountInstances - mdl.currentCount > 0;
 146                                                     }else{
 147                                                         mdl.scalable = false;
 148                                                     }
 149                                                 });
 150                                             }
 151                                         }
 152                                     });
 153                                     var versions = _.uniqBy(availableVersions, 'modelInfo.modelVersion');
 154                                     newVNFName.availableVersions = _.sortBy(_.uniq(versions, response.data.service, true),"modelInfo.modelVersion");
 155                                 }).catch(function (error) {
 156                                 $log.error(error);
 157                                 vm.errorMsg = error;
 158                             });
 159                         });
 160                     }
 161                 }
 162             }, true);
 163         };
 164
 165         var extractVNFModel = function (csarVNF, sdcService, selectionVNF) {
 166             /**
 167              @param selectionVNF A vnf *instance* selected in "available VNF" drop-down box
 168              @param csarVNF      A VNF *MODEL* that has an invariantUuid same as selectionVNF (might be
 169              a different version; i.e. selectionVNF.modelVersionId <> csarVNF.uuid)
 170              @param sdcService   The Service *MODEL* which has the related VNF `csarVNF`.
 171              */
 172             var versionCsarData = {
 173                 vnfInstanceId: "",
 174                 vnfName: csarVNF.name,
 175                 modelInfo: {
 176                     modelType: "vnf",
 177                     modelInvariantId: csarVNF.invariantUuid,
 178                     modelVersionId: csarVNF.uuid,
 179                     modelName: csarVNF.name,
 180                     modelVersion: csarVNF.version,
 181                     modelCustomizationName: csarVNF.modelCustomizationName,
 182                     modelCustomizationId: csarVNF.customizationUuid
 183                 },
 184                 cloudConfiguration: selectionVNF.cloudConfiguration || {},
 185                 requestInfo: {
 186                     source: "VID",
 187                     suppressRollback: false,
 188                     requestorId: attuid
 189                 },
 190                 relatedInstanceList: [
 191                     {
 192                         relatedInstance: {
 193                             instanceId: selectionVNF["service-instance-node"]["0"].properties['service-instance-id'],
 194                             modelInfo: {
 195                                 modelType: "service",
 196                                 modelInvariantId: sdcService.invariantUuid,
 197                                 modelVersionId: sdcService.uuid,
 198                                 modelName: sdcService.name,
 199                                 modelVersion: sdcService.version
 200                             }
 201                         }
 202                     }
 203                 ],
 204                 requestParameters: {
 205                     usePreload: true
 206                 }
 207             };
 208
 209             return versionCsarData;
 210         };
 211
 212         vm.close = function () {
 213             $uibModalInstance.close();
 214         };
 215
 216         vm.uploadConfigFile = function (file) {
 217             var defer = $q.defer();
 218             Upload.upload({
 219                 url: "change-management/uploadConfigUpdateFile",
 220                 file: file,
 221                 transformResponse: [function (data) {
 222                     return data;
 223                 }]
 224             })
 225                 .then(function (configUpdateResponse) {
 226                     vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value = configUpdateResponse && JSON.parse(configUpdateResponse.data).payload;
 227                     defer.resolve(true);
 228                 })
 229                 .catch(function (error) {
 230                     defer.resolve(false);
 231                 });
 232             return defer.promise;
 233         };
 234
 235
 236         /***converting objects to scheduler format (taken from IST) - was altered for Scale out support ***/
 237         function extractChangeManagementCallbackDataStr(changeManagement) {
 238             console.log(changeManagement);
 239             var result = {};
 240             result.requestType = changeManagement.workflow;
 241             var workflowType = changeManagement.workflow;
 242             result.requestDetails = [];
 243             _.forEach(changeManagement.vnfNames, function (vnf) {
 244
 245                 try{
 246                     var requestInfoData ={};
 247                     var requestParametersData ={};
 248                     var moduleToScale = _.find(vnf.vfModules, {"scale": true});
 249                     if (vnf.availableVersions && vnf.availableVersions.length!=0){
 250
 251                         requestInfoData ={
 252                             source: vnf.availableVersions[0].requestInfo.source,
 253                             suppressRollback: vnf.availableVersions[0].requestInfo.suppressRollback,
 254                             requestorId: vnf.availableVersions[0].requestInfo.requestorId
 255                         }
 256
 257                         if(workflowType=='Update'){
 258                             requestParametersData = {
 259                                 usePreload: vnf.availableVersions[0].requestParameters.usePreload
 260                             }
 261                         }else if(workflowType=="Replace"){
 262                             requestParametersData = {
 263                                 rebuildVolumeGroups: vnf.availableVersions[0].requestParameters.usePreload
 264                             }
 265                         }else if(workflowType=="VNF In Place Software Update"){
 266                             var payloadObj = {
 267                                 'existing_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Existing software version').value,
 268                                 'new_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'New software version').value,
 269                                 'operations_timeout':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Operations timeout').value
 270                             };
 271                             requestParametersData = {
 272                                 payload: JSON.stringify(payloadObj)
 273                             }
 274                         }else if(workflowType=="VNF Config Update"){
 275                             requestParametersData = {
 276                                 payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
 277                             }
 278                         }else if(workflowType=="VNF Scale Out"){
 279                             if(!moduleToScale) return null;
 280
 281                             if(moduleToScale.userParams) {
 282                                 requestParametersData = {
 283                                     userParams: moduleToScale.userParams
 284                                     //,usePreload: true
 285                                 }
 286                             }else{
 287                                 requestParametersData = {
 288                                     userParams: []
 289                                     //,usePreload: false
 290                                 }
 291                             }
 292                         }
 293                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: workflowType '+ workflowType);
 294                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: requestParametersData '+ requestParametersData);
 295
 296                     }else if(workflowType=="VNF In Place Software Update"){
 297                         var payloadObj = {
 298                             'existing_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Existing software version').value,
 299                             'new_software_version':vm.getInternalWorkFlowParameter(workflowType, 'text', 'New software version').value,
 300                             'operations_timeout':vm.getInternalWorkFlowParameter(workflowType, 'text', 'Operations timeout').value
 301                         };
 302                         requestParametersData = {
 303                             payload: JSON.stringify(payloadObj)
 304                         }
 305                     }else if(workflowType=="VNF Config Update"){
 306                         requestParametersData = {
 307                             payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
 308                         }
 309                     }
 310
 311                     var data;
 312                     if(workflowType=="VNF Scale Out") {
 313                         data = {
 314                             vnfName: vnf.name,
 315                             vnfInstanceId: vnf.id,
 316                             modelInfo: {
 317                                 modelType: 'vfModule',
 318                                 modelInvariantId: moduleToScale.invariantUuid,
 319                                 modelName: moduleToScale.modelCustomizationName,
 320                                 modelVersion: moduleToScale.version,
 321                                 modelCustomizationName: moduleToScale.modelCustomizationName,
 322                                 modelCustomizationId: moduleToScale.customizationUuid,
 323                                 modelVersionId: moduleToScale.uuid
 324                             },
 325                             cloudConfiguration: vnf.cloudConfiguration,
 326                             requestInfo: requestInfoData,
 327                             relatedInstanceList: [],
 328                             requestParameters:requestParametersData,
 329                             configurationParameters: JSON.parse(vm.getInternalWorkFlowParameter("VNF Scale Out", "text", "Configuration Parameters").value)
 330                         };
 331                         requestInfoData.instanceName = vnf.name + "_" + (moduleToScale.currentCount + 1);
 332                     }else{
 333                         data = {
 334                             vnfName: vnf.name,
 335                             vnfInstanceId: vnf.id,
 336                             modelInfo: {
 337                                 modelType: 'vnf',
 338                                 modelInvariantId: vnf.properties['model-invariant-id'],
 339                                 modelVersionId: vnf.modelVersionId,
 340                                 modelName: vnf.properties['vnf-name'],
 341                                 modelVersion: vnf.version,
 342                                 modelCustomizationName: vnf.properties['model-customization-name'],
 343                                 modelCustomizationId: vnf.properties['model-customization-id']
 344                             },
 345                             cloudConfiguration: vnf.cloudConfiguration,
 346                             requestInfo: requestInfoData,
 347                             relatedInstanceList: [],
 348                             requestParameters:requestParametersData
 349                         };
 350                     }
 351
 352                     var serviceInstanceId = '';
 353                     _.forEach(vnf['service-instance-node'], function (instanceNode) {
 354                         if(instanceNode['node-type'] === 'service-instance'){
 355                             serviceInstanceId = instanceNode.properties['service-instance-id'];
 356                         }
 357                     });
 358
 359                     if (vnf.availableVersions && vnf.availableVersions.length!=0){
 360                         _.forEach(vnf.availableVersions[0].relatedInstanceList, function (related) {
 361                             var rel = related.relatedInstance;
 362                             var relatedInstance = {
 363                                 instanceId: serviceInstanceId,
 364                                 modelInfo: {
 365                                     modelType: rel.modelInfo.modelType,
 366                                     modelInvariantId: rel.modelInfo.modelInvariantId,
 367                                     modelVersionId: rel.modelInfo.modelVersionId,
 368                                     modelName: rel.modelInfo.modelName,
 369                                     modelVersion: rel.modelInfo.modelVersion,
 370                                     modelCustomizationName: rel.modelInfo.modelCustomizationName,
 371                                     modelCustomizationId: rel.modelInfo.modelCustomizationId
 372                                 }
 373                             };
 374                             if (rel.vnfInstanceId)
 375                                 relatedInstance.instanceId = rel.vnfInstanceId;
 376
 377                             data.relatedInstanceList.push({relatedInstance: relatedInstance});
 378                         });
 379                         if(workflowType=="VNF Scale Out") {
 380                             //push vnf to related as well as the service instance
 381                             var relatedInstance = {
 382                                 instanceId: vnf.id,
 383                                 modelInfo: {
 384                                     modelCustomizationId: vnf.availableVersions[0].modelInfo.modelCustomizationId,
 385                                     modelCustomizationName: vnf.availableVersions[0].modelInfo.modelCustomizationName,
 386                                     modelInvariantId: vnf.availableVersions[0].modelInfo.modelInvariantId,
 387                                     modelName: vnf.availableVersions[0].modelInfo.modelName,
 388                                     modelType: vnf.availableVersions[0].modelInfo.modelType,
 389                                     modelVersion: vnf.availableVersions[0].modelInfo.modelVersion,
 390                                     modelVersionId: vnf.availableVersions[0].modelInfo.modelVersionId
 391                                 }
 392                             };
 393                             data.relatedInstanceList.push({relatedInstance: relatedInstance});
 394                         }
 395                     }
 396                 }catch(err){
 397                     $log.error('SchedulerCtrl::extractChangeManagementCallbackDataStr error: ' + err);
 398                     vm.errorMsg = err;
 399                 }
 400
 401                 result.requestDetails.push(data);
 402             });
 403             return JSON.stringify(result);
 404         }
 405
 406         function getWorkflowParametersFromForm() {
 407             let workflowParameters =
 408                 {requestDetails:{
 409                         cloudConfiguration:{},
 410                         requestParameters:{userParams:[{}]}
 411                     }};
 412             workflowParameters.requestDetails.cloudConfiguration = vm.changeManagement.vnfNames[0].cloudConfiguration;
 413
 414             let parameters = vm.getRemoteWorkFlowParameters(vm.changeManagement.workflow);
 415             parameters.forEach((parameter)=>{
 416                 let inputField = document.getElementById('so-workflow-parameter-'+parameter.soFieldName);
 417             workflowParameters.requestDetails.requestParameters.userParams[0][parameter.soFieldName]=inputField.value;
 418         });
 419
 420             return workflowParameters;
 421         }
 422
 423         vm.openModal = function () {
 424             if(vm.hasScheduler) { //scheduling supported
 425                 vm.scheduleWorkflow();
 426             } else {
 427                 //no scheduling support
 428                 vm.executeWorkflow();
 429             }
 430         };
 431
 432         vm.scheduleWorkflow = function () {
 433             $scope.widgetParameter = ""; // needed by the scheduler?
 434
 435             // properties needed by the scheduler so it knows whether to show
 436             // policy or sniro related features on the scheduler UI or not.
 437             vm.changeManagement.policyYN = "Y";
 438             vm.changeManagement.sniroYN = "Y";
 439
 440             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_ADD_MSO_TESTAPI_FIELD)) {
 441                 vm.changeManagement.testApi = DataService.getMsoRequestParametersTestApi();
 442             }
 443             var data = {
 444                 widgetName: 'Portal-Common-Scheduler',
 445                 widgetData: vm.changeManagement,
 446                 widgetParameter: $scope.widgetParameter
 447             };
 448
 449             window.parent.postMessage(data, VIDCONFIGURATION.SCHEDULER_PORTAL_URL);
 450         };
 451
 452         vm.executeWorkflow = function () {
 453             if ( vm.localWorkflows && vm.localWorkflows.length > 0 ) {
 454                 vm.triggerLocalWorkflow();
 455             } else {
 456                 let source = vm.getRemoteWorkflowSource(vm.changeManagement.workflow);
 457                 if( source === "NATIVE"){
 458                     vm.triggerLocalWorkflow();
 459                 }else {
 460                     vm.triggerRemoteWorkflow();
 461                 }
 462             }
 463         };
 464
 465         vm.triggerLocalWorkflow = function () {
 466             var dataToSo = extractChangeManagementCallbackDataStr(vm.changeManagement);
 467             if (dataToSo) {
 468                 var vnfName = vm.changeManagement.vnfNames[0].name;
 469                 changeManagementService.postChangeManagementNow(dataToSo, vnfName);
 470             }
 471         };
 472
 473         vm.triggerRemoteWorkflow = function () {
 474             let cachedWorkflowDetails = vm.getCachedWorkflowDetails(vm.changeManagement.workflow);
 475             if (cachedWorkflowDetails.length > 0) {
 476                 let workflowParameters = getWorkflowParametersFromForm();
 477                 if (workflowParameters) {
 478                     let servieInstanceId = vm.changeManagement.vnfNames[0]['service-instance-node'][0].properties['service-instance-id'];
 479                     let vnfInstanceId = vm.changeManagement.vnfNames[0].id;
 480                     let workflow_UUID = cachedWorkflowDetails[0].id;
 481                     changeManagementService.postWorkflowsParametersNow(servieInstanceId, vnfInstanceId, workflow_UUID, workflowParameters);
 482                 }
 483             }
 484         };
 485
 486         vm.loadSubscribers = function () {
 487             vm.subscribers = [];
 488             AaiService.getSubscribers(function (response) {
 489                 vm.subscribers = response;
 490             });
 491         };
 492
 493         vm.loadServiceTypes = function () {
 494             vm.serviceTypes = [];
 495
 496             AaiService.getSubscriberServiceTypes(vm.changeManagement.subscriberId)
 497                 .then(function (response) {
 498                     vm.serviceTypes = response.data;
 499                 })
 500                 .catch(function (error) {
 501                     $log.error(error);
 502                     vm.errorMsg = error;
 503                 });
 504         };
 505
 506         vm.loadVNFTypes = function () {
 507             vm.vnfTypes = [];
 508             vm.vnfTypesTemp = [];
 509             vm.serviceInstances = [];
 510
 511             var instances = vm.changeManagement.serviceType["service-instances"]["service-instance"];
 512             // var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
 513
 514             vm.vnfs = [];
 515             vm.vfModules = [];
 516
 517             AaiService.getVnfsByCustomerIdAndServiceType(
 518                 vm.changeManagement.subscriberId,
 519                 vm.changeManagement.serviceType["service-type"]
 520             ).then(function (response) {
 521                     var vnfsData = response.data.results;
 522                     if (vnfsData) {
 523                         for (var i = 0; i < vnfsData.length; i++) {
 524                             if (vnfsData[i]) {
 525                                 const nodeType = vnfsData[i]['node-type'];
 526                                 if (nodeType === "generic-vnf") {
 527                                     if (_.find(vnfsData[i]['related-to'], function (node) {
 528                                         return node['node-type'] === 'vserver'
 529                                     }) !== undefined) {
 530                                         vm.vnfs.push(vnfsData[i]);
 531                                     }
 532                                 } else if (nodeType === "service-instance") {
 533                                     vm.serviceInstances.push(vnfsData[i]);
 534                                 } else if (nodeType === "vf-module") {
 535                                     vm.vfModules.push(vnfsData[i]);
 536                                 }
 537                             }
 538                         }
 539
 540                         vm.vnfs = _.flattenDeep(
 541                             _.remove(vm.vnfs, function (vnf) {
 542                                 var nfRole = vnf.properties['nf-role'];
 543                                 if (nfRole !== undefined) {
 544                                     return nfRole !== 'null' && nfRole !== '';
 545                                 }
 546                             })
 547                         );
 548
 549                         var filteredVnfs = _.uniqBy(vm.vnfs, function (vnf) {
 550                             return vnf.properties['nf-role'];
 551                         });
 552
 553                         _.forEach(filteredVnfs, function (vnf) {
 554                             vm.vnfTypes.push(vnf.properties['nf-role'])
 555                         });
 556                     }
 557                 }
 558             );
 559         };
 560
 561         var fromVNFVersions = [];
 562
 563         vm.loadVNFVersions = function () {
 564             fromVNFVersions = [];
 565             vm.serviceInstancesToGetVersions = [];
 566             var versions = [];
 567             _.forEach(vm.vnfs, function (vnf) {
 568                 if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']
 569                     && vnf.properties["model-invariant-id"]
 570                     && vnf.properties["model-version-id"]) {
 571                     vm.serviceInstancesToGetVersions.push({
 572                             "model-invariant-id": vnf.properties["model-invariant-id"],
 573                             "model-version-id": vnf.properties["model-version-id"]
 574                         }
 575                     );
 576
 577                     versions.push(vnf.properties["model-invariant-id"]);
 578                 }
 579             });
 580
 581             if (versions.length > 0) {
 582                 AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
 583                     if (response.data) {
 584
 585                         $log.debug("getVnfVersionsByInvariantId: response", response);
 586
 587                         fromVNFVersions = vm.serviceInstancesToGetVersions
 588                             .map(function (serviceInstanceToGetVersion) {
 589                                 const model = _.find(response.data.model, {'model-invariant-id': serviceInstanceToGetVersion['model-invariant-id']});
 590                                 $log.debug("getVnfVersionsByInvariantId: model for " + serviceInstanceToGetVersion['model-invariant-id'], model);
 591
 592                                 const modelVer = _.find(model["model-vers"]["model-ver"], {'model-version-id': serviceInstanceToGetVersion['model-version-id']});
 593                                 $log.debug("getVnfVersionsByInvariantId: modelVer for " + serviceInstanceToGetVersion['model-version-id'], modelVer);
 594
 595                                 var modelVersionId = serviceInstanceToGetVersion["model-version-id"];
 596                                 var modelVersion = modelVer["model-version"];
 597
 598                                 return {"key": modelVersionId, "value": modelVersion};
 599                             });
 600
 601                         vm.fromVNFVersions = _.uniqBy(fromVNFVersions, 'value');
 602                     }
 603                 })
 604             }
 605         };
 606
 607
 608         function getVnfs(modelInvariantId) {
 609             return new Promise(function (resolve, reject) {
 610                 AaiService.getVnfVersionsByInvariantId(modelInvariantId)
 611                     .then(function (response) {
 612                         if (response.data.httpCode !== null &&
 613                             response.data.httpCode === 200) {
 614                             var vnfsData = response.data.t.results;
 615                             for (var i = 0; i < vnfsData.length; i++) {
 616                                 if (vnfsData[i]) {
 617                                     if (vnfsData[i].nodeType === "generic-vnf") {
 618                                         resolve(vnfsData[i]);
 619                                     } else if (vnfsData[i].nodeType === "service-instance") {
 620                                         vm.serviceInstances.push(vnfsData[i]);
 621                                     }
 622                                 }
 623                             }
 624                             resolve(null);
 625                         }
 626                         resolve(null);
 627                     })
 628                     .catch(function (error) {
 629                         reject(error);
 630                         vm.errorMsg = error;
 631                     });
 632             });
 633         }
 634
 635         var getVersionNameForId = function(versionId) {
 636             var version = _.find(fromVNFVersions, {"key": versionId});
 637             return version.value;
 638         };
 639
 640         vm.loadVNFNames = function () {
 641             vm.vnfNames = [];
 642             const vnfs = vm.changeManagement.fromVNFVersion ? vm.vnfs : [];
 643             _.forEach(vnfs, function (vnf) {
 644
 645                 var selectedVersionNumber = getVersionNameForId(vm.changeManagement.fromVNFVersion);
 646
 647                 if (vnf.properties['nf-role'] === vm.changeManagement.vnfType &&
 648                     selectedVersionNumber === getVersionNameForId(vnf.properties["model-version-id"])) {
 649                     var vServer = {};
 650
 651                     _.forEach(vnf['related-to'], function (node) {
 652                         if (node['node-type'] === 'vserver') {
 653                             vServer = extractLcpRegionIdAndTenantId(node.url);
 654                         }
 655                     });
 656
 657                     var serviceInstancesIds =
 658                         _.filter(vnf['related-to'], {'node-type': 'service-instance'})
 659                             .map(function (serviceInstance) { return serviceInstance.id });
 660
 661                     var serviceInstances = _.filter(vm.serviceInstances, function(serviceInstance) {
 662                         return _.includes(serviceInstancesIds, serviceInstance.id);
 663                     });
 664
 665                     // logging only
 666                     if (serviceInstancesIds.length === 0) {
 667                         $log.error("loadVNFNames: no serviceInstancesIds for vnf", vnf);
 668                     } else {
 669                         $log.debug("loadVNFNames: serviceInstancesIds", serviceInstancesIds);
 670                         $log.debug("loadVNFNames: serviceInstances", serviceInstances);
 671                     }
 672
 673                     vm.vnfNames.push({
 674                         "id": vnf.properties["vnf-id"],
 675                         "name": vnf.properties["vnf-name"],
 676                         "invariant-id": vnf.properties["model-invariant-id"],
 677                         "service-instance-node": serviceInstances,
 678                         "modelVersionId": vnf.properties["model-version-id"],
 679                         "properties": vnf.properties,
 680                         'cloudConfiguration': vServer,
 681                         "relatedTo": vnf['related-to']
 682                     });
 683                 }
 684             });
 685         };
 686
 687         function extractLcpRegionIdAndTenantId(url) {
 688
 689             var cloudConfiguration = {
 690                 lcpCloudRegionId: '',
 691                 tenantId: ''
 692             };
 693
 694             /*
 695              e.g., in both URLs below -
 696                - lcpCloudRegionId == 'rdm5b'
 697                - tenantId == '0675e0709bd7444a9e13eba8b40edb3c'
 698
 699              "url": "https://aai-conexus-e2e.ecomp.cci.att.com:8443/aai/v10/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 700              "url": "/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 701              */
 702
 703             var cloudRegionMatch = url.match(/\/cloud-regions\/cloud-region\/[^\/]+\/([^\/]+)/);
 704             var tenantMatch = url.match(/\/tenants\/tenant\/([^\/]+)/);
 705
 706             cloudConfiguration.lcpCloudRegionId = cloudRegionMatch[1];
 707             cloudConfiguration.tenantId = tenantMatch[1];
 708
 709             return cloudConfiguration;
 710         };
 711
 712         vm.loadWorkFlows = function () {
 713             vm.localWorkflowsParameters = new Map();
 714             vm.remoteWorkflowsParameters = new Map();
 715             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_HANDLE_SO_WORKFLOWS)) {
 716                 return vm.loadRemoteWorkFlows()
 717                     .then(function () {
 718                         vm.workflows = vm.remoteWorkflows.map(item => item.name);
 719                     }).then(function () {
 720                         vm.loadRemoteWorkFlowsParameters();
 721                     });
 722             }else{
 723                 return vm.loadLocalWorkFlows()
 724                     .then(vm.loadLocalWorkFlowsParameters)
 725                     .then(function () {
 726                         vm.workflows = vm.localWorkflows;
 727                     })
 728             }
 729         };
 730
 731         vm.loadLocalWorkFlows = function () {
 732             return changeManagementService.getWorkflows(vm.changeManagement.vnfNames)
 733                 .then(function (response) {
 734                     vm.localWorkflows = response.data.workflows || [];
 735                 }).catch(function (error) {
 736                     $log.error(error);
 737                     vm.errorMsg = error;
 738                 });
 739         };
 740
 741         vm.loadRemoteWorkFlows = function () {
 742             let vnfModelIDs = vm.changeManagement.vnfNames.map(vnfName => vnfName.modelVersionId);
 743             return changeManagementService.getSOWorkflows(vnfModelIDs)
 744                 .then(function (response) {
 745                     vm.remoteWorkflows = response.data || [];
 746                 }).catch(function (error) {
 747                     $log.error(error);
 748                     vm.errorMsg = error;
 749                 });
 750         };
 751
 752         vm.loadLocalWorkFlowsParameters = function () {
 753             vm.localWorkflows.forEach(function(workflow) {
 754                 vm.loadLocalWorkFlowParameters(workflow);
 755             });
 756         };
 757
 758         vm.loadLocalWorkFlowParameters = function (workflow) {
 759             changeManagementService.getLocalWorkflowParameter(workflow)
 760                 .then(function (response) {
 761                     vm.localWorkflowsParameters.set(workflow, response.data.parameterDefinitions);
 762                 })
 763                 .catch(function (error) {
 764                     $log.error(error);
 765                     vm.errorMsg = error;
 766                 });
 767         };
 768
 769         vm.loadRemoteWorkFlowsParameters = function () {
 770             vm.remoteWorkflows.forEach(function(workflow) {
 771                 if (workflow.source ==='SDC' || workflow.source === 'sdc' ){
 772                     vm.loadRemoteWorkFlowParameters(workflow);
 773                 } else {
 774                     vm.loadLocalWorkFlowParameters(workflow.name);
 775                 }
 776             });
 777         };
 778
 779         vm.loadRemoteWorkFlowParameters = function (workflow) {
 780             let parameters = [];
 781             workflow.workflowInputParameters
 782                 .filter( function (param) {
 783                     return param.soPayloadLocation === "userParams"
 784                 })
 785                 .forEach(function (param) {
 786                         let workflowParams = vm.repackAttributes(param);
 787                         if (param.validation.length > 0) {
 788                             let validation = param.validation[0];
 789                             if ('maxLength' in validation) {
 790                                 workflowParams.maxLength = validation.maxLength;
 791                             }
 792                             if ('allowableChars' in validation) {
 793                                 workflowParams.pattern = validation.allowableChars;
 794                             }
 795                         }
 796                         workflowParams.type = param.inputType;
 797
 798                         parameters.push(workflowParams);
 799                     }
 800                 );
 801             vm.remoteWorkflowsParameters.set(workflow.name, parameters);
 802         };
 803
 804         vm.repackAttributes = function (workflowParam){
 805             return {
 806                 name: workflowParam.label,
 807                 required: workflowParam.required,
 808                 id: workflowParam.soFieldName,
 809                 soFieldName: workflowParam.soFieldName,
 810                 maxLength: '500',
 811                 pattern: '.*'
 812             }
 813         };
 814
 815         vm.getRemoteWorkFlowParameters = function (workflow) {
 816             if (workflow && vm.remoteWorkflowsParameters.has(workflow)) {
 817                 return vm.remoteWorkflowsParameters.get(workflow)
 818             }
 819             return [];
 820         };
 821
 822         vm.hasPatternError = function(form, itemName){
 823             return form[itemName].$error.pattern;
 824         }
 825
 826         vm.hasAsyncFnError = function(form, itemName){
 827             return form[itemName].$error.validateAsyncFn;
 828         }
 829
 830         vm.getIdFor = function(type, id, name){
 831             return "internal-workflow-parameter-" + type + "-" + id + "-" + (name ? name.split(' ').join('-').toLowerCase() : "");
 832         }
 833
 834         vm.getInternalWorkFlowParameters = function (workflow, type) {
 835             if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type) != []) {
 836                 return vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type);
 837             }
 838             return [];
 839         };
 840
 841         vm.getInternalWorkFlowParameter = function (workflow, type, parameterName) {
 842             if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type) != []) {
 843                 return vm.localWorkflowsParameters.get(workflow).filter(parameter => parameter.type==type).filter(parameter => parameter.name === parameterName)[0]
 844             }
 845         };
 846
 847         vm.getRemoteWorkflowSource = (workflow) => {
 848             return vm.getCachedWorkflowDetails(workflow)[0].source;
 849         };
 850
 851         vm.getCachedWorkflowDetails = function (workflow) {
 852             return vm.remoteWorkflows.filter( function (remoteWorkflow) {
 853                 return remoteWorkflow.name === workflow;
 854             });
 855
 856         };
 857
 858         //Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
 859         $scope.selectFileForVNFName = function (fileInput) {
 860             if (fileInput && fileInput.id) {
 861                 var vnfName = _.filter(vm.changeManagement.vnfNames, {"invariant-id": fileInput.id});
 862                 var file = fileInput.files[0];
 863                 var fileReader = new FileReader();
 864                 fileReader.onload = function (load) {
 865                     try {
 866                         var lines = load.target.result;
 867                         vnfName[0].selectedFile = JSON.parse(lines);
 868                     } catch (error) {
 869                         $log.error(error);
 870                         vm.errorMsg = error;
 871                     }
 872                 };
 873                 fileReader.readAsText(file);
 874             }
 875         };
 876
 877         vm.selectVersionForVNFName = function (vnfName) {
 878             console.log("Will add version for selected vnf name: " + vnfName.name);
 879         };
 880
 881         vm.isConfigUpdate = function () {
 882             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfConfigUpdate;
 883         };
 884
 885         vm.isScaleOut = function () {
 886             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfScaleOut;
 887         };
 888
 889         vm.shouldShowVnfInPlaceFields = function () {
 890             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfInPlace;
 891         };
 892
 893         vm.setPreload = function (fileEl) {
 894             var files = fileEl.files;
 895             var file = files[0];
 896             var reader = new FileReader();
 897
 898             reader.onloadend = function(evt) {
 899                 if (evt.target.readyState === FileReader.DONE) {
 900                     $scope.$apply(function () {
 901                         $scope.moduleArr[0].userParams = JSON.parse(evt.target.result);
 902                     });
 903                 }
 904             };
 905
 906             reader.readAsText(file);
 907         };
 908
 909         init();
 910     }
 911 })();