// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License. You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied. See the License for the

// specific language governing permissions and limitations

// under the License.

(function(cloudStack, $) {

var ingressEgressDataMap = function(elem) {

var elemData = {

id: elem.ruleid,

protocol: elem.protocol,

startport: elem.startport,

endport: elem.endport,

cidr: elem.cidr ? elem.cidr : ''.concat(elem.account, ' - ', elem.securitygroupname),

tags: elem.tags

};

if (elemData.startport == 0 && elemData.endport) {

elemData.startport = '0';

} else if (elem.icmptype && elem.icmpcode) {

elemData.startport = elem.icmptype;

elemData.endport = elem.icmpcode;

}

return elemData;

};

//value of Primary IP in subselect dropdown is -1, for single VM selection (API parameter virtualmachineid + vmguestip), e.g. enableStaticNat API, createPortForwardingRule API.

var singleVmSecondaryIPSubselect = function(args) {

var instance = args.context.instances[0];

var network = args.context.networks[0];

if (args.context.ipAddresses[0].isportable) { //portable IP which has multiple NICs. Each NIC has a different network ID.

$.ajax({

url: createURL('listNics'),

data: {

virtualmachineid: instance.id

},

success: function(json) {

var nics = json.listnicsresponse.nic;

var ipSelection = [];

$(nics).map(function(index, nic) {

var primaryIp = nic.ipaddress;

var secondaryIps = nic.secondaryip ? nic.secondaryip : [];

var prefix = '[NIC ' + (index + 1) + '] ';

// Add primary IP as default

ipSelection.push({

id: nic.networkid + ',-1',

description: prefix + primaryIp + ' (Primary)'

});

// Add secondary IPs

$(secondaryIps).map(function(index, secondaryIp) {

ipSelection.push({

id: nic.networkid + ',' + secondaryIp.ipaddress,

description: prefix + secondaryIp.ipaddress

});

});

});

args.response.success({

data: ipSelection

});

}

});

} else { //non-portable IP which has only one NIC

/*

var nic = $.grep(instance.nic, function(nic) {

return nic.networkid == network.id;

})[0];

*/

// Get NIC IPs

$.ajax({

url: createURL('listNics'),

data: {

virtualmachineid: instance.id,

nicId: instance.nic[0].id

},

success: function(json) {

var nic = json.listnicsresponse.nic[0];

var primaryIp = nic.ipaddress;

var secondaryIps = nic.secondaryip ? nic.secondaryip : [];

var ipSelection = [];

// Add primary IP as default

ipSelection.push({

id: -1,

description: primaryIp + ' (Primary)'

});

// Add secondary IPs

$(secondaryIps).map(function(index, secondaryIp) {

ipSelection.push({

id: secondaryIp.ipaddress,

description: secondaryIp.ipaddress

});

});

args.response.success({

data: ipSelection

});

}

});

}

};

//value of Primary IP in subselect dropdown is itself (not -1), for multiple VM selection (API parameter vmidipmap), e.g. assignToLoadBalancerRule API.

var multipleVmSecondaryIPSubselect = function(args) {

var instance = args.context.instances[0];

var network = args.context.networks[0];

if (args.context.ipAddresses[0].isportable) { //portable IP which has multiple NICs. Each NIC has a different network ID.

$.ajax({

url: createURL('listNics'),

data: {

virtualmachineid: instance.id

},

success: function(json) {

var nics = json.listnicsresponse.nic;

var ipSelection = [];

//portable IP has multiple NICs. Each NIC has a different network ID.

$(nics).map(function(index, nic) {

var primaryIp = nic.ipaddress;

var secondaryIps = nic.secondaryip ? nic.secondaryip : [];

var prefix = '[NIC ' + (index + 1) + '] ';

// Add primary IP as default

ipSelection.push({

id: nic.networkid + ',' + primaryIp,

description: prefix + primaryIp + ' (Primary)'

});

// Add secondary IPs

$(secondaryIps).map(function(index, secondaryIp) {

ipSelection.push({

id: nic.networkid + ',' + secondaryIp.ipaddress,

description: prefix + secondaryIp.ipaddress

});

});

});

args.response.success({

data: ipSelection

});

}

});

} else { //non-portable IP which has only one NIC

/*

var nic = $.grep(instance.nic, function(nic) {

return nic.networkid == network.id;

})[0];

*/

// Get NIC IPs

$.ajax({

url: createURL('listNics'),

data: {

virtualmachineid: instance.id,

nicId: instance.nic[0].id

},

success: function(json) {

var nic = json.listnicsresponse.nic[0];

var primaryIp = nic.ipaddress;

var secondaryIps = nic.secondaryip ? nic.secondaryip : [];

var ipSelection = [];

var existingIps = $(args.context.subItemData).map(

function(index, item) { return item.itemIp; }

);

// Add primary IP as default

if ($.inArray(primaryIp, existingIps) == -1) {

ipSelection.push({

id: primaryIp,

description: primaryIp + ' (Primary)'

});

}

// Add secondary IPs

$(secondaryIps).map(function(index, secondaryIp) {

if ($.inArray(secondaryIp.ipaddress, existingIps) == -1) {

ipSelection.push({

id: secondaryIp.ipaddress,

description: secondaryIp.ipaddress

});

}

});

args.response.success({

data: ipSelection

});

}

});

}

};

var ipChangeNotice = function() {

cloudStack.dialog.confirm({

message: 'message.ip.address.changed',

action: function() {

$('#browser .container').cloudBrowser('selectPanel', {

panel: $('#browser .panel:last').prev(),

complete: function() {

$(window).trigger('cloudStack.fullRefresh');

}

});

}

});

};

var zoneObjs = [];

var actionFilters = {

ipAddress: function(args) {

var allowedActions = args.context.actions;

var disallowedActions = [];

var ipObj = args.context.item;

var status = ipObj.state;

//***** apply to both Isolated Guest Network IP, VPC IP (begin) *****

if (status == 'Destroyed' ||

status == 'Releasing' ||

status == 'Released' ||

status == 'Creating' ||

status == 'Allocating' ||

ipObj.account == 'system' ||

ipObj.issystem == true) {

return [];

}

if (ipObj.issourcenat) { //sourceNAT IP doesn't support staticNAT

disallowedActions.push('enableStaticNAT');

disallowedActions.push('disableStaticNAT');

disallowedActions.push('remove');

} else { //non-sourceNAT IP supports staticNAT

if (ipObj.isstaticnat) {

disallowedActions.push('enableStaticNAT');

} else {

disallowedActions.push('disableStaticNAT');

}

}

//***** apply to both Isolated Guest Network IP, VPC IP (end) *****

if (!('vpc' in args.context)) { //***** Guest Network section > Guest Network page > IP Address page *****

if (args.context.networks[0].networkofferingconservemode == false) {

/*

(1) If IP is SourceNat, no StaticNat/VPN/PortForwarding/LoadBalancer can be enabled/added.

*/

if (ipObj.issourcenat == true) {

disallowedActions.push('enableStaticNAT');

disallowedActions.push('enableVPN');

}

/*

(2) If IP is non-SourceNat, show StaticNat/VPN/PortForwarding/LoadBalancer at first.

1. Once StaticNat is enabled, hide VPN/PortForwarding/LoadBalancer.

2. Once VPN is enabled, hide StaticNat/PortForwarding/LoadBalancer.

3. Once a PortForwarding rule is added, hide StaticNat/VPN/LoadBalancer.

4. Once a LoadBalancer rule is added, hide StaticNat/VPN/PortForwarding.

*/

else { //ipObj.issourcenat == false

if (ipObj.isstaticnat) { //1. Once StaticNat is enabled, hide VPN/PortForwarding/LoadBalancer.

disallowedActions.push('enableVPN');

}

if (ipObj.vpnenabled) { //2. Once VPN is enabled, hide StaticNat/PortForwarding/LoadBalancer.

disallowedActions.push('enableStaticNAT');

}

//3. Once a PortForwarding rule is added, hide StaticNat/VPN/LoadBalancer.

$.ajax({

url: createURL('listPortForwardingRules'),

data: {

ipaddressid: ipObj.id,

listAll: true

},

dataType: 'json',

async: false,

success: function(json) {

var rules = json.listportforwardingrulesresponse.portforwardingrule;

if (rules != null && rules.length > 0) {

disallowedActions.push('enableVPN');

disallowedActions.push('enableStaticNAT');

}

}

});

//4. Once a LoadBalancer rule is added, hide StaticNat/VPN/PortForwarding.

$.ajax({

url: createURL('listLoadBalancerRules'),

data: {

publicipid: ipObj.id,

listAll: true

},

dataType: 'json',

async: false,

success: function(json) {

var rules = json.listloadbalancerrulesresponse.loadbalancerrule;

if (rules != null && rules.length > 0) {

disallowedActions.push('enableVPN');

disallowedActions.push('enableStaticNAT');

}

}

});

}

}

if (ipObj.networkOfferingHavingVpnService == true) {

if (ipObj.vpnenabled) {

disallowedActions.push('enableVPN');

} else {

disallowedActions.push('disableVPN');

}

} else { //ipObj.networkOfferingHavingVpnService == false

disallowedActions.push('disableVPN');

disallowedActions.push('enableVPN');

}

} else { //***** VPC section > Configuration VPC > Router > Public IP Addresses *****

if (ipObj.issourcenat) { //VPC sourceNAT IP: supports VPN

if (ipObj.vpnenabled) {

disallowedActions.push('enableVPN');

} else {

disallowedActions.push('disableVPN');

}

} else { //VPC non-sourceNAT IP: doesn't support VPN

disallowedActions.push('enableVPN');

disallowedActions.push('disableVPN');

}

}

allowedActions = $.grep(allowedActions, function(item) {

return $.inArray(item, disallowedActions) == -1;

});

return allowedActions;

},

securityGroups: function(args) {

var allowedActions = [];

var isSecurityGroupOwner = isAdmin() || isDomainAdmin() ||

args.context.item.account == args.context.users[0].account;

if (isSecurityGroupOwner &&

args.context.item.state != 'Destroyed' &&

args.context.item.name != 'default') {

allowedActions.push('remove');

}

return allowedActions;

}

};

var networkOfferingObjs = [];

var advZoneObjs;

cloudStack.sections.network = {

title: 'label.network',

id: 'network',

sectionSelect: {

preFilter: function(args) {

var sectionsToShow = ['networks'];

$.ajax({

url: createURL('listZones'),

data: {

networktype: 'Advanced'

},

async: false,

success: function(json) {

advZoneObjs = json.listzonesresponse.zone;

if (advZoneObjs != null && advZoneObjs.length > 0) {

sectionsToShow.push('vpc');

sectionsToShow.push('vpnCustomerGateway');

}

}

});

$.ajax({

url: createURL('listNetworks', {

ignoreProject: true

}),

data: {

supportedServices: 'SecurityGroup',

listAll: true,

details: 'min'

},

async: false,

success: function(json) {

if (json.listnetworksresponse.network != null && json.listnetworksresponse.network.length > 0) {

sectionsToShow.push('securityGroups');

}

}

});

return sectionsToShow;

},

label: 'label.select-view'

},

sections: {

networks: {

id: 'networks',

type: 'select',

title: 'label.guest.networks',

listView: {

actions: {

add: {

label: 'label.add.isolated.network',

preFilter: function(args) {

if (advZoneObjs != null && advZoneObjs.length > 0) {

for (var i = 0; i < advZoneObjs.length; i++) {

if (advZoneObjs[i].securitygroupsenabled != true) { //'Add Isolated Guest Network with SourceNat' is only supported in Advanced SG-disabled zone

return true;

}

}

return false;

} else {

return false;

}

},

createForm: {

title: 'Add Isolated Guest Network with SourceNat',

fields: {

name: {

label: 'label.name',

validation: {

required: true

},

docID: 'helpGuestNetworkName'

},

displayText: {

label: 'label.display.text',

validation: {

required: true

},

docID: 'helpGuestNetworkDisplayText'

},

zoneId: {

label: 'label.zone',

validation: {

required: true

},

docID: 'helpGuestNetworkZone',

select: function(args) {

$.ajax({

url: createURL('listZones'),

success: function(json) {

var zones = $.grep(json.listzonesresponse.zone, function(zone) {

return (zone.networktype == 'Advanced' && zone.securitygroupsenabled != true); //Isolated networks can only be created in Advanced SG-disabled zone (but not in Basic zone nor Advanced SG-enabled zone)

});

args.response.success({

data: $.map(zones, function(zone) {

return {

id: zone.id,

description: zone.name

};

})

});

}

});

}

},

networkOfferingId: {

label: 'label.network.offering',

validation: {

required: true

},

dependsOn: 'zoneId',

docID: 'helpGuestNetworkNetworkOffering',

select: function(args) {

var data = {

zoneid: args.zoneId,

guestiptype: 'Isolated',

supportedServices: 'SourceNat',

state: 'Enabled'

};

if ('vpc' in args.context) { //from VPC section

$.extend(data, {

forVpc: true

});

}

else { //from guest network section

var vpcs;

$.ajax({

url: createURL('listVPCs'),

data: {

listAll: true

},

async: false,

success: function(json) {

vpcs = json.listvpcsresponse.vpc;

}

});

if (vpcs == null || vpcs.length == 0) { //if there is no VPC in the system

$.extend(data, {

forVpc: false

});

}

}

if(!isAdmin()) { //normal user is not aware of the VLANs in the system, so normal user is not allowed to create network with network offerings whose specifyvlan = true

$.extend(data, {

specifyvlan: false

});

}

$.ajax({

url: createURL('listNetworkOfferings'),

data: data,

success: function(json) {

networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering;

args.$select.change(function() {

var $vlan = args.$select.closest('form').find('[rel=vlan]');

var networkOffering = $.grep(

networkOfferingObjs, function(netoffer) {

return netoffer.id == args.$select.val();

}

)[0];

if (networkOffering.specifyvlan) {

$vlan.css('display', 'inline-block');

} else {

$vlan.hide();

}

});

args.response.success({

data: $.map(networkOfferingObjs, function(zone) {

return {

id: zone.id,

description: zone.name

};

})

});

}

});

}

},

vlan: {

label: 'VLAN',

validation: {

required: true

},

isHidden: true

},

vpcid: {

label: 'label.vpc',

dependsOn: 'networkOfferingId',

select: function(args) {

var networkOfferingObj;

var $form = args.$select.closest('form');

var data = {

listAll: true,

details: 'min'

};

if (args.context.vpc) {

data.id = args.context.vpc[0].id;

}

$(networkOfferingObjs).each(function(key, value) {

if (value.id == args.networkOfferingId) {

networkOfferingObj = value;

return false; //break each loop

}

});

if (networkOfferingObj.forvpc == true) {

args.$select.closest('.form-item').css('display', 'inline-block');

$.ajax({

url: createURL('listVPCs'),

data: data,

success: function(json) {

var items = json.listvpcsresponse.vpc;

var data;

if (items != null && items.length > 0) {

data = $.map(items, function(item) {

return {

id: item.id,

description: item.name

}

});

}

args.response.success({

data: data

});

}

});

$form.find('.form-item[rel=networkDomain]').hide();

} else {

args.$select.closest('.form-item').hide();

$form.find('.form-item[rel=networkDomain]').show();

args.response.success({

data: null

});

}

}

},

guestGateway: {

label: 'label.guest.gateway',

docID: 'helpGuestNetworkGateway'

},

guestNetmask: {

label: 'label.guest.netmask',

docID: 'helpGuestNetworkNetmask'

},

networkDomain: {

label: 'label.network.domain'

},

domain: {

label: 'label.domain',

isHidden: function(args) {

if (isAdmin() || isDomainAdmin())

return false;

else

return true;

},

select: function(args) {

if (isAdmin() || isDomainAdmin()) {

$.ajax({

url: createURL("listDomains&listAll=true"),

success: function(json) {

var items = [];

items.push({

id: "",

description: ""

});

var domainObjs = json.listdomainsresponse.domain;

$(domainObjs).each(function() {

items.push({

id: this.id,

description: this.path

});

});

args.response.success({

data: items

});

}

});

args.$select.change(function() {

var $form = $(this).closest('form');

if ($(this).val() == "") {

$form.find('.form-item[rel=account]').hide();

} else {

$form.find('.form-item[rel=account]').css('display', 'inline-block');

}

});

} else {

args.response.success({

data: null

});

}

},

},

account: {

label: 'label.account',

validation: {

required: true

},

isHidden: function(args) {

if (isAdmin() || isDomainAdmin())

return false;

else

return true;

}

}

}

},

action: function(args) {

var dataObj = {

zoneId: args.data.zoneId,

name: args.data.name,

displayText: args.data.displayText,

networkOfferingId: args.data.networkOfferingId

};

if (args.data.guestGateway != null && args.data.guestGateway.length > 0) {

$.extend(dataObj, {

gateway: args.data.guestGateway

});

}

if (args.data.guestNetmask != null && args.data.guestNetmask.length > 0) {

$.extend(dataObj, {

netmask: args.data.guestNetmask

});

}

if (args.$form.find('.form-item[rel=vpcid]').css("display") != "none") {

$.extend(dataObj, {

vpcid: args.data.vpcid

});

}

if (args.$form.find('.form-item[rel=vlan]').css('display') != 'none') {

$.extend(dataObj, {

vlan: args.data.vlan

});

}

if (args.data.networkDomain != null && args.data.networkDomain.length > 0 && args.$form.find('.form-item[rel=vpcid]').css("display") == "none") {

$.extend(dataObj, {

networkDomain: args.data.networkDomain

});

}

if (args.data.domain != null && args.data.domain.length > 0) {

$.extend(dataObj, {

domainid: args.data.domain

});

if (args.data.account != null && args.data.account.length > 0) {

$.extend(dataObj, {

account: args.data.account

});

}

}

$.ajax({

url: createURL('createNetwork'),

data: dataObj,

success: function(json) {

args.response.success({

data: json.createnetworkresponse.network

});

},

error: function(json) {

args.response.error(parseXMLHttpResponse(json));

}

});

},

messages: {

notification: function() {

return 'Add Isolated Guest Network';

}

}

},

rootAdminAddGuestNetwork: $.extend({}, addGuestNetworkDialog.def, {

isHeader: true

}),

addGloboNetworkNetwork: $.extend({}, globoNetworkAPI.networkDialog.def, {

isHeader: true

}),

},

id: 'networks',

fields: {

name: {

label: 'label.name'

},

account: {

label: 'label.account'

},

type: {

label: 'label.type'

},

cidr: {

label: 'label.cidr'

},

ip6cidr: {

label: 'label.ipv6.CIDR'

}

},

advSearchFields: {

zoneid: {

label: 'label.zone',

select: function(args) {

$.ajax({

url: createURL('listZones'),

data: {

listAll: true

},

success: function(json) {

var zones = json.listzonesresponse.zone ? json.listzonesresponse.zone : [];

args.response.success({

data: $.map(zones, function(zone) {

return {

id: zone.id,

description: zone.name

};

})

});

}

});

}

},

domainid: {

label: 'label.domain',

select: function(args) {

if (isAdmin() || isDomainAdmin()) {

$.ajax({

url: createURL('listDomains'),

data: {

listAll: true,

details: 'min'

},

success: function(json) {

var array1 = [{

id: '',

description: ''

}];

var domains = json.listdomainsresponse.domain;

if (domains != null && domains.length > 0) {

for (var i = 0; i < domains.length; i++) {

array1.push({

id: domains[i].id,

description: domains[i].path

});

}

}

args.response.success({

data: array1

});

}

});

} else {

args.response.success({

data: null

});

}

},

isHidden: function(args) {

if (isAdmin() || isDomainAdmin())

return false;

else

return true;

}

},

account: {

label: 'label.account',

isHidden: function(args) {

if (isAdmin() || isDomainAdmin())

return false;

else

return true;

}

},

tagKey: {

label: 'label.tag.key'

},

tagValue: {

label: 'label.tag.value'

}

},

dataProvider: function(args) {

var data = {};

listViewDataProvider(args, data);

$.ajax({

url: createURL('listNetworks'),

data: data,

async: false,

success: function(data) {

args.response.success({

data: data.listnetworksresponse.network

});

},

error: function(data) {

args.response.error(parseXMLHttpResponse(data));

}

});

},

detailView: {

name: 'label.guest.network.details',

viewAll: {

path: 'network.ipAddresses',

label: 'label.menu.ipaddresses',

preFilter: function(args) {

if (args.context.networks[0].state == 'Destroyed')

return false;

return true;

}

},

actions: {

edit: {

label: 'label.edit',

messages: {

notification: function(args) {

return 'label.edit.network.details';

}

},

action: function(args) {

var data = {

id: args.context.networks[0].id,

name: args.data.name,

displaytext: args.data.displaytext

};

//args.data.networkdomain is null when networkdomain field is hidden

if (args.data.networkdomain != null && args.data.networkdomain != args.context.networks[0].networkdomain) {

$.extend(data, {

networkdomain: args.data.networkdomain

});

}

var oldcidr;

$.ajax({

url: createURL("listNetworks&id=" + args.context.networks[0].id),

dataType: "json",

async: false,

success: function(json) {

oldcidr = json.listnetworksresponse.network[0].cidr;

}

});

if (args.data.cidr != "" && args.data.cidr != oldcidr) {

$.extend(data, {

guestvmcidr: args.data.cidr

});

}

//args.data.networkofferingid is null when networkofferingid field is hidden

if (args.data.networkofferingid != null && args.data.networkofferingid != args.context.networks[0].networkofferingid) {

$.extend(data, {

networkofferingid: args.data.networkofferingid

});

if (args.context.networks[0].type == "Isolated") { //Isolated network

cloudStack.dialog.confirm({

message: 'Do you want to keep the current guest network CIDR unchanged?',

action: function() { //"Yes" button is clicked

$.extend(data, {

changecidr: false

});

$.ajax({

url: createURL('updateNetwork'),

data: data,

success: function(json) {

var jid = json.updatenetworkresponse.jobid;

args.response.success({

_custom: {

jobId: jid,

getUpdatedItem: function(json) {

var item = json.queryasyncjobresultresponse.jobresult.network;

return {

data: item

};

}

}

});

}

});

},

cancelAction: function() { //"Cancel" button is clicked

$.extend(data, {

changecidr: true

});

$.ajax({

url: createURL('updateNetwork'),

data: data,

success: function(json) {

var jid = json.updatenetworkresponse.jobid;

args.response.success({

_custom: {

jobId: jid,

getUpdatedItem: function(json) {

var item = json.queryasyncjobresultresponse.jobresult.network;

return {

data: item

};

}

}

});

}

});

}

});

return;