// 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 zoneObjs, podObjs, clusterObjs, domainObjs, networkOfferingObjs, physicalNetworkObjs;

var selectedClusterObj, selectedZoneObj, selectedPublicNetworkObj, selectedManagementNetworkObj, selectedPhysicalNetworkObj, selectedGuestNetworkObj;

var nspMap = {}; //from listNetworkServiceProviders API

var nspHardcodingArray = []; //for service providers listView (hardcoding, not from listNetworkServiceProviders API)

// Add router type to virtual router

// -- can be either Project, VPC, or System (standard)

var mapRouterType = function(index, router) {

var routerType = _l('label.menu.system');

if (router.projectid) routerType = _l('label.project');

if (router.vpcid) routerType = 'VPC';

return $.extend(router, {

routerType: routerType

});

};

cloudStack.publicIpRangeAccount = {

dialog: function(args) {

return function(args) {

var data = args.data ? args.data : {};

var fields = {

account: { label: 'Account', defaultValue: data.account },

domainid: {

label: 'Domain',

defaultValue: data.domainid,

select: function(args) {

$.ajax({

url: createURL('listDomains'),

data: { listAll: true },

success: function(json) {

args.response.success({

data: $.map(json.listdomainsresponse.domain, function(domain) {

return {

id: domain.id,

description: domain.path

};

})

});

}

});

}

}

};

var success = args.response.success;

if (args.$item) { // Account data is read-only after creation

$.ajax({

url: createURL('listDomains'),

data: { id: data.domainid, listAll: true },

success: function(json) {

var domain = json.listdomainsresponse.domain[0];

cloudStack.dialog.notice({

message: '<ul><li>' + _l('label.account') + ': ' + data.account + '</li>' +

'<li>' + _l('label.domain') + ': ' + domain.path + '</li></ul>'

});

}

});

} else {

cloudStack.dialog.createForm({

form: {

title: 'label.add.account',

desc: '(optional) Please specify an account to be associated with this IP range.',

fields: fields

},

after: function(args) {

var data = cloudStack.serializeForm(args.$form);

success({ data: data });

}

});

}

};

}

};

var getTrafficType = function(physicalNetwork, typeID) {

var trafficType = {};

$.ajax({

url: createURL('listTrafficTypes'),

data: {

physicalnetworkid: physicalNetwork.id

},

async: false,

success: function(json) {

trafficType = $.grep(

json.listtraffictypesresponse.traffictype,

function(trafficType) {

return trafficType.traffictype == typeID;

}

)[0];

}

});

if(trafficType.xennetworklabel == null || trafficType.xennetworklabel == 0)

trafficType.xennetworklabel = dictionary['label.network.label.display.for.blank.value'];

if(trafficType.kvmnetworklabel == null || trafficType.kvmnetworklabel == 0)

trafficType.kvmnetworklabel = dictionary['label.network.label.display.for.blank.value'];

if(trafficType.vmwarenetworklabel == null || trafficType.vmwarenetworklabel == 0)

trafficType.vmwarenetworklabel = dictionary['label.network.label.display.for.blank.value'];

if(trafficType.ovmnetworklabel == null || trafficType.ovmnetworklabel == 0)

trafficType.ovmnetworklabel = dictionary['label.network.label.display.for.blank.value'];

return trafficType;

};

var updateTrafficLabels = function(trafficType, labels, complete) {

var array1 = [];

if(labels.xennetworklabel != dictionary['label.network.label.display.for.blank.value'])

array1.push("&xennetworklabel=" + labels.xennetworklabel);

if(labels.kvmnetworklabel != dictionary['label.network.label.display.for.blank.value'])

array1.push("&kvmnetworklabel=" + labels.kvmnetworklabel);

if(labels.vmwarenetworklabel != dictionary['label.network.label.display.for.blank.value'])

array1.push("&vmwarenetworklabel=" + labels.vmwarenetworklabel);

if(labels.ovmnetworklabel != dictionary['label.network.label.display.for.blank.value'])

array1.push("&ovmnetworklabel=" + labels.ovmnetworklabel);

$.ajax({

url: createURL('updateTrafficType' + array1.join("")),

data: {

id: trafficType.id

},

success: function(json) {

var jobID = json.updatetraffictyperesponse.jobid;

cloudStack.ui.notifications.add(

{

desc: 'Update traffic labels',

poll: pollAsyncJobResult,

section: 'System',

_custom: { jobId: jobID }

},

complete ? complete : function() {}, {},

function(data) {

// Error

cloudStack.dialog.notice({ message: parseXMLHttpResponse(data) });

}, {}

);

}

})

};

function virtualRouterProviderActionFilter(args) {

var allowedActions = [];

var jsonObj = args.context.item; //args.context.item == nspMap["virtualRouter"]

if(jsonObj.state == "Enabled")

allowedActions.push("disable");

else if(jsonObj.state == "Disabled")

allowedActions.push("enable");

return allowedActions;

};

cloudStack.sections.system = {

title: 'label.menu.infrastructure',

id: 'system',

// System dashboard

dashboard: {

dataProvider: function(args) {

var dataFns = {

zoneCount: function(data) {

$.ajax({

url: createURL('listZones'),

success: function(json) {

dataFns.podCount($.extend(data, {

zoneCount: json.listzonesresponse.count ?

json.listzonesresponse.count : 0,

zones: json.listzonesresponse.zone

}));

}

});

},

podCount: function(data) {

$.ajax({

url: createURL('listPods'),

data: {

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

dataFns.clusterCount($.extend(data, {

podCount: json.listpodsresponse.count ?

json.listpodsresponse.count : 0

}));

}

});

},

clusterCount: function(data) {

$.ajax({

url: createURL('listClusters'),

data: {

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

dataFns.hostCount($.extend(data, {

clusterCount: json.listclustersresponse.count ?

json.listclustersresponse.count : 0

}));

//comment the 4 lines above and uncomment the following 4 lines if listHosts API still responds slowly.

/*

dataFns.primaryStorageCount($.extend(data, {

clusterCount: json.listclustersresponse.count ?

json.listclustersresponse.count : 0

}));

*/

}

});

},

hostCount: function(data) {

$.ajax({

url: createURL('listHosts'),

data: {

type: 'routing',

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

dataFns.primaryStorageCount($.extend(data, {

hostCount: json.listhostsresponse.count ?

json.listhostsresponse.count : 0

}));

}

});

},

primaryStorageCount: function(data) {

$.ajax({

url: createURL('listStoragePools'),

data: {

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

dataFns.secondaryStorageCount($.extend(data, {

primaryStorageCount: json.liststoragepoolsresponse.count ?

json.liststoragepoolsresponse.count : 0

}));

//comment the 4 lines above and uncomment the following 4 lines if listHosts API still responds slowly.

/*

dataFns.systemVmCount($.extend(data, {

primaryStorageCount: json.liststoragepoolsresponse.count ?

json.liststoragepoolsresponse.count : 0

}));

*/

}

});

},

secondaryStorageCount: function(data) {

$.ajax({

url: createURL('listHosts'),

data: {

type: 'SecondaryStorage',

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

dataFns.systemVmCount($.extend(data, {

secondaryStorageCount: json.listhostsresponse.count ?

json.listhostsresponse.count : 0

}));

}

});

},

systemVmCount: function(data) {

$.ajax({

url: createURL('listSystemVms'),

data: {

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

dataFns.virtualRouterCount($.extend(data, {

systemVmCount: json.listsystemvmsresponse.count ?

json.listsystemvmsresponse.count : 0

}));

}

});

},

virtualRouterCount: function(data) {

$.ajax({

url: createURL('listRouters'),

data: {

projectid: -1,

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

var total1 = json.listroutersresponse.count ? json.listroutersresponse.count : 0;

$.ajax({

url: createURL('listRouters'),

data: {

listAll: true,

page: 1,

pagesize: 1 //specifying pagesize as 1 because we don't need any embedded objects to be returned here. The only thing we need from API response is "count" property.

},

success: function(json) {

var total2 = json.listroutersresponse.count ? json.listroutersresponse.count : 0;

dataFns.capacity($.extend(data, {

virtualRouterCount: (total1 + total2)

}));

}

});

}

});

},

capacity: function(data) {

if (data.zoneCount) {

$.ajax({

url: createURL('listCapacity'),

success: function(json) {

var capacities = json.listcapacityresponse.capacity;

var capacityTotal = function(id, converter) {

var capacity = $.grep(capacities, function(capacity) {

return capacity.type == id;

})[0];

var total = capacity ? capacity.capacitytotal : 0;

if (converter) {

return converter(total);

}

return total;

};

complete($.extend(data, {

cpuCapacityTotal: capacityTotal(1, cloudStack.converters.convertHz),

memCapacityTotal: capacityTotal(0, cloudStack.converters.convertBytes),

storageCapacityTotal: capacityTotal(2, cloudStack.converters.convertBytes)

}));

}

});

} else {

complete($.extend(data, {

cpuCapacityTotal: cloudStack.converters.convertHz(0),

memCapacityTotal: cloudStack.converters.convertBytes(0),

storageCapacityTotal: cloudStack.converters.convertBytes(0)

}));

}

}

};

var complete = function(data) {

args.response.success({

data: data

});

};

dataFns.zoneCount({});

}

},

zoneDashboard: function(args) {

$.ajax({

url: createURL('listCapacity'),

data: { zoneid: args.context.zones[0].id },

success: function(json) {

var capacities = json.listcapacityresponse.capacity;

var data = {};

$(capacities).each(function() {

var capacity = this;

data[capacity.type] = {

used: cloudStack.converters.convertByType(capacity.type, capacity.capacityused),

total: cloudStack.converters.convertByType(capacity.type, capacity.capacitytotal),

percent: parseInt(capacity.percentused)

};

});

args.response.success({

data: data

});

}

});

},

// Network-as-a-service configuration

naas: {

providerListView: {

id: 'networkProviders',

fields: {

name: { label: 'label.name' },

state: {

label: 'label.state',

converter: function(str) {

// For localization

return str;

},

indicator: { 'Enabled': 'on', 'Disabled': 'off' }

}

},

dataProvider: function(args) {

refreshNspData();

args.response.success({

data: nspHardcodingArray

})

},

detailView: function(args) {

return cloudStack.sections.system.naas.networkProviders.types[

args.context.networkProviders[0].id

];

}

},

mainNetworks: {

'public': {

detailView: {

actions: {

edit: {

label: 'label.edit',

action: function(args) {

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Public');

updateTrafficLabels(trafficType, args.data, function () {

args.response.success();

});

}

}

},

tabs: {

details: {

title: 'label.details',

fields: [

{

traffictype: { label: 'label.traffic.type' },

broadcastdomaintype: { label: 'label.broadcast.domain.type' }

},

{

xennetworklabel: { label: 'label.xen.traffic.label', isEditable: true },

kvmnetworklabel: { label: 'label.kvm.traffic.label', isEditable: true },

vmwarenetworklabel: { label: 'label.vmware.traffic.label', isEditable: true },

ovmnetworklabel: { label: 'OVM traffic label',isEditable: true }

}

],

dataProvider: function(args) {

$.ajax({

url: createURL("listNetworks&listAll=true&trafficType=Public&isSystem=true&zoneId="+selectedZoneObj.id),

dataType: "json",

async: false,

success: function(json) {

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Public');

var items = json.listnetworksresponse.network;

selectedPublicNetworkObj = items[0];

// Include traffic labels

selectedPublicNetworkObj.xennetworklabel = trafficType.xennetworklabel;

selectedPublicNetworkObj.kvmnetworklabel = trafficType.kvmnetworklabel;

selectedPublicNetworkObj.vmwarenetworklabel = trafficType.vmwarenetworklabel;

selectedPublicNetworkObj.ovmnetworklabel = trafficType.ovmnetworklabel;

args.response.success({data: selectedPublicNetworkObj});

}

});

}

},

ipAddresses: {

title: 'label.ip.ranges',

custom: function(args) {

return $('<div></div>').multiEdit({

context: args.context,

noSelect: true,

fields: {

'gateway': { edit: true, label: 'label.gateway' },

'netmask': { edit: true, label: 'label.netmask' },

'vlan': { edit: true, label: 'label.vlan', isOptional: true },

'startip': { edit: true, label: 'label.start.IP' },

'endip': { edit: true, label: 'label.end.IP' },

'account': {

label: 'label.account',

custom: {

buttonLabel: 'label.add.account',

action: cloudStack.publicIpRangeAccount.dialog()

}

},

'add-rule': { label: 'label.add', addButton: true }

},

add: {

label: 'label.add',

action: function(args) {

var array1 = [];

array1.push("&zoneId=" + args.context.zones[0].id);

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

array1.push("&vlan=" + todb(args.data.vlan));

else

array1.push("&vlan=untagged");

array1.push("&gateway=" + args.data.gateway);

array1.push("&netmask=" + args.data.netmask);

array1.push("&startip=" + args.data.startip);

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

array1.push("&endip=" + args.data.endip);

if (args.data.account) {

array1.push("&account=" + args.data.account.account);

array1.push("&domainid=" + args.data.account.domainid);

}

array1.push("&forVirtualNetwork=true"); //indicates this new IP range is for public network, not guest network

$.ajax({

url: createURL("createVlanIpRange" + array1.join("")),

dataType: "json",

success: function(json) {

var item = json.createvlaniprangeresponse.vlan;

args.response.success({

data: item,

notification: {

label: 'label.add.ip.range',

poll: function(args) {

args.complete();

}

}

});

},

error: function(XMLHttpResponse) {

var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

args.response.error(errorMsg);

}

});

}

},

actions: {

destroy: {

label: 'label.remove.ip.range',

action: function(args) {

$.ajax({

url: createURL('deleteVlanIpRange&id=' + args.context.multiRule[0].id),

dataType: 'json',

async: true,

success: function(json) {

args.response.success({

notification: {

label: 'label.remove.ip.range',

poll: function(args) {

args.complete();

}

}

});

},

error: function(json) {

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

}

});

}

}

},

dataProvider: function(args) {

$.ajax({

url: createURL("listVlanIpRanges&zoneid=" + args.context.zones[0].id + "&networkId=" + selectedPublicNetworkObj.id),

dataType: "json",

success: function(json) {

var items = json.listvlaniprangesresponse.vlaniprange;

args.response.success({

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

return $.extend(item, {

account: {

_buttonLabel: item.account,

account: item.account,

domainid: item.domainid

}

});

})

});

}

});

}

});

}

}

}

}

},

'storage': {

detailView: {

actions: {

edit: {

label: 'label.edit',

action: function(args) {

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Storage');

updateTrafficLabels(trafficType, args.data, function () {

args.response.success();

});

}

}

},

tabs: {

details: {

title: 'label.details',

fields: [

{

traffictype: { label: 'label.traffic.type' },

broadcastdomaintype: { label: 'label.broadcast.domain.type' }

},

{

xennetworklabel: { label: 'label.xen.traffic.label', isEditable: true },

kvmnetworklabel: { label: 'label.kvm.traffic.label', isEditable: true },

vmwarenetworklabel: { label: 'label.vmware.traffic.label', isEditable: true },

ovmnetworklabel: { label: 'OVM traffic label', isEditable: true }

}

],

dataProvider: function(args) {

$.ajax({

url: createURL("listNetworks&listAll=true&trafficType=Storage&isSystem=true&zoneId="+selectedZoneObj.id),

dataType: "json",

async: false,

success: function(json) {

var items = json.listnetworksresponse.network;

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Storage');

selectedPublicNetworkObj = items[0];

selectedPublicNetworkObj.xennetworklabel = trafficType.xennetworklabel;

selectedPublicNetworkObj.kvmnetworklabel = trafficType.kvmnetworklabel;

selectedPublicNetworkObj.vmwarenetworklabel = trafficType.vmwarenetworklabel;

selectedPublicNetworkObj.ovmnetworklabel = trafficType.ovmnetworklabel;

args.response.success({data: selectedPublicNetworkObj});

}

});

}

},

ipAddresses: {

title: 'label.ip.ranges',

custom: function(args) {

return $('<div></div>').multiEdit({

context: args.context,

noSelect: true,

fields: {

'podid': {

label: 'label.pod',

select: function(args) {

$.ajax({

url: createURL("listPods&zoneid=" + selectedZoneObj.id),

dataType: "json",

success: function(json) {

var items = [];

var pods = json.listpodsresponse.pod;

$(pods).each(function(){

items.push({name: this.id, description: this.name}); //should be "{id: this.id, description: this.name}" (to be consistent with dropdown in createFrom and edit mode) (Brian will fix widget later)

});

args.response.success({ data: items });

}

});

}

},

'gateway': { edit: true, label: 'label.gateway' },

'netmask': { edit: true, label: 'label.netmask' },

'vlan': { edit: true, label: 'label.vlan', isOptional: true },

'startip': { edit: true, label: 'label.start.IP' },

'endip': { edit: true, label: 'label.end.IP' },

'add-rule': { label: 'label.add', addButton: true }

},

add: {

label: 'label.add',

action: function(args) {

var array1 = [];

array1.push("&zoneId=" + args.context.zones[0].id);

array1.push("&podid=" + args.data.podid);

array1.push("&gateway=" + args.data.gateway);

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

array1.push("&vlan=" + todb(args.data.vlan));

array1.push("&netmask=" + args.data.netmask);

array1.push("&startip=" + args.data.startip);

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

array1.push("&endip=" + args.data.endip);

$.ajax({

url: createURL("createStorageNetworkIpRange" + array1.join("")),

dataType: "json",

success: function(json) {

args.response.success({

_custom: {

jobId: json.createstoragenetworkiprangeresponse.jobid

},

notification: {

label: 'label.add.ip.range',

poll: pollAsyncJobResult

}

});

},

error: function(XMLHttpResponse) {

var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

args.response.error(errorMsg);

}

});

}

},

actions: {

destroy: {

label: 'label.delete',

action: function(args) {

$.ajax({

url: createURL('deleteStorageNetworkIpRange&id=' + args.context.multiRule[0].id),

dataType: 'json',

async: true,

success: function(json) {

args.response.success({

notification: {

label: 'label.remove.ip.range',

poll: function(args) {

args.complete();

}

}

});

}

});

}

}

},

dataProvider: function(args) {

$.ajax({

url: createURL("listStorageNetworkIpRange&zoneid=" + args.context.zones[0].id + "&networkId=" + selectedPublicNetworkObj.id),

dataType: "json",

success: function(json) {

var items = json.liststoragenetworkiprangeresponse.storagenetworkiprange;

args.response.success({data: items});

}

});

}

});

}

}

}

}

},

'management': {

detailView: {

actions: {

edit: {

label: 'label.edit',

action: function(args) {

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Management');

updateTrafficLabels(trafficType, args.data, function () {

args.response.success();

});

}

}

},

tabs: {

details: {

title: 'label.details',

fields: [

{

traffictype: { label: 'label.traffic.type' },

broadcastdomaintype: { label: 'label.broadcast.domain.type' }

},

{

xennetworklabel: { label: 'label.xen.traffic.label', isEditable: true },

kvmnetworklabel: { label: 'label.kvm.traffic.label', isEditable: true },

vmwarenetworklabel: { label: 'label.vmware.traffic.label', isEditable: true },

ovmnetworklabel: { label: 'OVM traffic label', isEditable: true }

}

],

dataProvider: function(args) {

$.ajax({

url: createURL("listNetworks&listAll=true&issystem=true&trafficType=Management&zoneId=" + selectedZoneObj.id),

dataType: "json",

success: function(json) {

selectedManagementNetworkObj =json.listnetworksresponse.network[0];

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Management');

selectedManagementNetworkObj.xennetworklabel = trafficType.xennetworklabel;

selectedManagementNetworkObj.kvmnetworklabel = trafficType.kvmnetworklabel;

selectedManagementNetworkObj.vmwarenetworklabel = trafficType.vmwarenetworklabel;

selectedManagementNetworkObj.ovmnetworklabel = trafficType.ovmnetworklabel;

args.response.success({ data: selectedManagementNetworkObj });

}

});

}

},

ipAddresses: { //read-only listView (no actions) filled with pod info (not VlanIpRange info)

title: 'label.ip.ranges',

listView: {

fields: {

name: { label: 'label.pod' }, //pod name

gateway: { label: 'label.gateway' }, //'Reserved system gateway' is too long and causes a visual format bug (2 lines overlay)

netmask: { label: 'label.netmask' }, //'Reserved system netmask' is too long and causes a visual format bug (2 lines overlay)

startip: { label: 'label.start.IP' }, //'Reserved system start IP' is too long and causes a visual format bug (2 lines overlay)

endip: { label: 'label.end.IP' } //'Reserved system end IP' is too long and causes a visual format bug (2 lines overlay)

},

dataProvider: function(args) {

var array1 = [];

if(args.filterBy != null) {

if(args.filterBy.search != null && args.filterBy.search.by != null && args.filterBy.search.value != null) {

switch(args.filterBy.search.by) {

case "name":

if(args.filterBy.search.value.length > 0)

array1.push("&keyword=" + args.filterBy.search.value);

break;

}

}

}

$.ajax({

url: createURL("listPods&zoneid=" + selectedZoneObj.id + "&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),

dataType: "json",

async: true,

success: function(json) {

var items = json.listpodsresponse.pod;

args.response.success({ data:items });

}

});

}

}

}

}

}

},

'guest': { //physical network + Guest traffic type

detailView: {

actions: {

edit: {

label: 'label.edit',

action: function(args) {

var vlan;

if(args.data.endVlan == null || args.data.endVlan.length == 0)

vlan = args.data.startVlan;

else

vlan = args.data.startVlan + "-" + args.data.endVlan;

var array1 = [];

if(vlan != null && vlan.length > 0)

array1.push("&vlan=" + todb(vlan));

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

array1.push("&tags=" + todb(args.data.tags));

$.ajax({

url: createURL("updatePhysicalNetwork&id=" + selectedPhysicalNetworkObj.id + array1.join("")),

dataType: "json",

success: function(json) {

var jobId = json.updatephysicalnetworkresponse.jobid;

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Guest');

updateTrafficLabels(trafficType, args.data, function() {

args.response.success({ _custom: { jobId: jobId }});

});

}

});

},

notification: { poll: pollAsyncJobResult }

}

},

tabFilter: function(args) {

var hiddenTabs = [];

if (selectedZoneObj.networktype == 'Basic')

hiddenTabs.push("network");

else //selectedZoneObj.networktype == 'Advanced'

hiddenTabs.push("ipAddresses");

return hiddenTabs;

},

tabs: {

details: {

title: 'label.details',

preFilter: function(args) {

var hiddenFields = [];

if(selectedZoneObj.networktype == "Basic") {

hiddenFields.push("startVlan");

hiddenFields.push("endVlan");

}

return hiddenFields;

},

fields: [

{ //updatePhysicalNetwork API

state: { label: 'label.state' },

startVlan: {

label: 'label.start.vlan',

isEditable: true

},

endVlan: {

label: 'label.end.vlan',

isEditable: true

},

tags: { label: 'Tags', isEditable: true },

broadcastdomainrange: { label: 'label.broadcast.domain.range' }

},

{ //updateTrafficType API

xennetworklabel: { label: 'label.xen.traffic.label', isEditable: true },

kvmnetworklabel: { label: 'label.kvm.traffic.label', isEditable: true },

vmwarenetworklabel: { label: 'label.vmware.traffic.label', isEditable: true },

ovmnetworklabel: { label: 'OVM traffic label', isEditable: true }

}

],

dataProvider: function(args) { //physical network + Guest traffic type

//refresh physical network

$.ajax({

url: createURL('listPhysicalNetworks'),

data: {

id: args.context.physicalNetworks[0].id

},

async: true,

success: function(json) {

selectedPhysicalNetworkObj = json.listphysicalnetworksresponse.physicalnetwork[0];

var startVlan, endVlan;

var vlan = selectedPhysicalNetworkObj.vlan;

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

if(vlan.indexOf("-") != -1) {

var vlanArray = vlan.split("-");

startVlan = vlanArray[0];

endVlan = vlanArray[1];

}

else {

startVlan = vlan;

}

selectedPhysicalNetworkObj["startVlan"] = startVlan;

selectedPhysicalNetworkObj["endVlan"] = endVlan;

}

//traffic type

var xentrafficlabel, kvmtrafficlabel, vmwaretrafficlabel;

var trafficType = getTrafficType(selectedPhysicalNetworkObj, 'Guest'); //refresh Guest traffic type

selectedPhysicalNetworkObj["xennetworklabel"] = trafficType.xennetworklabel;

selectedPhysicalNetworkObj["kvmnetworklabel"] = trafficType.kvmnetworklabel;

selectedPhysicalNetworkObj["vmwarenetworklabel"] = trafficType.vmwarenetworklabel;

selectedPhysicalNetworkObj["ovmnetworklabel"] = trafficType.ovmnetworklabel;

args.response.success({

actionFilter: function() {

var allowedActions = ['edit'];

return allowedActions;

},

data: selectedPhysicalNetworkObj

});

}

});

}

},

ipAddresses: {

title: 'label.ip.ranges',

custom: function(args) {

return $('<div></div>').multiEdit({

context: args.context,

noSelect: true,

fields: {

'podid': {

label: 'label.pod',

select: function(args) {

$.ajax({

url: createURL("listPods&zoneid=" + selectedZoneObj.id),

dataType: "json",

success: function(json) {

var items = [];

var pods = json.listpodsresponse.pod;

$(pods).each(function(){

items.push({name: this.id, description: this.name}); //should be "{id: this.id, description: this.name}" (to be consistent with dropdown in createFrom and edit mode) (Brian will fix widget later)

});

args.response.success({ data: items });

}