gerrit.onap Code Review - sandbox-vid.git/blob

   1 (function () {
   2     'use strict';
   3
   4     appDS2.controller("newChangeManagementModalController", ["$uibModalInstance", "$uibModal",'$q', "AaiService", "changeManagementService", "Upload",
   5         "$log", "$scope", "_", "COMPONENT", "VIDCONFIGURATION", newChangeManagementModalController]);
   6
   7     function newChangeManagementModalController($uibModalInstance, $uibModal,$q, AaiService, changeManagementService, Upload, $log, $scope, _, COMPONENT, VIDCONFIGURATION) {
   8
   9         var vm = this;
  10         vm.configUpdatePatternError = "Invalid file type. Please select a file with a CSV extension.";
  11         vm.configUpdateContentError = "Invalid file structure.";
  12
  13         vm.softwareVersionRegex = "[-a-zA-Z0-9\.]+";
  14
  15         var init = function () {
  16             vm.changeManagement = {};
  17
  18             loadServicesCatalog();
  19             registerVNFNamesWatcher();
  20             vm.loadSubscribers();
  21         };
  22
  23         var loadServicesCatalog = function () {
  24             changeManagementService.getAllSDCServices()
  25                 .then(function (response) {
  26                     vm.SDCServicesCatalog = response.data;
  27                 })
  28                 .catch(function (error) {
  29                     $log.error(error);
  30                 })
  31         };
  32
  33         var registerVNFNamesWatcher = function () {
  34             $scope.$watch('vm.changeManagement.vnfNames', function (newVal, oldVal) {
  35                 if (!oldVal || newVal && newVal.length > oldVal.length) { //JUST THE LAST ONE ADDED
  36                     var newVNFName = _.last(vm.changeManagement.vnfNames);
  37                     if (oldVal) {
  38                         vm.changeManagement.vnfNames = oldVal;
  39                         vm.changeManagement.vnfNames.push(newVNFName);
  40                     }
  41                     if (newVNFName && newVNFName["service-instance-node"]) {
  42                         var availableVersions = [];
  43                         var services = _.filter(vm.SDCServicesCatalog.services,
  44                             {"invariantUUID": newVNFName["service-instance-node"][0].properties["model-invariant-id"]});
  45
  46                         _.each(services, function (service) {
  47                             changeManagementService.getSDCService(service.uuid)
  48                                 .then(function (response) {
  49                                     _.each(response.data.vnfs, function (vnf) {
  50                                         if (newVNFName["invariant-id"] === vnf.invariantUuid) {
  51                                             availableVersions.push(extractVNFModel(vnf, response.data.service, newVNFName));
  52                                         }
  53                                     });
  54                                     var versions = _.uniqBy(availableVersions, 'modelInfo.modelVersion');
  55                                     newVNFName.availableVersions = _.sortBy(_.uniq(versions, response.data.service, true),"modelInfo.modelVersion");
  56                                 }).catch(function (error) {
  57                                 $log.error(error);
  58                             });
  59                         });
  60                     }
  61                 }
  62             }, true);
  63         };
  64
  65         var extractVNFModel = function (csarVNF, sdcService, selectionVNF) {
  66             var versionCsarData = {
  67                 vnfInstanceId: "",
  68                 vnfName: csarVNF.name,
  69                 modelInfo: {
  70                     modelType: "vnf",
  71                     modelInvariantId: csarVNF.invariantUuid,
  72                     modelVersionId: selectionVNF.modelVersionId,
  73                     modelName: csarVNF.name,
  74                     modelVersion: csarVNF.version,
  75                     modelCustomizationName: csarVNF.modelCustomizationName,
  76                     modelCustomizationId: csarVNF.customizationUuid
  77                 },
  78                 cloudConfiguration: {
  79                     lcpCloudRegionId: "mdt1",
  80                     tenantId: "88a6ca3ee0394ade9403f075db23167e"
  81                 },
  82                 requestInfo: {
  83                     source: "VID",
  84                     suppressRollback: false,
  85                     requestorId: "az2016"
  86                 },
  87                 relatedInstanceList: [
  88                     {
  89                         relatedInstance: {
  90                             instanceId: selectionVNF["service-instance-node"]["0"].properties['service-instance-id'],
  91                             modelInfo: {
  92                                 modelType: "service",
  93                                 modelInvariantId: selectionVNF["service-instance-node"]["0"].properties['model-invariant-id'],
  94                                 modelVersionId: selectionVNF.modelVersionId,
  95                                 modelName: sdcService.name,
  96                                 modelVersion: sdcService.version,
  97                                 modelCustomizationName: selectionVNF["service-instance-node"]["0"].properties['model-customization-name'], //TODO: Missing
  98                                 modelCustomizationId: selectionVNF["service-instance-node"]["0"].properties['model-customization-id']
  99                             }
 100                         }
 101                     }
 102                 ],
 103                 requestParameters: {
 104                     usePreload: true
 105                 }
 106             };
 107
 108             return versionCsarData;
 109         };
 110
 111         vm.close = function () {
 112             $uibModalInstance.close();
 113         };
 114
 115         vm.uploadConfigFile = function (file) {
 116             var defer = $q.defer();
 117             Upload.upload({
 118                 url: "change-management/uploadConfigUpdateFile",
 119                 file: file,
 120                 transformResponse: [function (data) {
 121                     return data;
 122                 }]
 123             })
 124             .then(function (configUpdateResponse) {
 125                 vm.changeManagement.configUpdateFile = configUpdateResponse && JSON.parse(configUpdateResponse.data).payload;
 126                 defer.resolve(true);
 127             })
 128             .catch(function (error) {
 129                 defer.resolve(false);
 130             });
 131             return defer.promise;
 132         };
 133
 134
 135                 /***converting objects to scheduler format (taken from IST)***/
 136                 function extractChangeManagementCallbackDataStr(changeManagement) {
 137                         console.log(changeManagement);
 138                         var result = {};
 139                         result.requestType = changeManagement.workflow;
 140                         var workflowType = changeManagement.workflow;
 141                         result.requestDetails = [];
 142                         _.forEach(changeManagement.vnfNames, function (vnf) {
 143
 144                                 try{
 145                                 var requestInfoData ={};
 146                                 var requestParametersData ={};
 147                                 if (vnf.availableVersions && vnf.availableVersions.length!=0){
 148
 149                                         requestInfoData ={
 150                                                 source: vnf.availableVersions[0].requestInfo.source,
 151                                                 suppressRollback: vnf.availableVersions[0].requestInfo.suppressRollback,
 152                                                 requestorId: vnf.availableVersions[0].requestInfo.requestorId
 153                                         }
 154
 155                                         if(workflowType=='Update'){
 156                                                 requestParametersData = {
 157                                                         usePreload: vnf.availableVersions[0].requestParameters.usePreload
 158                                                 }
 159                                         }else if(workflowType=="Replace"){
 160                                                 requestParametersData = {
 161                                                         rebuildVolumeGroups: vnf.availableVersions[0].requestParameters.usePreload
 162                                                 }
 163                                         }else if(workflowType=="VNF In Place Software Update"){
 164                                                 var payloadObj = {
 165                                                         'existing_software_version':changeManagement.existingSoftwareVersion,
 166                                                         'new_software_version':changeManagement.newSoftwareVersion,
 167                                                         'operations_timeout':changeManagement.operationTimeout
 168                                                 };
 169                                                 requestParametersData = {
 170                                                         payload: JSON.stringify(payloadObj)
 171                                                 }
 172                                         }else if(workflowType=="VNF Config Update"){
 173                                                 requestParametersData = {
 174                                                         payload: changeManagement.configUpdateFile
 175                                                 }
 176                                         }
 177                                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: workflowType '+ workflowType);
 178                                         $log.info('SchedulerWidgetCtrl:extractChangeManagementCallbackDataStr info:: requestParametersData '+ requestParametersData);
 179
 180                                 }else if(workflowType=="VNF In Place Software Update"){
 181                                         var payloadObj = {
 182                                                 'existing_software_version':changeManagement.existingSoftwareVersion,
 183                                                 'new_software_version':changeManagement.newSoftwareVersion,
 184                                                 'operations_timeout':changeManagement.operationTimeout
 185                                         };
 186                                         requestParametersData = {
 187                                                 payload: JSON.stringify(payloadObj)
 188                                         }
 189                                 }else if(workflowType=="VNF Config Update"){
 190                                         requestParametersData = {
 191                                                 payload: changeManagement.configUpdateFile
 192                                         }
 193                                 }
 194
 195                                 var data = {
 196                                         vnfName: vnf.name,
 197                                         vnfInstanceId: vnf.id,
 198                                         modelInfo: {
 199                                                 modelType: 'vnf',
 200                                                 modelInvariantId: vnf.properties['model-invariant-id'],
 201                                                 modelVersionId: vnf.modelVersionId,
 202                                                 modelName: vnf.properties['vnf-name'],
 203                                                 modelVersion: vnf.version,
 204                                                 modelCustomizationName: vnf.properties['model-customization-name'],
 205                                                 modelCustomizationId: vnf.properties['model-customization-id']
 206                                         },
 207                                         cloudConfiguration: vnf.cloudConfiguration,
 208                                         requestInfo: requestInfoData,
 209                                         relatedInstanceList: [],
 210                                         requestParameters:requestParametersData
 211                                 };
 212
 213                                 var serviceInstanceId = '';
 214                                 _.forEach(vnf['service-instance-node'], function (instanceNode) {
 215                                         if(instanceNode['node-type'] === 'service-instance'){
 216                                                 serviceInstanceId = instanceNode.properties['service-instance-id'];
 217                                         }
 218                                 });
 219
 220                                 if (vnf.availableVersions && vnf.availableVersions.length!=0){
 221                                         _.forEach(vnf.availableVersions[0].relatedInstanceList, function (related) {
 222                                                 var rel = related.relatedInstance;
 223                                                 var relatedInstance = {
 224                                                         instanceId: serviceInstanceId,
 225                                                         modelInfo: {
 226                                                                 modelType: rel.modelInfo.modelType,
 227                                                                 modelInvariantId: rel.modelInfo.modelInvariantId,
 228                                                                 modelVersionId: rel.modelInfo.modelVersionId,
 229                                                                 modelName: rel.modelInfo.modelName,
 230                                                                 modelVersion: rel.modelInfo.modelVersion,
 231                                                                 modelCustomizationName: rel.modelInfo.modelCustomizationName,
 232                                                                 modelCustomizationId: rel.modelInfo.modelCustomizationId
 233                                                         }
 234                                                 };
 235                                                 if (rel.vnfInstanceId)
 236                                                         relatedInstance.instanceId = rel.vnfInstanceId;
 237
 238                                                 data.relatedInstanceList.push({relatedInstance: relatedInstance});
 239                                         });
 240                                 }
 241                                 }catch(err){
 242                                         $log.error('SchedulerCtrl::extractChangeManagementCallbackDataStr error: ' + err);
 243                                 }
 244
 245                                 result.requestDetails.push(data);
 246                         });
 247                         return JSON.stringify(result);
 248                 }
 249
 250         vm.openModal = function () {
 251             if(VIDCONFIGURATION.SCHEDULER_PORTAL_URL) { //scheduling supported
 252                                 $scope.widgetParameter = ""; // needed by the scheduler?
 253
 254                                 // properties needed by the scheduler so it knows whether to show
 255                                 // policy or sniro related features on the scheduler UI or not.
 256                                 vm.changeManagement.policyYN = "Y";
 257                                 vm.changeManagement.sniroYN = "Y";
 258
 259                                 var data = {
 260                                         widgetName: 'Portal-Common-Scheduler',
 261                                         widgetData: vm.changeManagement,
 262                                         widgetParameter: $scope.widgetParameter
 263                                 };
 264
 265                                 window.parent.postMessage(data, VIDCONFIGURATION.SCHEDULER_PORTAL_URL);
 266                         } else {
 267                                 //no scheduling support
 268                                 var dataToSo = extractChangeManagementCallbackDataStr(vm.changeManagement);
 269                                 var vnfName = vm.changeManagement.vnfNames[0].name;
 270                                 changeManagementService.postChangeManagementNow(dataToSo, vnfName);
 271                         }
 272         };
 273
 274         vm.loadSubscribers = function () {
 275             vm.subscribers = [];
 276             AaiService.getSubscribers(function (response) {
 277                 vm.subscribers = response;
 278             });
 279         };
 280
 281         vm.loadServiceTypes = function () {
 282             vm.serviceTypes = [];
 283
 284             AaiService.getSubscriberServiceTypes(vm.changeManagement.subscriberId)
 285                 .then(function (response) {
 286                     vm.serviceTypes = response.data;
 287                 })
 288                 .catch(function (error) {
 289                     $log.error(error);
 290                 });
 291         };
 292
 293         vm.loadVNFTypes = function () {
 294             vm.vnfTypes = [];
 295             vm.vnfTypesTemp = [];
 296             vm.serviceInstances = [];
 297
 298             var instances = vm.changeManagement.serviceType["service-instances"]["service-instance"];
 299             // var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
 300
 301             vm.vnfs = [];
 302
 303             AaiService.getVnfsByCustomerIdAndServiceType(
 304                 vm.changeManagement.subscriberId,
 305                 vm.changeManagement.serviceType["service-type"]
 306             ).then(function (response) {
 307                     var vnfsData = response.data.results;
 308                     if (vnfsData) {
 309                         for (var i = 0; i < vnfsData.length; i++) {
 310                             if (vnfsData[i]) {
 311                                 const nodeType = vnfsData[i]['node-type'];
 312                                 if (nodeType === "generic-vnf") {
 313                                     if (_.find(vnfsData[i]['related-to'], function (node) {
 314                                             return node['node-type'] === 'vserver'
 315                                         }) !== undefined) {
 316                                         vm.vnfs.push(vnfsData[i]);
 317                                     }
 318                                 } else if (nodeType === "service-instance") {
 319                                     vm.serviceInstances.push(vnfsData[i]);
 320                                 }
 321                             }
 322                         }
 323
 324                         vm.vnfs = _.flattenDeep(
 325                             _.remove(vm.vnfs, function (vnf) {
 326                                 var nfRole = vnf.properties['nf-role'];
 327                                 if (nfRole !== undefined) {
 328                                     return nfRole !== 'null' && nfRole !== '';
 329                                 }
 330                             })
 331                         );
 332
 333                         var filteredVnfs = _.uniqBy(vm.vnfs, function (vnf) {
 334                             return vnf.properties['nf-role'];
 335                         });
 336
 337                         _.forEach(filteredVnfs, function (vnf) {
 338                             vm.vnfTypes.push(vnf.properties['nf-role'])
 339                         });
 340                     }
 341                 }
 342             );
 343         };
 344
 345         var fromVNFVersions = [];
 346
 347         vm.loadVNFVersions = function () {
 348             fromVNFVersions = [];
 349             vm.serviceInstancesToGetVersions = [];
 350             var versions = [];
 351             _.forEach(vm.vnfs, function (vnf) {
 352                 if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']) {
 353
 354                     vm.serviceInstancesToGetVersions.push({
 355                         "model-invariant-id": vnf.properties["model-invariant-id"],
 356                         "model-version-id": vnf.properties["model-version-id"] }
 357                     );
 358
 359                     versions.push(vnf.properties["model-invariant-id"]);
 360                 }
 361             });
 362
 363             if (versions.length > 0) {
 364                 AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
 365                     if (response.data) {
 366
 367                         $log.debug("getVnfVersionsByInvariantId: response", response);
 368
 369                         fromVNFVersions = vm.serviceInstancesToGetVersions
 370                             .map(function (serviceInstanceToGetVersion) {
 371                                 const model = _.find(response.data.model, {'model-invariant-id': serviceInstanceToGetVersion['model-invariant-id']});
 372                                 $log.debug("getVnfVersionsByInvariantId: model for " + serviceInstanceToGetVersion['model-invariant-id'], model);
 373
 374                                 const modelVer = _.find(model["model-vers"]["model-ver"], {'model-version-id': serviceInstanceToGetVersion['model-version-id']});
 375                                 $log.debug("getVnfVersionsByInvariantId: modelVer for " + serviceInstanceToGetVersion['model-version-id'], modelVer);
 376
 377                                 var modelVersionId = serviceInstanceToGetVersion["model-version-id"];
 378                                 var modelVersion = modelVer["model-version"];
 379
 380                                 return {"key": modelVersionId, "value": modelVersion};
 381                             });
 382
 383                         vm.fromVNFVersions = _.uniqBy(fromVNFVersions, 'value');
 384                     }
 385                 })
 386             }
 387         };
 388
 389
 390         function getVnfs(modelInvariantId) {
 391             return new Promise(function (resolve, reject) {
 392                 AaiService.getVnfVersionsByInvariantId(modelInvariantId)
 393                     .then(function (response) {
 394                         if (response.data.httpCode !== null &&
 395                             response.data.httpCode === 200) {
 396                             var vnfsData = response.data.t.results;
 397                             for (var i = 0; i < vnfsData.length; i++) {
 398                                 if (vnfsData[i]) {
 399                                     if (vnfsData[i].nodeType === "generic-vnf") {
 400                                         resolve(vnfsData[i]);
 401                                     } else if (vnfsData[i].nodeType === "service-instance") {
 402                                         vm.serviceInstances.push(vnfsData[i]);
 403                                     }
 404                                 }
 405                             }
 406                             resolve(null);
 407                         }
 408                         resolve(null);
 409                     })
 410                     .catch(function (error) {
 411                         reject(error);
 412                     });
 413             });
 414         }
 415
 416         var getVersionNameForId = function(versionId) {
 417             var version = _.find(fromVNFVersions, {"key": versionId});
 418             return version.value;
 419         };
 420
 421         vm.loadVNFNames = function () {
 422             vm.vnfNames = [];
 423             const vnfs = vm.changeManagement.fromVNFVersion ? vm.vnfs : [];
 424             _.forEach(vnfs, function (vnf) {
 425
 426                 var selectedVersionNumber = getVersionNameForId(vm.changeManagement.fromVNFVersion);
 427
 428                 if (vnf.properties['nf-role'] === vm.changeManagement.vnfType &&
 429                     selectedVersionNumber === getVersionNameForId(vnf.properties["model-version-id"])) {
 430                     var vServer = {};
 431
 432                     _.forEach(vnf['related-to'], function (node) {
 433                         if (node['node-type'] === 'vserver') {
 434                             vServer = extractLcpRegionIdAndTenantId(node.url);
 435                         }
 436                     });
 437
 438                     var serviceInstancesIds =
 439                         _.filter(vnf['related-to'], {'node-type': 'service-instance'})
 440                             .map(function (serviceInstance) { return serviceInstance.id });
 441
 442                     var serviceInstances = _.filter(vm.serviceInstances, function(serviceInstance) {
 443                         return _.includes(serviceInstancesIds, serviceInstance.id);
 444                     });
 445
 446                     // logging only
 447                     if (serviceInstancesIds.length === 0) {
 448                         $log.error("loadVNFNames: no serviceInstancesIds for vnf", vnf);
 449                     } else {
 450                         $log.debug("loadVNFNames: serviceInstancesIds", serviceInstancesIds);
 451                         $log.debug("loadVNFNames: serviceInstances", serviceInstances);
 452                     }
 453
 454                     vm.vnfNames.push({
 455                         "id": vnf.properties["vnf-id"],
 456                         "name": vnf.properties["vnf-name"],
 457                         "invariant-id": vnf.properties["model-invariant-id"],
 458                         "service-instance-node": serviceInstances,
 459                         "modelVersionId": vnf.properties["model-version-id"],
 460                         "properties": vnf.properties,
 461                         'cloudConfiguration': vServer,
 462                         "relatedTo": vnf['related-to']
 463                     });
 464                 }
 465             });
 466         };
 467
 468         function extractLcpRegionIdAndTenantId(url) {
 469
 470             var cloudConfiguration = {
 471                 lcpCloudRegionId: '',
 472                 tenantId: ''
 473             };
 474
 475             /*
 476              e.g., in both URLs below -
 477                - lcpCloudRegionId == 'rdm5b'
 478                - tenantId == '0675e0709bd7444a9e13eba8b40edb3c'
 479
 480              "url": "https://aai-conexus-e2e.ecomp.cci.att.com:8443/aai/v10/cloud-infrastructure/cloud-regions/cloud-region/att-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 481              "url": "/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/att-aic/rdm5b/tenants/tenant/0675e0709bd7444a9e13eba8b40edb3c/vservers/vserver/932b330d-733e-427d-a519-14eebd261f70"
 482              */
 483
 484             var cloudRegionMatch = url.match(/\/cloud-regions\/cloud-region\/[^\/]+\/([^\/]+)/);
 485             var tenantMatch = url.match(/\/tenants\/tenant\/([^\/]+)/);
 486
 487             cloudConfiguration.lcpCloudRegionId = cloudRegionMatch[1];
 488             cloudConfiguration.tenantId = tenantMatch[1];
 489
 490             return cloudConfiguration;
 491         };
 492
 493         vm.loadWorkFlows = function () {
 494             changeManagementService.getWorkflows(vm.changeManagement.vnfNames)
 495                 .then(function(response) {
 496                     vm.workflows = response.data.workflows;
 497                 })
 498                 .catch(function(error) {
 499                     $log.error(error);
 500                 });
 501         };
 502
 503         //Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
 504         $scope.selectFileForVNFName = function (fileInput) {
 505             if (fileInput && fileInput.id) {
 506                 var vnfName = _.filter(vm.changeManagement.vnfNames, {"invariant-id": fileInput.id});
 507                 var file = fileInput.files[0];
 508                 var fileReader = new FileReader();
 509                 fileReader.onload = function (load) {
 510                     try {
 511                         var lines = load.target.result;
 512                         vnfName[0].selectedFile = JSON.parse(lines);
 513                     } catch (error) {
 514                         $log.error(error);
 515                     }
 516                 };
 517                 fileReader.readAsText(file);
 518             }
 519         };
 520
 521         vm.selectVersionForVNFName = function (vnfName) {
 522             console.log("Will add version for selected vnf name: " + vnfName.name);
 523         };
 524
 525         vm.isConfigUpdate = function () {
 526             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfConfigUpdate;
 527         }
 528
 529         vm.shouldShowVnfInPlaceFields = function () {
 530             return vm.changeManagement.workflow === COMPONENT.WORKFLOWS.vnfInPlace;
 531         };
 532
 533         init();
 534     }
 535 })();