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             var result = {};
 255             result.requestType = changeManagement.workflow;
 256             var workflowType = changeManagement.workflow;
 257             result.requestDetails = [];
 258             _.forEach(changeManagement.vnfNames, function (vnf) {
 259
 260                 try {
 261                     var requestInfoData = {};
 262                     var requestParametersData = {};
 263                     var moduleToScale = _.find(vnf.vfModules, {"scale": true});
 264                     if (vnf.availableVersions && vnf.availableVersions.length != 0) {
 265
 266                         requestInfoData = {
 267                             source: vnf.availableVersions[0].requestInfo.source,
 268                             suppressRollback: vnf.availableVersions[0].requestInfo.suppressRollback,
 269                             requestorId: vnf.availableVersions[0].requestInfo.requestorId
 270                         };
 271
 272                         if (workflowType == 'Update') {
 273                             requestParametersData = {
 274                                 usePreload: vnf.availableVersions[0].requestParameters.usePreload
 275                             };
 276                         } else if (workflowType == "Replace") {
 277                             requestParametersData = {
 278                                 rebuildVolumeGroups: vnf.availableVersions[0].requestParameters.usePreload
 279                             };
 280                         } else if (workflowType == "VNF In Place Software Update") {
 281                             var payloadObj = {
 282                                 'existing_software_version': vm.getInternalWorkFlowParameter(workflowType, 'text', 'Existing software version').value,
 283                                 'new_software_version': vm.getInternalWorkFlowParameter(workflowType, 'text', 'New software version').value,
 284                                 'operations_timeout': vm.getInternalWorkFlowParameter(workflowType, 'text', 'Operations timeout').value
 285                             };
 286                             requestParametersData = {
 287                                 payload: JSON.stringify(payloadObj)
 288                             };
 289                         } else if (workflowType == "PNF Software Upgrade") {
 290                             requestParametersData = {
 291                                 userParams: [
 292                                     { "name":"pnfId",
 293                                       "value":vnf.properties["vnf-id"]
 294                                     },
 295                                     { "name":"pnfName",
 296                                       "value": vnf.name
 297                                     },
 298                                     { "name":"targetSoftwareVersion",
 299                                       "value":vm.getInternalWorkFlowParameter(workflowType, 'text', 'Target software version').value
 300                                     }
 301                                 ]
 302                             };
 303
 304                         } else if (workflowType == "VNF Config Update") {
 305                             requestParametersData = {
 306                                 payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
 307                             };
 308                         } else if (workflowType == "VNF Scale Out") {
 309                             if (!moduleToScale) return null;
 310
 311                             if (moduleToScale.userParams) {
 312                                 requestParametersData = {
 313                                     userParams: moduleToScale.userParams
 314                                     //,usePreload: true
 315                                 };
 316                             } else {
 317                                 requestParametersData = {
 318                                     userParams: []
 319                                     //,usePreload: false
 320                                 };
 321                             }
 322                         }
 323                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: workflowType ' + workflowType);
 324                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: requestParametersData ' + requestParametersData);
 325
 326                     } else if (workflowType == "VNF In Place Software Update") {
 327                         var payloadObj = {
 328                             'existing_software_version': vm.getInternalWorkFlowParameter(workflowType, 'text', 'Existing software version').value,
 329                             'new_software_version': vm.getInternalWorkFlowParameter(workflowType, 'text', 'New software version').value,
 330                             'operations_timeout': vm.getInternalWorkFlowParameter(workflowType, 'text', 'Operations timeout').value
 331                         };
 332                         requestParametersData = {
 333                             payload: JSON.stringify(payloadObj)
 334                         };
 335                     }  else if (workflowType == "VNF Config Update") {
 336                         requestParametersData = {
 337                             payload: vm.getInternalWorkFlowParameter("VNF Config Update", "FILE", "Attach configuration file").value
 338                         };
 339                     }
 340
 341                     var data;
 342                     if (workflowType == "VNF Scale Out") {
 343                         data = {
 344                             vnfName: vnf.name,
 345                             vnfInstanceId: vnf.id,
 346                             modelInfo: {
 347                                 modelType: 'vfModule',
 348                                 modelInvariantId: moduleToScale.invariantUuid,
 349                                 modelName: moduleToScale.modelCustomizationName,
 350                                 modelVersion: moduleToScale.version,
 351                                 modelCustomizationName: moduleToScale.modelCustomizationName,
 352                                 modelCustomizationId: moduleToScale.customizationUuid,
 353                                 modelVersionId: moduleToScale.uuid
 354                             },
 355                             cloudConfiguration: vnf.cloudConfiguration,
 356                             requestInfo: requestInfoData,
 357                             relatedInstanceList: [],
 358                             requestParameters: requestParametersData,
 359                             configurationParameters: JSON.parse(vm.getInternalWorkFlowParameter("VNF Scale Out", "text", "Configuration Parameters").value)
 360                         };
 361                         requestInfoData.instanceName = vnf.name + "_" + (moduleToScale.currentCount + 1);
 362                     } else if (workflowType === "PNF Software Upgrade") {
 363                          data = nativeWorkflowRequestData('pnf', requestParametersData, vnf, requestInfoData);
 364                     } else {
 365                          data = nativeWorkflowRequestData('vnf', requestParametersData, vnf, requestInfoData);
 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 nativeWorkflowRequestData(modelType, requestParametersData, vnf, requestInfoData) {
 423             var data = {
 424                    modelInfo: {
 425                       modelType: modelType,
 426                       modelInvariantId: vnf.properties['model-invariant-id'],
 427                       modelVersionId: vnf.modelVersionId,
 428                       modelName: vnf.properties['vnf-name'],
 429                       modelVersion: vnf.version,
 430                       modelCustomizationName: vnf.properties['model-customization-name'],
 431                       modelCustomizationId: vnf.properties['model-customization-id']
 432                    },
 433                    cloudConfiguration: vnf.cloudConfiguration,
 434                    requestInfo: requestInfoData,
 435                    requestParameters: requestParametersData
 436             };
 437             data[modelType + 'InstanceId'] = vnf.id;
 438             if (modelType == "vnf"){
 439                data[modelType + 'Name'] = vnf.name;
 440                data['relatedInstanceList'] =  [] ;
 441             }
 442             return data;
 443         }
 444
 445         function getWorkflowParametersFromForm() {
 446             let workflowParameters =
 447                 {
 448                     requestDetails: {
 449                         cloudConfiguration: {},
 450                         requestParameters: {userParams: [{}]}
 451                     }
 452                 };
 453             workflowParameters.requestDetails.cloudConfiguration = vm.changeManagement.vnfNames[0].cloudConfiguration;
 454
 455             let parameters = vm.getRemoteWorkFlowParameters(vm.changeManagement.workflow);
 456             parameters.forEach((parameter) => {
 457                 let inputField = document.getElementById('so-workflow-parameter-' + parameter.soFieldName);
 458                 workflowParameters.requestDetails.requestParameters.userParams[0][parameter.soFieldName] = inputField.value;
 459             });
 460
 461             return workflowParameters;
 462         }
 463
 464         vm.openModal = function () {
 465             if (vm.hasScheduler) { //scheduling supported
 466                 vm.scheduleWorkflow();
 467             } else {
 468                 //no scheduling support
 469                 vm.executeWorkflow();
 470             }
 471         };
 472
 473         vm.collectWorkflowFieldsValues = function () {
 474             /**
 475              * Transforms items with name and value properties, to associative map, e.g the array
 476              * [{name: foo, value: bar}, {name: baz, value: fiz}] will become the object {foo: bar, baz: fiz}
 477              */
 478             return vm.getAllInternalWorkFlowParameters(
 479                     vm.changeManagement.workflow
 480             ).reduce(function (result, item) {
 481                 result[item.name] = item.value;
 482                 return result;
 483             }, {});
 484         };
 485
 486         vm.scheduleWorkflow = function () {
 487             $scope.widgetParameter = ""; // needed by the scheduler?
 488
 489             // properties needed by the scheduler so it knows whether to show
 490             // policy or sniro related features on the scheduler UI or not.
 491             vm.changeManagement.policyYN = "Y";
 492             vm.changeManagement.sniroYN = "Y";
 493
 494             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_ADD_MSO_TESTAPI_FIELD)) {
 495                 vm.changeManagement.testApi = DataService.getMsoRequestParametersTestApi();
 496             }
 497             var data = {
 498                 widgetName: 'Portal-Common-Scheduler',
 499                 widgetData: Object.assign({}, vm.changeManagement, vm.collectWorkflowFieldsValues()),
 500                 widgetParameter: $scope.widgetParameter
 501             };
 502
 503             if (window.parent !== window.self) {
 504                 window.parent.postMessage(data, VIDCONFIGURATION.SCHEDULER_PORTAL_URL);
 505             } else {
 506                 vm.errorMsg = {message: "Portal not found. Cannot send: " + JSON.stringify(data)};
 507                 throw vm.errorMsg; // prevent popup closure
 508             }
 509         };
 510
 511         vm.executeWorkflow = function () {
 512             if (vm.localWorkflows && vm.localWorkflows.length > 0) {
 513                 vm.triggerLocalWorkflow();
 514             } else {
 515                 let source = vm.getRemoteWorkflowSource(vm.changeManagement.workflow);
 516                 if (_.toUpper(source) === "NATIVE") {
 517                     vm.triggerLocalWorkflow();
 518                 } else {
 519                     vm.triggerRemoteWorkflow();
 520                 }
 521             }
 522         };
 523
 524         vm.triggerLocalWorkflow = function () {
 525             var dataToSo = extractChangeManagementCallbackDataStr(vm.changeManagement);
 526             if (dataToSo) {
 527                 var vnfName = vm.changeManagement.vnfNames[0].name;
 528                 changeManagementService.postChangeManagementNow(dataToSo, vnfName);
 529             }
 530         };
 531
 532         vm.triggerRemoteWorkflow = function () {
 533             let cachedWorkflowDetails = vm.getCachedWorkflowDetails(vm.changeManagement.workflow);
 534             if (cachedWorkflowDetails.length > 0) {
 535                 let workflowParameters = getWorkflowParametersFromForm();
 536                 if (workflowParameters) {
 537                     let servieInstanceId = vm.changeManagement.vnfNames[0]['service-instance-node'][0].properties['service-instance-id'];
 538                     let vnfInstanceId = vm.changeManagement.vnfNames[0].id;
 539                     let workflow_UUID = cachedWorkflowDetails[0].id;
 540                     changeManagementService.postWorkflowsParametersNow(servieInstanceId, vnfInstanceId, workflow_UUID, workflowParameters);
 541                 }
 542             }
 543         };
 544
 545         vm.loadSubscribers = function () {
 546             vm.subscribers = [];
 547             AaiService.getSubscribers(function (response) {
 548                 vm.subscribers = response;
 549             });
 550         };
 551
 552         vm.loadServiceTypes = function () {
 553             vm.serviceTypes = [];
 554
 555             AaiService.getSubscriberServiceTypes(vm.changeManagement.subscriberId)
 556                 .then(function (response) {
 557                     vm.serviceTypes = response.data;
 558                 })
 559                 .catch(function (error) {
 560                     $log.error(error);
 561                     vm.errorMsg = error;
 562                 });
 563         };
 564
 565         function isCompatibleNFRole(vnf) {
 566
 567             return vnf.properties['nf-role'] === vm.changeManagement['vnfType'] || !vm.changeManagement['vnfType'];
 568
 569         }
 570
 571         function isValidVnf(vnf) {
 572
 573             let result =  isCompatibleNFRole(vnf) && vnf.properties["model-invariant-id"]
 574                 && vnf.properties["model-version-id"];
 575
 576             return result;
 577         }
 578
 579         function loadCloudRegions() {
 580             AaiService.getLcpCloudRegionTenantList(
 581                 vm.changeManagement.subscriberId,
 582                 vm.changeManagement.serviceType["service-type"],
 583                 function (response) {
 584                     $scope.isFeatureFlagCloudOwner = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST);
 585                     $scope.cloudRegionList = _.uniqBy(response, 'cloudRegionOptionId');
 586                 });
 587         }
 588
 589         vm.serviceTypeChanged = function () {
 590             if ($scope.isNewFilterChangeManagmentEnabled()) {
 591                 loadCloudRegions();
 592             } else {
 593                 vm.searchVNFs();
 594             }
 595         };
 596
 597         vm.searchVNFs = function () {
 598             vm.vnfTypes = [];
 599             vm.vnfTypesTemp = [];
 600             vm.serviceInstances = [];
 601             vm.fromVNFVersions = [];
 602             vm.vnfNames = [];
 603             vm.changeManagement.vnfNames = [];
 604
 605             var instances = vm.changeManagement.serviceType["service-instances"]["service-instance"];
 606             // var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
 607
 608             vm.vnfs = [];
 609             vm.vfModules = [];
 610
 611             let nfRole = null;
 612             let cloudRegion = null;
 613
 614             if ($scope.isNewFilterChangeManagmentEnabled()) {
 615                 nfRole = vm.changeManagement.vnfType ? vm.changeManagement.vnfType : null;
 616                 cloudRegion = vm.changeManagement.cloudRegion ? vm.changeManagement.cloudRegion : null;
 617             }
 618
 619             AaiService.getVnfsByCustomerIdAndServiceType(
 620                 vm.changeManagement.subscriberId,
 621                 vm.changeManagement.serviceType["service-type"],
 622                 nfRole,
 623                 cloudRegion,
 624             ).then(function (response) {
 625                     vm.isSearchedVNF = true;
 626                     var vnfsData = response.data.results;
 627                     if (vnfsData) {
 628                         for (var i = 0; i < vnfsData.length; i++) {
 629                             if (vnfsData[i]) {
 630                                 const nodeType = vnfsData[i]['node-type'];
 631                                 if (nodeType === "generic-vnf") {
 632                                     if (_.find(vnfsData[i]['related-to'], function (node) {
 633                                         return node['node-type'] === 'vserver';
 634                                     }) !== undefined) {
 635                                         vm.vnfs.push(vnfsData[i]);
 636                                     }
 637                                 } else if (nodeType === "service-instance") {
 638                                     vm.serviceInstances.push(vnfsData[i]);
 639                                 } else if (nodeType === "vf-module") {
 640                                     vm.vfModules.push(vnfsData[i]);
 641                                 }
 642                             }
 643                         }
 644
 645                         vm.vnfs = _.flattenDeep(
 646                             _.remove(vm.vnfs, function (vnf) {
 647                                 var nfRole = vnf.properties['nf-role'];
 648                                 if (nfRole !== undefined) {
 649                                     return nfRole !== 'null' && nfRole !== '';
 650                                 }
 651                             })
 652                         );
 653
 654                         var filteredVnfs = _.uniqBy(vm.vnfs, function (vnf) {
 655                             return vnf.properties['nf-role'];
 656                         });
 657
 658                         _.forEach(filteredVnfs, function (vnf) {
 659                             vm.vnfTypes.push(vnf.properties['nf-role'])
 660                         });
 661                     }
 662                     if ($scope.isNewFilterChangeManagmentEnabled()) {
 663                         vm.loadVNFVersions();
 664                     }
 665                 }
 666             );
 667         };
 668
 669         var fromVNFVersions = [];
 670
 671         vm.loadVNFVersions = function () {
 672             fromVNFVersions = [];
 673             vm.serviceInstancesToGetVersions = [];
 674             var versions = [];
 675             _.forEach(vm.vnfs, function (vnf) {
 676                 if (isValidVnf(vnf)) {
 677                     vm.serviceInstancesToGetVersions.push({
 678                             "model-invariant-id": vnf.properties["model-invariant-id"],
 679                             "model-version-id": vnf.properties["model-version-id"]
 680                         }
 681                     );
 682
 683                     versions.push(vnf.properties["model-invariant-id"]);
 684                 }
 685             });
 686
 687             if (versions.length > 0) {
 688                 AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
 689                     if (response.data) {
 690
 691                         $log.debug("getVnfVersionsByInvariantId: response", response);
 692
 693                         fromVNFVersions = vm.serviceInstancesToGetVersions
 694                             .map(function (serviceInstanceToGetVersion) {
 695                                 const model = _.find(response.data.model, {'model-invariant-id': serviceInstanceToGetVersion['model-invariant-id']});
 696                                 $log.debug("getVnfVersionsByInvariantId: model for " + serviceInstanceToGetVersion['model-invariant-id'], model);
 697
 698                                 const modelVer = _.find(model["model-vers"]["model-ver"], {'model-version-id': serviceInstanceToGetVersion['model-version-id']});
 699                                 $log.debug("getVnfVersionsByInvariantId: modelVer for " + serviceInstanceToGetVersion['model-version-id'], modelVer);
 700
 701                                 var modelVersionId = serviceInstanceToGetVersion["model-version-id"];
 702                                 var modelVersion = modelVer["model-version"];
 703
 704                                 return {"key": modelVersionId, "value": modelVersion};
 705                             });
 706
 707                         vm.fromVNFVersions = _.uniqBy(fromVNFVersions, 'value');
 708                     }
 709                 });
 710             }
 711         };
 712
 713
 714         function getVnfs(modelInvariantId) {
 715             return new Promise(function (resolve, reject) {
 716                 AaiService.getVnfVersionsByInvariantId(modelInvariantId)
 717                     .then(function (response) {
 718                         if (response.data.httpCode !== null &&
 719                             response.data.httpCode === 200) {
 720                             var vnfsData = response.data.t.results;
 721                             for (var i = 0; i < vnfsData.length; i++) {
 722                                 if (vnfsData[i]) {
 723                                     if (vnfsData[i].nodeType === "generic-vnf") {
 724                                         resolve(vnfsData[i]);
 725                                     } else if (vnfsData[i].nodeType === "service-instance") {
 726                                         vm.serviceInstances.push(vnfsData[i]);
 727                                     }
 728                                 }
 729                             }
 730                             resolve(null);
 731                         }
 732                         resolve(null);
 733                     })
 734                     .catch(function (error) {
 735                         reject(error);
 736                         vm.errorMsg = error;
 737                     });
 738             });
 739         }
 740
 741         var getVersionNameForId = function (versionId) {
 742             var version = _.find(fromVNFVersions, {"key": versionId});
 743             return version.value;
 744         };
 745
 746         vm.loadVNFNames = function () {
 747             vm.changeManagement.vnfNames = [];
 748             vm.vnfNames = [];
 749
 750             const vnfs = vm.changeManagement.fromVNFVersion ? vm.vnfs : [];
 751             _.forEach(vnfs, function (vnf) {
 752
 753                 var selectedVersionNumber = getVersionNameForId(vm.changeManagement.fromVNFVersion);
 754
 755                 if (isCompatibleNFRole(vnf) &&
 756                     selectedVersionNumber === getVersionNameForId(vnf.properties["model-version-id"])) {
 757                     var vServer = {};
 758
 759                     _.forEach(vnf['related-to'], function (node) {
 760                         if (node['node-type'] === 'vserver') {
 761                             vServer = extractLcpRegionIdAndTenantId(node.url);
 762                         }
 763                     });
 764
 765                     var serviceInstancesIds =
 766                         _.filter(vnf['related-to'], {'node-type': 'service-instance'})
 767                             .map(function (serviceInstance) {
 768                                 return serviceInstance.id
 769                             });
 770
 771                     var serviceInstances = _.filter(vm.serviceInstances, function (serviceInstance) {
 772                         return _.includes(serviceInstancesIds, serviceInstance.id);
 773                     });
 774
 775                     // logging only
 776                     if (serviceInstancesIds.length === 0) {
 777                         $log.error("loadVNFNames: no serviceInstancesIds for vnf", vnf);
 778                     } else {
 779                         $log.debug("loadVNFNames: serviceInstancesIds", serviceInstancesIds);
 780                         $log.debug("loadVNFNames: serviceInstances", serviceInstances);
 781                     }
 782
 783                     vm.vnfNames.push({
 784                         "id": vnf.properties["vnf-id"],
 785                         "name": vnf.properties["vnf-name"],
 786                         "invariant-id": vnf.properties["model-invariant-id"],
 787                         "service-instance-node": serviceInstances,
 788                         "modelVersionId": vnf.properties["model-version-id"],
 789                         "properties": vnf.properties,
 790                         'cloudConfiguration': vServer,
 791                         "relatedTo": vnf['related-to']
 792                     });
 793                 }
 794             });
 795         };
 796
 797         function extractLcpRegionIdAndTenantId(url) {
 798
 799             var cloudConfiguration = {
 800                 lcpCloudRegionId: '',
 801                 tenantId: ''
 802             };
 803
 804             /*
 805              e.g., in both URLs below -
 806                - lcpCloudRegionId == 'rdm5b'
 807                - tenantId == '0675e0709bd7444a9e13eba8b40edb3c'
 808
 809              "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"
 810              "url": "/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 811              */
 812
 813             var cloudRegionMatch = url.match(/\/cloud-regions\/cloud-region\/[^\/]+\/([^\/]+)/);
 814             var tenantMatch = url.match(/\/tenants\/tenant\/([^\/]+)/);
 815
 816             cloudConfiguration.lcpCloudRegionId = cloudRegionMatch[1];
 817             cloudConfiguration.tenantId = tenantMatch[1];
 818
 819             return cloudConfiguration;
 820         };
 821
 822         vm.loadWorkFlows = function () {
 823             vm.localWorkflowsParameters = new Map();
 824             vm.remoteWorkflowsParameters = new Map();
 825             if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_HANDLE_SO_WORKFLOWS)) {
 826                 return vm.loadRemoteWorkFlows()
 827                     .then(function () {
 828                         vm.workflows = vm.remoteWorkflows.map(item => item.name);
 829                     }).then(function () {
 830                         vm.loadRemoteWorkFlowsParameters();
 831                     });
 832             } else {
 833                 return vm.loadLocalWorkFlows()
 834                     .then(vm.loadLocalWorkFlowsParameters)
 835                     .then(function () {
 836                         vm.workflows = vm.localWorkflows;
 837                     });
 838             }
 839         };
 840
 841         vm.loadLocalWorkFlows = function () {
 842             return changeManagementService.getWorkflows(vm.changeManagement.vnfNames)
 843                 .then(function (response) {
 844                     vm.localWorkflows = response.data.workflows || [];
 845                 }).catch(function (error) {
 846                     $log.error(error);
 847                     vm.errorMsg = error;
 848                 });
 849         };
 850
 851         vm.loadRemoteWorkFlows = function () {
 852             let vnfModelIDs = (vm.changeManagement.vnfNames || []).map(vnfName => vnfName.modelVersionId);
 853             if (vnfModelIDs.length === 0) {
 854                 vm.remoteWorkflows = [];
 855                 return $q.resolve();
 856             }
 857             return changeManagementService.getSOWorkflows(vnfModelIDs)
 858                 .then(function (response) {
 859                     vm.remoteWorkflows = response.data || [];
 860                 }).catch(function (error) {
 861                     $log.error(error);
 862                     vm.errorMsg = error;
 863                 });
 864         };
 865
 866         vm.loadLocalWorkFlowsParameters = function () {
 867             vm.localWorkflows.forEach(function (workflow) {
 868                 vm.loadLocalWorkFlowParameters(workflow);
 869             });
 870         };
 871
 872         vm.loadLocalWorkFlowParameters = function (workflow) {
 873             changeManagementService.getLocalWorkflowParameter(workflow)
 874                 .then(function (response) {
 875                     vm.localWorkflowsParameters.set(workflow, response.data.parameterDefinitions);
 876                 })
 877                 .catch(function (error) {
 878                     $log.error(error);
 879                     vm.errorMsg = error;
 880                 });
 881         };
 882
 883         vm.loadRemoteWorkFlowsParameters = function () {
 884             vm.remoteWorkflows.forEach(function (workflow) {
 885                 if (workflow.source === 'SDC' || workflow.source === 'sdc') {
 886                     vm.loadRemoteWorkFlowParameters(workflow);
 887                 } else {
 888                     vm.loadLocalWorkFlowParameters(workflow.name);
 889                 }
 890             });
 891         };
 892
 893         vm.loadRemoteWorkFlowParameters = function (workflow) {
 894             let parameters = [];
 895             workflow.workflowInputParameters
 896                 .filter(function (param) {
 897                     return param.soPayloadLocation === "userParams"
 898                 })
 899                 .forEach(function (param) {
 900                         let workflowParams = vm.repackAttributes(param);
 901                         if (param.validation.length > 0) {
 902                             let validation = param.validation[0];
 903                             if ('maxLength' in validation) {
 904                                 workflowParams.maxLength = validation.maxLength;
 905                             }
 906                             if ('allowableChars' in validation) {
 907                                 workflowParams.pattern = validation.allowableChars;
 908                             }
 909                         }
 910                         workflowParams.type = param.inputType;
 911
 912                         parameters.push(workflowParams);
 913                     }
 914                 );
 915             vm.remoteWorkflowsParameters.set(workflow.name, parameters);
 916         };
 917
 918         vm.repackAttributes = function (workflowParam) {
 919             return {
 920                 name: workflowParam.label,
 921                 required: workflowParam.required,
 922                 id: workflowParam.soFieldName,
 923                 soFieldName: workflowParam.soFieldName,
 924                 maxLength: '500',
 925                 pattern: '.*'
 926             }
 927         };
 928
 929         vm.getRemoteWorkFlowParameters = function (workflow) {
 930             if (workflow && vm.remoteWorkflowsParameters.has(workflow)) {
 931                 return vm.remoteWorkflowsParameters.get(workflow)
 932             }
 933             return [];
 934         };
 935
 936         vm.hasPatternError = function (form, itemName) {
 937             return form[itemName].$error.pattern;
 938         };
 939
 940         vm.hasAsyncFnError = function (form, itemName) {
 941             return form[itemName].$error.validateAsyncFn;
 942         };
 943
 944         vm.getIdFor = function (type, item) {
 945             return "internal-workflow-parameter-" + type + "-" + item.id + "-" + (item.displayName ? item.displayName.split(' ').join('-').toLowerCase() : "");
 946         };
 947
 948         vm.getAllInternalWorkFlowParameters = function (workflow) {
 949             if (workflow && vm.localWorkflowsParameters.has(workflow) && vm.localWorkflowsParameters.get(workflow)) {
 950                 return vm.localWorkflowsParameters.get(workflow);
 951             }
 952             return [];
 953         };
 954
 955         vm.getInternalWorkFlowParameters = function (workflow, type) {
 956             return vm.getAllInternalWorkFlowParameters(workflow).filter(parameter => parameter.type === type);
 957         };
 958
 959         vm.getInternalWorkFlowParameter = function (workflow, type, parameterName) {
 960             return vm.getInternalWorkFlowParameters(workflow, type).filter(parameter => parameter.displayName === parameterName)[0];
 961         };
 962
 963         vm.getRemoteWorkflowSource = (workflow) => {
 964             return vm.getCachedWorkflowDetails(workflow)[0].source;
 965         };
 966
 967         vm.getCachedWorkflowDetails = function (workflow) {
 968             return vm.remoteWorkflows.filter(function (remoteWorkflow) {
 969                 return remoteWorkflow.name === workflow;
 970             });
 971
 972         };
 973
 974         //Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
 975         $scope.selectFileForVNFName = function (fileInput) {
 976             if (fileInput && fileInput.id) {
 977                 var vnfName = _.filter(vm.changeManagement.vnfNames, {"invariant-id": fileInput.id});
 978                 var file = fileInput.files[0];
 979                 var fileReader = new FileReader();
 980                 fileReader.onload = function (load) {
 981                     try {
 982                         var lines = load.target.result;
 983                         vnfName[0].selectedFile = JSON.parse(lines);
 984                     } catch (error) {
 985                         $log.error(error);
 986                         vm.errorMsg = error;
 987                     }
 988                 };
 989                 fileReader.readAsText(file);
 990             }
 991         };
 992
 993         vm.selectVersionForVNFName = function (vnfName) {
 994             console.log("Will add version for selected vnf name: " + vnfName.name);
 995         };
 996
 997         vm.isConfigUpdate = function () {
 998             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfConfigUpdate;
 999         };
1000
1001         vm.isScaleOut = function () {
1002             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfScaleOut;
1003         };
1004
1005         vm.shouldShowVnfInPlaceFields = function () {
1006             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfInPlace;
1007         };
1008
1009         vm.setPreload = function (fileEl) {
1010             var files = fileEl.files;
1011             var file = files[0];
1012             var reader = new FileReader();
1013
1014             reader.onloadend = function (evt) {
1015                 if (evt.target.readyState === FileReader.DONE) {
1016                     $scope.$apply(function () {
1017                         $scope.moduleArr[0].userParams = JSON.parse(evt.target.result);
1018                     });
1019                 }
1020             };
1021
1022             reader.readAsText(file);
1023         };
1024
1025         init();
1026     }
1027 })();