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

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