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