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