skyquake/plugins/launchpad/src/instantiate/instantiateStore.js

   1 /*
   2  *
   3  *   Copyright 2016 RIFT.IO Inc
   4  *
   5  *   Licensed under the Apache License, Version 2.0 (the "License");
   6  *   you may not use this file except in compliance with the License.
   7  *   You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *   Unless required by applicable law or agreed to in writing, software
  12  *   distributed under the License is distributed on an "AS IS" BASIS,
  13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *   See the License for the specific language governing permissions and
  15  *   limitations under the License.
  16  *
  17  */
  18 import NetworkServiceActions from './launchNetworkServiceActions.js';
  19 import NetworkServiceSource from './launchNetworkServiceSource.js';
  20 import GUID from 'utils/guid.js';
  21 import AppHeaderActions from 'widgets/header/headerActions.js';
  22 import Alt from '../alt';
  23 import _cloneDeep from 'lodash/cloneDeep';
  24 import _find from 'lodash/find';
  25 import _merge from 'lodash/merge';
  26
  27 class LaunchNetworkServiceStore {
  28     constructor() {
  29         this.nsd = [];
  30         this.nsdDict = {};
  31         this.vnfd = [];
  32         this.pnfd = [];
  33         this.vld = [];
  34         this.name = "";
  35         this.ipProfiles = [];
  36         this.dnsServers = [];
  37         this.sshKeysList = [];
  38         this.sshKeysRef = [];
  39         this.sla_parameters = [];
  40         this.selectedNSDid;
  41         this.selectedNSD = {};
  42         this.dataCenters = [];
  43         this.isLoading = false;
  44         this.hasConfigureNSD = false;
  45         this.hasConfigureVNFD = false;
  46         this['input-parameters'] = [];
  47         this.displayPlacementGroups = true;
  48         this.bindActions(NetworkServiceActions);
  49         this.nsdConfiguration = {
  50             name:'',
  51             dataCenterID: null
  52         };
  53         /*Collection of vnf state containting cloud account and datacenter info.
  54         keyed off vnfd-id-ref
  55         */
  56         this.usersList = [];
  57         this.configAgentAccounts = [];
  58
  59         this.isPreviewing = false;
  60         this.isOpenMano = false;
  61
  62         this.displayVIMAccounts = false;
  63         this.resourceOrchestrators = [{
  64             name: 'openmano',
  65             'ro-account-type': 'openmano'
  66         }];
  67         this.selectedResourceOrchestrator = this.resourceOrchestrators[0];
  68         this.dataCenterID = null;
  69         this.vnfDataCenters = {};
  70         this.registerAsync(NetworkServiceSource);
  71         this.exportPublicMethods({
  72             getMockData: getMockData.bind(this),
  73             getMockSLA: getMockSLA.bind(this),
  74             saveNetworkServiceRecord: this.saveNetworkServiceRecord,
  75             nsFn: this.nsFn,
  76             vnfFn: this.vnfFn,
  77             updateInputParam: this.updateInputParam,
  78             resetView: this.resetView,
  79             nameUpdated: this.nameUpdated,
  80             //nspg
  81             descriptorSelected: this.descriptorSelected.bind(this),
  82             deselectDescriptor: this.deselectDescriptor,
  83             previewDescriptor: this.previewDescriptor,
  84             vldFn: this.vldFn,
  85             ipProfileFn: this.ipProfileFn,
  86             dnsFn: this.dnsFn,
  87             usersFn: this.usersFn,
  88             sshFn: this.sshFn
  89         });
  90     }
  91
  92     //
  93     resetView = () => {
  94         console.log('reseting state');
  95         this.setState({
  96             name: '',
  97             'input-parameter-xpath': null,
  98             'ns-placement-groups': null,
  99             'vnf-placement-groups':null
 100         })
 101     }
 102
 103
 104     //Action Handlers
 105     getCatalogSuccess(catalogs) {
 106         let self = this;
 107         let nsdDict = {};
 108         let nsd = [];
 109         let vnfd = [];
 110         let pnfd = [];
 111         catalogs.forEach(function(catalog) {
 112             switch (catalog.type) {
 113                 case "nsd":
 114                     nsd.push(catalog);
 115                     try {
 116                         self.descriptorSelected(catalog.descriptors[0])
 117                     } catch (e) {
 118                         console.log('unable to select catalog')
 119                     }
 120                     break;
 121                 case "vnfd":
 122                     vnfd.push(catalog);
 123                     break;
 124                 case "pnfd":
 125                     pnfd.push(catalog);
 126                     break;
 127             }
 128         });
 129         nsd[0].descriptors.map(function(n) {
 130             nsdDict[n.id] = n;
 131         })
 132         this.setState({
 133             nsd, vnfd, pnfd, nsdDict,
 134
 135         });
 136     }
 137     getConfigAgentSuccess(configAgentAccounts) {
 138         this.setState({
 139             configAgentAccounts: configAgentAccounts
 140         })
 141     }
 142     getDataCentersSuccess(data) {
 143         let dataCenters = data;
 144
 145         let newState = {
 146             dataCenters: dataCenters || []
 147         };
 148     if (this.ro && this.ro['account-type'] == 'openmano') {
 149             newState.dataCenterID = dataCenters[this.ro.name][0].uuid
 150         }
 151         this.setState(newState)
 152     }
 153     getVDUSuccess(VNFD) {
 154         this.setState({
 155             sla_parameters: VNFD
 156         })
 157     }
 158     launchNSRLoading() {
 159         Alt.actions.global.showScreenLoader.defer();
 160         this.setState({
 161             isLoading: true
 162         });
 163         console.log('is Loading', this)
 164     }
 165     launchNSRSuccess(data) {
 166         console.log('Launching Network Service')
 167         let tokenizedHash = window.location.hash.split('/');
 168         Alt.actions.global.hideScreenLoader.defer();
 169         this.setState({
 170             isLoading: false
 171         });
 172         return window.location.hash = 'launchpad/' + tokenizedHash[2];
 173     }
 174     launchNSRError(data) {
 175         Alt.actions.global.showNotification.defer(data);
 176         Alt.actions.global.hideScreenLoader.defer();
 177         this.setState({
 178             isLoading: false
 179         });
 180     }
 181     getInstantiateSshKeySuccess = (data) => {
 182         this.setState({
 183             sshKeysList: data,
 184             sshKeysRef: []
 185         })
 186     }
 187     getResourceOrchestratorAccountsSuccess = (data) => {
 188         let self = this;
 189         Alt.actions.global.hideScreenLoader.defer();
 190         let ROAccounts = [];
 191         ROAccounts = ROAccounts.concat(data).filter(function(r){ return r.name != "rift" });
 192         this.setState({
 193             resourceOrchestrators: ROAccounts,
 194             selectedResourceOrchestrator: ROAccounts[0],
 195             dataCenterID: ROAccounts[0] && ROAccounts[0].datacenters && ROAccounts[0].datacenters.datacenters && ROAccounts[0].datacenters.datacenters[0] && ROAccounts[0].datacenters.datacenters[0].name,
 196             dataCenterType:  ROAccounts[0] && ROAccounts[0].datacenters && ROAccounts[0].datacenters.datacenters && ROAccounts[0].datacenters.datacenters[0] && ROAccounts[0].datacenters.datacenters[0]['datacenter-type'],
 197             displayVIMAccounts: false
 198         })
 199     }
 200     getResourceOrchestratorError = (data) => {
 201         console.log('getResourceOrchestrator Error: ', data)
 202     }
 203     //Form handlers
 204     nameUpdated = (e) => {
 205         this.setState({
 206             name: e.target.value
 207         })
 208     }
 209     deselectDescriptor = () => {
 210         console.log('deselecting')
 211         this.setState({
 212             selectedNSDid: null,
 213             selectedNSD: {},
 214             isPreviewing: false
 215         })
 216     }
 217     descriptorSelected = (data) => {
 218         let NSD = data;
 219         let VNFIDs = [];
 220         this.resetView();
 221         let newState = {
 222             selectedNSDid: NSD.id,
 223             vld: NSD && NSD.vld && NSD.vld.map(function(v) {
 224                 //Adding a type for UI state management
 225                 //This is deleted before launch
 226                 if(v['ip-profile-ref']) {
 227                     v.type = 'ip-profile-ref';
 228                 } else {
 229                     if(v['vim-network-name']) {
 230                         v.type = 'vim-network-name';
 231                     } else {
 232                         v.type = 'none';
 233                     }
 234                 }
 235                 return v;
 236             }),
 237             ipProfiles: NSD['ip-profiles']
 238         };
 239         newState.selectedNSD = data;
 240         newState['input-parameters'] = [];
 241         newState['vnf-input-parameter'] = [];
 242         if (NSD['input-parameter-xpath']) {
 243             let vnfParameters = [];
 244             newState.hasConfigureNSD = true;
 245             NSD['input-parameter-xpath'].map(function(p) {
 246                 if (isVNFDInputParameter(p)) {
 247                     newState.hasConfigureVNFD = true;
 248                     vnfParameters.push(p);
 249                 } else {
 250                     newState.hasConfigureNSD = true;
 251                     newState['input-parameters'].push(p);
 252                 }
 253             })
 254             newState['vnf-input-parameter'] = NSD['constituent-vnfd'].map(function(vnf) {
 255                 return {
 256                     'name': vnf['vnf-name'],
 257                     'member-vnf-index-ref': vnf['member-vnf-index'],
 258                     'vnfd-id-ref': vnf['vnfd-id-ref'],
 259                     'input-parameter':_cloneDeep(vnfParameters)
 260                 }
 261             })
 262         } else {
 263             newState.hasConfigureNSD = false;
 264             newState['input-parameter'] = null;
 265         }
 266         if(NSD['ns-placement-groups'] && NSD['ns-placement-groups'].length > 0 ) {
 267             newState['ns-placement-groups'] = NSD['ns-placement-groups'];
 268         }
 269         if(NSD['vnf-placement-groups'] && NSD['vnf-placement-groups'].length > 0 ) {
 270             newState['vnf-placement-groups'] = NSD['vnf-placement-groups'];
 271         }
 272         NSD["constituent-vnfd"] && NSD["constituent-vnfd"].map((v) => {
 273             VNFIDs.push(v["vnfd-id-ref"]);
 274         })
 275         this.getInstance().getVDU(VNFIDs);
 276         this.setState(newState);
 277
 278         function isVNFDInputParameter(p){
 279             return p.xpath.match('vnfd-catalog');
 280         }
 281     }
 282     previewDescriptor = (data) => {
 283         let self = this;
 284         return function(e) {
 285             self.setState({
 286                 isPreviewing: true,
 287                 selectedNSD: data
 288             })
 289         }
 290     }
 291     updateInputParam = (i, value) => {
 292         let ip = this['input-parameters'];
 293         ip[i].value = value;
 294         this.setState({
 295             'input-parameters': ip
 296         });
 297     }
 298     updateVnfInputParam = (i, j, value) => {
 299         let ip = this['vnf-input-parameter'];
 300         ip[i]['input-parameter'][j].value = value;
 301         this.setState({
 302             'vnf-input-parameter': ip
 303         });
 304     }
 305     nsFn = () => {
 306         let self = this;
 307         return {
 308             updateSelectedRoAccount: (resourceOrchestrator) => {
 309                 let nsd = self.nsd[0];
 310                 var newState = {
 311                     selectedResourceOrchestrator: JSON.parse(JSON.parse(resourceOrchestrator.target.value))
 312                 };
 313                 // if no datacenters and ro is not rift-ro
 314                 if (!(newState.selectedResourceOrchestrator.datacenters && newState.selectedResourceOrchestrator.datacenters.datacenters) ) {
 315                     Alt.actions.global.showNotification.defer("No data centers configured in resource orchestrator");
 316                 } else {
 317                     newState.dataCenterID = newState.selectedResourceOrchestrator.datacenters.datacenters[0].name;
 318                     newState.dataCenterType = newState.selectedResourceOrchestrator.datacenters.datacenters[0]['datacenter-type'];
 319                     newState.displayPlacementGroups = newState.selectedResourceOrchestrator.name == "rift" ? true : false;
 320                 }
 321                 self.setState(newState);
 322             },
 323             updateSelectedDataCenter: (dataCenter) => {
 324                 let dataCenterID = JSON.parse(JSON.parse(dataCenter.target.value));
 325                 let dataCenterType = _find(self.selectedResourceOrchestrator.datacenters.datacenters, {name: dataCenterID})
 326
 327                 self.setState({
 328                     dataCenterID,
 329                     dataCenterType
 330                 });
 331             },
 332             placementGroupUpdate: (i, k, event) => {
 333                 let value = event.target.value;
 334                 let pg = self['ns-placement-groups'];
 335                 pg[i][k] = value;
 336                 self.setState({
 337                     'ns-placement-groups': pg
 338                 })
 339             },
 340             hostAggregateUpdate: (pgi, hai, k, event) => {
 341                 let value = event.target.value;
 342                 let pg = self['ns-placement-groups'];
 343                 let ha = pg[pgi]['host-aggregate'][hai];
 344                 ha[k] = value;
 345                 self.setState({
 346                     'ns-placement-groups': pg
 347                 })
 348             },
 349             addHostAggregate: (pgi) => {
 350                 let pg = self['ns-placement-groups'];
 351                 let ha = pg[pgi]['host-aggregate'];
 352                 ha.push({});
 353                 self.setState({
 354                     'ns-placement-groups': pg
 355                 })
 356             },
 357             removeHostAggregate: (pgi, hai) => {
 358                 let pg = self['ns-placement-groups'];
 359                 let ha = pg[pgi]['host-aggregate'];
 360                 ha.splice(hai, 1);
 361                 self.setState({
 362                     'ns-placement-groups': pg
 363                 })
 364             },
 365             getNSDByID: (id) => {
 366
 367             }
 368         }
 369     }
 370     vnfFn = () => {
 371         let self = this;
 372         return {
 373             placementGroupUpdate: (i, k, event) => {
 374                 let value = event.target.value;
 375                 let pg = self['vnf-placement-groups'];
 376                 pg[i][k] = value;
 377                 self.setState({
 378                     'vnf-placement-groups': pg
 379                 })
 380             },
 381             hostAggregateUpdate: (pgi, hai, k, event) => {
 382                 let value = event.target.value;
 383                 let pg = self['vnf-placement-groups'];
 384                 let ha = pg[pgi]['host-aggregate'][hai];
 385                 ha[k] = value;
 386                 self.setState({
 387                     'vnf-placement-groups': pg
 388                 })
 389             },
 390             addHostAggregate: (pgi) => {
 391                 let pg = self['vnf-placement-groups'];
 392                 let ha = pg[pgi]['host-aggregate'];
 393                 ha.push({});
 394                 self.setState({
 395                     'vnf-placement-groups': pg
 396                 })
 397             },
 398             removeHostAggregate: (pgi, hai) => {
 399                 let pg = self['vnf-placement-groups'];
 400                 let ha = pg[pgi]['host-aggregate'];
 401                 ha.splice(hai, 1);
 402                 self.setState({
 403                     'vnf-placement-groups': pg
 404                 })
 405             },
 406             updateSelectedConfigAgent:  (id) => {
 407                 return function(e) {
 408                     let configAgentRef = JSON.parse(e.target.value);
 409                     let vnfDC = self.vnfDataCenters;
 410                     if(configAgentRef) {
 411                         if (!vnfDC[id]) {
 412                             vnfDC[id] = {};
 413                         }
 414                         vnfDC[id]['config-agent-account'] = configAgentRef;
 415                     } else {
 416                         if(vnfDC[id].hasOwnProperty('datacenter')) {
 417                             delete vnfCA[id]['config-agent-account'];
 418                         } else {
 419                             delete vnfCA[id];
 420                         }
 421                     }
 422                     self.setState({
 423                         vnfDataCenters: vnfDC
 424                     });
 425                 }
 426             },
 427             updateSelectedDataCenter: (id, dataCenter) => {
 428                 let vnfDC = self.vnfDataCenters;
 429                 let dc = JSON.parse(JSON.parse(dataCenter.target.value));
 430                 if (!vnfDC[id]) {
 431                     vnfDC[id] = {};
 432                 }
 433                 vnfDC[id]['member-vnf-index-ref'];
 434                 if (dc) {
 435                     vnfDC[id].datacenter = dc;
 436                 } else {
 437                     delete vnfDC[id];
 438                 }
 439
 440                 self.setState({
 441                     vnfDataCenters: vnfDC
 442                 });
 443             }
 444         }
 445     }
 446     vldFn = () => {
 447         let self = this;
 448         return {
 449             updateType: (i) => {
 450                 return function(e){
 451                     let type = e.target.value;
 452                     let vld = self.vld;
 453                     if (vld[i].hasOwnProperty('type')) {
 454                         delete vld[i][vld[i].type]
 455                     }
 456                     vld[i].type = type;
 457                     vld[i][type] = '';
 458                     if(type == 'ip-profile-ref') {
 459                         let IPProfile = self.ipProfiles;
 460                         vld[i][type] = IPProfile[0] && IPProfile[0].name;
 461                         delete vld[i]['vim-network-name'];
 462                         delete vld[i]['ipv4-nat-pool-name'];
 463                     } else {
 464                         delete vld[i]['dns-server'];
 465                         vld[i]['ipv4-nat-pool-name'] = self.dataCenterID
 466                     }
 467                     if(type == 'none') {
 468                         delete vld[i]['ip-profile-ref'];
 469                         delete vld[i]['vim-network-name'];
 470                         delete vld[i]['ipv4-nat-pool-name'];
 471                     }
 472                     self.setState({vld:vld});
 473                 }
 474             },
 475             updateValue:  (i, type) => {
 476                 return function(e) {
 477                     // Select Option returns JSON values.
 478                     let value = e.target.nodeName == "SELECT" ? JSON.parse(e.target.value) : e.target.value;
 479                     let vld = self.vld;
 480                     vld[i][type] = value;
 481                     self.setState({vld:vld});
 482                 }
 483             }
 484         }
 485     }
 486     ipProfileFn = () => {
 487         let self = this;
 488         return {
 489             updateProfile: (i, key) => {
 490                 return function(e) {
 491                     // Select Option returns JSON values.
 492                     let value = e.target.nodeName == "SELECT" ? JSON.parse(e.target.value) : e.target.value;
 493                     self.ipProfiles[i]['ip-profile-params'][key] = value;
 494
 495                     if (value == '') {
 496                         // Don't send this key
 497                         delete self.ipProfiles[i]['ip-profile-params'][key];
 498                     }
 499
 500                     self.setState({ipProfiles:self.ipProfiles});
 501                 }
 502             },
 503             updateVersion: (i) => {
 504                 return function(e) {
 505                     // Select Option returns JSON values.
 506                     let value = e.target.value;
 507                     self.ipProfiles[i]['ip-profile-params']['ip-version'] = value;
 508                     self.setState({ipProfiles:self.ipProfiles});
 509                 }
 510             },
 511             updateDNS: (i, dnsIndex) => {
 512                 return function(e) {
 513                     // Select Option returns JSON values.
 514                 let value = e.target.nodeName == "SELECT" ? JSON.parse(e.target.value) : e.target.value;
 515                     self.ipProfiles[i]['ip-profile-params']['dns-server'][dnsIndex] = value;
 516                     self.setState({ipProfiles:self.ipProfiles});
 517                 }
 518             },
 519             updateDHCP: (i, property) => {
 520                 return function(e) {
 521                     let value = e.target.value;
 522                     //If value is meant to be boolean, convert it
 523                     if(value == "true" || value == "false") {
 524                         value = JSON.parse(value);
 525                     }
 526                     if(!self.ipProfiles[i]['ip-profile-params'].hasOwnProperty('dhcp-params')) {
 527                         self.ipProfiles[i]['ip-profile-params']['dhcp-params'] = {
 528                             enabled: true,
 529                             'start-address': '',
 530                             count: ''
 531                         }
 532                     }
 533                     //Removing DCHP property on disable to allow instantiation
 534                     if(!value) {
 535                         self.ipProfiles[i]['ip-profile-params']['dhcp-params'] = {
 536                             enabled: false
 537                         };
 538                     } else {
 539                         self.ipProfiles[i]['ip-profile-params']['dhcp-params'][property] = value;
 540                     }
 541                     self.setState({ipProfiles:self.ipProfiles});
 542                 }
 543             }
 544         }
 545     }
 546     dnsFn = () => {
 547         let self = this;
 548         return {
 549             addDNS: (i) => {
 550                 let self = this;
 551                 return function(e) {
 552                     if(self.ipProfiles[i]['ip-profile-params']['dns-server']) {
 553                         self.ipProfiles[i]['ip-profile-params']['dns-server'].unshift({})
 554                     } else {
 555                         self.ipProfiles[i]['ip-profile-params']['dns-server'] = [{}];
 556                     }
 557
 558                     self.setState({ipProfiles:self.ipProfiles});
 559                 }
 560             },
 561             removeDNS: (i, k) => {
 562                 let self = this;
 563                 return function(e) {
 564                     self.ipProfiles[i]['ip-profile-params']['dns-server'].splice(k, 1);
 565                     if(self.ipProfiles[i]['ip-profile-params']['dns-server'].length == 0) {
 566                         delete self.ipProfiles[i]['ip-profile-params']['dns-server'];
 567                     }
 568                     self.setState({ipProfiles:self.ipProfiles});
 569                 }
 570             },
 571             updateDNS: (i, k) => {
 572                 let self = this;
 573                 return function(e) {
 574                     let value = e.target.value;
 575                     self.ipProfiles[i]['ip-profile-params']['dns-server'][k].address = value;
 576                     self.setState({ipProfiles:self.ipProfiles});
 577                 }
 578             }
 579         }
 580     }
 581     sshFn = () => {
 582         let self = this;
 583         return {
 584             updateNewKeyRefSelection: (e) => {
 585                 self.setState({
 586                     newRefSelection: e.target.value
 587                 })
 588             },
 589             updateKeyRef: (refIndex, remove) => {
 590                 let self = this;
 591                 return function(e) {
 592                     let sshKeysRef = self.sshKeysRef;
 593                     if(!remove) {
 594                         // if(!e.target.value) {
 595                         //     return Alt.actions.global.showError.defer('Please select a key pair');
 596                         // } else {
 597                             if(!isNaN(refIndex)){
 598                                 sshKeysRef.splice(refIndex, 1);
 599                                 sshKeysRef.push(e.target.value);
 600                             } else {
 601                                 sshKeysRef.push(e.target.value);
 602                             }
 603                         // }
 604                     } else {
 605                         sshKeysRef.splice(refIndex, 1);
 606                     }
 607                     self.setState({
 608                         sshKeysRef: sshKeysRef,
 609                         newRefSelection: null
 610                     })
 611                 }
 612             }
 613         }
 614     }
 615     usersFn = () => {
 616         let self = this;
 617         return {
 618             add: function(sshKeysList) {
 619                 return function(e) {
 620                     let newUser = {
 621                         name: '',
 622                         'user-info': '',
 623                         'ssh-authorized-key': [sshKeysList[0].name]
 624                     }
 625                     let usersList = self.usersList;
 626                     usersList.push(newUser);
 627                     self.setState({
 628                         usersList:  usersList
 629                     })
 630                 }
 631             },
 632             remove: function(i) {
 633                 return function() {
 634                     self.usersList.splice(i, 1);
 635                     self.setState({
 636                         usersList: self.usersList
 637                     })
 638                 }
 639             },
 640             update: function(i, key) {
 641                 return function(e) {
 642                     let value = e.target.value;
 643                     self.usersList[i][key] = value;
 644                     self.setState({
 645                         usersList: self.usersList
 646                     })
 647                 }
 648             },
 649             updateSSHkeyRef: function(i, j, remove){
 650                 return function(e) {
 651                     let usersList = _cloneDeep(self.usersList)
 652                     let keys = usersList[i]['ssh-authorized-key'];
 653                     if(!remove) {
 654                         let keyRef = JSON.parse(e.target.value).name;
 655                         if(!isNaN(j)) {
 656                             keys.splice(j, 1);
 657                         }
 658                         keys.push(keyRef);
 659                     } else {
 660                         keys.splice(j, 1);
 661                     }
 662                     usersList[i]['ssh-authorized-key'] = keys;
 663                     self.setState({
 664                         usersList: usersList
 665                     })
 666                 }
 667             }
 668         }
 669     }
 670     saveNetworkServiceRecord(name, launch) {
 671         let self = this;
 672         //input-parameter: [{uuid: < some_unique_name>, xpath: <same as you got from nsd>, value: <user_entered_value>}]
 673         /*
 674         'input-parameter-xpath':[{
 675                 'xpath': 'someXpath'
 676             }],
 677          */
 678         let nsPg = null;
 679         let vnfPg = null;
 680         let guuid = GUID();
 681
 682         // Create a filtered NSD payload from the decorated one as RW.REST cannot handle extra parameters now
 683         let nsdPayload = {};
 684         nsdPayload = _cloneDeep(_find(this.state.nsd[0].descriptors, {id: this.state.selectedNSDid}));
 685
 686         if (nsdPayload != {}) {
 687             nsdPayload['meta'] && delete nsdPayload['meta'];
 688             nsdPayload['constituent-vnfd'] && nsdPayload['constituent-vnfd'].map((constituentVnfd) => {
 689                 constituentVnfd['vnf-name'] && delete constituentVnfd['vnf-name'];
 690                 constituentVnfd['name'] && delete constituentVnfd['name'];
 691             });
 692             nsdPayload['placement-groups'] && nsdPayload['placement-groups'].map((placementGroup) => {
 693                 placementGroup['member-vnfd'] && placementGroup['member-vnfd'].map((memberVnfd) => {
 694                 memberVnfd['name'] && delete memberVnfd['name'];
 695             });
 696             })
 697             nsdPayload['ns-placement-groups'] && delete nsdPayload['ns-placement-groups'];
 698             nsdPayload['vnf-placement-groups'] && delete nsdPayload['vnf-placement-groups'];
 699             nsdPayload.vld = this.state.vld;
 700             nsdPayload.vld && nsdPayload.vld.map(function(v){
 701                 delete v['none'];
 702                 delete v.type;
 703             });
 704             nsdPayload['input-parameter-xpath'] && nsdPayload['input-parameter-xpath'].map((x) => delete x.value);
 705         }
 706         let payload = {
 707             id: guuid,
 708             "name": name,
 709             "short-name": name,
 710             "description": "a description for " + guuid,
 711             "admin-status": launch ? "ENABLED" : "DISABLED",
 712             "nsd": nsdPayload
 713         }
 714
 715         if(!this.state.selectedResourceOrchestrator) {
 716             Alt.actions.global.showNotification.defer("No Resource Orchestrator selected");
 717             return;
 718         }
 719         if (this.state.selectedResourceOrchestrator.name != "rift") {
 720             payload["resource-orchestrator"] = this.state.selectedResourceOrchestrator.name;
 721         }
 722
 723         if(!this.state.dataCenterID) {
 724             Alt.actions.global.showNotification.defer("No Data Center selected");
 725             return;
 726         }
 727         payload["datacenter"] = this.state.dataCenterID;
 728
 729         //Clean Input Parameters
 730         if (this.state.hasConfigureNSD) {
 731             let ips = _cloneDeep(this.state['input-parameters']);
 732
 733             let ipsToSend = ips.filter(function(ip) {
 734                 if (ip.value && ip.value != "") {
 735                     delete ip.label;
 736                     delete ip.name;
 737                     delete ip['default-value'];
 738
 739                     return true;
 740                 }
 741                 return false;
 742             });
 743             if (ipsToSend.length > 0) {
 744                 payload['input-parameter'] = ipsToSend;
 745             }
 746         }
 747         //Clean VNF Input Parameters
 748         if (this.state.hasConfigureVNFD) {
 749             let vnf = _cloneDeep(this.state['vnf-input-parameter']);
 750             vnf = vnf.filter(function(v){
 751                 delete v.name;
 752                 v['input-parameter'] = v['input-parameter'].filter(
 753                     function(i) {
 754                         if(i.value && i.value != "") {
 755                             delete i.label;
 756                             delete i['default-value'];
 757                             return true;
 758                         }
 759                         return false;
 760                 });
 761                 if (v['input-parameter'].length) {
 762                     return true;
 763                 }
 764                     return false;
 765             })
 766             if (vnf.length > 0) {
 767                 payload['vnf-input-parameter'] = vnf;
 768             }
 769         }
 770         let VnfDataCenters = this.state.vnfDataCenters;
 771         if (Object.keys(VnfDataCenters).length) {
 772             payload['vnf-datacenter-map'] = Object.keys(VnfDataCenters).map(function(k) {
 773                 return {
 774                     'member-vnf-index-ref' : k,
 775                     datacenter: VnfDataCenters[k].datacenter
 776                 }
 777             })
 778         }
 779         // These placement groups need to be refactored. Too much boilerplate.
 780         if (this.state.displayPlacementGroups) {
 781             nsPg = this.state['ns-placement-groups'];
 782             vnfPg = this.state['vnf-placement-groups'];
 783             if(nsPg && (nsPg.length > 0)) {
 784                 payload['nsd-placement-group-maps'] = nsPg.map(function(n, i) {
 785                     if(n['availability-zone'] || n['server-group'] || (n['host-aggregate'].length > 0)) {
 786                         var obj = {
 787                             'cloud-type': self.state.dataCenterType
 788                         };
 789                         if(n['host-aggregate'].length > 0) {
 790                             obj['host-aggregate'] = n['host-aggregate'].map(function(h, j) {
 791                                 return {
 792                                     'metadata-key': h.key,
 793                                     'metadata-value': h.value
 794                                 }
 795                             })
 796                         }
 797                         if(n['availability-zone'] && (n['availability-zone'] != '')) {
 798                             obj['availability-zone'] = {name: n['availability-zone']};
 799                         }
 800                         if(n['server-group'] && (n['server-group'] != '')) {
 801                             obj['server-group'] = {name: n['server-group']};
 802                         }
 803                         obj['placement-group-ref'] = n.name;
 804                         return obj;
 805                     }
 806                 }).filter(function(o){
 807                     if(o) {
 808                         return true;
 809                     } else {
 810                         return false;
 811                     }
 812                 });
 813             };
 814             if(vnfPg && (vnfPg.length > 0)) {
 815                 let vnfDataCenterDictionary = {};
 816                 payload['vnf-datacenter-map'] && payload['vnf-datacenter-map'].map(function(d) {
 817                     vnfDataCenterDictionary[d['member-vnf-index-ref']] = d.datacenter
 818                 })
 819                 payload['vnfd-placement-group-maps'] = vnfPg.map(function(n, i) {
 820                     if(n['availability-zone'] || n['server-group'] || (n['host-aggregate'].length > 0)) {
 821                         let DC = vnfDataCenterDictionary[n['member-vnf-index']];
 822                         var obj = {
 823                             'cloud-type': DC ? _find(self.state.selectedResourceOrchestrator.datacenters.datacenters, {name: DC})['datacenter-type'] : self.state.dataCenterType
 824                         };
 825                         if(n['host-aggregate'].length > 0) {
 826                             obj['host-aggregate'] = n['host-aggregate'].map(function(h, j) {
 827                                 return {
 828                                     'metadata-key': h.key,
 829                                     'metadata-value': h.value
 830                                 }
 831                             })
 832                         }
 833                         if(n['server-group'] && (n['server-group'] != '')) {
 834                             obj['server-group'] = {name: n['server-group']};
 835                         }
 836                         if(n['availability-zone'] && (n['availability-zone'] != '')) {
 837                             obj['availability-zone'] = {name: n['availability-zone']};
 838                         }
 839                         obj['placement-group-ref'] = n.name;
 840                         obj['vnfd-id-ref'] = n['vnfd-id-ref'];
 841                         return obj;
 842                     }
 843                 }).filter(function(o){
 844                     if(o) {
 845                         return true;
 846                     } else {
 847                         return false;
 848                     }
 849                 });
 850             }
 851         }
 852
 853         //Add SSH-Keys
 854         payload['ssh-authorized-key'] = this.state.sshKeysRef.map(function(k) {
 855             return {'key-pair-ref': JSON.parse(k).name};
 856         });
 857         //Add Users
 858         payload['user'] = addKeyPairRefToUsers(this.state.usersList);
 859         console.log(payload)
 860         this.launchNSR({
 861             'nsr': [payload]
 862         });
 863     }
 864 }
 865
 866
 867 function addKeyPairRefToUsers(list) {
 868     return list.map(function(u) {
 869         return {
 870             name: u.name,
 871             'user-info': u['user-info'],
 872             'ssh-authorized-key': u['ssh-authorized-key'].map(function(k) {
 873                 return {
 874                     'key-pair-ref' : k
 875                 }
 876             })
 877         }
 878     })
 879 }
 880
 881 function getMockSLA(id) {
 882     console.log('Getting mock SLA Data for id: ' + id);
 883     this.setState({
 884         sla_parameters: slaData
 885     });
 886 }
 887
 888 function getMockData() {
 889     console.log('Getting mock Descriptor Data');
 890     this.setState({
 891         nsd: data.nsd,
 892         vnfd: data.vnfd,
 893         pnfd: data.pnfd
 894     });
 895 }
 896 export default LaunchNetworkServiceStore;