if (!options) options = {};

var $forms = $wizard.find('form').filter(function() {

return !options.all ? !$(this).closest('.multi-edit').size() : true;

});

var $physicalNetworkItems = $wizard.find(

'.steps .setup-physical-network .select-container.multi'

).filter(':not(.disabled)');

var $publicTrafficItems = $wizard.find(

'.steps .setup-public-traffic .data-body .data-item');

var $storageTrafficItems = $wizard.find(

'.steps .setup-storage-traffic .data-body .data-item');

var groupedForms = {};

if ($physicalNetworkItems.find('li.traffic-type-draggable.storage').size()) {

$wizard.find('li.conditional.storage-traffic').show();

} else {

$wizard.find('li.conditional.storage-traffic').hide();

}

if (options.all) {

return cloudStack.serializeForm($forms, {

escapeSlashes: true

});

}

// Group form fields together, by form ID

$forms.each(function() {

var $form = $(this);

var id = $form.attr('rel');

if (!id) return true;

groupedForms[id] = cloudStack.serializeForm($form, {

escapeSlashes: true

});

return true;

});

// Get physical network data

groupedForms.physicalNetworks = $.map(

$physicalNetworkItems,

function(network) {

var $network = $(network);

var $guestForm = $wizard.find('form[guest-network-id=' + $network.index() + ']');

var trafficTypeConfiguration = {};

$network.find('.traffic-type-draggable').each(function() {

var $trafficType = $(this);

var trafficTypeID = $trafficType.attr('traffic-type-id');

trafficTypeConfiguration[trafficTypeID] = $trafficType.data('traffic-type-data');

});

return {

id: $network.index(),

name: $network.find('.field.name input[type=text]').val(),

isolationMethod: $network.find('.field.name select').val(),

// Traffic type list

trafficTypes: $.map(

$network.find('.traffic-type-draggable'),

function(trafficType) {

var $trafficType = $(trafficType);

return $trafficType.attr('traffic-type-id');

}

),

// Traffic type configuration data

trafficTypeConfiguration: trafficTypeConfiguration,

guestConfiguration: $guestForm.size() ? cloudStack.serializeForm($guestForm) : null

};

}

);

// Get public traffic data (multi-edit)

groupedForms.publicTraffic = $.map(

$publicTrafficItems,

function(publicTrafficItem) {

var $publicTrafficItem = $(publicTrafficItem);

var publicTrafficData = {};

var fields = [

'gateway',

'netmask',

'vlanid',

'startip',

'endip'

];

$(fields).each(function() {

publicTrafficData[this] =

$publicTrafficItem.find('td.' + this + ' span').html();

});

return publicTrafficData;

}

);

// Get storage traffic data (multi-edit)

groupedForms.storageTraffic = $.map(

$storageTrafficItems,

function(storageTrafficItem) {

var $storageTrafficItem = $(storageTrafficItem);

var storageTrafficData = {};

var fields = [

'gateway',

'netmask',

'vlan',

'startip',

'endip'

];

$(fields).each(function() {

storageTrafficData[this] =

$storageTrafficItem.find('td.' + this + ' span').html();

});

return storageTrafficData;

}

);

// Hack to fix forward slash JS error

$.each(groupedForms, function(key1, value1) {

$.each(value1, function(key2, value2) {

if (typeof value2 == 'string') {

groupedForms[key1][key2] = value2.replace(/__forwardSlash__/g, '\/');

}

});

});

// Include zone network type

if (groupedForms.zone) {

groupedForms.zone.networkType = $forms.find('input[name=network-model]:checked').val();

// Include zone isolation mode, supported for Advanced zones only

if (groupedForms.zone.networkType == 'Advanced') {

groupedForms.zone.sgEnabled = $forms.find('input[name=zone-advanced-sg-enabled]')

.is(':checked') ? true : false;

}

}

return groupedForms;

if ($form.closest('.multi-edit').find('.data-item').size()) {

return true;

}

cloudStack.dialog.notice({

message: dictionary['message.please.add.at.lease.one.traffic.range']

});

return false;

var $enabledPhysicalNetworks = $form.filter(':not(.disabled)').filter(function() {

return $(this).find('.traffic-type-draggable').size();

});

var $trafficTypes = $enabledPhysicalNetworks.find('.traffic-type-draggable');

var $configuredTrafficTypes = $trafficTypes.filter(function() {

var $trafficType = $(this);

return ($trafficType.data('traffic-type-data') != null);

});

if ($enabledPhysicalNetworks.size() > 1 &&

$configuredTrafficTypes.size() != $trafficTypes.size()) {

cloudStack.dialog.notice({

message: _l('message.configure.all.traffic.types')

});

return false;

}

return true;

var $multiEditForm = $step.find('.multi-edit form');

var $physicalNetworks = $step.find('.select-container.multi');

var isCustomValidated;

if ($multiEditForm.size()) {

isCustomValidated = customValidation.networkRanges($multiEditForm);

} else if ($physicalNetworks.size()) {

isCustomValidated = customValidation.physicalNetworks($physicalNetworks);

} else {

isCustomValidated = true;

}

return isCustomValidated;

return getData($wizard, {

all: true

})['network-model'] == 'Advanced';

var $existingPhysicalNetworks = physicalNetwork.getNetworks($wizard);

// Initialize physical networks

if (!$existingPhysicalNetworks.size()) {

physicalNetwork.add($wizard);

} else if (!isAdvancedNetwork($wizard)) {

$existingPhysicalNetworks.filter(':first').siblings().each(function() {

physicalNetwork.remove($(this));

});

}

physicalNetwork.updateNetworks(physicalNetwork.getNetworks($wizard));

$wizard.find('.traffic-types-drag-area ul li').removeClass('required disabled clone');

// Setup clone traffic types

$(physicalNetwork.cloneTrafficTypes($wizard)).each(function() {

var trafficTypeID = this;

$wizard.find('.traffic-types-drag-area ul li').filter(function() {

return $(this).hasClass(trafficTypeID);

}).addClass('clone');

});

// Setup required traffic types

$(physicalNetwork.requiredTrafficTypes($wizard)).each(function() {

var trafficTypeID = this;

var $firstPhysicalNetwork = physicalNetwork.getNetworks($wizard).filter(':first');

// First physical network gets required traffic types

physicalNetwork.assignTrafficType(trafficTypeID, $firstPhysicalNetwork);

$wizard.find('.traffic-types-drag-area ul li').filter(function() {

return $(this).hasClass(trafficTypeID);

}).addClass('required');

});

// Setup disabled traffic types

$(physicalNetwork.disabledTrafficTypes($wizard)).each(function() {

var trafficTypeID = this;

var $trafficType = physicalNetwork.getTrafficType(this, $wizard);

physicalNetwork.unassignTrafficType($trafficType);

$wizard.find('.traffic-types-drag-area ul li').filter(function() {

return $(this).hasClass(trafficTypeID);

}).addClass('disabled');

});

var trafficData = $trafficType.data('traffic-type-data') ?

$trafficType.data('traffic-type-data') : {};

var hypervisor = getData($trafficType.closest('.zone-wizard')).zone.hypervisor;

var zoneType = getData($trafficType.closest('.zone-wizard')).zone.networkType;

var fields;

if (hypervisor == 'VMware') {

fields = {

vSwitchName: {

label: 'label.vswitch.name' ,

defaultValue: trafficData.vSwitchName

},

vlanId: {

label: 'label.vlan.id',

defaultValue: trafficData.vlanId

}

};

if(zoneType == 'Advanced') {

if($trafficType.hasClass('guest') || $trafficType.hasClass('public')) {

if(trafficData.vSwitchType == null) {

var useDvs = false;

$.ajax({

url: createURL('listConfigurations'),

data: {

name: 'vmware.use.dvswitch'

},

async: false,

success: function(json) {

if (json.listconfigurationsresponse.configuration[0].value == 'true') {

useDvs = true;

}

}

});

if (useDvs == true) {

var useNexusDvs = false;

$.ajax({

url: createURL('listConfigurations'),

data: {

name: 'vmware.use.nexus.vswitch'

},

async: false,

success: function(json) {

if (json.listconfigurationsresponse.configuration[0].value == 'true') {

useNexusDvs = true;

}

}

});

if (useNexusDvs == true) {

trafficData.vSwitchType = 'nexusdvs';

fields.vSwitchName.defaultValue = 'epp0';

} else {

trafficData.vSwitchType = 'vmwaredvs';

fields.vSwitchName.defaultValue = 'dvSwitch0';

}

} else { //useDvs == false

trafficData.vSwitchType = 'vmwaresvs';

fields.vSwitchName.defaultValue = 'vSwitch0';

}

}

$.extend(fields, {

vSwitchType: {

label: 'label.vSwitch.type',

select: function (args) {

args.response.success({

data: [{

id: 'nexusdvs',

description: 'Cisco Nexus 1000v Distributed Virtual Switch'

}, {

id: 'vmwaresvs',

description: 'VMware vNetwork Standard Virtual Switch'

}, {

id: 'vmwaredvs',

description: 'VMware vNetwork Distributed Virtual Switch'

}]

});

},

defaultValue: trafficData.vSwitchType

}

});

}

}

} else {

fields = {

label: {

label: hypervisor + ' ' + _l('label.traffic.label'),

defaultValue: trafficData.label

}

};

}

cloudStack.dialog.createForm({

form: {

title: _l('label.edit.traffic.type'),

desc: _l('message.edit.traffic.type'),

fields: fields

},

after: function(args) {

$trafficType.data('traffic-type-data', args.data);

}

});

return cloudStack.zoneWizard.requiredTrafficTypes({

data: getData($wizard)

});

return cloudStack.zoneWizard.disabledTrafficTypes({

data: getData($wizard)

});

return cloudStack.zoneWizard.cloneTrafficTypes({

data: getData($wizard)

});

var $items = $container.find('.select-container.multi');

$items.each(function() {

var $item = $(this);

var $networkName = $item.find('.field.name input[type=text]');

var $networkId = $item.find('input[name=id]');

var $networkTypes = $item.find('.field.network-types input');

var index = $item.index();

$networkId.val(index);

$networkName.attr('name', 'physicalNetworks[' + index + ']' + '.name');

$networkTypes.val(index);

});

var $trafficType = $container.find('li.traffic-type-draggable').filter(function() {

return $(this).attr('traffic-type-id') == trafficTypeID;

});

if (physicalNetwork.isTrafficTypeClone($trafficType) && !$container.closest('.select-container.multi').size()) {

// Get traffic type from original container

return $trafficType.filter(function() {

return $(this).closest(

physicalNetwork.getOriginalTrafficContainer($trafficType)

).size();

});

}

return $trafficType;

var $dragContainer = physicalNetwork.getMainContainer($trafficType)

.find('.traffic-types-drag-area ul > li')

.filter(function() {

return $(this).hasClass($trafficType.attr('traffic-type-id'));

})

.find('ul');

return $dragContainer;

var $container = physicalNetwork.getMainContainer($physicalNetwork);

var $trafficType = physicalNetwork.getTrafficType(trafficTypeID, $container);

var $dropArea = $physicalNetwork.find('.drop-container ul');

if ($physicalNetwork.find('.traffic-type-draggable[traffic-type-id=' + trafficTypeID + ']').size()) return false;

if (physicalNetwork.isTrafficTypeClone($trafficType)) {

if (!physicalNetwork.getTrafficType(trafficTypeID, $physicalNetwork).size()) {

$trafficType = $trafficType.clone()

.removeClass('disabled')

.appendTo($dropArea)

.draggable(physicalNetwork.draggableOptions($physicalNetwork.closest('.zone-wizard')));

} else {

return false;

}

} else {

$trafficType.appendTo($dropArea);

}

if (data) {

$trafficType.data('traffic-type-data', data);

}

physicalNetwork.updateNetworks($.merge($physicalNetwork, $physicalNetwork.siblings()));

return $trafficType;

var $wizard = $trafficType.closest('.zone-wizard');

var $originalContainer = physicalNetwork.getOriginalTrafficContainer($trafficType);

var $physicalNetworks = physicalNetwork.getNetworks($wizard);

var trafficTypeID = $trafficType.attr('traffic-type-id');

if (!physicalNetwork.isTrafficTypeClone($trafficType) &&

$.inArray(trafficTypeID, physicalNetwork.requiredTrafficTypes($wizard)) == -1) {

$trafficType.appendTo($originalContainer);

} else {

physicalNetwork.assignTrafficType(

trafficTypeID,

$physicalNetworks.filter(':first')

);

if (physicalNetwork.isTrafficTypeClone($trafficType) &&

$physicalNetworks.find('.traffic-type-draggable[traffic-type-id=' + trafficTypeID + ']').size() > 1) {

$trafficType.remove();

}

}

return $trafficType;

// Basic zones do not have multiple physical networks

if (!isAdvancedNetwork($containers.closest('.zone-wizard')))

return false;

var $emptyContainers = $containers.filter(function() {

return !$(this).find('li').size();

});

return !$emptyContainers.size() ? $containers.size() : false;

var $mainContainer = physicalNetwork.getMainContainer($containers);

var $allPhysicalNetworks = physicalNetwork.getNetworks($mainContainer);

var containerTotal = isAdvancedNetwork($containers.closest('.zone-wizard')) ?

2 : 1;

$allPhysicalNetworks.each(function() {

var $ul = $(this).find('.drop-container ul');

if (!$(this).find('li').size()) {

$(this).addClass('disabled');

$ul.fadeOut();

} else {

$(this).removeClass('disabled');

$ul.show();

}

});

$containers.each(function() {

var $currentContainer = $(this);

if (!$currentContainer.find('li').size() &&

$containers.size() > containerTotal) {

$currentContainer.remove();

}

});

$containers = $containers.closest('.setup-physical-network')

.find('.select-container.multi');

if (physicalNetwork.needsNewNetwork($containers)) {

physicalNetwork.add($mainContainer.parent());

}

$containers.filter(':first').find('.remove.physical-network').remove();

return $containers;

return {

appendTo: $wizard,

helper: 'clone',

// Events

start: function(event, ui) {

$(this).addClass('disabled');

},

stop: function(event, ui) {

$(this).removeClass('disabled');

},

cancel: '.edit-traffic-type'

};

var $container = $wizard.find('.setup-physical-network .content.input-area form');

var $physicalNetworkItem = $('<div>').addClass('select-container multi');

var $deleteButton = $('<div>').addClass('button remove physical-network')

.attr({

title: 'Remove this physical network'

})

.append('<span>').addClass('icon').html('&nbsp;');

var $icon = $('<div>').addClass('physical-network-icon');

var $nameField = $('<div>').addClass('field name').append(

$('<div>').addClass('name').append(

$('<label>').html('Physical network name')

),

$('<div>').addClass('value').append(

$('<input>').attr({

type: 'text'

}).addClass('required disallowSpecialCharacters')

)

);

var ovsTunnelManager = false;

$.ajax({

url: createURL('listConfigurations'),

data: {

name: 'sdn.ovs.controller'

},

dataType: "json",

async: false,

success: function(json) {

var items = json.listconfigurationsresponse.configuration; //2 entries returned: 'sdn.ovs.controller', 'sdn.ovs.controller.default.label'

$(items).each(function() {

if (this.name == 'sdn.ovs.controller') {

if (this.value == 'true' || this.value == true) {

ovsTunnelManager = true;

}

return false; //break each loop

}

});

}

});

//when OVS tunnel manager is used

//if(ovsTunnelManager == true) {

//Advanced zone supports 2 isolation method(VLAN, GRE), so show dropdown including the 2 options

if ($wizard.find('.select-network-model input:radio[name=network-model]:checked').val() == 'Advanced') {

$nameField.append(

$('<div>').append(

$('<span style=\"font-size:11px;padding-right:5px;padding-left:40px\">').html('Isolation method'),

$('<select>').append(

$('<option>').attr({

value: 'VLAN'

}).html('VLAN'),

$('<option>').attr({

value: 'GRE'

}).html('GRE'),

$('<option>').attr({

value: 'STT'

}).html('STT'),

$('<option>').attr({

value: 'VNS'

}).html('VNS'),

$('<option>').attr({

value: 'SSP'

}).html('SSP'),

$('<option>').attr({

value: 'VXLAN'

}).html('VXLAN'),

$('<option>').attr({

value: 'ODL'

}).html('ODL'),

$('<option>').attr({

value: 'L3VPN'

}).html('L3VPN'),

$('<option>').attr({

value: 'VSP'

}).html('VSP'),

$('<option>').attr({

value: 'VCS'

}).html('VCS')

)

)

);

}

//Basic zone supports only 1 isolation method (L3), so there is no point showing dropdown.

// }

//when OVS tunnel manager is not used, isolationmethods parameter in createPhysicalNetwork API is ignored. So no showing dropdown.

//isolationmethods parameter has not been used by network gurus so far. By default(i.e. when OVS tunnel manager is not used), networks are isolated with VLANs in Advanced zone, with L3 in basic zone.

//No longer the case, as the Nicira stuff also depends on this now

var $dropContainer = $('<div>').addClass('drop-container').append(

$('<span>').addClass('empty-message').html(

'Drag and drop traffic types you would like to add here.'

),

$('<ul>').hide()

).droppable({

over: function(event, ui) {

var $ul = $(this).find('ul');

$ul.addClass('active');

if (!$ul.find('li').size()) {

$(this).closest('.select-container.multi').removeClass('disabled');

$ul.fadeIn();

}

},

out: function(event, ui) {

var $ul = $(this).find('ul');

$ul.removeClass('active');

physicalNetwork.updateNetworks($(this).closest('.select-container.multi'));

},

drop: function(event, ui) {

var trafficTypeID = ui.draggable.attr('traffic-type-id');

var $physicalNetwork = $(this).closest('.select-container.multi');

var trafficTypeData = ui.draggable.data('traffic-type-data');

if (trafficTypeID == 'guest' &&

ui.draggable.closest('.select-container.multi').size()) {

ui.draggable.remove();

}

physicalNetwork.assignTrafficType(trafficTypeID, $physicalNetwork, trafficTypeData);

}

});

var $idField = $('<input>').attr({

type: 'hidden',

name: 'id',

value: 0

});

// Initialize new default network form elem

$physicalNetworkItem.append(

$icon,

$nameField,

$idField,

$dropContainer

);

// Only advanced zones can remove physical network

if (isAdvancedNetwork($wizard)) {

$physicalNetworkItem.prepend($deleteButton);

}

$physicalNetworkItem.hide().appendTo($container).fadeIn('fast');

$physicalNetworkItem.find('.name input').val('Physical Network ' + parseInt($physicalNetworkItem.index() + 1));

physicalNetwork.renumberFormItems($container);

// Remove network action

$physicalNetworkItem.find('.button.remove.physical-network').click(function() {

physicalNetwork.remove($physicalNetworkItem);

});

$physicalNetworkItem.addClass('disabled'); // Since there are no traffic types yet

return $physicalNetworkItem;

var $container = $physicalNetworkItem.closest('.setup-physical-network .content.input-area form');

var $trafficTypes = $physicalNetworkItem.find('li.traffic-type-draggable');

$trafficTypes.each(function() {

var trafficTypeID = $(this).attr('traffic-type-id');

physicalNetwork.assignTrafficType(

trafficTypeID,

$physicalNetworkItem.prev()

);

});

$trafficTypes.filter('.clone').remove();

physicalNetwork.updateNetworks($physicalNetworkItem.parent().find('.multi'));

$container.validate('refresh');

var $physicalNetworks = physicalNetwork.getNetworks($wizard);

var $tabs = guestTraffic.makeTabs($physicalNetworks, args);

var $container = guestTraffic.getMainContainer($wizard);

// Cleanup

guestTraffic.remove($wizard);

$container.find('.content form').hide();

$tabs.appendTo($container.find('.content .select-container'));

var $subnav = $container.find('ul.subnav').remove(); // Fix to avoid subnav becoming tab ul

$container.tabs();

$container.prepend($subnav);

$container.find('.field').hide();