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

   1 (function () {
   2     'use strict';
   3
   4     appDS2.controller("newChangeManagementModalController", ["$uibModalInstance", "$uibModal", "AaiService", "changeManagementService",
   5         "$log", "$scope", "_", newChangeManagementModalController]);
   6
   7     function newChangeManagementModalController($uibModalInstance, $uibModal, AaiService, changeManagementService, $log, $scope, _) {
   8         var vm = this;
   9
  10         var init = function () {
  11             vm.changeManagement = {};
  12
  13             loadServicesCatalog();
  14             registerVNFNamesWatcher();
  15             vm.loadSubscribers();
  16         };
  17
  18         var loadServicesCatalog = function () {
  19             changeManagementService.getAllSDCServices()
  20                 .then(function (response) {
  21                     vm.SDCServicesCatalog = response.data;
  22                 })
  23                 .catch(function (error) {
  24                     $log.error(error);
  25                 })
  26         };
  27
  28         var registerVNFNamesWatcher = function () {
  29             $scope.$watch('vm.changeManagement.vnfNames', function (newVal, oldVal) {
  30                 if (!oldVal || newVal && newVal.length > oldVal.length) { //JUST THE LAST ONE ADDED
  31                     var newVNFName = _.last(vm.changeManagement.vnfNames);
  32                     if (oldVal) {
  33                         vm.changeManagement.vnfNames = oldVal;
  34                         vm.changeManagement.vnfNames.push(newVNFName);
  35                     }
  36                     if (newVNFName && newVNFName["service-instance-node"]) {
  37                         var availableVersions = [];
  38                         var services = _.filter(vm.SDCServicesCatalog.services,
  39                             {"invariantUUID": newVNFName["service-instance-node"][0].properties["model-invariant-id"]});
  40
  41                         _.each(services, function (service) {
  42                             changeManagementService.getSDCService(service.uuid)
  43                                 .then(function (response) {
  44                                     _.each(response.data.vnfs, function (vnf) {
  45                                         if (newVNFName["invariant-id"] === vnf.invariantUuid) {
  46                                             availableVersions.push(extractVNFModel(vnf, response.data.service, newVNFName));
  47                                         }
  48                                     });
  49                                     var versions = _.uniqBy(availableVersions, ['modelInfo.modelVersion']);
  50                                     newVNFName.availableVersions = _.uniq(versions, response.data.service, true);
  51                                 }).catch(function (error) {
  52                                 $log.error(error);
  53                             });
  54                         });
  55                     }
  56                 }
  57             }, true);
  58         };
  59
  60         var extractVNFModel = function (csarVNF, sdcService, selectionVNF) {
  61             var versionCsarData = {
  62                 vnfInstanceId: "",
  63                 vnfName: csarVNF.name,
  64                 modelInfo: {
  65                     modelType: "vnf",
  66                     modelInvariantId: csarVNF.invariantUuid,
  67                     modelVersionId: selectionVNF.modelVersionId,
  68                     modelName: csarVNF.name,
  69                     modelVersion: csarVNF.version,
  70                     modelCustomizationName: csarVNF.modelCustomizationName,
  71                     modelCustomizationId: csarVNF.customizationUuid
  72                 },
  73                 cloudConfiguration: {
  74                     lcpCloudRegionId: "mdt1",
  75                     tenantId: "88a6ca3ee0394ade9403f075db23167e"
  76                 },
  77                 requestInfo: {
  78                     source: "VID",
  79                     suppressRollback: false,
  80                     requestorId: "az2016"
  81                 },
  82                 relatedInstanceList: [
  83                     {
  84                         relatedInstance: {
  85                             instanceId: selectionVNF["service-instance-node"]["0"].properties['service-instance-id'],
  86                             modelInfo: {
  87                                 modelType: "service",
  88                                 modelInvariantId: selectionVNF["service-instance-node"]["0"].properties['model-invariant-id'],
  89                                 modelVersionId: selectionVNF.modelVersionId,
  90                                 modelName: sdcService.name,
  91                                 modelVersion: sdcService.version,
  92                                 modelCustomizationName: selectionVNF["service-instance-node"]["0"].properties['model-customization-name'], //TODO: Missing
  93                                 modelCustomizationId: selectionVNF["service-instance-node"]["0"].properties['model-customization-id']
  94                             }
  95                         }
  96                     }
  97                 ],
  98                 requestParameters: {
  99                     usePreload: true
 100                 }
 101             };
 102
 103             return versionCsarData;
 104         };
 105
 106         vm.close = function () {
 107             $uibModalInstance.close();
 108         };
 109
 110         vm.schedule = function () {
 111             $uibModalInstance.close(vm.changeManagement);
 112
 113             var modalInstance = $uibModal.open({
 114                 templateUrl: 'app/vid/scripts/modals/new-scheduler/new-scheduler.html',
 115                 controller: 'newSchedulerController',
 116                 controllerAs: 'vm',
 117                 resolve: {
 118                     changeManagement: function () {
 119                         return vm.changeManagement;
 120                     }
 121                 }
 122             });
 123
 124             modalInstance.result.then(function (result) {
 125                 console.log("This is the result of the new change management modal.", result);
 126             })
 127         };
 128
 129         vm.loadSubscribers = function () {
 130             vm.subscribers = [];
 131             AaiService.getSubscribers(function (response) {
 132                 vm.subscribers = response;
 133             });
 134         };
 135
 136         vm.loadServiceTypes = function () {
 137             vm.serviceTypes = [];
 138
 139             AaiService.getSubscriberServiceTypes(vm.changeManagement.subscriberId)
 140                 .then(function (response) {
 141                     vm.serviceTypes = response.data;
 142                 })
 143                 .catch(function (error) {
 144                     $log.error(error);
 145                 });
 146         };
 147
 148         vm.loadVNFTypes = function () {
 149             vm.vnfTypes = [];
 150             vm.vnfTypesTemp = [];
 151             vm.serviceInstances = [];
 152
 153             var instances = vm.changeManagement.serviceType["service-instances"]["service-instance"];
 154             // var promiseArrOfGetVnfs = preparePromiseArrOfGetVnfs(instances);
 155
 156             vm.vnfs = [];
 157
 158             AaiService.getVnfsByCustomerIdAndServiceType(
 159                 vm.changeManagement.subscriberId,
 160                 vm.changeManagement.serviceType["service-type"]
 161             ).then(function (response) {
 162                     var vnfsData = response.data.results;
 163                     if (vnfsData) {
 164                         for (var i = 0; i < vnfsData.length; i++) {
 165                             if (vnfsData[i]) {
 166                                 const nodeType = vnfsData[i]['node-type'];
 167                                 if (nodeType === "generic-vnf") {
 168                                     _.forEach(vnfsData[i]['related-to'], function (node) {
 169                                         if (node['node-type'] === 'vserver') {
 170                                             vm.vnfs.push(vnfsData[i]);
 171                                         }
 172                                     })
 173                                 } else if (nodeType === "service-instance") {
 174                                     vm.serviceInstances.push(vnfsData[i]);
 175                                 }
 176                             }
 177                         }
 178
 179                         vm.vnfs = _.flattenDeep(
 180                             _.remove(vm.vnfs, function (vnf) {
 181                                 var nfRole = vnf.properties['nf-role'];
 182                                 if (nfRole !== undefined) {
 183                                     return nfRole !== 'null' && nfRole !== '';
 184                                 }
 185                             })
 186                         );
 187
 188                         var filteredVnfs = _.uniqBy(vm.vnfs, function (vnf) {
 189                             return vnf.properties['nf-role'];
 190                         });
 191
 192                         _.forEach(filteredVnfs, function (vnf) {
 193                             vm.vnfTypes.push(vnf.properties['nf-role'])
 194                         });
 195                     }
 196                 }
 197             );
 198         };
 199
 200         vm.loadVNFVersions = function () {
 201             vm.fromVNFVersions = [];
 202             vm.serviceInstancesToGetVersions = [];
 203             var versions = [];
 204             _.forEach(vm.vnfs, function (vnf) {
 205                 if (vnf.properties['nf-role'] === vm.changeManagement['vnfType']) {
 206
 207                 vm.serviceInstancesToGetVersions.push(vnf);
 208
 209                 versions.push(vnf.properties["model-invariant-id"]);
 210
 211
 212                 }
 213             });
 214
 215             AaiService.getVnfVersionsByInvariantId(versions).then(function (response) {
 216                 if (response.data) {
 217                     var key = response.data.model["0"]["model-invariant-id"];
 218                     var value = response.data.model["0"]["model-vers"]["model-ver"]["0"]["model-version"];
 219                     var element = {"key": key, "value": value};
 220                     vm.fromVNFVersions.push(element);
 221                 }
 222                 //TODO promise all and call the new api to get the versions.
 223                 // vm.fromVNFVersions.push(response.data.model["0"]["model-vers"]["model-ver"]["0"]["model-version"]);
 224                 // if(vm.serviceInstancesToGetVersions.length > 0){
 225                 //
 226                 // var promiseArrOfGetVnfs = preparePromiseArrOfGetVersions('a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb');
 227                 //
 228                 // Promise.all(promiseArrOfGetVnfs).then(function (allData) {
 229                 //     vm.vnfs = _.flattenDeep(_.without(allData, null));
 230                 //     var filteredVnfs = _.sortedUniqBy(vm.vnfs, function (vnf) {
 231                 //         return vnf.properties.vnfType;
 232                 //     });
 233                 //
 234                 //     _.forEach(filteredVnfs, function (vnf) {
 235                 //         vm.vnfTypes.push(vnf.properties.vnfType)
 236                 //     });
 237                 //
 238                 // }).catch(function (error) {
 239                 //     $log(error);
 240                 // });
 241                 // }
 242             })
 243             // debugger;
 244
 245         };
 246
 247         // function preparePromiseArrOfGetVersions(serviceInstances) {
 248         //     var promiseArr = [];
 249         //     for (var i = 0; i < serviceInstances.length; i++) {
 250         //         var modelInvariantId = serviceInstances[i].properties["model-invariant-id"];
 251         //         promiseArr.push(
 252         //             getVnfs(modelInvariantId)
 253         //         );
 254         //     }
 255         //     return promiseArr;
 256         // }
 257
 258         function getVnfs(modelInvariantId) {
 259             return new Promise(function (resolve, reject) {
 260                 AaiService.getVnfVersionsByInvariantId(modelInvariantId)
 261                     .then(function (response) {
 262                         if (response.data.httpCode !== null &&
 263                             response.data.httpCode === 200) {
 264                             var vnfsData = response.data.t.results;
 265                             for (var i = 0; i < vnfsData.length; i++) {
 266                                 if (vnfsData[i]) {
 267                                     if (vnfsData[i].nodeType === "generic-vnf") {
 268                                         resolve(vnfsData[i]);
 269                                     } else if (vnfsData[i].nodeType === "service-instance") {
 270                                         vm.serviceInstances.push(vnfsData[i]);
 271                                     }
 272                                 }
 273                             }
 274                             resolve(null);
 275                         }
 276                         resolve(null);
 277                     })
 278                     .catch(function (error) {
 279                         reject(error);
 280                     });
 281             });
 282         }
 283
 284         vm.loadVNFNames = function () {
 285             vm.vnfNames = [];
 286
 287             _.forEach(vm.vnfs, function (vnf) {
 288
 289                 if (vnf.properties['nf-role'] === vm.changeManagement.vnfType) {
 290                     var vServer = {};
 291
 292                     _.forEach(vnf['related-to'], function (node) {
 293                         if (node['node-type'] === 'vserver') {
 294                             vServer = extractLcpRegionIdAndTenantId(node.url);
 295                         }
 296                     });
 297
 298                     vm.vnfNames.push({
 299                         "id": vnf.properties["vnf-id"],
 300                         "name": vnf.properties["vnf-name"],
 301                         "invariant-id": vnf.properties["model-invariant-id"],
 302                         "service-instance-node": _.filter(vm.serviceInstances, {id: vnf["related-to"][0].id}),
 303                         "modelVersionId": vnf.properties["model-version-id"],
 304                         "properties": vnf.properties,
 305                         'cloudConfiguration': vServer,
 306                         "relatedTo": vnf['related-to']
 307                     });
 308                 }
 309             });
 310         };
 311
 312         function extractLcpRegionIdAndTenantId(url) {
 313
 314             var cloudConfiguration = {
 315                 lcpCloudRegionId: '',
 316                 tenantId: ''
 317             };
 318
 319             var splitedUrlByDash = _.split(url, '/', 100);
 320
 321             cloudConfiguration.lcpCloudRegionId = splitedUrlByDash[7];
 322             cloudConfiguration.tenantId = splitedUrlByDash[10];
 323
 324             return cloudConfiguration;
 325         };
 326
 327         vm.loadWorkFlows = function () {
 328             var vnfs = [];
 329             angular.forEach(vm.changeManagement.vnfNames, function (vnfName) {
 330                 vnfs.push(vnfName.name)
 331             });
 332
 333             //TODO: When we'll have the mappings, use the backend call to get the workflows
 334             // changeManagementService.getWorkflows(vnfs)
 335             // .then(function(response) {
 336             //     vm.workflows = response.data;
 337             // })
 338             // .catch(function(error) {
 339             //     $log.error(error);
 340             // });
 341
 342             vm.workflows = ["Update", "Replace"];
 343         };
 344
 345         //Must be $scope because we bind to the onchange of the html (cannot attached to vm variable).
 346         $scope.selectFileForVNFName = function (fileInput) {
 347             if (fileInput && fileInput.id) {
 348                 var vnfName = _.filter(vm.changeManagement.vnfNames, {"invariant-id": fileInput.id});
 349                 var file = fileInput.files[0];
 350                 var fileReader = new FileReader();
 351                 fileReader.onload = function (load) {
 352                     try {
 353                         var lines = load.target.result;
 354                         vnfName[0].selectedFile = JSON.parse(lines);
 355                     } catch (error) {
 356                         $log.error(error);
 357                     }
 358                 };
 359                 fileReader.readAsText(file);
 360             }
 361         };
 362
 363         vm.selectVersionForVNFName = function (vnfName) {
 364             console.log("Will add version for selected vnf name: " + vnfName.name);
 365         };
 366
 367         init();
 368     }
 369 })();